Share via

Multi-agent patterns

Multi-agent patterns require some form of agent-to-agent interaction. The agents participate in a secure mesh of capabilities, with each agent being a well-behaved participant that exchanges signals and coordinates work.

Implement cross-agent and tool invocations by using the principles of least privilege, simplicity, auditability, and robust governance. To reduce complexity, prefer platform-native orchestration for internal flows where possible, and use Model Context Protocol (MCP) for secure, authenticated access to tools and data. Use Linux Foundation Agent2Agent (A2A) protocol for cross-platform agent integration with published contracts, and MCP-fronted agents as appropriate. Standardize security and management of connected agents by using published Software Development Kits (SDKs) with native MCP and A2A support.

Complex use cases might involve a hybrid of magentic, serial, and concurrent agent types. For example, a document generation workflow might require both serial steps (pick a template, generate grounded content, and inspect for compliance), and a concurrent workflow where multiple compliance checks run in parallel. Both simple and complex magentic agent types can be used within the workflow.

Diagram of a multi-agent workflow showing concurrent and serial flows between Agent 1A, 1B, 2, and 3, with human review at the end.

Multi-agent interaction recommendations

  • Prefer platform-native orchestration for internal flows with subagents where possible to keep orchestration simple.

  • Use MCP for tool and data access, including Microsoft 365 service tools. It's the recommended way to surface data and actions to agents with enterprise-grade security, authentication, and auditing.

  • Use A2A for cross-platform agent-to-agent messaging. Design for capability discovery and task contracts. Require agents to publish "agent cards" (capabilities) and use A2A's task and artifact model so workflows can discover, invoke, and track long-running tasks across runtimes.

  • Integrate mature or abstracted agents via MCP or A2A to avoid reimplementing logic and improve reuse and end-to-end traceability and control.

  • Integrate connected external agents by using published SDKs to standardize security, registration, and observability.

  • Enforce policy and auditing at the control-plane layer with frameworks like Agent 365 to keep agents compliant and observable.

  • Use least-privileged scope when calling MCP-hosted tools, such as from workflow steps for data lookups or actions.

  • To limit surface area and improve performance, use validation of typed payloads between steps and components where needed, with defined schemas and necessary context passing. Design for descriptive errors so that agents can self correct based on error messages.

  • Design for parallelism, limit inter-agent context to what is strictly necessary, and use short-term memory to avoid redundant work.

  • Include users in the workflow and communicate when agents collaborate. Require human approvals for high-impact cross-agent actions. Allow cancel and skip on long-running steps and surface summaries. Reconcile conflicting outputs.

Evaluating MCP and A2A in agent architectures

MCP (Model Context Protocol) and A2A (Linux Foundation's Agent2Agent) are complementary open source standards for building agentic applications.

Diagram of two AI agents with A2A interfaces communicating, each connecting to separate MCP servers with tools and agents as tools panels.

Both standards offer similar functionality for client-server flows and skill discovery. The following table lists where each protocol has clear differentiators when choosing how to connect multiple agents.

Capability MCP A2A
Multimodality Requires MCP host to support Allows advertisement of supported media types to enable strongly typed data exchanges.
Proactive notifications and subscriptions System notification support System and content notifications.
Multi‑turn interactions MCP server can optionally elicit additional information. Context management stays with host. The contextId allows context management across agents. Multiple tasks might exist within a single context. "Input required" is equivalent to MCP elicitations.
Orchestration MCP host orchestrates which tools to invoke and synthesizes final output Invoked agent uses its own chain‑of‑thought and orchestration. Tools/APIs are opaque to requesting agent.
Negotiation Requires MCP client update for new modalities or functions Dynamic negotiation for supported flows is more robust for service updates.

MCP provides a simple, straightforward way for agents to interact with external objects like APIs, data sources, or other agents. It provides strong controls for a single orchestrator to select, invoke, filter, reason, and synthesize the outcome. This protocol suits scenarios where you prefer control of the reasoning and weighting over flexibility and dynamism.

A2A is better suited for scenarios where the agents are or must be opaque to each other. For example, if the multi-agent workflow requires inputs from an external agent, or agents owned by two different engineering organizations. Support for negotiation reduces the dependency for client-server code updates when a service publishes new functionality.

Learn more:

Next steps

  • Last updated on