When a single agent becomes insufficient for complex tasks, multi-agent architectures distribute responsibilities across multiple specialized agents. Several coordination patterns have emerged: the supervisor pattern has one agent delegate tasks to worker agents and aggregate their results; the debate pattern has multiple agents argue different positions while a judge selects the best answer; the mixture-of-agents approach uses multiple LLMs to generate candidates and aggregates the best one; and the critic agent pattern adds a secondary reviewer that iterates on the primary agent's output. Agent specialization assigns distinct expertise areas, while agent delegation allows one agent to assign sub-tasks to another with more appropriate skills. An agent swarm takes this further, using many simple agents that achieve complex behavior through emergent coordination without centralized control.
The Model Context Protocol (MCP), introduced by Anthropic, is an open standard for connecting AI agents to external tools and data sources through a unified interface. MCP defines a client-server architecture: AI applications act as clients connecting to MCP servers that expose tools (executable functions), resources (readable data sources), and prompts via a standardized protocol. The key distinction is that tools are actions the agent can execute while resources are data the agent can read for context. MCP supports stdio transport for local processes and HTTP with Server-Sent Events for remote connections, enabling seamless integration with files, databases, and APIs.
Google's Agent-to-Agent (A2A) protocol addresses a different layer: communication between agents themselves rather than between agents and tools. A2A enables peer-to-peer collaboration and task delegation between agents, who discover each other's capabilities through Agent Cards — JSON metadata files describing skills and endpoints. To manage multi-agent systems at scale, orchestration layers coordinate how agents communicate, delegate tasks, share context, and combine outputs. Shared memory patterns and blackboard architectures allow agents to post partial solutions and read each other's contributions, while message passing enables coordination without shared state.