How to Build a Multi-Agent Solution in Copilot Studio for AB-620 (2026 Hands-On Guide)

Last Updated: June 2026

TL;DR: A Copilot Studio multi-agent solution links a primary orchestrator agent to child agents, connected agents, MCP tools and external agents over the Agent2Agent (A2A) protocol. This capability sits in the domain that carries 40 to 45 percent of the AB-620 exam. This guide builds one step by step and flags every preview feature so you study the right thing.

Multi-agent design is the single most heavily weighted skill on Microsoft's newest agent-building certification, and it is also the one candidates practise least. Exam AB-620 leads to the Microsoft Certified: AI Agent Builder Associate credential, whose official exam title is "Designing and Building Integrated AI Solutions in Copilot Studio" [1]. Reading about orchestration is not the same as wiring it up, and the exam rewards people who have actually built the thing.

This hands-on guide walks through building a working multi-agent solution in Microsoft Copilot Studio: a primary orchestrator agent, an extended tool connected over the Model Context Protocol (MCP), a delegated child or connected agent, and an external agent reached through the Agent2Agent (A2A) protocol. Every step is checked against Microsoft Learn and the official AB-620 skills outline, and every preview-only feature is marked so you do not over-rely on it on exam day. When you are planning your wider certification path, you can browse Examinotion's Microsoft AI exam preparation courses.

What AB-620 Tests About Multi-Agent Solutions

AB-620 is an intermediate, associate-level certification for professional developers and advanced makers who build, extend and integrate custom agents for enterprise use [1]. The exam went into beta on 21 April 2026 and reached general availability in June 2026, which makes it one of the freshest credentials in Microsoft's AI portfolio [1]. It runs for 120 minutes, the passing score is 700 out of 1000, the standard fee is USD 165, and at launch it is delivered in English only [1].

The exam is organised into three skill domains, and their weightings tell you exactly where to spend your study time. The table below is taken verbatim from the official Microsoft Learn study guide [2].

Multi-agent collaboration lives inside that 40 to 45 percent domain, which is the largest of the three. Within "Integrate and extend agents in Copilot Studio", Microsoft lists a sub-section called "Configure multi-agent collaboration from Copilot Studio" with five named skills [2]:

• Design multi-agent solutions in Copilot Studio
• Integrate a Microsoft Foundry agent
• Integrate an existing agent in Copilot Studio
• Integrate a Fabric data agent
• Create a multi-agent solution by using the A2A protocol

The same domain also covers adding tools to agents, including configuring MCP tools and configuring computer use [2]. In other words, the build skills in this guide are not a sideshow, they are the heart of the exam. If you want the full exam-level overview before you start building, read our AB-620 exam guide, then come back here for the hands-on work.

Multi-Agent Building Blocks in Copilot Studio

Before building anything, get the vocabulary right, because Microsoft uses precise terms and the exam tests whether you know the difference. Microsoft Copilot Studio is the platform you build in, and it was formerly called Power Virtual Agents, so ignore any older "PVA" references you find in training material. A multi-agent solution in Copilot Studio is a primary agent that delegates parts of a request to other agents or tools rather than trying to do everything itself.

There are two ways one agent works with another inside Copilot Studio, and they are not interchangeable [3]:

• Child agents, also called inline agents, are lightweight agents created within a parent agent. They share the parent's context and behave like reusable subroutines for small, well-defined jobs.
• Connected agents are separate, fully featured agents with their own orchestration, tools and knowledge. The main agent delegates a slice of the request to them and resumes when they finish.

A connected agent can be another Copilot Studio agent in the same environment, or it can be an external agent reached through one of four channels [3]. The table below summarises the building blocks, their correct names and their release status as of June 2026, because mixing up generally available and preview features is an easy way to lose marks.

