The AI agent ecosystem has entered the protocol proliferation phase that historically precedes consolidation. In the last 18 months, four significant standards have emerged: MCP (Anthropic, late 2024), ACP (IBM Research, March 2025), A2A (Google, April 2025), and ANP (an independent working group). Each addresses a different layer of the stack — and one problem remains unanswered.
Key takeaways
- MCP (Model Context Protocol) has won the tool-calling layer — over 10,000 active servers and 164 million SDK downloads per month (Linux Foundation data, April 2026)
- A2A (Agent2Agent, Google) handles task coordination between agents — it complements MCP, not competes with it
- The transport problem — how AI agents find each other and communicate peer-to-peer?Peer-to-peer: A communication model where nodes connect directly to each other without a central server (P2P). across NAT?NAT: Network Address Translation — a technique where many devices on a local network share one public IP address, leaving them not directly reachable from outside. — remains unsolved
- IETF and W3C are running standards tracks; transport layer resolution expected around 2027–2028
- AI architects are advised to build systems with clean separation between application semantics (MCP/A2A) and transport
What each protocol actually does
The proliferation looks more chaotic than it is, because most protocols address different layers of a stack rather than competing for the same slot. The confusion comes from marketing: each is described as "the standard for AI agent communication" without specifying which communication problem it solves.
MCP is a tool-calling interface. It defines how a model discovers what functions a server exposes, how to invoke them, and how to interpret the response. It is a typed RPC contract between a model client and a tool server, running over HTTP. The Linux Foundation confirmed over 10,000 active public MCP servers and 164 million monthly Python SDK downloads by April 2026. MCP has already won the tool-calling layer — standardization is effectively done.
A2A is a task coordination interface. Where MCP defines how an agent calls a tool, A2A defines how two agents delegate a task. It introduces Agent Cards (capability advertisements), task lifecycle states, and three interaction modes: synchronous, streaming, and asynchronous. Google donated it to the Linux Foundation in June 2025.
ACP (IBM) is a message envelope format — lightweight, stateless, designed for simple agent-to-agent exchange without A2A's full coordination semantics. ANP (independent) is a discovery and identity protocol built on DIDs?DID: Decentralized Identifier — an identity identifier independent of any central registry and verifiable cryptographically. — a foundation for decentralized agent marketplaces. The emerging stack: discovery via ANP, task coordination via A2A, tool calls via MCP, lightweight messaging via ACP.
| Protocol | Layer | Function |
|---|---|---|
| MCP | Tool calling | Typed RPC between model and tool server |
| A2A | Task coordination | Task delegation between agents |
| ACP | Messaging | Lightweight, stateless envelope format |
| ANP | Discovery and identity | DID-based protocol for decentralized agent marketplaces |
The problem that remains unsolved
Every protocol in this list runs over HTTP. This reflects where they came from: research teams, API providers, and enterprise software companies for whom HTTP is an unquestioned assumption. The problem is that HTTP assumes a reachable server. Behind NAT — and 88% of networked devices sit behind NAT — there is no reachable server without a relay.
For agent fleets that need to route tasks directly between peers across cloud boundaries, home networks, and edge deployments, this centralization forces every message through relay infrastructure. Relay adds latency, cost, and a failure mode.
The technologies to solve it exist. UDP hole-punching with STUN provides NAT traversal for roughly 70% of network topologies. QUIC?QUIC: A modern UDP-based transport protocol providing encrypted, reliable connections without TCPs head-of-line blocking. (RFC 9000) provides reliable delivery without TCP's head-of-line blocking. These are the same primitives WireGuard uses for VPN tunnels and WebRTC uses for browser-to-browser media.
Pilot Protocol has the most complete published specification — including an IETF Internet-Draft covering addressing, tunnel establishment, and NAT traversal for agent networks. libp2p provides battle-tested primitives.
Why this matters
MCP and A2A are stable enough to build production agent systems on. The transport layer is 18–24 months behind them. The next 12 months will bring production hardening of MCP and A2A, not new fundamental designs.
The lesson from the microservices era is directly applicable: clean separation between application semantics and transport is cheap to implement now and expensive to retrofit later. Systems that introduce this separation today will have the most flexibility when transport standards stabilize — with formal IETF specifications expected around 2027–2028.
What's next
- IETF and W3C are running standards tracks for agent network transport — formal specifications expected around 2027–2028
- Pilot Protocol and libp2p are currently the most mature candidates for the de facto P2P agent transport standard
- AI architects are advised to adopt MCP immediately (stable, low risk) and A2A for multi-agent coordination — and to design with clean separation from the transport layer
Sources
- VentureBeat — MCP solved tool calling. A2A solved coordination. What solves transport?
- Linux Foundation — MCP adoption data (April 2026)
- IETF — Pilot Protocol Internet-Draft
