Google Cloud launched the Agent-to-Agent (A2A) protocol on April 9, 2025, and donated it to the Linux Foundation under Apache 2.0 licensing. Version 0.3, released July 31, 2025, added gRPC support, signed security cards, and an extended Python SDK. Over 150 organizations now support the standard — making A2A the first serious attempt at an interoperability layer for AI agents.
The timing matters. Anthropic’s MCP protocol crossed 97 million installs in March 2026, up from roughly 100,000 at its late-2024 launch. Every major AI provider — Claude, GPT-5.4, Gemini — now ships MCP-compatible tooling. But MCP connects models to tools. A2A connects agents to agents. Understanding the difference is essential for anyone building multi-agent systems.
What A2A Actually Does
A2A enables AI agents from different providers to discover each other’s capabilities, delegate tasks, and report results across platforms. The protocol is built on HTTP, JSON-RPC, and Server-Sent Events — standard web infrastructure rather than proprietary formats.
The core mechanism is the Agent Card: a JSON metadata document describing what an agent can do, what skills it offers, and how to contact it. When Agent A needs a capability it lacks — say, translating a document into Mandarin — it queries available Agent Cards, finds Agent B with translation skills, delegates the task via JSON-RPC, and receives the result asynchronously.
Tasks in A2A can be immediate or long-running with status tracking. This statefulness is a critical design choice: real-world agent workflows — procurement approvals, multi-step research, compliance reviews — take hours or days, not milliseconds.
A2A vs MCP: Complementary, Not Competing
The most common misconception is that A2A and MCP compete. They operate on different axes entirely.
| Dimension | MCP (Anthropic) | A2A (Google) |
|---|---|---|
| Purpose | Connects agents to tools and data sources | Connects agents to other agents |
| Direction | Vertical (model ↔ tool) | Horizontal (agent ↔ agent) |
| State | Stateless — no task lifecycle | Stateful — long-running task management |
| Discovery | No agent discovery mechanism | Agent Cards for capability discovery |
| Adoption | 97 million installs (March 2026) | 150+ supporting organizations |
| Use case | Agent reads a database, calls an API, writes a file | Agent delegates subtask to another agent |
The Auth0 engineering team’s analysis puts it concisely: MCP is the tool integration layer, A2A is the agent collaboration layer. A procurement agent might use MCP to read an invoice from a database (vertical), then use A2A to ask a compliance agent on a different platform to verify the vendor (horizontal). Both protocols in the same workflow.
The Historical Parallel
The closest precedent is HTTP standardizing the early web. Before HTTP, networks existed but couldn’t interoperate. Each system spoke its own protocol. HTTP didn’t replace existing networks — it created a common language between them. A2A aims to do the same for AI agents: not replace MCP, OpenClaw skills, or Salesforce Agentforce, but let them communicate.
Salesforce contributed the Agent Card concept to A2A — a JSON contract specifying capabilities, identity, compliance tags, and Trust Score. That a company of Salesforce’s scale is actively shaping the spec rather than building a proprietary alternative suggests real industry commitment to interoperability. Agentforce 3 will use both MCP and A2A for cross-system agent orchestration.
What This Means for Developers
For developers building AI agent systems, the practical implication is straightforward: build with MCP for tool integration today (it has 97 million installs and 10,000+ active servers), and design agent interfaces that can adopt A2A as the protocol matures.
The A2A specification is open, versioned, and actively maintained at a2a-protocol.org. The Python SDK is available for immediate use. The protocol supports both JSON-RPC and gRPC bindings, covering both lightweight prototyping and high-performance production deployments.
The 150-organization coalition behind A2A — including Google, Salesforce, and the Linux Foundation — provides institutional backing that most open standards lack at this stage. Whether A2A becomes the HTTP of agents depends on adoption over the next 12 months. The infrastructure is ready. The question is whether enough agent builders use it to create the network effects that make interoperability self-reinforcing.