Multi-agent design is powerful, but it is not always the right answer. Microsoft's own guidance is blunt on this point. As the documentation puts it, "Multi-agent orchestration can be powerful, but it's not always necessary and you should consider carefully before adopting a multi-agent approach to your solution" [3]. A useful rule of thumb from the same page is that a single agent's routing quality degrades once it has more than 30 to 40 choices of action across its tools, topics and connected agents, which is the signal to split work into separate agents [3]. Expect the exam to test that judgement, not just the mechanics.

Before You Start: Prerequisites and Environment

You cannot build along with this guide without the right environment, and the exam expects you to know what that environment is. At minimum you need a Microsoft Power Platform environment, which includes Microsoft Dataverse, plus permission to create solutions and agents in it. A developer or sandbox environment is ideal for practice so you do not affect production data.

Licensing changed in a way that trips up older study notes, so get it current. Copilot Studio is metered in Copilot Credits, not "messages", a change Microsoft made on 1 September 2025 [11]. Any guide that still talks about a "messages" allowance is out of date. The prepaid pack is USD 200 per month for 25,000 Copilot Credits, and there is also a pay-as-you-go option billed through an Azure subscription [11]. A free Copilot Studio user licence lets you build and test agents in the test pane, but you cannot publish an agent on a trial licence alone [11].

One platform setting underpins almost everything in this guide: generative orchestration. Generative orchestration is the mode where the agent uses a language model to decide, turn by turn, which tools, topics or connected agents best match the user's intent. It must be switched on before you can add MCP tools or computer use, and it is what lets a primary agent route intelligently to connected agents [5]. Enable it early, under the agent's settings, so the later steps work.

For the external integrations you will also need a few extras: an MCP server that supports Streamable HTTP transport, an external agent exposing an A2A-compliant endpoint, or a Microsoft Foundry project and agent identifier if you experiment with the preview Foundry path [4][5][8]. If you have only ever built a single agent before, our walkthrough on building custom agents in Copilot Studio for AB-730 is a gentler on-ramp to the basics this guide assumes.

Step 1: Build Your Primary Orchestrator Agent

The orchestrator is the agent users talk to, and its job is to understand intent and route work to the right place. Start at copilotstudio.microsoft.com and sign in with your work account. On the Home page, describe in natural language what the agent should do, up to 1,024 characters, and Copilot Studio drafts a name, description and instructions and suggests knowledge and tools for you [10].

Once the agent is provisioned, the Overview page becomes your configuration hub, showing the name, description, instructions, triggers, knowledge and tools in one place [10]. Spend your time on the instructions, because they are the most important lever over agent behaviour. Tell the orchestrator clearly what it handles directly and what it should hand off, for example: "For billing questions, delegate to the Billing agent. For IT support, delegate to the IT agent."

Add any knowledge the orchestrator needs itself through the Knowledge section, which supports websites, SharePoint, Dataverse, public documents and enterprise connectors, with Azure AI Search available for more advanced retrieval [2]. If you want to understand how Copilot grounds answers in your data before you wire knowledge in, our explainer on how Microsoft 365 Copilot works covers grounding and the semantic index in plain terms.

Now enable generative orchestration in the agent's settings, then test the bare orchestrator in the Test your agent panel on the right before adding any complexity. Getting a clean baseline first means that when you add tools and sub-agents, you can tell what changed. Build incrementally, because debugging a four-component multi-agent solution all at once is miserable.

Step 2: Add an MCP Tool to Extend Your Agent

The Model Context Protocol (MCP) is an open standard that lets your agent reach external tools and data through a single connection rather than a bespoke integration for each one. When an agent connects to an MCP server, it can use the server's tools, which are functions the model can call, and its resources, which are file-like data the agent reads for context [5]. Copilot Studio supports MCP tools and resources only; it does not yet support MCP "prompts", so do not claim it does on the exam [5].

