Announcing a new IDE for PostgreSQL in VS Code from Microsoft
We are excited to announce the public preview of the brand-new PostgreSQL extension for Visual Studio Code (VS Code), designed to simplify PostgreSQL database management and development workflows. With this extension, you can now manage database objects, draft queries with intelligent assistance from context-aware IntelliSense and our ‘@pgsql’ GitHub Copilot agent—all without ever leaving your favorite code editor. Addressing Developer Challenges Many of you face hurdles in managing time effectively, with 41% of developers struggling with task-switching, according to the 2024 StackOverflow Developer Survey. Additionally, the 2024 Stripe Developer Coefficient Report reveals that developers spend up to 50% of their time debugging and troubleshooting code and databases. These inefficiencies are further compounded by the absence of integrated tools that unify database management and application development. The PostgreSQL extension for VS Code addresses these challenges head-on by integrating Postgres database tools and the @pgsql GitHub Copilot agent, providing a unified application development and database management experience. By integrating robust features such as Entra ID authentication for centralized identity management and deep Azure Database for PostgreSQL integration, this extension empowers you to focus on building innovative applications rather than wrestling with fragmented workflows. Key Features The public preview release of the PostgreSQL extension for VS Code introduces a suite of powerful new capabilities that enhance productivity and streamline development for application developers working with Postgres. Schema Visualization Schema visualization is a breeze with our ‘right-click’ context menu options. o Right-click on the database entry in the Object Explorer and select “Visualize Schema” Single click to expand. Database aware GitHub Copilot AI assistance directly within VS Code providing PostgreSQL database context reduces the PostgreSQL learning curve and improves developer productivity. Simplified interaction with PostgreSQL databases and development tools using natural language. Commands such as "@pgsql" enable you to query databases, optimize schemas, and execute SQL operations with ease. Context menus, such as “Rewrite Query”, “Explain Query”, “Analyze Query Performance” provide AI Intelligence inside the query editor window. Real-time, expert-level guidance to help keep PostgreSQL databases performant and secure and improve code quality. PostgreSQL Copilot Context Menu Options Single click to expand. Using the PostgreSQL Copilot Context Menu, Single click to expand. GitHub Copilot Chat Agent Mode GitHub Copilot Chat agent mode provides a database context aware intelligent assistant that can perform multi-stage tasks, moving beyond the question-and-answer chat experience. Agent mode allows the Copilot to bring in additional context from your workspace and, with permission, it can write and debug code on its own. Agent mode transforms PostgreSQL development by providing real-time, AI-driven guidance that simplifies complex tasks like app prototyping, debugging, schema optimization, and performance tuning. In this example, we’ll ask the agent to create a new database on a specific server in my Saved Connections and enable the PostGIS extension. Single click to expand. The @pgsql agent begins by listing the server connections, connecting to the server ‘postgis’, drafts the script to modify the database and waits for permission to continue before making changes. Database modifications require explicit permission from the user. Add Database Connections with Ease Simplified connection management for local and cloud-hosted PostgreSQL instances. Support for multiple connection profiles and connection string parsing for easy setup. Direct browsing and filtering of Azure Database for PostgreSQL deployments. Integration with Entra ID for centralized security and identity management. Connect with ease to your existing Azure Database for PostgreSQL deployments with the “Browse Azure” option in the “Add New Connection” menu. Single click to expand. Connect to local Docker deployments with the Parameters or Connection String option. Single click to expand. Password-less authentication with Entra Id Streamlined Authentication: Eliminates the need for manual login, offering a seamless integration experience for you. Automatic Token Refresh: Ensures uninterrupted connectivity and minimizes the risk of authentication timeouts during development. Enhanced Security: Provides robust protection by leveraging Entra-ID's secure authentication protocols. Time Efficiency: Reduces overhead by automating token management, allowing you to focus on coding rather than administrative tasks. Enterprise Compatibility: Aligns with corporate security standards and simplifies access to PostgreSQL databases in enterprise environments. User Consistency: You can use your existing Entra-ID credentials, avoiding the need to manage separate accounts. Database Explorer Provides a structured view of database objects such as schemas, tables, and functions. Enables creation, modification, and deletion of database objects. Single click to expand. Query History Session query history is available below the Object Explorer. This allows you to quickly review previously run queries for reuse. Single click to expand. Query Editing with Context-aware IntelliSense Context-aware IntelliSense for auto-completion of SQL keywords, table names, and functions. Syntax highlighting and auto-formatting for improved query readability. Query history tracking for reusing previously executed queries. Single click to expand. What Sets the PostgreSQL Extension for VS Code Apart? The PostgreSQL extension for VS Code stands out in the crowded landscape of developer database management tools due to its unparalleled functionality and intuitive design. Here’s what makes it special: Enhanced Productivity: Features like context-aware IntelliSense and SQL formatting save time and minimize errors. pgsql GitHub Copilot Chat agent: Database and workspace context awareness, enabling smarter and more contextually relevant assistance for developers – combined with the ability to perform multi-step tasks. Streamlined Onboarding: The Connection Manager ensures you can get started within minutes. Improved Security: Entra ID integration provides robust access control and centralized identity management, including the ability to browse your Azure Database for PostgreSQL instances. Comprehensive Toolset: You can manage database objects, execute queries, and deploy instances all within VS Code. Seamless Cloud Integration: Deep integration with Azure Database for PostgreSQL simplifies cloud database management. Getting Started with the PostgreSQL extension for Visual Studio Code Installing the PostgreSQL extension for VS Code is simple: Open the Extensions view in VS Code. Search for "PostgreSQL" in the Extensions Marketplace. Select and install the Preview PostgreSQL extension with the blue elephant seen in the screenshot below. xtension ID: (ms-ossdata.vscode-pgsql) Also available in the online Visual Studio Code Marketplace. Enabling the PostgreSQL GitHub Copilot Chat You will need the GitHub Copilot and GitHub Copilot chat extensions installed in VS Code to be able to log into their GitHub Account and use "@pgsql" in the chat interface to interact with their PostgreSQL database. Feedback and Support We value your insights. Use the built-in feedback tool in VS Code to share your thoughts and report issues. Your feedback will help us refine the extension and ensure it meets the needs of the developer community. Regarding the standard preview license language included in this first release - Our goal is to ensure this extension is widely available and consumable by all Postgres users equally. We’re going to update the license. Stay tuned for updates. Get Started The PostgreSQL extension for VS Code offers significant enhancements to development efficiency and productivity. We encourage you to explore the public preview today and experience improved workflows with PostgreSQL databases. To learn more and get started, visit: https://aka.ms/pg-vscode-docs Special thanks to Jonathon Frost, Principal PM for all of his work on the @pgsql GitHub Copilot.New GitHub Copilot Global Bootcamp: Now with Virtual and In-Person Workshops!
From June 17 to July 10, you can learn from anywhere in the world — online or in your own city! The GitHub Copilot Global Bootcamp started in February as a fully virtual learning journey — and it was a hit. More than 60,000 developers joined the first edition across multiple languages and regions. Now, we're excited to launch the second edition — bigger and better — featuring both virtual and in-person workshops, hosted by tech communities around the globe. This new edition arrives shortly after the announcements at Microsoft Build 2025, where the GitHub and Visual Studio Code teams revealed exciting news: The GitHub Copilot Chat extension is going open source, reinforcing transparency and collaboration. AI is being deeply integrated into Visual Studio Code, now evolving into an open source AI editor. New APIs and tools are making it easier than ever to build with AI and LLMs. This bootcamp is your opportunity to explore these new tools, understand how to use GitHub Copilot effectively, and be part of the growing global conversation about AI in software development.Step-by-Step: How to Setup Copilot Chat in VS Code
Copilot Chat is an AI-powered chatbot leveraging OpenAI's GPT-4, designed to enhance your coding workflow. Learn how to set up Copilot Chat step by step in Visual Studio Code (VS Code). Benefit from personalized and flexible coding environments, code analysis, automated unit test generation, and bug fixes. Prerequisites include an active GitHub account and the latest version of VS Code. Elevate your coding efficiency to new heights with Copilot Chat.Demystifying GitHub Copilot Security Controls: easing concerns for organizational adoption
At a recent developer conference, I delivered a session on Legacy Code Rescue using GitHub Copilot App Modernization. Throughout the day, conversations with developers revealed a clear divide: some have fully embraced Agentic AI in their daily coding, while others remain cautious. Often, this hesitation isn't due to reluctance but stems from organizational concerns around security and regulatory compliance. Having witnessed similar patterns during past technology shifts, I understand how these barriers can slow adoption. In this blog, I'll demystify the most common security concerns about GitHub Copilot and explain how its built-in features address them, empowering organizations to confidently modernize their development workflows. GitHub Copilot Model Training A common question I received at the conference was whether GitHub uses your code as training data for GitHub Copilot. I always direct customers to the GitHub Copilot Trust Center for clarity, but the answer is straightforward: “No. GitHub uses neither Copilot Business nor Enterprise data to train the GitHub model.” Notice this restriction also applies to third-party models as well (e.g. Anthropic, Google). GitHub Copilot Intellectual Property indemnification policy A frequent concern I hear is, since GitHub Copilot’s underlying models are trained on sources that include public code, it might simply “copy and paste” code from those sources. Let’s clarify how this actually works: Does GitHub Copilot “copy/paste”? “The AI models that create Copilot’s suggestions may be trained on public code, but do not contain any code. When they generate a suggestion, they are not “copying and pasting” from any codebase.” To provide an additional layer of protection, GitHub Copilot includes a “duplicate detection filter”. This feature helps prevent suggestions that closely match public code from being surfaced. (Note: This duplicate detection currently does not apply to the Copilot coding agent.) More importantly, customers are protected by an Intellectual Property indemnification policy. This means that if you receive an unmodified suggestion from GitHub Copilot and face a copyright claim as a result, Microsoft will defend you in court. GitHub Copilot Data Retention Another frequent question I hear concerns GitHub Copilot’s data retention policies. For organizations on GitHub Copilot Business and Enterprise plans, retention practices depend on how and where the service is accessed from: Access through IDE for Chat and Code Completions: Prompts and Suggestions: Not retained. User Engagement Data: Kept for two years. Feedback Data: Stored for as long as needed for its intended purpose. Other GitHub Copilot access and use: Prompts and Suggestions: Retained for 28 days. User Engagement Data: Kept for two years. Feedback Data: Stored for as long as needed for its intended purpose. For Copilot Coding Agent, session logs are retained for the life of the account in order to provide the service. Excluding content from GitHub Copilot To prevent GitHub Copilot from indexing sensitive files, you can configure content exclusions at the repository or organization level. In VS Code, use the .copilotignore file to exclude files client-side. Note that files listed in .gitignore are not indexed by default but may still be referenced if open or explicitly referenced (unless they’re excluded through .copilotignore or content exclusions). The life cycle of a GitHub Copilot code suggestion Here are the key protections at each stage of the life cycle of a GitHub Copilot code suggestion: In the IDE: Content exclusions prevent files, folders, or patterns from being included. GitHub proxy (pre-model safety): Prompts go through a GitHub proxy hosted in Microsoft Azure for pre-inference checks: screening for toxic or inappropriate language, relevance, and hacking attempts/jailbreak-style prompts before reaching the model. Model response: With the public code filter enabled, some suggestions are suppressed. The vulnerability protection feature blocks insecure coding patterns like hardcoded credentials or SQL injections in real time. Disable access to GitHub Copilot Free Due to the varying policies associated with GitHub Copilot Free, it is crucial for organizations to ensure it is disabled both in the IDE and on GitHub.com. Since not all IDEs currently offer a built-in option to disable Copilot Free, the most reliable method to prevent both accidental and intentional access is to implement firewall rule changes, as outlined in the official documentation. Agent Mode Allow List Accidental file system deletion by Agentic AI assistants can happen. With GitHub Copilot agent mode, the "Terminal auto approve” setting in VS Code can be used to prevent this. This setting can be managed centrally using a VS Code policy. MCP registry Organizations often want to restrict access to allow only trusted MCP servers. GitHub now offers an MCP registry feature for this purpose. This feature isn’t available in all IDEs and clients yet, but it's being developed. Compliance Certifications The GitHub Copilot Trust Center page lists GitHub Copilot's broad compliance credentials, surpassing many competitors in financial, security, privacy, cloud, and industry coverage. SOC 1 Type 2: Assurance over internal controls for financial reporting. SOC 2 Type 2: In-depth report covering Security, Availability, Processing Integrity, Confidentiality, and Privacy over time. SOC 3: General-use version of SOC 2 with broad executive-level assurance. ISO/IEC 27001:2013: Certification for a formal Information Security Management System (ISMS), based on risk management controls. CSA STAR Level 2: Includes a third-party attestation combining ISO 27001 or SOC 2 with additional cloud control matrix (CCM) requirements. TISAX: Trusted Information Security Assessment Exchange, covering automotive-sector security standards. In summary, while the adoption of AI tools like GitHub Copilot in software development can raise important questions around security, privacy, and compliance, it’s clear that existing safeguards in place help address these concerns. By understanding the safeguards, configurable controls, and robust compliance certifications offered, organizations and developers alike can feel more confident in embracing GitHub Copilot to accelerate innovation while maintaining trust and peace of mind.How Reasoning Models are transforming Logical AI thinking
Introduction Reasoning models are a new category of specialized language models. They are designed to break down complex problems into smaller, manageable steps and solve them through explicit logical reasoning (This step is also called “thinking”). Unlike general-purpose LLMs which might generate direct answers, reasoning models are specifically trained to show their work and follow a more structured thought process. Some models don’t show their logical reasoning phase while others explicitly show their logical reasoning phase. The reasoning phase shows how the model can break down the problem stated into smaller problems (Decomposition), try different approaches (Ideation), choose the best approaches (validation), reject invalid approaches (possibly backtracking) and finally choose the best answer (execution/solving). Reasoning models like OpenAI’s o1, o1-mini, o3-mini, and DeepSeek-R1 are available in the AI Toolkit for VS Code model catalog, Azure AI Foundry model catalog as well as online for free usage (rate-limited) in the Github Marketplace for models. There are some key differences between reasoning models and general-purpose LLMs. These are summarized in the following table. Summary Table Feature Reasoning Models General Purpose LLMs Primary Purpose and Strengths Explicit step-by-step problem solving and logical reasoning General-purpose text generation and understanding Problem-Solving Approach Break down problems into smaller sub-steps and shows intermediate reasoning (“thinking” phase) Show the output directly without showing intermediate steps. Mostly pattern based next token prediction Output Structure Highly structured, with clear delineation between reasoning steps More flexible and conversational, may mix reasoning with other content Training Specifically trained on step-by-step reasoning tasks and formal logic Trained on a diverse corpus of text data with many different writing styles and purposes Usage of Chain-of-Thought Built into the core architecture and training process Can use chain-of-thought prompting but not inherently designed for it. Must specifically ask for this in the prompt. Interpretability and Error Detection Detecting errors is easier due to explicit reasoning steps Black-box nature makes reasoning for output harder to trace Computational Efficiency May require more computing resources due to step-by-step processing, especially at inference time Relatively lower computing requirements at inference time and usually more efficient for direct responses Latency for response May be slower for simple tasks that don't require explicit reasoning May struggle with complex logical problems requiring step-by-step analysis and interpretation. Examples OpenAI o1, o1-mini, o3-mini, DeepSeek-R1 GPT-4o, Llama3.3, Claude Use cases Scientific reasoning, legal analysis, complex problem-solving, AI agents with multi-step decision-making Chatbots, Text summarization, content generation, Q&A, code completion Since we know that reasoning models excel at logical step-by step problem solving, we will give them tasks. We will be using DeepSeek-R1 from the GitHub model marketplace and AI Toolkit for VSCode for this analysis. Task 1 – Solve a logical puzzle We will use a variation of the river crossing problem that has some interesting constraints and needs some level of backtracking which humans excel at. This is the prompt that we will use is Can you solve this logic puzzle and show it as a diagram "A farmer with a wolf, a goat, and a cabbage must cross a river by boat. The boat can carry only the farmer and a single item. If left unattended together, the wolf would eat the goat, or the goat would eat the cabbage. How can they cross the river without anything being eaten?" AI Toolkit Session follows below: User Can you solve this logic puzzle and show it as a diagram "A farmer with a wolf, a goat, and a cabbage must cross a river by boat. The boat can carry only the farmer and a single item. If left unattended together, the wolf would eat the goat, or the goat would eat the cabbage. How can they cross the river without anything being eaten?" DeepSeek-R1 <think> Okay, so the user wants me to solve this logic puzzle about the farmer crossing the river with a wolf, goat, and cabbage. Let me start by recalling the problem. The farmer can only take one item at a time in the boat. If left alone, the wolf eats the goat, and the goat eats the cabbage. The goal is to get everyone across safely. First, I need to break down the constraints. The boat can carry the farmer and one item. So each trip either the farmer goes alone or takes one item. The main issue is the forbidden pairs: wolf and goat can't be left alone, goat and cabbage can't be left alone. So whenever the farmer moves, the remaining items on either bank must not include these pairs. Let me think through the possible steps. Let's consider the initial state: all four (farmer, wolf, goat, cabbage) are on the left bank. The goal is to get all to the right bank. The first thought: if the farmer takes the goat first. Then left bank has wolf and cabbage. They are safe because wolf and cabbage don't interact. So after first trip, farmer and goat are on the right, wolf and cabbage on the left. Then the farmer goes back alone to the left. Now, the right bank has just the goat. Then the farmer can take either the wolf or the cabbage next. Suppose he takes the wolf. Then on the right bank would be wolf and goat. Oh no, that's a problem because the wolf would eat the goat. So that's forbidden. Alternatively, after taking the goat over and returning alone, the farmer could take the cabbage. If he takes the cabbage to the right bank, then left bank has wolf. Right bank has goat and cabbage. But when he takes the cabbage over, the goat is now on the right with the cabbage. If the farmer leaves them to go back, the goat would eat the cabbage. So that's not allowed either. Wait, this seems confusing. Let's track step by step. State 0: All on left (F, W, G, C). Right is empty. Step 1: Farmer takes goat to right. Now left has W, C; right has F, G. That's safe. Then Step 2: Farmer goes back alone to left. Now left has F, W, C; right has G. Step 3: Farmer takes either W or C. Suppose he takes W. Now right has F, W, G. Left has C. But when he takes W, he leaves G and W on the right? Wait, no. When farmer takes W to the right, after step 3, left has C, right has F, W, G. But if he leaves W and G on the right, that's a problem (wolf and goat). Wait, no, the farmer is there too. So actually, if the farmer is present, they can't eat. The problem occurs only when unattended. So when the farmer takes W to the right, he's with W and G on the right. Then he can leave W there and take G back? Wait, but that would complicate things. Wait, let's step through again. After step 2: left is F, W, C; right is G. Step 3: Farmer takes W to right. Left has C. Right has F, W, G. Since farmer is on the right, wolf and goat are not left alone. Then the farmer leaves W on the right, goes back with G. Wait, but if he leaves W on the right, then the right bank has W and G, but farmer is taking G back. Wait, no. If the farmer takes W to the right, then right bank now has W and G. But the farmer is there. So he can take W to the right bank, and then he stays there, but then he can't take G back. Wait, no. Wait, no. Let me correct this. If the farmer is taking the wolf from left to right, starting at left (F, W, C) and right (G). After moving W: Left has C (and no farmer), right has F, W, G. Wait, but left would have C alone, which is safe. Then the farmer is on the right with W and G. Then he has to leave either W or G to go back. But if he leaves W and G on the right, unattended, that's a problem. So he can't leave them. Thus, the farmer needs to take something with him. Wait, so step 3 alternatives: after step 2 (left has F, W, C; right has G), farmer takes cabbage to the right: Left becomes W (and no farmer), right has F, C, G. But then when he takes C to the right, the right bank would have C and G, which would be a problem if left unattended. Because farmer is on the right, so they are attended. Then he leaves C there, takes G back to left. But that seems steps going back and forth. This is getting a bit tangled. Let's try outlining possible valid moves. The key insight here is that the goat is the only item that can't be left with either wolf or cabbage. So the farmer must ensure that whenever the goat is on a bank without the farmer, there are no other dangerous items there. So, the strategy that typically works is: Take goat over first. Return alone. Take either wolf or cabbage over. Bring goat back. Take the other item (cabbage or wolf) over. Return alone. Take goat over again. Let me check this. Step-by-Step: Start: All on left (F, W, G, C) Take G to right. State: Left: W, C; Right: F, G. Safe, because Left has W and C (no conflict). Farmer returns to left alone. State: F, W, C | G. Farmer takes W to right. State: Left: C; Right: F, W, G. But on the right, when the farmer leaves W there, does he take G back? No. Wait, after bringing W to right, the farmer would have to leave something. If he takes W to the right and leaves it there while he goes back, then right has W and G. The farmer is on the way back, so they are left alone. That's a problem because wolf and goat would be together. Therefore, this is invalid. Hence, step 3 taking W leads to a problem. Ah, so to avoid that, after step 2, instead of taking W, the farmer should take C. Alternative Step 3: After returning, take C to right. Take C to right. State: Left: F, W; Right: G, C. But when he takes C to right, the farmer leaves left bank as W. Which is safe, just wolf alone. Right bank has F, C, G. But when he leaves C and G on the right (since farmer is there, they are safe). Wait, the farmer is present, so they don't eat. So he can leave them, then go back. So step 4: return alone. State: Left: F, W; Right: C, G. Wait, no. Let me track correctly: After Step 1: left: W, C; right: F, G. Step 2: return to left alone. Now left: F, W, C; right: G. Step 3: take C to right. After moving, left: W; farmer is taking C to right. So left becomes W and farmer is moving to right, so left has W alone (which is safe). Right now has F, G, C. But upon arrival, farmer is with G and C. So they are safe. Step 4: farmer returns to left alone. Now left: F, W; right: G, C. But on the left, F and W are there, which is okay. On right, G and C are unattended – that's a problem! Goat would eat cabbage. Wait, even though the farmer has left, he's on left now. So the right bank has G and C without the farmer. So that violates the conditions. So this path would result in the goat eating the cabbage. Hence invalid. Therefore, taking the cabbage on step 3 leads to a problem when returning. Therefore, neither taking W nor taking C works here. Hmm. So alternative approach: after step 2, when the farmer is on the left with W and C, instead of taking C or W, he needs to take the goat back. Wait, but that seems to reverse step 1. That can't help. Wait, maybe the key is that after taking the goat over first, then the farmer must bring it back later to avoid leaving dangerous pairs. Let's try a different sequence: Take goat to right. Left: W, C; Right: F, G. Return alone to left. Left: F, W, C; Right: G. Take wolf to right. Left: C; Right: F, W, G. But as before, after this, farmer is on right with W and G. If he leaves W there and takes G back, then right has W alone, which is okay. So: Take goat back to left. Left: F, C, G; Right: W. Now left has C, G, F; right has W. Then take cabbage to right. Left: G; Right: F, W, C. Then return alone to left. Take goat to right. Now all are on right. Done. This seems to work. Let's verify each step: Take G over. Left: W, C (safe); Right: F, G. Return alone. Left: F, W, C; Right: G. Take W over. Left: C (safe). Right: F, W, G. Farmer is present, so W and G safe. Take G back. Left: F, G, C; Right: W (safe). Wait, on left, when farmer takes G back, left now has G and C with farmer. So when he arrives, left has F, G, C; right has W. But then when he leaves again, left would have G and C, which would be a problem (goat eats cabbage). Wait, no. After step 4, after taking G back, the state is: Left: F, G, C (farmer is there); Right: W. Then the farmer leaves to take C over: Step 5: Take C over. Left: G (alone on left? Wait, no. Wait, if farmer takes C to right, he leaves G on left. Wait, no. Let's see: After step 4: farmer is on left with G, having brought G back from the right. So left has F, C, G; right has W. Then, step 5: farmer takes C to right. So left becomes F, G on left? Wait no: starting from: Left: F, C, G; Right: W. When farmer takes C to right, farmer and C move to right. Left becomes G alone, but without the farmer. That's bad because goat alone on left but nothing else. So it's safe. Wait, goat alone is okay. Goat on left alone is harmless. So after step 5, right has F, C, W. Left has G. But the farmer is on the right. Then step 6: farmer returns alone to left. Left: F, G; Right: W, C. Step 7: Take G to right. Now all on right: F, G, W, C. Done. But let's check at each step: Step 1: left (W, C), right (F, G) - safe. Step 2: left (F, W, C), right (G). Farmer is on left. Step 3: take W to right. Left has C (safe). Right has F, W, G. Farmer there. Step 4: take G back. Left: F, G, C (farmer there). Right: W. So now right has W alone, safe. Step 5: take C to right. Left: G alone (safe). Right: F, W, C. Farmer there. Step 6: return alone. Left: G (farmer on right). So G alone on left is safe. Wait no, after step 6: farmer returns to left, now left has F, G; right has W, C. Farmer is on left with G, right has W and C (separately, so no problem). Safe. Step 7: take G to right. Now all on right. Done. Yes, that works. So the steps are: Farmer and Goat → right. Farmer ← left. Farmer and Wolf → right. Farmer and Goat ← left. Farmer and Cabbage → right. Farmer ← left. Farmer and Goat → right. Each step maintains safety on both banks. Hence the solution is this sequence. Then, to represent it as a diagram, perhaps using a flowchart showing each state with left and right banks, connected by arrows indicating the steps. </think> To solve the puzzle, follow these steps systematically, ensuring that no dangerous pairs are left unattended: Cross with Goat: Farmer takes the Goat to the right bank. Left: Wolf, Cabbage | Right: Farmer, Goat Return Alone: Farmer returns to the left bank alone. Left: Farmer, Wolf, Cabbage | Right: Goat Cross with Wolf: Farmer takes the Wolf to the right bank. Left: Cabbage | Right: Farmer, Wolf, Goat Return with Goat: Farmer brings the Goat back to the left bank. Left: Farmer, Goat, Cabbage | Right: Wolf Cross with Cabbage: Farmer takes the Cabbage to the right bank. Left: Goat | Right: Farmer, Wolf, Cabbage Return Alone: Farmer returns to the left bank alone. Left: Farmer, Goat | Right: Wolf, Cabbage Final Trip with Goat: Farmer takes the Goat to the right bank. Left: (empty) | Right: Farmer, Wolf, Goat, Cabbage Diagram (simplified as a flowchart): <>Plain text Start: F, W, G, C | [Left] → [Right] (empty) Take G ➔ [W, C] | [F, G] Return ↵ [F, W, C] | [G] Take W ➔ [C] | [F, W, G] Take G ↵ [F, G, C] | [W] Take C ➔ [G] | [F, W, C] Return ↵ [F, G] | [W, C] Take G ➔ [ ] | [F, W, G, C] All cross safely! 🚣✨ Token used: 3278 (11693 characters) Conclusion As you can see it has arrived at the right answer, and you can see it taking the following steps Reformulating the problem as a set of constraints Adding symbols for each of the interacting entities. Then it takes a series of steps to see if they satisfy the constraints and discards ones that do not. Then it layers each of these steps to build an efficient solution based on backtracking and trial-and-error. Finally, once it has a probable answer, it crosschecks again on the constraints and draws the diagram as we instructed it (with symbols for each). A nice touch is that it has also shown the answer in human readable text before to make it easy to follow. Task 2 – Explain obfuscated code Another scenario that we can often face in our lives as programmers is stumbling across a piece of code in our codebase that does something clever but alas, it has no documentation. Sounds familiar? Let's see how DeepSeek-R1 can tackle this task. This is the prompt we will use What does this program do? What language is it in? And what are such programs called? s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" AI toolkit Session transcript follows: User What does this program do? What language is it in? and what are such programs called? s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" DeepSeek-R1 <think> Okay, so I need to figure out what this program does, what language it's written in, and what such programs are called. Let me start by looking closely at the code. First, the code starts with s='s=\47%s\47;printf "$s" "$s"'; followed by printf "$s" "$s". Hmm, the initial part is assigning a string to variable s. The string seems to have some escape characters. The \47 is probably an octal escape in some programming language. Since 47 in octal is 39 in decimal, which is the ASCII code for a single quote ('). So s='s=\47%s\47;printf "$s" "$s"' would actually translate to s='s='%s';printf "$s" "$s"'. Wait, let me check that. So the single quote in the string is escaped using \47, which would allow the string to include a single quote without closing the string prematurely. So the value of s is a string that starts with 's=' followed by a single quote (from \47), then %s, then another single quote (again \47), followed by ;printf "$s" "$s". Then, the next part is printf "$s" "$s". So they're using printf with the format string stored in s and the argument is the same s variable. Let's think step by step. Let's substitute s into the printf command. The s variable is: 's=\47%s\47;printf "$s" "$s"'. When printf is executed, the format string is s, which includes a %s placeholder. The arguments passed to printf are "$s", so the first %s in the format string is replaced by the value of s. Wait, but in the first line, the code is written as s='s=\47%s\47;printf "$s" "$s"'; which when interpreted would need to handle the single quotes correctly. Let me parse this. The assignment is s='...' where the content inside the single quotes includes \47, which as I thought is a single quote. So the actual value of s when assigned is: s='s='%s';printf "$s" "$s"'. Wait, maybe not. Let me think again. The original assignment is s='s=\47%s\47;printf "$s" "$s"'; So inside the single-quoted string, \47 is an escape sequence. But in some shells like Bash, inside single quotes, escapes are not processed unless the single quote is closed. Wait, but the code is using printf, which is a shell command, suggesting maybe this is a shell script? But in the shell, single quotes don't allow escaping, except for the single quote itself by using '''. Wait, but maybe the code is in a different language where \47 represents a single quote. For example, in C, octal escapes are allowed in strings. Wait, but the code uses printf with "$s" as the format and "$s" as the argument. Let me try to simulate this. Let's suppose s has the value: s='s=\47%s\47;printf "$s" "$s"'. Then, when the printf is executed: printf "$s" "$s". So substituting variables, the format string is the value of s, which is 's=\47%s\47;printf "$s" "$s"'. Then, the first argument is also s. So the %s in the format will be replaced by the value of the first argument, which is s. Wait, but the substitution happens inside the format string. Let me try writing it out. Let's say s is the string 's=\47%s\47;printf "$s" "$s"'. Then, when we do printf "$s" "$s", the %s in the format string will be replaced by the argument "$s". So the output would be the format string with %s replaced by s's value. Let's compute that. Replacing the %s with the value of s gives: s='\47 followed by the value of s (which includes \47%s\47) followed by \47'; then ;printf "$s" "$s". Hmm, that's getting a bit tangled. Maybe this program is a quine? A quine is a program that outputs its own source code. So perhaps this code, when run, generates its own source as output. Let's test this idea. Let's see what the output would be. The initial value of s is s='s=\47%s\47;printf "$s" "$s"'. Then printf is called with the format string being s and the argument being s. So substituting, the format string is 's=\47%s\47;printf "$s" "$s"', and the %s will be replaced with the same string. Let's do that: replacing %s with the value of s (i.e., the string 's=\47%s\47;printf "$s" "$s"') into the format string. So the result would be s='\47's=\47%s\47;printf "$s" "$s"'' followed by ;printf "$s" "$s". Wait, no. Let me actually plug in the substitution. The original s is: s=\47%s\47;printf "$s" "$s" So when we replace the %s in the format with the s itself, the line becomes s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" Wait, but wait. Let me process this step by step. Let me consider what happens when the printf command runs. The first printf is given the format string in variable s, which is 's=\47%s\47;printf "$s" "$s"' (the outer single quotes in the assignment are part of the shell syntax, but the actual content is s=\47%s\47;printf "$s" "$s"). Wait, no. Let's clarify: in shell scripting, when you assign s='some string', the variable s holds 'some string' without the single quotes. Wait, no. Wait in shell scripting, variable assignments like s='value' assign s the literal 'value', with the quotes used to delimit the string but not part of the value. So in this code, s is assigned the string s=\47%s\47;printf "$s" "$s" where \47 is a literal \ followed by 47, but when interpreted inside a shell, what's the actual value? Wait, but shell does not interpret octal escapes in normal strings unless using certain commands like echo with flags. Oh, but here they're using printf, which does interpret backslash escapes. Wait, but variable assignment in shell doesn't process escapes unless in certain contexts. So if s is assigned as s='s=\47%s\47;printf ...', then \47 is literally a backslash followed by 4 and 7, not as an octal escape. Hmm, that complicates things. So in that case, when the printf is executed, the format string would have \47 which printf would interpret as octal 47 (if the format string is processed with printf's escape handling). Wait, but the shell's printf command processes the escapes in the format string. Wait, the shell's printf uses the format string and replaces escape sequences in it if they are present. But in this code, the format string is stored in $s, which is being passed as the first argument to printf, and the second argument is $s. Let's take an example. Let's say s is the string 's=\47%s\47;printf "$s" "$s"'. Then, when you run printf "$s" "$s", the first argument (the format) is "s=\47%s\47;printf "$s" "$s"" and the second argument is the same string. So the %s in the format will be replaced by the second argument. Wait, but the format has \47 which, when interpreted by printf, is octal 47, which is a single quote. So in the format string, s=\47%s\47 becomes s='%s' after replacing \47 with '. Then the %s is replaced by the argument, which is the original s value. Wait, this is getting a bit confusing. Maybe I should write down the actual evaluation step by step. Let me try to reproduce the program and see what the output is. The program is: s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" Assuming this is a shell script (Bash, perhaps), let's parse this. The first part assigns the variable s to the string 's=\47%s\47;printf "$s" "$s"'. Then, the printf command is executed with the format string "$s" and the argument "$s". So, expanding variables, the printf command becomes: printf 's=\47%s\47;printf "$s" "$s"' "$s" So the format string is 's=\47%s\47;printf "$s" "$s"' with %s, and the argument is the value of s (same string). Now, when printf processes the format string, it replaces the %s with the argument. But the format string includes \47, which in the printf command is interpreted as an octal escape for the character with octal value 47, which is 39 in decimal, which is ASCII for '. Therefore, \47 becomes ', so the format string would be 's='%s';printf "$s" "$s"'. So substituting the argument (which is s='s=\47%s\47;printf "$s" "$s"') into the %s: s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" Wait, but substituting the value of s into the format, which is now 's=%s' with the %s being replaced by s, which includes the same string. Wait, this seems like a quine, where the program generates its own source code. When you run the printf command, it replaces %s with the original s variable, but within a structure that reconstructs the original program. Let me try creating the output step by step. The original code is: s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" The printf command is: printf "s=\47%s\47;printf "$s" "$s"" "$s" Because the $s in the format is replaced by the variable s. Wait, but variables inside single quotes are not expanded. Wait, no, in the assignment, the string is in single quotes, so variables inside aren't expanded. Then in the printf "$s" "$s", the $s are in double quotes, so they get expanded. Wait, but the first line is s='s=\47%s\47;printf "$s" "$s"'; Then, the second command is printf "$s" "$s". Because $s is in double quotes, the shell will replace $s with its value, which is 's=\47%s\47;printf "$s" "$s"'. Wait, but not exactly, because in the assignment, the variable s is assigned the literal string between the single quotes. Let's clarify with an example: suppose s is assigned to the literal characters s=\47%s\47;printf "$s" "$s". Because the assignment is s='...', so the single quotes around the value when assigning mean that everything inside is literal, so \47 is just three characters: backslash, 4, 7. But when you use printf "$s" "$s", the shell first substitutes the $s variables. So the first argument to printf is the value of s: s=\47%s\47;printf "$s" "$s". Then the second argument is the same. The printf command now has a format string where %s is present. Also, in the format string, there are \47 sequences. But when the shell's printf processes the format string, it will interpret backslash escapes. So the \47 in the format string, as parsed by printf, represents an octal escape code for the single quote. So let me reconstruct the formatted output: The format string after substitution is "s=\47%s\47;printf "$s" "$s"" (wait, not exactly, because variables inside double quotes are expanded, but inside the format string here it's the literal s value). Maybe I need to consider that when the line is parsed, the printf command receives the expanded variables. Wait, step by step: Original code: s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" The first part assigns s to the string "s=\47%s\47;printf "$s" "$s"" (but with the $s inside the string being literal because of the single quotes). So after assignment, the variable s contains the literal characters: s=\47%s\47;printf "$s" "$s" Now, the printf command is executed as printf "$s" "$s". The shell replaces $s with its value, so the command becomes: printf 's=\47%s\47;printf "$s" "$s"' 's=\47%s\47;printf "$s" "$s"' Notice that the first argument is the format string: 's=\47%s\47;printf "$s" "$s"' But when printf processes this format string, it replaces the \47 with the octal value 47, which is a single quote. So the format string becomes: s='%s';printf "$s" "$s" Then, the %s is replaced with the second argument: 's=\47%s\47;printf "$s" "$s"' So the resulting output is: s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" Which is exactly the original code. Therefore, this program outputs its own source code. Therefore, it's a quine. Now, regarding the language: this uses printf, which is a shell command. The syntax of variable assignment and the use of quotes indicates that it's a shell script. The initial assignment uses single quotes to define the variable s, then uses printf in a way that constructs the output by embedding the variable's content. Therefore, this code is written in a shell scripting language, probably Bash or similar. Such programs that produce their own source code as output are called quines. So putting this all together: the program is a quine written in a shell scripting language (like Bash) that prints its own source code when executed. </think> The program is a quine, which is a program that outputs its own source code when executed. It is written in shell script (specifically compatible with Bourne shell or Bash). Here's how it works: Variable Assignment: The string s='s=\47%s\47;printf "$s" "$s"' assigns the variable s with a format string containing \47 (an octal escape for the single quote '). The %s acts as a placeholder for string substitution. Print Command: The printf "$s" "$s" uses the value of s as both the format string and the argument. The shell expands $s, replacing %s with the original value of s and interpreting \47 as '. Self-Referential Output: When executed, the program constructs its identical source code by substituting %s with the escaped version of s, reproducing the original code. Language: Shell script (Bash/Bourne-like shell). Program Type: Quine. Output: <>Plain text s='s=\47%s\47;printf "$s" "$s"';printf "$s" "$s" This matches the original code, confirming it's a quine. Token used: 3376 (12922 characters) Conclusion So, as you can see from the example above, the model followed a series of logical steps to arrive at the answer It examines the code, simulates some parts of the code to figure out what it does At the same time, it also sees certain functions such as print and single quotes and guesses that the language is bash scripting It then simulates the entire program and realizes that code output is same as the generating code. It knows from its world knowledge and training that such programs are called quines. Armed with all this information, it validates the entire chain of thought to be sure of its answer and then finally formulates and prints the answer. Task 3 – Solve an optimization problem with constraints In everyday life, we often must solve problems when we have budgets and cost constraints or want to maximize revenue or profit or any other such numerical target. We might have metrics to measure them and might guess some relationships between different variables. For example, when we have a set marketing budget and different channels such as online ads, Linkedin/X posts and emails to send to prospective attendees, how do we distribute this budget between different channels with slightly different audiences and efficacy of reach and signs ups (say for an online seminar or a conference). Let us look at a similar problem but in the manufacturing domain. This is the prompt that we will give. I want to sell a certain number of items (children's toys) in order to maximize my profit. Market research tells me that if I set the price at $1.50, I will be able to sell 5000 items, and for every 10 cents I lower the price below $1.50 I will be able to sell another 1000 items. Suppose that my manufacturing setup costs ( “start-up costs” ) total $2000, and the manufacturing cost per item ( “marginal cost” ) is $0.50. Find the price to set per item and the number of items that I need to sell in order to maximize my profit and also determine the maximum profit I can get. AI Toolkit Session follows: User I want to sell a certain number of items (children's toys) in order to maximize my profit. Market research tells me that if I set the price at $1.50, I will be able to sell 5000 items, and for every 10 cents I lower the price below $1.50 I will be able to sell another 1000 items. Suppose that my manufacturing setup costs ( “start-up costs” ) total $2000, and the manufacturing cost per item ( “marginal cost” ) is $0.50. Find the price to set per item and the number of items that I need to sell in order to maximize my profit and also determine the maximum profit I can get. Deepseek-R1 <think> Okay, let's try to figure out how to maximize the profit for selling these children's toys. Hmm, so the problem gives me some information about price, quantity sold, start-up costs, and marginal cost. I need to model this mathematically and then find the optimal price and quantity. Let's break it down step by step. First, the initial price is $1.50, and at that price, they can sell 5000 items. Then, for every 10 cents they lower the price below $1.50, they can sell an additional 1000 items. So, the price decrease affects the quantity sold. I need to model the relationship between price and quantity sold. Let me denote the number of times they lower the price by 10 cents as x. So, if x = 0, the price is $1.50, and quantity sold is 5000. If x = 1, the price is $1.40, and quantity sold is 5000 + 1000*1 = 6000. If x = 2, price is $1.30, quantity is 7000, and so on. So, in general, if they lower the price x times, the price becomes: Price = 1.50 - 0.10x dollars. And the quantity sold becomes: Quantity = 5000 + 1000x items. But x has to be a non-negative integer, right? Wait, or can x be any non-negative real number? The problem says "for every 10 cents I lower the price below $1.50 I will be able to sell another 1000 items." So, is the 10 cent decrease a discrete step or can we consider a continuous decrease? Hmm, the problem doesn't specify that we have to keep the price in multiples of 10 cents. Maybe it's continuous. But the phrasing is "for every 10 cents," which suggests that each 10 cent decrease gives an additional 1000 items. But maybe we can model it as a linear relationship. Let me check. If the price drops by 10 cents, quantity increases by 1000. So, per 1 cent decrease, quantity increases by 100 items? Wait, 10 cents correspond to 1000 items, so 1 cent decrease would correspond to 1000/10 = 100 items per cent. So, we can model the quantity sold as a linear function of the price decrease. Let me define the price p as a variable, then express the quantity sold in terms of p. Alternatively, if we consider p in dollars, the relationship is: when p decreases by $0.10, quantity increases by 1000. So, if we let p = 1.50 - 0.10x, then quantity q = 5000 + 1000x. Solving for x in terms of p: x = (1.50 - p)/0.10. Then plug into q: q = 5000 + 1000*(1.50 - p)/0.10. Let me compute that. q = 5000 + 1000*(1.50 - p)/0.10 = 5000 + 1000*( (1.50 - p) / 0.10 ). Let's compute the coefficient: 1000 / 0.10 = 10,000. So, q = 5000 + 10,000*(1.50 - p) = 5000 + 15,000 - 10,000p = 20,000 - 10,000p. Wait, that seems like a linear demand function where q = 20,000 - 10,000p. Let me check that. When p = 1.50, q = 20,000 - 10,000*(1.50) = 20,000 - 15,000 = 5000, which matches. If p decreases by $0.10 to 1.40, then q = 20,000 - 10,000*(1.40) = 20,000 - 14,000 = 6,000, which is 5000 + 1000. So that works. Therefore, the quantity sold is a linear function of price: q = 20,000 - 10,000p. So, we can model this as a linear demand curve. Alternatively, maybe they want us to model x as a continuous variable, so that x can take any non-negative real value, meaning that the price can be any value below $1.50, not necessarily in increments of 10 cents, and the quantity sold would adjust accordingly. So, if you lower the price by 5 cents, then you can sell 500 more items. But does the problem allow that? The market research says "for every 10 cents I lower the price below $1.50 I will be able to sell another 1000 items." So, it's a rate: 10 cents decrease => 1000 items more. So, that is $0.10 decrease corresponds to 1000 items increase. Therefore, the slope of the demand curve is dq/dp = -1000 / 0.10 = -10,000. So, the demand function is linear with slope -10,000. So, starting from p = 1.50, q = 5000. So, the equation is q = -10,000(p - 1.50) + 5000 = -10,000p + 15,000 + 5000 = 20,000 - 10,000p, which is the same as before. So, yes, continuous. Therefore, the quantity sold as a function of price is q(p) = 20,000 - 10,000p. Alternatively, we can write p as a function of q. Let's solve for p: q = 20,000 - 10,000p => 10,000p = 20,000 - q => p = (20,000 - q)/10,000 => p = 2 - q/10,000. So, the inverse demand function is p = 2 - q/10,000. Okay, so total revenue R is pq. So, R = pq = (2 - q/10,000)*q = 2q - q²/10,000. Total cost C consists of fixed costs (start-up costs) of $2000 and variable costs of $0.50 per item. So, total cost is C = 2000 + 0.50q. Therefore, profit π is total revenue minus total cost: π = R - C = (2q - q²/10,000) - (2000 + 0.50q) = 2q - q²/10,000 - 2000 - 0.50q Simplify: π = (2q - 0.50q) - q²/10,000 - 2000 = 1.50q - q²/10,000 - 2000. So, profit as a function of quantity q is π(q) = - (q²)/10,000 + 1.50q - 2000. To maximize profit, we need to find the value of q that maximizes π(q). Since this is a quadratic function with a negative coefficient on q², it opens downward, so the maximum is at the vertex. The vertex of a quadratic function ax² + bx + c is at x = -b/(2a). Here, a = -1/10,000 and b = 1.50. Therefore, the quantity that maximizes profit is: q = -b/(2a) = -1.50 / (2*(-1/10,000)) = -1.50 / (-2/10,000) = (1.50 * 10,000)/2 = (15,000)/2 = 7,500. So, the profit-maximizing quantity is 7,500 items. Then, the corresponding price can be found from the inverse demand function p = 2 - q/10,000 = 2 - 7,500/10,000 = 2 - 0.75 = $1.25 per item. Let me verify that. So, at q = 7500, p = $1.25. Then, total revenue R = p*q = 1.25 * 7500 = $9,375. Total cost C = 2000 + 0.50*7500 = 2000 + 3750 = $5,750. Profit π = 9,375 - 5,750 = $3,625. Is this the maximum profit? Let's check another point. Suppose q = 7000. Then, p = 2 - 7000/10,000 = 2 - 0.7 = $1.30. Revenue = 1.30 * 7000 = $9,100. Cost = 2000 + 0.50*7000 = 2000 + 3500 = $5,500. Profit = 9,100 - 5,500 = $3,600, which is less than $3,625. Similarly, q = 8000, which would be p = 2 - 8000/10,000 = 2 - 0.8 = $1.20. Revenue = 1.20 * 8000 = $9,600. Cost = 2000 + 0.50*8000 = 2000 + 4000 = $6,000. Profit = 9,600 - 6,000 = $3,600, again less than $3,625. So, 7500 seems to be the maximum. Alternatively, since we derived this using calculus (vertex of parabola), it's correct. But just to check. Alternatively, if we take derivative of π(q) with respect to q: dπ/dq = 1.50 - 2q/10,000. Set derivative equal to zero: 1.50 - (2q)/10,000 = 0 => (2q)/10,000 = 1.50 => q = (1.50 * 10,000)/2 = 7,500. So, same result. Wait, but in the original problem, they mention that for every 10 cents decrease, you can sell another 1000 items. So, starting at $1.50 with 5000 items. Then, decreasing by 10 cents increments gives 1000 more each time. So, how does it work at 7500 items? That would be an increase of 2500 items from the original 5000. Since each 10 cents decrease gives 1000 more, 2500 would be 2.5 times 10 cents. So, decrease price by 25 cents? Wait, but in the model we had, q = 20,000 - 10,000p. So, if p is $1.25, which is a $0.25 decrease from $1.50, then yes, (1.50 - 1.25)/0.10 = 2.5, so x=2.5. Then, quantity sold is 5000 + 1000*2.5 = 7500. So, even though x is 2.5, which is not an integer, the problem didn't specify that the price has to be in 10-cent increments, so allowing x to be a real number. So, in reality, you could set the price at $1.25, even though it's a 25-cent decrease, which is 2.5 times 10 cents. So, the model allows for continuous variables, which is fine. So, the conclusion is that the optimal price is $1.25 per item, selling 7500 items, resulting in a maximum profit of $3,625. Wait, let me just confirm profit calculation once again: Revenue: 7500 * 1.25 = 7500 * 1 + 7500 * 0.25 = 7500 + 1875 = 9375. Cost: 2000 + 7500 * 0.50 = 2000 + 3750 = 5750. Profit: 9375 - 5750 = 3625. Yes, that's $3,625. So, all checks out. So, the answer is price of $1.25, quantity of 7500, profit of $3,625. Final Answer The optimal price is \boxed{1.25} dollars per item, the number of items to sell is \boxed{7500}, and the maximum profit is \boxed{3625} dollars. </think> To determine the optimal price, quantity, and maximum profit for selling children's toys, we start by modeling the relationship between price and quantity sold. The market research indicates that for every $0.10 decrease in price below $1.50, the quantity sold increases by 1000 items. This results in a linear demand function. Demand Function: The price ( p ) and quantity ( q ) are related by the equation: [ q = 20,000 - 10,000p ] Solving for ( p ) gives the inverse demand function: [ p = 2 - \frac{q}{10,000} ] Profit Function: Total revenue ( R ) is given by ( R = p \times q ): [ R = \left(2 - \frac{q}{10,000}\right) q = 2q - \frac{q^2}{10,000} ] Total cost ( C ) includes fixed costs of $2000 and variable costs of $0.50 per item: [ C = 2000 + 0.50q ] Profit ( \pi ) is total revenue minus total cost: [ \pi = \left(2q - \frac{q^2}{10,000}\right) - (2000 + 0.50q) = 1.50q - \frac{q^2}{10,000} - 2000 ] Maximizing Profit: The profit function is a quadratic equation, and the maximum profit occurs at the vertex. For the quadratic equation ( \pi(q) = -\frac{q^2}{10,000} + 1.50q - 2000 ), the vertex is found at: [ q = -\frac{b}{2a} = -\frac{1.50}{2 \left(-\frac{1}{10,000}\right)} = \frac{1.50 \times 10,000}{2} = 7,500 ] Substituting ( q = 7,500 ) into the inverse demand function gives the optimal price: [ p = 2 - \frac{7,500}{10,000} = 2 - 0.75 = 1.25 ] Calculating Maximum Profit: Total revenue at ( q = 7,500 ) and ( p = 1.25 ): [ R = 1.25 \times 7,500 = 9,375 ] Total cost: [ C = 2000 + 0.50 \times 7,500 = 2000 + 3750 = 5,750 ] Maximum profit: [ \pi = 9,375 - 5,750 = 3,625 ] Final Answer The optimal price is \boxed{1.25} dollars per item, the number of items to sell is \boxed{7500}, and the maximum profit is \boxed{3625} dollars. Token used: 3399 (10017 characters) Conclusion As you can see the various steps logically laid out where the model uses its knowledge of the worlds (profits = sales - cost), generates an algebraic function to link the behavior of various variables and then uses calculus to maximize the profit function to arrive at the right price and quantity for maximum profit. Resources Reasoning models on OpenAI - https://platform.openai.com/docs/guides/reasoning Bring your own models on AI Toolkit - using Ollama and API keys Building Retrieval Augmented Generation on VSCode & AI ToolkitIntroducing Learn Cloud: A VS Code Extension to simplify your First Deployment to the Cloud.
Have you ever wanted to deploy your code to the cloud, but felt overwhelmed by the complexity and options? Do you wish there was a way to learn the basics of cloud computing while working on your own project? Whether you have an existing codebase or you want to start from a beginner friendly starter project, Learn Cloud will help you get your app up and running in the cloud in minutes.Supercharge Your Dev Workflows with GitHub Copilot Custom Skills
The Problem Every team has those repetitive, multi-step workflows that eat up time: Running a sequence of CLI commands, parsing output, and generating a report Querying multiple APIs, correlating data, and summarizing findings Executing test suites, analyzing failures, and producing actionable insights You've probably documented these in a wiki or a runbook. But every time, you still manually copy-paste commands, tweak parameters, and stitch results together. What if your AI coding assistant could do all of that — triggered by a single natural language request? That's exactly what GitHub Copilot Custom Skills enable. What Are Custom Skills? A skill is a folder containing a SKILL.md file (instructions for the AI), plus optional scripts, templates, and reference docs. When you ask Copilot something that matches the skill's description, it loads the instructions and executes the workflow autonomously. Think of it as giving your AI assistant a runbook it can actually execute, not just read. Without Skills With Skills Read the wiki for the procedure Copilot loads the procedure automatically Copy-paste 5 CLI commands Copilot runs the full pipeline Manually parse JSON output Script generates a formatted HTML report 15-30 minutes of manual work One natural language request, ~2 minutes How It Works The key insight: the skill file is the contract between you and the AI. You describe what to do and how, and Copilot handles the orchestration. Prerequisites Requirement Details VS Code Latest stable release GitHub Copilot Active Copilot subscription (Individual, Business, or Enterprise) Agent mode Select "Agent" mode in the Copilot Chat panel (the default in recent versions) Runtime tools Whatever your scripts need — Python, Node.js, .NET CLI, az CLI, etc. Note: Agent Skills follow an open standard — they work across VS Code, GitHub Copilot CLI, and GitHub Copilot coding agent. No additional extensions or cloud services are required for the skill system itself. Anatomy of a Skill .github/skills/my-skill/ ├── SKILL.md # Instructions (required) └── references/ ├── resources/ │ ├── run.py # Automation script │ ├── query-template.sql # Reusable query template │ └── config.yaml # Static configuration └── reports/ └── report_template.html # Output template The SKILL.md File Every skill has the same structure: --- name: my-skill description: 'What this does and when to use it. Include trigger phrases so Copilot knows when to load it. USE FOR: specific task A, task B. Trigger phrases: "keyword1", "keyword2".' argument-hint: 'What inputs the user should provide.' --- # My Skill ## When to Use - Situation A - Situation B ## Quick Start \```powershell cd .github/skills/my-skill/references/resources py run.py <arg1> <arg2> \``` ## What It Does | Step | Action | Purpose | |------|--------|---------| | 1 | Fetch data from source | Gather raw input | | 2 | Process and transform | Apply business logic | | 3 | Generate report | Produce actionable output | ## Output Description of what the user gets back. Key Design Principles Description is discovery. The description field is the only thing Copilot reads to decide whether to load your skill. Pack it with trigger phrases and keywords. Progressive loading. Copilot reads only name + description (~100 tokens) for all skills. It loads the full SKILL.md body only for matched skills. Reference files load only when the procedure references them. Self-contained procedures. Include everything the AI needs to execute — exact commands, parameter formats, file paths. Don't assume prior knowledge. Scripts do the heavy lifting. The AI orchestrates; your scripts execute. This keeps the workflow deterministic and reproducible. Example: Build a Deployment Health Check Skill Let's build a skill that checks the health of a deployment by querying an API, comparing against expected baselines, and generating a summary. Step 1 — Create the folder structure .github/skills/deployment-health/ ├── SKILL.md └── references/ └── resources/ ├── check_health.py └── endpoints.yaml Step 2 — Write the SKILL.md --- name: deployment-health description: 'Check deployment health across environments. Queries health endpoints, compares response times against baselines, and flags degraded services. USE FOR: deployment validation, health check, post-deploy verification, service status. Trigger phrases: "check deployment health", "is the deployment healthy", "post-deploy check", "service health".' argument-hint: 'Provide the environment name (e.g., staging, production).' --- # Deployment Health Check ## When to Use - After deploying to any environment - During incident triage to check service status - Scheduled spot checks ## Quick Start \```bash cd .github/skills/deployment-health/references/resources python check_health.py <environment> \``` ## What It Does 1. Loads endpoint definitions from `endpoints.yaml` 2. Calls each endpoint, records response time and status code 3. Compares against baseline thresholds 4. Generates an HTML report with pass/fail status ## Output HTML report at `references/reports/health_<environment>_<date>.html` Step 3 — Write the script # check_health.py import sys, yaml, requests, time, json from datetime import datetime def main(): env = sys.argv[1] with open("endpoints.yaml") as f: config = yaml.safe_load(f) results = [] for ep in config["endpoints"]: url = ep["url"].replace("{env}", env) start = time.time() resp = requests.get(url, timeout=10) elapsed = time.time() - start results.append({ "service": ep["name"], "status": resp.status_code, "latency_ms": round(elapsed * 1000), "threshold_ms": ep["threshold_ms"], "healthy": resp.status_code == 200 and elapsed * 1000 < ep["threshold_ms"] }) healthy = sum(1 for r in results if r["healthy"]) print(f"Health check: {healthy}/{len(results)} services healthy") # ... generate HTML report ... if __name__ == "__main__": main() Step 4 — Use it Just ask Copilot in agent mode: "Check deployment health for staging" Copilot will: Match against the skill description Load the SKILL.md instructions Run python check_health.py staging Open the generated report Summarize findings in chat More Skill Ideas Skills aren't limited to any specific domain. Here are patterns that work well: Skill What It Automates Test Regression Analyzer Run tests, parse failures, compare against last known-good run, generate diff report API Contract Checker Compare Open API specs between branches, flag breaking changes Security Scan Reporter Run SAST/DAST tools, correlate findings, produce prioritized report Cost Analysis Query cloud billing APIs, compare costs across periods, flag anomalies Release Notes Generator Parse git log between tags, categorize changes, generate changelog Infrastructure Drift Detector Compare live infra state vs IaC templates, flag drift Log Pattern Analyzer Query log aggregation systems, identify anomaly patterns, summarize Performance Bench marker Run benchmarks, compare against baselines, flag regressions Dependency Auditor Scan dependencies, check for vulnerabilities and outdated packages The pattern is always the same: instructions (SKILL.md) + automation script + output template. Tips for Writing Effective Skills Do Front-load the description with keywords — this is how Copilot discovers your skill Include exact commands — cd path/to/dir && python script.py <args> Document input/output clearly — what goes in, what comes out Use tables for multi-step procedures — easier for the AI to follow Include time zone conversion notes if dealing with timestamps Bundle HTML report templates — rich output beats plain text Don't Don't use vague descriptions — "A useful skill" won't trigger on anything Don't assume context — include all paths, env vars, and prerequisites Don't put everything in SKILL.md — use references/ for large files Don't hardcode secrets — use environment variables or Azure Key Vault Don't skip error guidance — tell the AI what common errors look like and how to fix them Skill Locations Skills can live at project or personal level: Location Scope Shared with team? .github/skills/<name>/ Project Yes (via source control) .agents/skills/<name>/ Project Yes (via source control) .claude/skills/<name>/ Project Yes (via source control) ~/.copilot/skills/<name>/ Personal No ~/.agents/skills/<name>/ Personal No ~/.claude/skills/<name>/ Personal No Project-level skills are committed to your repo and shared with the team. Personal skills are yours and roam with your VS Code settings sync. You can also configure additional skill locations via the chat.skillsLocations VS Code setting. How Skills Fit in the Copilot Customization Stack Skills are one of several customization primitives. Here's when to use what: Primitive Use When Workspace Instructions (.github/copilot-instructions.md) Always-on rules: coding standards, naming conventions, architectural guidelines File Instructions (.github/instructions/*.instructions.md) Rules scoped to specific file patterns (e.g., all *.test.ts files) Prompts (.github/prompts/*.prompt.md) Single-shot tasks with parameterized inputs Skills (.github/skills/<name>/SKILL.md) Multi-step workflows with bundled scripts and templates Custom Agents (.github/agents/*.agent.md) Isolated subagents with restricted tool access or multi-stage pipelines Hooks (.github/hooks/*.json) Deterministic shell commands at agent lifecycle events (auto-format, block tools) Plugins Installable skill bundles from the community (awesome-copilot) Slash Commands & Quick Creation Skills automatically appear as slash commands in chat. Type / to see all available skills. You can also pass context after the command: /deployment-health staging /webapp-testing for the login page Want to create a skill fast? Type /create-skill in chat and describe what you need. Copilot will ask clarifying questions and generate the SKILL.md with proper frontmatter and directory structure. You can also extract a skill from an ongoing conversation: after debugging a complex issue, ask "create a skill from how we just debugged that" to capture the multi-step procedure as a reusable skill. Controlling When Skills Load Use frontmatter properties to fine-tune skill availability: Configuration Slash command? Auto-loaded? Use case Default (both omitted) Yes Yes General-purpose skills user-invocable: false No Yes Background knowledge the model loads when relevant disable-model-invocation: true Yes No Skills you only want to run on demand Both set No No Disabled skills The Open Standard Agent Skills follow an open standard that works across multiple AI agents: GitHub Copilot in VS Code — chat and agent mode GitHub Copilot CLI — terminal workflows GitHub Copilot coding agent — automated coding tasks Claude Code, Gemini CLI — compatible agents via .claude/skills/ and .agents/skills/ Skills you write once are portable across all these tools. Getting Started Create .github/skills/<your-skill>/SKILL.md in your repo Write a keyword-rich description in the YAML frontmatter Add your procedure and reference scripts Open VS Code, switch to Agent mode, and ask Copilot to do the task Watch it discover your skill, load the instructions, and execute Or skip the manual setup — type /create-skill in chat and describe what you need. That's it. No extension to install. No config file to update. No deployment pipeline. Just markdown and scripts, version-controlled in your repo. Custom Skills turn your documented procedures into executable AI workflows. Start with your most painful manual task, wrap it in a SKILL.md, and let Copilot handle the rest. Further Reading: Official Agent Skills docs Community skills & plugins (awesome-copilot) Anthropic reference skillsBuilding a Multi-Agent On-Call Copilot with Microsoft Agent Framework
Four AI agents, one incident payload, structured triage in under 60 seconds powered by Microsoft Agent Framework and Foundry Hosted Agents. Multi-Agent Microsoft Agent Framework Foundry Hosted Agents Python SRE / Incident Response When an incident fires at 3 AM, every second the on-call engineer spends piecing together alerts, logs, and metrics is a second not spent fixing the problem. What if an AI system could ingest the raw incident signals and hand you a structured triage, a Slack update, a stakeholder brief, and a draft post-incident report, all in under 10 seconds? That’s exactly what On-Call Copilot does. In this post, we’ll walk through how we built it using the Microsoft Agent Framework, deployed it as a Foundry Hosted Agent, and discuss the key design decisions that make multi-agent orchestration practical for production workloads. The full source code is open-source on GitHub. You can deploy your own instance with a single azd up . Why Multi-Agent? The Problem with Single-Prompt Triage Early AI incident assistants used a single large prompt: “Here is the incident. Give me root causes, actions, a Slack message, and a post-incident report.” This approach has two fundamental problems: Context overload. A real incident may have 800 lines of logs, 10 alert lines, and dense metrics. Asking one model to process everything and produce four distinct output formats in a single turn pushes token limits and degrades quality. Conflicting concerns. Triage reasoning and communication drafting are cognitively different tasks. A model optimised for structured JSON analysis often produces stilted Slack messages—and vice versa. The fix is specialisation: decompose the task into focused agents, give each agent a narrow instruction set, and run them in parallel. This is the core pattern that the Microsoft Agent Framework makes easy. Architecture: Four Agents Running Concurrently On-Call Copilot is deployed as a Foundry Hosted Agent—a containerised Python service running on Microsoft Foundry’s managed infrastructure. The core orchestrator uses ConcurrentBuilder from the Microsoft Agent Framework SDK to run four specialist agents in parallel via asyncio.gather() . All four panels populated simultaneously: Triage (red), Summary (blue), Comms (green), PIR (purple). Architecture: The orchestrator runs four specialist agents concurrently via asyncio.gather(), then merges their JSON fragments into a single response. All four agents The solution share a single Azure OpenAI Model Router deployment. Rather than hardcoding gpt-4o or gpt-4o-mini , Model Router analyses request complexity and routes automatically. A simple triage prompt costs less; a long post-incident synthesis uses a more capable model. One deployment name, zero model-selection code. Meet the Four Agents 🔍 Triage Agent Root cause analysis, immediate actions, missing data identification, and runbook alignment. suspected_root_causes · immediate_actions · missing_information · runbook_alignment 📋 Summary Agent Concise incident narrative: what happened and current status (ONGOING / MITIGATED / RESOLVED). summary.what_happened · summary.current_status 📢 Comms Agent Audience-appropriate communications: Slack channel update with emoji conventions, plus a non-technical stakeholder brief. comms.slack_update · comms.stakeholder_update 📝 PIR Agent Post-incident report: chronological timeline, quantified customer impact, and specific prevention actions. post_incident_report.timeline · .customer_impact · .prevention_actions The Code: Building the Orchestrator The entry point is remarkably concise. ConcurrentBuilder handles all the async wiring—you just declare the agents and let the framework handle parallelism, error propagation, and response merging. main.py — Orchestrator from agent_framework import ConcurrentBuilder from agent_framework.azure import AzureOpenAIChatClient from azure.ai.agentserver.agentframework import from_agent_framework from azure.identity import DefaultAzureCredential, get_bearer_token_provider from app.agents.triage import TRIAGE_INSTRUCTIONS from app.agents.comms import COMMS_INSTRUCTIONS from app.agents.pir import PIR_INSTRUCTIONS from app.agents.summary import SUMMARY_INSTRUCTIONS _credential = DefaultAzureCredential() _token_provider = get_bearer_token_provider( _credential, "https://cognitiveservices.azure.com/.default" ) def create_workflow_builder(): """Create 4 specialist agents and wire them into a ConcurrentBuilder.""" triage = AzureOpenAIChatClient(ad_token_provider=_token_provider).create_agent( instructions=TRIAGE_INSTRUCTIONS, name="triage-agent", ) summary = AzureOpenAIChatClient(ad_token_provider=_token_provider).create_agent( instructions=SUMMARY_INSTRUCTIONS, name="summary-agent", ) comms = AzureOpenAIChatClient(ad_token_provider=_token_provider).create_agent( instructions=COMMS_INSTRUCTIONS, name="comms-agent", ) pir = AzureOpenAIChatClient(ad_token_provider=_token_provider).create_agent( instructions=PIR_INSTRUCTIONS, name="pir-agent", ) return ConcurrentBuilder().participants([triage, summary, comms, pir]) def main(): builder = create_workflow_builder() from_agent_framework(builder.build).run() # starts on port 8088 if __name__ == "__main__": main() Key insight: DefaultAzureCredential means there are no API keys anywhere in the codebase. The container uses managed identity in production; local development uses your az login session. The same code runs in both environments without modification. Agent Instructions: Prompts as Configuration Each agent receives a tightly scoped system prompt that defines its output schema and guardrails. Here’s the Triage Agent—the most complex of the four: app/agents/triage.py TRIAGE_INSTRUCTIONS = """\ You are the **Triage Agent**, an expert Site Reliability Engineer specialising in root cause analysis and incident response. ## Task Analyse the incident data and return a single JSON object with ONLY these keys: { "suspected_root_causes": [ { "hypothesis": "string – concise root cause hypothesis", "evidence": ["string – supporting evidence from the input"], "confidence": 0.0 // 0-1, how confident you are } ], "immediate_actions": [ { "step": "string – concrete action with runnable command if applicable", "owner_role": "oncall-eng | dba | infra-eng | platform-eng", "priority": "P0 | P1 | P2 | P3" } ], "missing_information": [ { "question": "string – what data is missing", "why_it_matters": "string – why this data would help" } ], "runbook_alignment": { "matched_steps": ["string – runbook steps that match the situation"], "gaps": ["string – gaps or missing runbook coverage"] } } ## Guardrails 1. **No secrets** – redact any credential-like material as [REDACTED]. 2. **No hallucination** – if data is insufficient, set confidence to 0 and add entries to missing_information. 3. **Diagnostic suggestions** – when data is sparse, include diagnostic steps in immediate_actions. 4. **Structured output only** – return ONLY valid JSON, no prose. """ The Comms Agent follows the same pattern but targets a different audience: app/agents/comms.py COMMS_INSTRUCTIONS = """\ You are the **Comms Agent**, an expert incident communications writer. ## Task Return a single JSON object with ONLY this key: { "comms": { "slack_update": "Slack-formatted message with emoji, severity, status, impact, next steps, and ETA", "stakeholder_update": "Non-technical summary for executives. Focus on business impact and resolution." } } ## Guidelines - Slack: Use :rotating_light: for active SEV1/2, :warning: for degraded, :white_check_mark: for resolved. - Stakeholder: No jargon. Translate to business impact. - Tone: Calm, factual, action-oriented. Never blame individuals. - Structured output only – return ONLY valid JSON, no prose. """ Instructions as config, not code. Agent behaviour is defined entirely by instruction text strings. A non-developer can refine agent behaviour by editing the prompt and redeploying no Python changes needed. The Incident Envelope: What Goes In The agent accepts a single JSON envelope. It can come from a monitoring alert webhook, a PagerDuty payload, or a manual CLI invocation: Incident Input (JSON) { "incident_id": "INC-20260217-002", "title": "DB connection pool exhausted — checkout-api degraded", "severity": "SEV1", "timeframe": { "start": "2026-02-17T14:02:00Z", "end": null }, "alerts": [ { "name": "DatabaseConnectionPoolNearLimit", "description": "Connection pool at 99.7% on orders-db-primary", "timestamp": "2026-02-17T14:03:00Z" } ], "logs": [ { "source": "order-worker", "lines": [ "ERROR: connection timeout after 30s (attempt 3/3)", "WARN: pool exhausted, queueing request (queue_depth=847)" ] } ], "metrics": [ { "name": "db_connection_pool_utilization_pct", "window": "5m", "values_summary": "Jumped from 22% to 99.7% at 14:03Z" } ], "runbook_excerpt": "Step 1: Check DB connection dashboard...", "constraints": { "max_time_minutes": 15, "environment": "production", "region": "swedencentral" } } Declaring the Hosted Agent The agent is registered with Microsoft Foundry via a declarative agent.yaml file. This tells Foundry how to discover and route requests to the container: agent.yaml kind: hosted name: oncall-copilot description: | Multi-agent hosted agent that ingests incident signals and runs 4 specialist agents concurrently via Microsoft Agent Framework ConcurrentBuilder. metadata: tags: - Azure AI AgentServer - Microsoft Agent Framework - Multi-Agent - Model Router protocols: - protocol: responses environment_variables: - name: AZURE_OPENAI_ENDPOINT value: ${AZURE_OPENAI_ENDPOINT} - name: AZURE_OPENAI_CHAT_DEPLOYMENT_NAME value: model-router The protocols: [responses] declaration exposes the agent via the Foundry Responses API on port 8088. Clients can invoke it with a standard HTTP POST no custom API needed. Invoking the Agent Once deployed, you can invoke the agent with the project’s built-in scripts or directly via curl : CLI / curl # Using the included invoke script python scripts/invoke.py --demo 2 # multi-signal SEV1 demo python scripts/invoke.py --scenario 1 # Redis cluster outage # Or with curl directly TOKEN=$(az account get-access-token \ --resource https://ai.azure.com --query accessToken -o tsv) curl -X POST \ "$AZURE_AI_PROJECT_ENDPOINT/openai/responses?api-version=2025-05-15-preview" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "input": [ {"role": "user", "content": "<incident JSON here>"} ], "agent": { "type": "agent_reference", "name": "oncall-copilot" } }' The Browser UI The project includes a zero-dependency browser UI built with plain HTML, CSS, and vanilla JavaScript—no React, no bundler. A Python http.server backend proxies requests to the Foundry endpoint. The empty state. Quick-load buttons pre-populate the JSON editor with demo incidents or scenario files. Demo 1 loaded: API Gateway 5xx spike, SEV3. The JSON is fully editable before submitting. Agent Output Panels Triage: Root causes ranked by confidence. Evidence is collapsed under each hypothesis. Triage: Immediate actions with P0/P1/P2 priority badges and owner roles. Comms: Slack card with emoji substitution and a stakeholder executive summary. PIR: Chronological timeline with an ONGOING marker, customer impact in a red-bordered box. Performance: Parallel Execution Matters Incident Type Complexity Parallel Latency Sequential (est.) Single alert, minimal context (SEV4) Low 4–6 s ~16 s Multi-signal, logs + metrics (SEV2) Medium 7–10 s ~28 s Full SEV1 with long log lines High 10–15 s ~40 s Post-incident synthesis (resolved) High 10–14 s ~38 s asyncio.gather() running four independent agents cuts total latency by 3–4× compared to sequential execution. For a SEV1 at 3 AM, that’s the difference between a 10-second AI-powered head start and a 40-second wait. Five Key Design Decisions Parallel over sequential Each agent is independent and processes the full incident payload in isolation. ConcurrentBuilder with asyncio.gather() is the right primitive—no inter-agent dependencies, no shared state. JSON-only agent instructions Every agent returns only valid JSON with a defined schema. The orchestrator merges fragments with merged.update(agent_output) . No parsing, no extraction, no post-processing. No hardcoded model names AZURE_OPENAI_CHAT_DEPLOYMENT_NAME=model-router is the only model reference. Model Router selects the best model at runtime based on prompt complexity. When new models ship, the agent gets better for free. DefaultAzureCredential everywhere No API keys. No token management code. Managed identity in production, az login in development. Same code, both environments. Instructions as configuration Each agent’s system prompt is a plain Python string. Behaviour changes are text edits, not code logic. A non-developer can refine prompts and redeploy. Guardrails: Built into the Prompts The agent instructions include explicit guardrails that don’t require external filtering: No hallucination: When data is insufficient, the agent sets confidence: 0 and populates missing_information rather than inventing facts. Secret redaction: Each agent is instructed to redact credential-like patterns as [REDACTED] in its output. Mark unknowns: Undeterminable fields use the literal string "UNKNOWN" rather than plausible-sounding guesses. Diagnostic suggestions: When signal is sparse, immediate_actions includes diagnostic steps that gather missing information before prescribing a fix. Model Router: Automatic Model Selection One of the most powerful aspects of this architecture is Model Router. Instead of choosing between gpt-4o , gpt-4o-mini , or o3-mini per agent, you deploy a single model-router endpoint. Model Router analyses each request’s complexity and routes it to the most cost-effective model that can handle it. Model Router insights: models selected per request with associated costs. Model Router telemetry from Microsoft Foundry: request distribution and cost analysis. This means you get optimal cost-performance without writing any model-selection logic. A simple Summary Agent prompt may route to gpt-4o-mini , while a complex Triage Agent prompt with 800 lines of logs routes to gpt-4o all automatically. Deployment: One Command The repo includes both azure.yaml and agent.yaml , so deployment is a single command: Deploy to Foundry # Deploy everything: infra + container + Model Router + Hosted Agent azd up This provisions the Foundry project resources, builds the Docker image, pushes to Azure Container Registry, deploys a Model Router instance, and creates the Hosted Agent. For more control, you can use the SDK deploy script: Manual Docker + SDK deploy # Build and push (must be linux/amd64) docker build --platform linux/amd64 -t oncall-copilot:v1 . docker tag oncall-copilot:v1 $ACR_IMAGE docker push $ACR_IMAGE # Create the hosted agent python scripts/deploy_sdk.py Getting Started Quickstart # Clone git clone https://github.com/microsoft-foundry/oncall-copilot cd oncall-copilot # Install python -m venv .venv source .venv/bin/activate # .venv\Scripts\activate on Windows pip install -r requirements.txt # Set environment variables export AZURE_OPENAI_ENDPOINT="https://<account>.openai.azure.com/" export AZURE_OPENAI_CHAT_DEPLOYMENT_NAME="model-router" export AZURE_AI_PROJECT_ENDPOINT="https://<account>.services.ai.azure.com/api/projects/<project>" # Validate schemas locally (no Azure needed) MOCK_MODE=true python scripts/validate.py # Deploy to Foundry azd up # Invoke the deployed agent python scripts/invoke.py --demo 1 # Start the browser UI python ui/server.py # → http://localhost:7860 Extending: Add Your Own Agent Adding a fifth agent is straightforward. Follow this pattern: Create app/agents/<name>.py with a *_INSTRUCTIONS constant following the existing pattern. Add the agent’s output keys to app/schemas.py . Register it in main.py : main.py — Adding a 5th agent from app.agents.my_new_agent import NEW_INSTRUCTIONS new_agent = AzureOpenAIChatClient( ad_token_provider=_token_provider ).create_agent( instructions=NEW_INSTRUCTIONS, name="new-agent", ) workflow = ConcurrentBuilder().participants( [triage, summary, comms, pir, new_agent] ) Ideas for extensions: a ticket auto-creation agent that creates Jira or Azure DevOps items from the PIR output, a webhook adapter agent that normalises PagerDuty or Datadog payloads, or a human-in-the-loop agent that surfaces missing_information as an interactive form. Key Takeaways for AI Engineers The multi-agent pattern isn’t just for chatbots. Any task that can be decomposed into independent subtasks with distinct output schemas is a candidate. Incident response, document processing, code review, data pipeline validation—the pattern transfers. Microsoft Agent Framework gives you ConcurrentBuilder for parallel execution and AzureOpenAIChatClient for Azure-native auth—you write the prompts, the framework handles the plumbing. Foundry Hosted Agents let you deploy containerised agents with managed infrastructure, automatic scaling, and built-in telemetry. No Kubernetes, no custom API gateway. Model Router eliminates the model selection problem. One deployment name handles all scenarios with optimal cost-performance tradeoffs. Prompt-as-config means your agents are iterable by anyone who can edit text. The feedback loop from “this output could be better” to “deployed improvement” is minutes, not sprints. Resources Microsoft Agent Framework SDK powering the multi-agent orchestration Model Router Automatic model selection based on prompt complexity Foundry Hosted Agents Deploy containerised agents on managed infrastructure ConcurrentBuilder Samples Official agents-in-workflow sample this project follows DefaultAzureCredential Zero-config auth chain used throughout Hosted Agents Concepts Architecture overview of Foundry Hosted Agents The On-Call Copilot sample is open source under the MIT licence. Contributions, scenario files, and agent instruction improvements are welcome via pull request.
