MCP vs A2A: Which AI Agent Protocols Survived the Wild West

In April 2025, a survey out of Shanghai Jiao Tong University mapped more than a dozen protocols for AI agents to reach tools and talk to each other.¹ Eighteen months later, two of them carry nearly all the traffic. One merged into its rival, several went quiet, and a few were never communication protocols in the first place.

My first version of this post was a tour of that map. This one is the field report: what MCP and A2A each do, how they differ, what happened to the rest, and which one you need.

What Did the 2025 Survey Actually Map?

A gauge war. American railroads fought one in the 19th century: most northern lines ran on standard gauge or close to it, much of the South ran on 5 ft track, and freight crossing the line had to be reloaded or put on new wheels. Then, over two days at the end of May 1886, crews across the South pulled the spikes on one rail of every broad-gauge line, moved it three inches east, and spiked it back down.² Nobody won that argument on merit. The South re-laid its track because the rest of the country already ran on the other gauge.

The survey drew the map mid-war. It sorts protocols on two axes: context-oriented (an agent reaching tools and data) versus inter-agent (agents talking to agents), and general-purpose versus domain-specific. MCP sat alone in the general-purpose, context-oriented box. A2A shared the inter-agent box with ANP, Agora, and four others. Worth knowing when you read the ANP section: Gaowei Chang, who created ANP, is one of the paper’s authors.

What Did I Get Wrong the First Time?

Three things. I copied the survey’s table, which credits the Agent Connect Protocol to LangChain; the paper’s own text cites Cisco, and the project came out of Cisco’s Outshift incubator with LangChain and Galileo as collaborators.³ I listed CrowdES and Spatial Population Protocols as agent protocols, when the first is a CVPR paper about generating crowd trajectories and the second is a distributed-computing model for robot localization. And I closed with a claim that early adopters “report 40% faster development cycles.” I can’t trace that number to any source, so it’s gone.

What Is MCP For?

MCP lays the track from an agent to its own sidings: the tools and data it works with. Anthropic open-sourced it on November 25, 2024.⁴ On December 9, 2025, Anthropic donated it to the new Agentic AI Foundation (AAIF) under the Linux Foundation, alongside Block’s goose and OpenAI’s AGENTS.md, with AWS, Google, Microsoft, and OpenAI among the platinum members.⁵

A server exposes tools the model can call, resources it can read, and prompts a user can pick. The wire format is JSON-RPC 2.0, over stdio for local servers or Streamable HTTP for remote ones. Adoption isn’t in question anymore. At the donation, Anthropic counted more than 10,000 active public servers and 97 million monthly SDK downloads, and by July 2026 the Tier 1 SDKs were at “close to half-a-billion downloads a month.”⁶

The big change this year is the 2026-07-28 spec, which made MCP stateless. The initialize handshake is gone. So is Mcp-Session-Id. Every request carries its own protocol version and client capabilities, and the HTTP transport copies the method and tool name into headers so a gateway can route without parsing the body:⁷

1
POST /mcp HTTP/1.1
2
Content-Type: application/json
3
Accept: application/json, text/event-stream
4
MCP-Protocol-Version: 2026-07-28
5
Mcp-Method: tools/call
6
Mcp-Name: get_weather
7

8
{
9
  "jsonrpc": "2.0",
10
  "id": 1,
11
  "method": "tools/call",
12
  "params": {
13
    "name": "get_weather",
14
    "arguments": { "location": "Seattle, WA" },
15
    "_meta": {
16
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
17
      "io.modelcontextprotocol/clientCapabilities": {}
18
    }
19
  }
20
}

The maintainers put it bluntly: MCP is “transforming from a bidirectional stateful protocol into a request/response stateless protocol.” The payoff is operational. “Any request can now land on any server instance behind a plain round-robin load balancer without needing shared storage.”⁶ If you run a remote MCP server with sticky sessions and a Redis table of session IDs, you can delete both once your clients speak the new version. A server that needs state now hands the model an explicit handle (a cart ID, a browser context) and takes it back as an argument. Sampling and Roots are deprecated. When a server needs input mid-call, it returns "resultType": "input_required" and the client retries with the answers.

What Is A2A For?

A2A is interchange: the rules for handing a freight car to a railroad you don’t own. Google announced it on April 9, 2025, with more than 50 partners, and pitched it as a complement to MCP.⁸ It moved to the Linux Foundation that June and shipped 1.0 on March 12, 2026. In August, it joined MCP at the AAIF.⁹ By April 2026, the Linux Foundation counted more than 150 supporting organizations, with A2A built into Azure AI Foundry, Copilot Studio, and Amazon Bedrock AgentCore.¹⁰

The agent on the other end of an A2A call is opaque. You don’t see its tools or its prompts. You see an Agent Card it publishes at a well-known URL:

# what can this agent do, and which bindings does it speak?
curl -s https://agent.example.com/.well-known/agent-card.json \
  | jq '{skills: [.skills[].id], bindings: [.supportedInterfaces[].protocolBinding]}'