MCP reached general availability in Copilot Studio on 29 May 2025 [6]. As Microsoft's Zankar Desai put it in the launch announcement, "With MCP, you can add AI apps and agents into Copilot Studio with just a few clicks, empowering makers to seamlessly integrate Copilot Studio with existing knowledge sources and APIs" [6]. Two currency facts matter for the exam: generative orchestration must be enabled first, and only Streamable HTTP transport is supported because SSE transport was deprecated and dropped after August 2025 [5].

To add an MCP server to your orchestrator, follow these steps [5][13]:

1. Open the Tools page for your agent.
2. Select Add a tool, then New tool.
3. Choose Model Context Protocol. The MCP onboarding wizard opens.
4. Enter the Server name, Server description and Server URL.
5. Choose the authentication type: None, API key, or OAuth 2.0.
6. Select Create, then create or select a connection.
7. Select Add to agent.

The tools and resources the server publishes become available to the agent automatically, and if the server adds or removes a tool, Copilot Studio reflects the change dynamically without you re-importing anything [5]. Test a prompt that should trigger the new tool, and confirm in the test panel's activity map that the agent actually called it.

Step 3: Add a Connected Agent and Configure Delegation

With a working orchestrator, you can now hand off specialised work to another agent. From the Agents page of your main agent, select Add an agent, and choose whether to create a child agent, connect to another Copilot Studio agent in the same environment, or connect to an external agent [3]. For a first multi-agent solution, connecting a second Copilot Studio agent in the same environment is the most reliable path, and it is generally available rather than preview.

Delegation in generative orchestration is driven by descriptions, not by hard-coded rules. The orchestrator reads its own instructions and each connected agent's description, then routes the user's request to whichever agent best matches the intent [3]. This is why vague descriptions are the most common cause of bad routing. Give each sub-agent a distinct, specific description such as "Handles refunds, invoices and payment queries", not "Helps customers", so the orchestrator can tell them apart.

You can also force a handoff explicitly from inside a conversation flow. Within a topic, choose Add node, then Add an agent, to insert an agent redirect node; after the sub-agent finishes, the original topic resumes where it left off [3]. Use explicit redirects when a particular conversation step must always go to a particular agent, and rely on generative orchestration when routing should adapt to what the user actually asks.

Every connected and child agent appears on the Agents page with an Enabled toggle, so you can switch a sub-agent off without deleting it while you debug [3]. Test the full path now: ask the orchestrator something only the sub-agent can answer, and confirm the hand-off and the return both happen cleanly in the test panel.

Step 4: Connect an External Agent with the A2A Protocol

The Agent2Agent (A2A) protocol is the open standard for letting your Copilot Studio agent delegate work to an agent built and hosted somewhere else entirely. A2A defines a standard contract for agent communication, so an orchestrator can send a task to an external agent, pass rich structured metadata and full chat history, and receive a predictable response [4]. As Microsoft's documentation frames the difference from a plain connector, "By using A2A, Copilot Studio can delegate tasks to another agent, not just call APIs" [4].

A2A reached general availability in April 2026 [7]. Use it when the agent you want to reach runs on an external framework, lives outside Copilot Studio, and has its own domain-specific reasoning, because A2A supports multi-turn interactions and contextual metadata that HTTP connectors cannot carry [4]. To connect an external A2A agent [4]:

1. On the Agents page, select Add an agent.
2. Choose Connect to an external agent, then Agent2Agent.
3. Enter the A2A agent's endpoint URL, which is the message endpoint, not the agent card URL.
4. Copilot Studio pulls the name and description from the agent card at [endpoint]/.well-known/agent.json if one exists.
5. Select the authentication method: None, API key, or OAuth 2.0.
6. Select Create, then select or create a connection.
7. Select Add and configure.

Be precise about one distinction the exam likes to probe: A2A is for external agents that implement the open standard, whereas connecting to another Copilot Studio agent in the same environment uses the simpler internal path from Step 3, not A2A [3][4]. Both are generally available, but they are different mechanisms for different situations.

