Copilot Chat: Actions via API & MCP

Key insights

• Declarative agents: These agents use configuration and manifests instead of full custom code to define behavior.
  In the demo, the presenter shows how declarative agents can run real actions, not just answer questions.
• API plugins: API plugins let an agent call REST endpoints described with OpenAPI to read and write data.
  They work well for connecting to business systems and internal services in real time.
• Model Context Protocol (MCP): MCP exposes resources (files, responses), callable tools, and reusable prompts to agents.
  When the MCP server updates, those changes can appear in the agent dynamically, reducing manual upkeep.
• Microsoft 365 Agents Toolkit: The toolkit (used in Visual Studio Code) scaffolds agents and generates manifest and plugin files automatically.
  It speeds development and cuts configuration errors by writing the plumbing for you.
• Dynamic tool discovery: With MCP, tools and resources can change on the server and become available to Copilot Studio without redeploying the agent.
  This keeps agents aligned with live systems and lowers maintenance effort.
• Interactive UI widgets: The demo shows agents rendering richer interfaces (inline or full-screen) using the OpenAI Apps SDK and MCP-based actions.
  That enables practical experiences like approval forms and data-entry screens inside Copilot.

Overview of the Demo

The Microsoft YouTube video, presented by Sébastien Levert and published by Microsoft, demonstrates how to extend Copilot Chat declarative agents with real actions. Moreover, the demo comes from a Microsoft 365 & Power Platform community call and focuses on practical ways to connect agents to live systems. In addition, the presenter shows how to move beyond read-only scenarios so agents can query, create, and update data in external systems.

Furthermore, the session explains two main extensibility paths: API plugins and the MCP, or Model Context Protocol. As a result, developers can choose an approach that fits their environment and security model. Consequently, the demo serves as a roadmap for building agents that do more than respond to prompts.

What the Demo Shows

First, the demo walks through using the Microsoft 365 Agents Toolkit to scaffold a declarative agent and link it to services. Then, the presenter demonstrates how the toolkit can generate manifest files and plugin specifications automatically, saving manual configuration time. Additionally, the video highlights how the agent can call REST endpoints described by OpenAPI to interact with conventional business systems.

Next, the demo shifts to showing how an MCP server can publish tools, resources, and prompts that agents consume dynamically. Moreover, viewers see interactive examples where agents use server-published tools to retrieve live context and perform actions. In turn, this makes the agent feel more like an integrated assistant that can take concrete steps on behalf of a user.

Technical Paths: API Plugins and MCP

API plugins let agents call REST APIs described by OpenAPI, which makes them a natural fit for existing service endpoints. For instance, when an organization already exposes internal APIs, plugins provide a direct way for agents to read and write data. Meanwhile, the tooling around plugin metadata, app manifests, and action references helps keep integrations consistent.

On the other hand, MCP emphasizes dynamic discovery by exposing resources, callable tools, and reusable prompts from a server. Consequently, when the server updates its tools or resources, connected agents can reflect those changes without manual redeployments. Furthermore, the combination of MCP and the OpenAI Apps SDK enables richer UI widgets inside Copilot, such as approval forms or interactive dashboards.

Benefits and Tradeoffs

One clear benefit is developer productivity: the toolkit automates plumbing tasks like manifest updates and plugin scaffolding, so teams can iterate faster. However, faster setup may also hide important configuration details, which means teams must still validate security, permissions, and data handling. Therefore, this approach speeds development but also requires careful governance to avoid mistakes.

Moreover, dynamic tool discovery through MCP reduces maintenance overhead because server changes propagate to agents automatically. Yet, this dynamism carries tradeoffs in testing and stability since runtime changes can introduce unexpected behavior. Thus, teams need stronger staging and monitoring practices to balance agility with reliability.

Challenges and Best Practices

Security and permissions are primary challenges when enabling agents to act on data. For example, agents that can create or update records must operate under strict identity and consent rules, and teams must design authorization flows carefully. Additionally, error handling becomes more important because any external call can fail due to network, API changes, or rate limits.

Another challenge is user experience: richer UI widgets improve usability, but they also add complexity to design and testing. Consequently, teams must decide how much of the interaction lives in Copilot UI versus managed applications. Finally, monitoring and observability must be built into any production deployment so teams can trace agent actions and recover from mistakes quickly.

Implications for Developers and Organizations

For developers, the demo makes clear that both API plugins and MCP are viable depending on existing architecture and governance needs. Therefore, small teams with simple APIs may prefer plugins, while larger organizations with many evolving tools may gain from MCP’s dynamic model. In either case, the choice affects testing, deployment, and operational responsibilities.

For organizations, the takeaway is to balance agility with control: the new tooling speeds integration, but it demands robust security, monitoring, and change management. Consequently, teams should pilot integrations in controlled environments, iterate on authorization and UX, and adopt observability practices before broad rollout. Overall, the Microsoft demo charts a practical path forward while also highlighting the careful tradeoffs teams must manage.

Keywords

Copilot Chat declarative agent, Copilot actions and API plugins, MCP Copilot integration, extend Copilot with actions, custom API plugins for Copilot, Copilot developer guide, declarative agent tutorial, Microsoft Copilot extensibility