Copilot Chat: Advanced Agent Manifests

Key insights

• Demo summary: This note summarizes a community-call demo by Sébastien Levert about advanced manifest capabilities for Copilot Chat declarative agents.
  It highlights how Microsoft moves more agent behavior into the agent manifest instead of requiring custom backends.
• Core concept: A declarative agent is defined by a machine-readable manifest that lists instructions, conversation starters, actions, and the agent’s capabilities.
  The manifest tells the agent what it can access and how it should behave.
• Key capabilities: Manifests can enable features such as embedded knowledge, code interpreter (Python analysis and visuals), image generation, and connectors to enterprise data.
  Newer schema also supports connected agents so agents can call other agents when declared.
• Manifest controls: Use the manifest to set grounding sources (OneDrive, SharePoint, Dataverse, connectors), behavior overrides, disclaimers, and environment configurations to shape UX and responses.
  Agent-to-agent calls are currently text-only and can pass adaptive card data for processing.
• Benefits: Moving features into the manifest reduces custom backend work, speeds deployment, and keeps behavior transparent and centralized.
  It also enables richer grounding in enterprise data and adds analytical power through the code interpreter for math, data analysis, and visuals.
• Practical limits & governance: Capabilities require explicit declaration and appropriate permissions, and organizations must plan for security and transparency when granting data access.
  Design manifests with governance and user-facing disclaimers to control risk and expectations.

Microsoft published a demonstration video that explores the latest manifest-driven features for Copilot Chat declarative agents, and this article summarizes the key points for editorial review. The presentation, given by Sébastien Levert during a Microsoft 365 & Power Platform community call, shows practical examples of how to refine agent behavior, strengthen governance, and control user experience. Moreover, the demo highlights new manifest options such as disclaimers, behavior overrides, environment configurations, embedded knowledge, and agent-to-agent connections. The following sections break down what was shown, the implications for developers and IT teams, and the tradeoffs organizations should consider.

Video summary and context

The demo focuses on advanced manifest capabilities that let teams define richer agent behavior without building a full custom backend. Sébastien Levert walks through sample manifests and live examples to show how these capabilities change what a declarative agent can do. In addition, the session emphasizes governance controls that administrators can embed directly into the agent package. Finally, the video is positioned as a practical guide for anyone who wants to adopt manifest-driven agents within Microsoft 365.

What advanced manifest capabilities add

First, the manifest can now enable features like embedded knowledge, a code interpreter for running Python-based analysis, and graphic art or image generation from prompts. These features allow an agent to ground responses in enterprise data, run calculations and produce visuals, and even interact with other agents when explicitly declared. Moreover, manifests support connector-based grounding so agents can work with OneDrive, SharePoint, Dataverse, and other enterprise sources. As a result, teams can create specialized assistants that combine data access, computation, and creativity without writing a service for every capability.

How manifests change agent design

Importantly, Microsoft is shifting more behavior into the agent manifest itself, moving away from a model where every new feature required separate backend infrastructure. For example, the manifest now includes properties to list connected agents and to control what plugins or data sources an agent may use. Additionally, the manifest supports environment-specific configurations and explicit disclaimers that influence what the agent should say and how it should act. Consequently, developers must learn to express behavior and governance rules declaratively while preserving flexibility for runtime decisions.

Benefits and tradeoffs

The main advantage is speed and transparency: defining capabilities in a manifest reduces implementation complexity and centralizes control, which can accelerate deployment. However, this approach involves tradeoffs because moving logic into a manifest can increase manifest complexity and create a steeper learning curve for maintainers. Furthermore, while manifest-driven features simplify many scenarios, they may limit highly custom or stateful behaviors that previously relied on a backend service. Therefore, teams must weigh convenience and central governance against the need for bespoke processing or advanced integrations.

Implementation challenges and governance

From a governance perspective, manifests make it easier to declare what an agent may access, but administrators still face challenges around permissions, testing, and auditing. For instance, agent-to-agent communication is described as text-only, which creates constraints for workflows that need richer data exchange or binary artifacts. In addition, teams must design clear environment configurations and disclaimers to set user expectations and comply with policy requirements. Consequently, practical adoption requires careful planning around least-privilege access, traceability of actions, and robust testing to ensure that behavior overrides do not produce unexpected outcomes.

Practical takeaways for organizations

Organizations that want to experiment should start with sample manifests and small, controlled deployments to validate grounding sources and behavior overrides. Moreover, teams should document which capabilities are enabled and keep manifests under version control so changes are auditable and reversible. At the same time, architects must decide when to rely on manifest declarations and when a custom backend remains necessary for advanced processing or long-running tasks. Ultimately, the demo shows that manifest-driven agents can reduce friction and improve governance, but success requires careful balancing of control, flexibility, and operational complexity.

Keywords

Copilot Chat declarative agent, advanced manifest capabilities, Copilot manifest schema, declarative agent tutorials, Copilot extensibility manifest, AI agent manifest best practices, building declarative agents Copilot, Microsoft Copilot agent development