Building a Collaborative Agent Network in Copilot Studio

Multi-agent orchestration in Microsoft Copilot Studio lets you create a parent agent that coordinates child agents to solve complex problems. Each child agent can focus on a specific domain, using its own knowledge sources and tools, while the parent agent manages the overall workflow and combines results. This pattern is ideal for review, validation, and triage scenarios where a single agent would be too broad.

In this guide, we’ll build a Project Proposal Review Agent that reads an uploaded Excel file containing proposed projects, then delegates three distinct checks to child agents:

• Budget Allocation Agent – verifies that each project uses the correct budget code and that amounts fall within thresholds.
• Resource Capacity Agent – confirms that no resource is over-allocated across multiple projects.
• Policy Compliance Agent – ensures the project description matches allowable categories per company policy.

The parent agent collects the responses from all child agents and presents a consolidated summary to the user.

Scenario Overview

Imagine your company receives project proposals via a standardized Excel workbook. Each row includes:

A reviewer uploads this file to the agent. The parent agent extracts the data, then calls the three child agents in parallel. The child agents use their own knowledge (budget code lookup PDF, resource capacity logic, policy documents) to evaluate the rows. Finally, the parent agent combines the feedback into a single response.

Step 1: Create the Parent Agent

Open Copilot Studio and create a new agent named Project Proposal Review Agent. Write the following instructions for the parent agent. They define when to call each child agent and how to format the final answer.

When a user uploads an Excel file or asks for a proposal review:
1. Run the "Read Excel File" topic to extract workbook data.
2. Call the following child agents once each, in any order:
 - Budget Allocation Agent
 - Resource Capacity Agent
 - Policy Compliance Agent
3. Combine the outputs of all three child agents into a single message. If any child agent found issues, list them grouped by check type. If all checks passed, confirm approval.

When a user asks about budget codes or policy rules, use the Budget Allocation Agent or Policy Compliance Agent to answer.

Strict Instructions: Do not assist with any other tasks.

The “Read Excel File” topic will be created next.

Step 2: Create a Topic to Read the Excel File

Add a new topic named Read Excel File. Use a Question node to ask the user to upload the Excel file, then a Prompt node (with Code Interpreter enabled) to read all worksheets and return a JSON structure.

Before you begin, ensure Code Interpreter is turned on in the agent settings. If the toggle is disabled, ask your Power Platform admin to enable it in the environment’s AI settings. Also configure a global variable named varProjectProposalsJSON with type Table to hold the extracted data.

Use this prompt configuration:

Goal: Read an Excel workbook and return all cell values as structured JSON.

Inputs:
- Excel file: [UploadedFile]

Instructions:
1. Open the workbook and list all worksheets.
2. For each worksheet, get the used range.
3. Extract every non-blank cell’s address and value as a string.
4. Output JSON in the following format:

{
"worksheets": [
  {
    "name": "Proposals",
    "cells": [
      { "range": "A1", "value": "Project Name" },
      { "range": "A2", "value": "Cloud Migration" }
    ]
  }
]
}

Set the output type of the prompt to JSON and assign the result to Global.varProjectProposalsJSON.

Step 3: Build the Budget Allocation Child Agent

Child agents are separate agents created within the parent agent’s Agents panel. They can access global variables defined in the parent’s session, but each child runs its own topics and knowledge. Child agents do not automatically share knowledge files — attach knowledge at the appropriate agent level (parent or child) depending on who needs it.

Create a child agent named Budget Allocation Agent using the Create an agent option from the parent agent’s Agents menu. Attach a PDF document (upload it to the parent’s knowledge tab) that maps budget codes to departments and includes spending limits per code. For example:

• 1001 – IT Infrastructure (max $20,000)
• 2002 – Operations (max $10,000)
• 3001 – Marketing (max $15,000)

Add the following instructions:

1. Parse Global.varProjectProposalsJSON to extract each row.
2. For each row, check:
 - The Budget Code exists in the attached knowledge.
 - The Budget Amount does not exceed the limit for that code.
 - The Department matches the code’s allowed department.
