A2A and ACP: The Agent Coordination Protocols You Need to Know
MCP gets all the attention. Anthropic's Model Context Protocol became the poster child for AI agent standards, and for good reason. It solves a real problem: connecting agents to tools and data sources without building custom integrations for every combination.
But MCP only handles half the picture. It's the protocol for agent-to-resource communication. What about agent-to-agent communication?
That's where A2A and ACP come in. Google's Agent2Agent protocol and the Agentic Communication Protocol are quietly becoming the standards for how agents coordinate with each other. If you're building multi-agent systems, you need to understand both.
Table of Contents
- Why Agent-to-Agent Protocols Matter
- Google's A2A Protocol Basics
- ACP and Offline Coordination
- When to Use Which Protocol
- How A2A and ACP Compose with MCP
- Implementation Considerations
Why Agent-to-Agent Protocols Matter
Building a single AI agent is straightforward. Building five agents that need to coordinate? That's a different problem.
Without standards, every agent pair needs custom integration code. Agent A speaks JSON-RPC. Agent B expects REST calls. Agent C uses WebSockets. You end up writing translation layers for every combination.
Analogy: Think of it like international phone systems before country codes. You could make calls within your country, but connecting countries required manual operator assistance and custom routing rules. Agent protocols are the country codes and dialing standards that make direct connections possible.
The moment you need agents to delegate tasks, share context, or coordinate workflows, you need a common language. That's what A2A and ACP provide.
Google's A2A Protocol Basics
Agent2Agent emerged from Google's internal multi-agent architectures. The core idea is simple: agents communicate through structured messages with clear sender, receiver, and intent fields.
Here's what an A2A message looks like at its simplest:
| Field | Purpose | Example |
|---|---|---|
| sender_id | Agent initiating | "research_agent_1" |
| receiver_id | Target agent | "writing_agent_2" |
| intent | What's being requested | "summarize_findings" |
| payload | Actual data | {"topic": "protocols", "sources": [...]} |
| context | Shared session state | {"session_id": "abc123"} |
The protocol includes built-in support for:
Request-Response Patterns: One agent asks, another answers. Standard synchronous communication.
Task Delegation: An orchestrator agent assigns work to specialist agents and tracks completion.
State Sharing: Agents maintain a shared context object that travels with messages.
Capability Discovery: Agents can query what other agents can do before sending requests.
What makes A2A different from just sending JSON over HTTP is the standardized message envelope and the built-in patterns for common coordination scenarios. You don't have to invent your own protocol for task delegation or capability negotiation.
ACP and Offline Coordination
The Agentic Communication Protocol takes a different approach. While A2A focuses on synchronous request-response patterns, ACP is built for asynchronous, offline-first coordination.
ACP shines in scenarios where:
Agents operate on different schedules: One agent runs hourly, another runs daily. They need to coordinate without being online simultaneously.
Network reliability is uncertain: Mobile agents, edge deployments, or intermittent connectivity scenarios.
Long-running tasks: An agent kicks off a process that takes hours or days. The requesting agent doesn't want to hold a connection open.
ACP uses a message queue architecture. Agents publish messages to topics and subscribe to topics they care about. The protocol handles delivery guarantees, retry logic, and message ordering.
Key ACP concepts:
| Concept | Description | Use Case |
|---|---|---|
| Topics | Named channels | "data_processing_complete" |
| Subscriptions | Agent interests | Agent B subscribes to topic X |
| Persistence | Message storage | Offline agents catch up on missed messages |
| Delivery modes | At-least-once, exactly-once | Based on reliability needs |
ACP also includes built-in support for saga patterns. If you need to coordinate a multi-step workflow across agents with potential rollbacks, ACP provides the primitives for distributed transactions.
When to Use Which Protocol
The choice between A2A and ACP isn't either-or. Most multi-agent systems use both.
Use A2A when:
- You need immediate responses
- The calling agent waits for results before proceeding
- You're building request-response APIs between agents
- Agents are co-located or network latency is low
- You want simple capability discovery
Use ACP when:
- Tasks are long-running or time-delayed
- Agents operate on different schedules
- You need delivery guarantees across network failures
- Multiple agents need to subscribe to the same events
- You're implementing saga or workflow patterns
Real example: An agent system that analyzes customer feedback.
- The orchestrator uses A2A to request sentiment analysis from the NLP agent (synchronous, immediate result needed)
- The NLP agent uses ACP to publish "analysis_complete" events that trigger downstream summarization and reporting agents (asynchronous, fan-out pattern)
- The reporting agent uses A2A to request chart generation from the visualization agent (synchronous, needs specific output)
How A2A and ACP Compose with MCP
MCP, A2A, and ACP solve different problems. They're designed to work together.
MCP's role: Connect agents to tools, APIs, and data sources. When an agent needs to read a database, call an API, or use a tool, that happens over MCP.
A2A's role: Connect agents to other agents for synchronous coordination. When an agent needs another agent to do something and wants the result immediately, that happens over A2A.
ACP's role: Connect agents for asynchronous workflows. When agents need to publish events, coordinate long-running processes, or work across time zones, that happens over ACP.
In practice, an agent often uses all three:
- Receives a task via A2A from an orchestrator
- Fetches data via MCP from a database
- Processes the data
- Publishes results via ACP to a topic
- Returns status via A2A to the orchestrator
The protocols have clean separation of concerns. MCP handles vertical integration (agent to resources). A2A and ACP handle horizontal integration (agent to agent).
Implementation Considerations
If you're building a multi-agent system today, here's what to think about:
Start with A2A for agent coordination: It has broader tooling support and simpler semantics than ACP. Most coordination patterns map cleanly to request-response.
Add ACP when you hit A2A's limits: If you find yourself building retry logic, message queues, or pub-sub patterns on top of A2A, switch to ACP for those flows.
Use MCP for all tool and data access: Don't reinvent resource protocols. The MCP ecosystem is growing fast, and standardizing on it means less integration code.
Design for protocol evolution: These standards are still maturing. Build abstraction layers so you can swap implementations or upgrade protocol versions without rewriting your agents.
Security matters more in agent systems: A2A and ACP both support authentication and authorization, but they don't enforce it. Every agent-to-agent boundary is a trust boundary. Design your system accordingly.
Monitor message flows: Agent coordination creates complex message graphs. Build observability into your A2A and ACP implementations from day one. You'll need it for debugging.
One practical note: both A2A and ACP are still early. Expect breaking changes. Pin your protocol versions and test upgrades in staging environments.
The Real Story
The protocol conversations happening now will shape how we build AI systems for the next decade. MCP solved agent-to-tool communication. A2A and ACP are solving agent-to-agent communication.
These aren't competing standards. They're complementary pieces of a larger architecture. MCP for vertical integration. A2A for synchronous horizontal integration. ACP for asynchronous horizontal integration.
If you're building multi-agent systems, start with A2A for agent coordination and MCP for resource access. Add ACP when your workflows demand asynchronous patterns. The protocols compose cleanly, and the separation of concerns makes systems easier to reason about.
The best part? You don't have to wait for perfect standards. A2A and ACP are shipping in production systems today. The implementations are stable enough to build on, even if the specs are still evolving.
The future of AI isn't single agents. It's coordinated systems of specialized agents. A2A and ACP are how those systems will talk to each other.