Two further external paths exist but are public preview as of June 2026, so treat them as awareness-level knowledge rather than production tools. Connecting a Microsoft Foundry agent lets you bring in an agent built in the new Microsoft Foundry portal, identified by its agent ID, and the documentation page is explicitly titled with a preview label [8]. Connecting a Fabric data agent brings in a Microsoft Fabric analytics agent, also in preview, with limitations such as not being usable from a redirect node [3]. Know that they exist and that they are preview; do not assume preview behaviour on the exam.

Step 5: Test Your Multi-Agent Flow

Testing is its own exam domain, worth 20 to 25 percent, so do not treat it as an afterthought [2]. While building, the Test your agent panel on the right of the authoring canvas gives you a live conversation plus an activity map showing which tool, topic or connected agent handled each turn. Use the activity map to confirm the orchestrator routed to the agent or tool you expected, because a plausible-looking answer can still come from the wrong component.

For repeatable evaluation, AB-620 expects you to know test sets. The study guide lists "Create a test set", "Choose an evaluation method" and "Review test results" as named skills [2]. A test set is a saved collection of inputs and expected behaviours you can run again after each change, which is how you catch a routing regression before your users do. This matters more in multi-agent solutions, where a small description tweak on one sub-agent can quietly re-route traffic across the whole system.

Finish by exercising every path end to end: a question the orchestrator answers itself, one that triggers the MCP tool, one that delegates to the connected agent, and one that reaches the external A2A agent. A multi-agent solution is only as trustworthy as its least-tested hand-off, and the exam scenarios are written around exactly these seams.

Common Multi-Agent Mistakes That Cost Exam Marks

Most lost marks on this domain come from a handful of avoidable errors. Watch for these.

• Vague agent descriptions. Generative orchestration routes on descriptions, so "Helps users" produces unpredictable hand-offs. Write specific, distinct descriptions for every sub-agent [3].
• Building one giant agent. Past roughly 30 to 40 actions, a single agent's routing degrades, and the fix is to split into connected agents, not to add more tools [3].
• Confusing A2A with internal connections. A2A is for external standard-compliant agents; another Copilot Studio agent in the same environment uses the internal path. They are different mechanisms [3][4].
• Treating preview features as GA. Microsoft Foundry agent and Fabric data agent integrations are public preview, with real limitations. Do not assume production behaviour [8].
• Forgetting generative orchestration. MCP tools and computer use will not work until generative orchestration is enabled on the agent [5].
• Quoting deprecated transport. MCP in Copilot Studio uses Streamable HTTP only; SSE was dropped after August 2025 [5].
• Saying "messages" instead of Copilot Credits. Billing moved to Copilot Credits on 1 September 2025, and the exam uses current terminology [11].

How This Maps to the AB-620 Exam, and How to Practise

Be honest with yourself about difficulty: AB-620 is an associate-level developer exam, and the multi-agent domain rewards hands-on experience far more than memorisation. The questions in this area tend to be scenario-based, asking which integration path fits a described situation, so knowing the difference between a child agent, a connected agent, an A2A connection and an MCP tool is worth more than reciting a definition. There is no substitute for building a small multi-agent solution yourself, exactly as in the five steps above.

Microsoft provides an official learning path for this material, titled "Design and build multi-agent solutions in Microsoft Copilot Studio", with modules on designing multi-agent solutions, delegating with child agents, building with connected agents, and building cross-platform solutions with the A2A protocol [12]. Work through it in a developer environment with the authoring canvas open beside it. One planning note: the official AB-620 practice assessment was not yet available at general availability, as Microsoft typically releases these within about eight weeks of an exam leaving beta [1].

For the wider decision of where AB-620 fits against Microsoft's other agent and Copilot certifications, our comparison of AB-620 versus AB-730 versus AB-900 lays out who each exam is for. If you are still choosing a starting point, the AB-730 AI Business Professional preparation course covers the Copilot Studio agent-building foundations that AB-620 then builds on, and our broader guide to Microsoft Copilot agents sets the business context.

