GitHub Copilot: Create VS Code Agents

Key insights

• Copilot Studio — Central design hub for agents.
  Build, edit, and test agent logic and skills visually, then link to external code in VS Code for advanced customization.
• VS Code & GitHub Copilot — Developer workflow for agent logic.
  Clone agents to VS Code, use GitHub Copilot Chat in Agent Mode to generate code, plan changes with /init and /plan commands, then sync back to Copilot Studio.
• Work IQ & MCP — Context and connectors for real work data.
  Work IQ provides file, email, and meeting context; Model Context Protocol (MCP) adds connectors for Teams, Outlook, Word, and OneDrive so agents act on relevant content.
• Autonomous agent capabilities — Real workplace automation patterns demonstrated.
  Agents can detect selected senders, save attachments to OneDrive, edit docs based on email instructions, create professional replies, attach revised files, and post notifications to Teams.
• Testing and deployment — Iterative authoring and validation steps.
  Use Copilot Studio for quick tests and debugging, run demos from VS Code with GitHub Copilot Chat, then deploy agents with governance controls in place.
• Security and governance — Manage risk and lifecycle centrally.
  Use Copilot control systems and Microsoft 365 admin tools to enforce access, monitor agent activity, and keep agents aligned with organizational policies.

Video Overview

The YouTube video by Shervin Shaffie (Collaboration Simplified) walks viewers through how to evolve a basic Microsoft Copilot agent into a more capable autonomous solution using VS Code and GitHub Copilot. The presentation mixes hands-on code work and the visual tools in Copilot Studio, while also showing how Work IQ and the Model Context Protocol add real workplace context. Consequently, the video serves both as a tutorial and a practical demo for teams that want to automate routine processes. Moreover, Shaffie narrates the steps clearly and includes chaptered timestamps to help viewers jump to key parts of the build process.

First, the host reuses an existing agent created in the Microsoft 365 Copilot app and migrates it into Copilot Studio, then into a local development environment in VS Code. He demonstrates switching language models, adding MCP servers for Outlook, Teams, Word, and OneDrive, and configuring autonomous triggers. In addition, the video shows how to use GitHub Copilot Chat in Agent Mode to plan and implement agent behavior. Finally, the demo closes with tests that send emails, edit documents, and notify Teams so viewers see the full cycle in action.

How the Agent Is Built

Shaffie starts with the visual Agent Builder and then copies the agent into Copilot Studio to add more advanced controls, including selecting an LLM and connecting MCP tools. Then he clones the agent into VS Code to edit the agent code, use Git-based workflows, and apply GitHub Copilot suggestions for boilerplate and action logic. This hybrid approach shows how low-code and pro-code flows work together: the studio offers rapid composition while the IDE gives fine-grained control over behavior and connectors. As a result, teams can iterate quickly and keep production-quality code under source control.

Throughout the build, Shaffie emphasizes a cycle of initialize, plan, and execute commands to manage changes; for example, /init sets up the local agent and /plan outlines intended modifications. He also demonstrates syncing changes back into Copilot Studio, which preserves the visual artifact while allowing code-driven edits to persist. In addition, the use of GitHub Copilot Chat speeds up design of complex workflows and helps generate entire automation pipelines from simple plans. Overall, the process highlights how tooling integrations speed development without removing engineer oversight.

Key Capabilities Demonstrated

The demo shows an agent that autonomously detects emails from specified senders, saves attachments to OneDrive, edits documents according to instructions, drafts a professional reply, and notifies the user in Teams. Moreover, the agent leverages Work IQ to understand context across files, emails, and meetings, which helps the agent make more accurate changes and responses. Shaffie also adds MCP tools so the agent can act directly on Teams, Outlook, Word, and OneDrive resources. Consequently, viewers see a full automation pipeline that touches multiple Microsoft 365 services in a realistic scenario.

The video also highlights testing workflows in Copilot Studio and shows tips for validating agent behavior before deployment. For instance, Shaffie walks through test scenarios that confirm the agent saved attachments, performed edits, and sent the correct reply with an attached updated document. In addition, he points out how to iterate when results differ from expectations and how to adjust triggers or model parameters. Thus, testing and validation form a critical part of taking the agent from experiment to production.

Tradeoffs and Challenges

While the combined low-code and pro-code approach speeds delivery, it also introduces tradeoffs between speed and control: the visual studio lets teams build fast, but complex logic and error handling often require code-level work in VS Code. Similarly, choosing an LLM involves balancing accuracy, latency, and cost; higher-capability models improve reasoning but increase compute expense. Therefore, teams must weigh model choice against budget and response-time needs to meet operational constraints.

Security and governance also present challenges because agents access organizational data across multiple services. On one hand, broad access enables powerful automation; on the other hand, it raises risks around permissions, data leakage, and auditability. Consequently, the video stresses using governance controls, logging, and a Copilot control system to track agent lifecycles and provide needed oversight. In practice, reliable error handling and observability are essential to maintain trust in autonomous agents.

Practical Takeaways and Recommendations

For teams interested in following this path, Shaffie’s video suggests starting with a clear plan of the agent’s scope, then building iteratively: prototype in Copilot Studio, move to VS Code for custom actions, and use GitHub Copilot to accelerate coding. In addition, invest time in testing with realistic samples and set up monitoring so you can detect failures quickly. These steps help balance speed with reliability and give teams a repeatable path to production.

Finally, viewers should prepare for ongoing maintenance since agents that rely on context and external APIs need updates as data, processes, or permissions change. Therefore, keep source control, documentation, and governance practices in place to manage changes safely. In short, the video offers a practical, end-to-end pattern for building workplace agents but also makes clear that thoughtful tradeoffs and safeguards are required for safe, scalable automation.

Keywords

build copilot agents, github copilot agents, copilot agents vscode, create copilot agents tutorial, next-level copilot development, vs code github copilot integration, ai agents in vscode, copilot agent workflows