The card lists skills and auth schemes. It also names the bindings the agent accepts: JSON-RPC, gRPC, or plain HTTP+JSON. Work happens in tasks, and a task has a lifecycle a tool call doesn’t. It can sit in TASK_STATE_WORKING for an hour, stream progress over SSE, post updates to your webhook, or stop and ask you something:

1
POST /message:send HTTP/1.1
2
Host: agent.example.com
3
Content-Type: application/a2a+json
4
A2A-Version: 1.0
5

6
{"message": {"role": "ROLE_USER", "messageId": "msg-1",
7
             "parts": [{"text": "Book me a flight"}]}}

1
{"task": {"id": "task-uuid", "status": {
2
  "state": "TASK_STATE_INPUT_REQUIRED",
3
  "message": {"role": "ROLE_AGENT",
4
    "parts": [{"text": "Where would you like to fly from and to?"}]}}}}

You answer with the same taskId and the agent carries on. If you wrote A2A code against 0.x, check your method names. Version 1.0 renamed message/send to SendMessage and tasks/get to GetTask to match gRPC, and it replaced the typed TextPart and FilePart objects with one part type that holds text, raw bytes, a URL, or data. The card’s path changed earlier, in 0.3, from agent.json to agent-card.json.⁹

MCP vs A2A: What’s the Difference?

The overlap is real at the edges. MCP moved long-running tasks into an official extension, and you can wrap an A2A agent as an MCP tool if your client only speaks MCP. The test I use is ownership. If you can read the other side’s schema and it does what the schema says, it’s a tool, and MCP fits. If the other side has its own model and its own on-call rotation, it’s an agent, and that’s what A2A is for.

What Happened to ACP, ANP, and the Rest?

First, the name problem. There are now four ACPs: IBM’s Agent Communication Protocol, AGNTCY’s Agent Connect Protocol, OpenAI and Stripe’s Agentic Commerce Protocol, and Zed’s Agent Client Protocol, which connects code editors to coding agents. If someone tells you to “support ACP,” ask which one.

The IBM team said it plainly in August 2025: “ACP is officially merging with the A2A under the Linux Foundation,” and “the ACP team will be winding down active development.”¹¹ AGNTCY’s Agent Connect Protocol went the same way without an announcement. Its spec repo is archived, an open issue says it “should be deprecated since AGNTCY now supports A2A,” and AGNTCY’s own October proposal to the AAIF describes its messaging layer, SLIM, as “a transport binding beneath A2A.”³

ANP is the one holdout with a pulse. It aims at the open web rather than the enterprise, with identity built on W3C decentralized identifiers through its own did:wba method. It’s still moving: in August 2026 it dropped JSON-LD from its agent descriptions in favor of plain JSON, and in September it applied to join the AAIF.¹² That’s how gauge wars end. Nobody wins the argument. The smaller lines re-lay their track to match the traffic.

Which New Protocols Showed Up Since?

Two that matter for interfaces. AG-UI, released by CopilotKit in May 2025, standardizes the event stream between an agent and the app a person is looking at: text deltas, tool calls, and state updates over SSE or WebSockets.¹³ It has more than 16,000 GitHub stars and first-party integrations in Microsoft Agent Framework and Google’s ADK, among others. MCP Apps, the first official MCP extension, went stable on January 26, 2026. It lets a tool return interactive UI that renders inside the chat, and it grew out of MCP-UI and OpenAI’s Apps SDK. Claude, ChatGPT, Goose, and VS Code all render it.¹⁴

Payments are where the gauge war is still on. Google shipped AP2 in September 2025 as an extension of A2A and MCP, with signed mandates that prove a user approved a purchase. Weeks later, OpenAI and Stripe launched the Agentic Commerce Protocol. In January 2026, Google followed with the Universal Commerce Protocol, built with Shopify, Etsy, Wayfair, Target, and Walmart, which runs over A2A, MCP, or plain APIs.¹⁵ And x402, which revives the HTTP 402 “Payment Required” status code, became its own Linux Foundation project in April 2026.¹⁶ Four specs with overlapping backers. No winner yet.

Which Agent Protocol Should You Use?

If you’re exposing an API, a tool, or a data source to agents, build an MCP server. Target 2026-07-28, keep it stateless, and you’ll work in every major client. There’s no second choice here.

If you’re building several agents inside your own system, you probably don’t need A2A at all. Martin Fowler’s first law of distributed object design was “don’t distribute your objects,” and it applies to agents too. A subagent you deploy and get paged for is a function call with a long runtime. Wrapping it in A2A buys you a network hop, an auth scheme, and a task state machine you now own.

A2A earns its keep at an ownership boundary: a vendor’s agent, or another business unit’s, whose internals you’ll never see. If you’re shipping a front end for your agent, look at AG-UI; if your users live inside ChatGPT or Claude, use MCP Apps. Unless you sell things online, stay out of the payments fight for another year, and if you do, follow your payment processor’s lead. Everything else on the 2025 map is reading material.

Lay standard gauge. Build the interchange yard when a neighbor actually shows up.