Frequently Asked Questions

What is a multi-agent solution in Copilot Studio?

A multi-agent solution in Copilot Studio is a primary orchestrator agent that delegates parts of a user's request to other agents or tools instead of handling everything itself. It can route work to child agents, connected Copilot Studio agents, MCP tools, or external agents reached over the Agent2Agent (A2A) protocol, depending on the task [3].

Does AB-620 test multi-agent collaboration?

Yes. Multi-agent collaboration sits inside the "Integrate and extend agents in Copilot Studio" domain, which carries 40 to 45 percent of the AB-620 exam, the largest of its three domains. The study guide names specific skills including designing multi-agent solutions and creating one using the A2A protocol [2].

What is the difference between a child agent and a connected agent?

A child agent, also called an inline agent, is a lightweight sub-agent created inside a parent agent and sharing its context, suited to small reusable jobs. A connected agent is a separate, fully featured agent with its own orchestration, tools and knowledge that the main agent delegates work to [3].

Can Copilot Studio agents use MCP tools?

Yes. Copilot Studio agents can connect to an MCP server and use its tools and resources, a capability generally available since 29 May 2025. You must enable generative orchestration first, and the server must use Streamable HTTP transport, since SSE transport was deprecated after August 2025. MCP prompts are not yet supported [5][6].

Is the A2A protocol generally available in Copilot Studio?

Yes. The Agent2Agent (A2A) protocol reached general availability in April 2026 for connecting external agents that implement the open standard. Connecting to another Copilot Studio agent in the same environment is a different, simpler path that is also generally available, so do not confuse the two on the exam [4][7].

Are Microsoft Foundry and Fabric agent integrations production-ready?

No. As of June 2026, connecting a Microsoft Foundry agent or a Microsoft Fabric data agent to Copilot Studio is in public preview, with documented limitations. For the AB-620 exam, know that these integration paths exist and are preview-level, rather than assuming they behave like generally available features [3][8].

Conclusion

Building a multi-agent solution in Copilot Studio is the highest-value thing you can practise for AB-620, because the domain it belongs to carries more of the exam than any other. Work through the five steps in a developer environment: stand up an orchestrator, extend it with an MCP tool, delegate to a connected agent, reach out over the A2A protocol, and test every path with a saved test set. Get the vocabulary precise, respect which features are preview, and use current Copilot Credits terminology, and the scenario questions become far easier to read.

When you are ready to prepare across the wider Microsoft AI certification range, browse Examinotion's exam preparation courses to build a structured study plan around the exams in your career path.

Sources

1. Microsoft Certified: AI Agent Builder Associate — Microsoft Learn, accessed 2026-06-25
2. Study guide for Exam AB-620 — Microsoft Learn, accessed 2026-06-25
3. Add other agents overview — Microsoft Learn, accessed 2026-06-25
4. Connect to an agent over the Agent2Agent (A2A) protocol — Microsoft Learn, accessed 2026-06-25
5. Extend your agent with Model Context Protocol — Microsoft Learn, accessed 2026-06-25
6. Model Context Protocol (MCP) is now generally available in Microsoft Copilot Studio — Microsoft Copilot Blog, 29 May 2025
7. What's new in Copilot Studio: April 2026 updates and features — Microsoft Copilot Blog, 1 April 2026
8. Connect to a Microsoft Foundry agent (preview) — Microsoft Learn, accessed 2026-06-25
9. Automate web and desktop apps with computer use — Microsoft Learn, accessed 2026-06-25
10. Quickstart: Create and deploy an agent — Microsoft Learn, accessed 2026-06-25
11. Copilot Studio licensing — Microsoft Learn, accessed 2026-06-25
12. Design and build multi-agent solutions in Microsoft Copilot Studio — Microsoft Learn, accessed 2026-06-25
13. Connect your agent to an existing Model Context Protocol (MCP) server — Microsoft Learn, accessed 2026-06-25