Copilot Chat: Declarative Agent Setup

Key insights

• Declarative agents let organizations create tailored Copilot assistants by using manifest files (JSON/YAML) instead of custom code.
  They run on the same Sydney orchestrator used by Microsoft’s first-party agents and can reason over enterprise data and perform actions.
• Agent Builder and Visual Studio Code (with the Microsoft 365 Agents Toolkit) are the main tools to configure, test, and refine agents; this workflow was demonstrated by Sébastien Levert in a VS Code demo.
  Use the built-in test chat to try prompts and handle edge cases before deployment.
• Knowledge sources ground agent responses in enterprise content such as SharePoint, Teams chats, Outlook, and public URLs; choose focused, current documents to improve accuracy.
  Prioritize relevant files and avoid overloading the agent with large, unfocused data sets.
• Capabilities enable built-in AI skills like Code Interpreter for Python execution and Image Generator for visuals; turn on only the skills that match the agent’s purpose.
  Keep instructions and conversation starters clear to guide user interactions.
• Actions and APIs connect agents to external systems via Copilot connectors, custom web APIs, or Power Platform; define these with an OpenAPI spec and mark risky operations using isConsequential to require extra care.
  Test all action flows thoroughly to prevent unintended changes.
• Connected agents can call each other by including title IDs in manifests; interactions are text-only and driven by descriptive metadata.
  Admins manage availability, store settings, and advanced feature billing from the Microsoft 365 admin center.

Overview of the Video Demonstration

The Microsoft-produced video features Sébastien Levert demonstrating how to configure declarative agents for Copilot Chat using VS Code. In the walkthrough, he shows how to enable embedded knowledge, activate the Code Interpreter, and add an Image Generator capability so an agent can become a context-aware assistant. Consequently, the demo aims to take a basic agent manifest and turn it into a tool that can read enterprise content, run code, and produce images as needed.

Key Capabilities Highlighted

First, Levert explains how to ground responses in enterprise content by pointing agents to knowledge sources such as document libraries and public URLs. He emphasizes using focused, up-to-date files so the agent answers remain relevant and accurate, and he tests those sources in the built-in test chat to validate behavior. Moreover, the presentation clarifies how to declare optional built-in skills like the Code Interpreter when data analysis is part of the agent’s role.

Next, the demo covers how to attach actions using OpenAPI-style definitions to let agents call external systems safely. Levert recommends marking risky operations as consequential so the agent treats them with extra caution, and he shows how to wire up connectors for common workflows. In addition, he describes linking agents together by referencing title IDs so they can call on each other for specialized tasks.

How Configuration Works in Practice

Levert walks viewers through editing the agent manifest and using the Microsoft 365 Agents Toolkit in VS Code to scaffold and test components quickly. He demonstrates creating the app manifest, adding the declarative agent manifest, and optionally including a plugin manifest for extended features, which makes the setup repeatable and easier to maintain. As a result, teams can iterate fast: change the manifest, test in the Agent Builder, and then refine prompts and instructions based on observed conversations.

Furthermore, he shows practical tuning techniques such as providing explicit conversation starters and sample prompts so the agent understands its role and scope. He suggests avoiding too many large documents in knowledge sources to reduce noise and to prioritize the most concise, authoritative content. Thus, the recommended workflow balances quick experimentation with careful curation of the agent’s inputs.

Tradeoffs to Consider

While declarative agents simplify customization without heavy coding, they also create tradeoffs around control and complexity. On one hand, using manifests and no-code tools speeds deployment and reduces developer burden; on the other hand, complex behaviors still require careful design and testing to prevent unwanted actions. Therefore, organizations must weigh the speed of declarative setup against the need for rigorous validation, especially when agents can trigger consequential operations.

Another tradeoff concerns cost and data surface area: basic grounding is low cost, but integrating enterprise connectors and SharePoint can introduce tenant-level consumption charges and broaden data exposure. At the same time, richer capabilities like code execution or image generation increase utility but raise governance and security questions. Consequently, administrators must plan tenant settings and billing controls alongside capability enablement to keep risk in check.

Challenges and Practical Limitations

Levert points out several real-world challenges such as handling ambiguous queries, preventing hallucinations, and managing connected agent selection when multiple options exist. Moreover, because connected agents communicate via text and choose by metadata, teams need to write clear names, descriptions, and starters to ensure the right agent answers a request. In practice, this requires an ongoing effort to refine prompts and maintain metadata so the auto-selection mechanism works reliably.

Testing edge cases also proves essential: the demo shows how to simulate irrelevant or adversarial inputs to see how the agent reacts. Additionally, teams should flag operations that change external systems and build safety checks so the agent asks for confirmation or routes tasks to humans. Therefore, successful deployment blends automated capability with human governance and thorough testing.

What Organizations Should Take Away

Overall, the video offers a hands-on guide to making Copilot Chat agents more capable without heavy engineering, while also highlighting where caution is necessary. Teams can adopt the shown patterns to speed up useful assistants, yet they must invest time in knowledge curation, action gating, and billing governance to avoid surprises. Ultimately, the demo suggests a practical path: start small, validate outcomes, and expand capabilities as controls and confidence grow.

Keywords

Copilot Chat configuration, configure Copilot Chat, Copilot declarative agent, declarative agent capabilities, Copilot Chat setup guide, Microsoft Copilot declarative agents, Copilot agent configuration, Copilot Chat features