Practical Patterns for Child Agents, Connected Agents, A2A, MCP, and Long-Running Business Processes

Multi-agent solutions are becoming one of the most powerful capabilities in Microsoft Copilot Studio.

But most teams quickly discover that creating multiple agents is easy. Designing an orchestration model that remains understandable, governable, and maintainable is much harder.

In this practical session, we'll explore how to build multi-agent solutions in Copilot Studio using the newest orchestration capabilities, including child agents, connected agents, Agent-to-Agent (A2A) communication, MCP integrations, and the emerging GitHub Copilot harness capabilities.

Rather than focusing on individual features, we'll focus on architecture and orchestration:

* When a single agent is enough
* When to introduce child agents
* When connected agents become the better choice
* How A2A changes cross-agent collaboration
* How MCP connects agents to tools and external capabilities
* How state-driven orchestration enables long-running business processes
* How to avoid creating agent architectures that become impossible to govern

We'll also examine the evolving Copilot Studio runtime landscape and explain where the Standard Harness and GitHub Copilot Harness fit into modern agent architectures. Rather than treating harness selection as the primary decision, we'll show how business requirements, orchestration patterns, and required building blocks naturally guide the choice.

Using real-world examples and implementation patterns, including long-running enterprise workflows, you'll learn how successful organizations move beyond simple copilots and build orchestrated agent ecosystems that solve complex business problems.

You won't leave with another collection of features.

You'll leave with practical orchestration patterns you can apply immediately in your own Copilot Studio solutions.

What You'll Learn
* Designing Multi-Agent Systems
* Identifying meaningful boundaries between agents
* Specialization versus reuse
* Avoiding unnecessary orchestration complexity
* Establishing ownership and governance boundaries
* Child Agents and Connected Agents
* When to use child agents inside a solution
* When connected agents provide a better architectural boundary
* Delegation patterns and specialist-agent design
* Managing shared and isolated responsibilities

MCP and A2A
MCP as the standard mechanism for exposing tools and resources
A2A as the standard mechanism for collaborating with autonomous agents
When to choose a capability call versus agent delegation
Combining MCP and A2A in the same architecture

Orchestration Patterns
Orchestrator + specialist agents
Specialist networks
Hierarchical orchestration
Event-driven orchestration
Long-running business processes
Harnesses in Context

A practical overview of:

Standard Harness
GitHub Copilot Harness
Child Agents
Skills
Memory
Native file handling
Connected Agents
with a focus on how these building blocks affect architecture decisions rather than feature comparisons.

Real-World Example
A detailed walkthrough of a state-driven invoice processing solution built with:
Copilot Studio
Child Agents
Agent Flows
Dataverse
Connectors
showing how orchestration, state management, and specialization work together in production architectures.

Key Takeaways
After attending this session, you will be able to:
* Design practical multi-agent architectures in Copilot Studio
* Choose between child agents, connected agents, MCP, and A2A
* Apply proven orchestration patterns to complex business scenarios
* Build long-running processes using state-driven orchestration
* Understand where the Standard Harness and GitHub Copilot Harness fit within multi-agent architectures
* Avoid the most common multi-agent design mistakes
* Create solutions that remain maintainable, governable, and scalable