3. If any row violates these rules, output a message in the format:
 "Budget issues found:
  * [Project Name]
    - Amount: [Budget Amount]
    - Current Code: [Budget Code]
    - Issue: [description of violation]"
4. If all rows pass, say: "All budget allocations are correct."

Strict Instructions: Output only the results as described. Do not include extra commentary.

Step 4: Build the Resource Capacity Child Agent

This agent checks that each resource is not allocated beyond 100% across projects.

Create a child agent named Resource Capacity Agent. No extra knowledge is needed; the data in varProjectProposalsJSON is sufficient.

Instructions:

1. Aggregate Resource Name and sum Allocation % from Global.varProjectProposalsJSON.
2. For each resource, if total allocation exceeds 100%, report the over-allocation.
3. Output format:
 "Resource conflicts:
  * [Resource Name] is allocated [total%] across projects."
4. If no conflicts, say: "All resources are within capacity."

Strict Instructions: Do not output anything beyond the required format.

Step 5: Build the Policy Compliance Child Agent

This agent uses a company policy document (PDF) that lists acceptable project categories and descriptions.

Create a child agent named Policy Compliance Agent. Attach a PDF with rules such as:

• IT projects must contain “infrastructure” or “security” in the description.
• Operations projects must mention “relocation” or “facility”.
• Marketing projects must include “campaign” or “brand”.

Instructions:

1. For each row in Global.varProjectProposalsJSON, compare the Description against the policy rules in the attached knowledge.
2. Identify projects that violate policy.
3. Output format:
 "Policy violations:
  * [Project Name]
    - Description: [text]
    - Issue: [what policy rule is broken]"
4. If all pass, say: "All projects comply with policy."

Step 6: Wire the Agents Together

Back in the parent agent’s Overview tab, ensure each child agent is created and linked. The parent’s instructions already reference them by name. When a user triggers the review (by uploading a file or asking for a review), the parent agent will:

1. Execute the Read Excel File topic.
2. Invoke each child agent, passing the global variable.
3. Collect outputs and combine.

Test the flow by uploading a sample Excel file. After the child agents finish, you should see a consolidated message like:

Security and Performance Considerations

• Code Interpreter permissions: Only enable Code Interpreter for agents that truly need to run Python scripts. Limit the scope to the specific environment.
• Global variables: Variables shared across child agents should be scoped carefully. Avoid storing sensitive data unless encrypted.
• Child agent limits: Copilot Studio currently supports a limited number of child agents per parent. Check the latest limits in the documentation.
• Knowledge sources: Upload PDFs or documents with clear descriptions so the AI can retrieve the correct file.
• Testing: Use the Test pane with sample files to validate each child agent independently before integrating.

Common Mistakes and Troubleshooting

• Code Interpreter not enabled: The Excel reading prompt will fail if Code Interpreter is off. Verify both the agent setting and the environment setting in the Power Platform admin center.
• Global variable not available: If child agents cannot see Global.varProjectProposalsJSON, ensure the variable is created as a Global variable, not a local topic variable.
• Verbose child agent output: The instructions must enforce strict output formats; otherwise, the parent agent may not parse the results correctly.
• Missing knowledge descriptions: When uploading a PDF, provide a clear description (e.g., “Budget code mapping – use for validating department/code matches”) so the agent selects the right file.
• Agent not responding as expected: Review the conversation transcripts in Copilot Studio to see which topic or agent was triggered.

Recommendation

Multi-agent orchestration is powerful for building specialized, collaborative bots. Start with a simple two-agent setup (parent + one child) to understand the variable passing and output consolidation. Then expand with additional child agents as your workflow grows.

For further reading, explore the Microsoft Copilot Studio documentation on agents and topics, and the release notes for the latest multi-agent capabilities.

References

• Original article by Matthew Devaney: How To Use Multi-Agent Orchestration In Copilot Studio
• Microsoft Learn: Multi-agent orchestration in Copilot Studio
• Microsoft Learn: AI Builder code interpreter in Copilot Studio
• Microsoft Learn: Overview of Copilot Studio agents