You're building an AI agent. It needs to read your database, call some APIs, maybe coordinate with other agents. So you do what every developer does — wire up some REST endpoints, sprinkle JSON everywhere, and call it architecture. It works. Until it doesn't. 😼

The AI industry looked at this mess and did something almost out of character — tried to standardize before everything caught fire. Two protocols now sit at the center of agent development: MCP and A2A. As of March 2026, both live under the Linux Foundation's Agentic AI Foundation (AAIF), launched in December 2025 and co-founded by OpenAI, Anthropic, Google, Microsoft, AWS, and Block.

Peace in our time, right? Let me pour some cold water on that.

Two protocols, two problems

First, the basics that most hot takes get wrong: MCP and A2A don't compete. They solve different problems at different layers.

MCP (Model Context Protocol) — think of it as a universal plug standard for AI tools, like USB but for data. Your agent needs to read a file, query a database, or hit an API? MCP standardizes that conversation. Anthropic created it and donated it to the Linux Foundation in December 2025. It's crossed 97 million monthly SDK (software development kit — the toolbox developers use to build with a technology) downloads across Python and TypeScript. OpenAI, Google, Microsoft, Amazon — everyone adopted it. That's not hype. That's infrastructure.

A2A (Agent-to-Agent) — the protocol for agents talking to each other. If MCP is how an agent uses tools, A2A is how agents coordinate on a shared task. You have a coding agent, a testing agent, and a deployment agent that need to collaborate? A2A handles the handshakes. Google shipped it in April 2025 and donated it in June 2025. IBM's competing Agent Communication Protocol (ACP) merged into A2A in August 2025, consolidating two standards into one.

Here's the key insight: you need MCP first. An agent that can coordinate with other agents via A2A but has no tool access via MCP is a manager with no employees. Impressive title, zero output. Most production multi-agent systems in 2026 run both protocols — MCP as the foundation, A2A as the orchestration layer on top. 😹

What the press releases skip

Now let's talk about what the harmonious Linux Foundation announcements don't mention.

Anthropic created MCP and has the deepest integration — Claude Code, Claude Desktop, the MCP server registry. Google created A2A and runs the most complex multi-agent production systems across Search, Workspace, and Cloud. Both companies donated their protocols to a foundation, which looks generous until you notice the pattern: open-source the spec, keep the best implementation proprietary.

Tech companies have pulled this move a dozen times. Donating the protocol doesn't erase the head start. It means competitors play catch-up using specifications someone else wrote.

Then there's the "rest" category. AGNTCY, custom enterprise protocols, and the practical reality that most agent systems in 2026 still use REST APIs (a simple way for programs to exchange data over the web) with raw JSON and call it architecture. Standards adoption is always slower than standards advocates want.

The fragmentation risk hasn't vanished either. Nothing stops a major player from forking these protocols or shipping "extensions" that are technically compatible but practically lock you in. We watched this exact movie with web standards, container specs, and cloud APIs. The AAIF is young. The goodwill is fragile.

What you actually do

Adopt MCP now. It's the closest thing to a universal standard for tool integration. 97 million monthly downloads is real adoption, not a vanity metric. Building an agent that talks to external tools? MCP is the interface. Don't roll your own.

Watch A2A, don't marry it yet. Multi-agent orchestration is still early. Most real-world systems use simple patterns — sequential chains, basic fan-out (one task split across multiple workers) — that don't need a formal protocol. A2A matters when genuinely distributed agents from different vendors need to collaborate. That's a small but growing use case.

Ignore everything else. AGNTCY, custom enterprise standards, vendor-specific protocols — none have the backing or adoption to survive. Betting on a niche protocol is how you end up rewriting your integration layer in 18 months.

The real question

It isn't which protocol wins. They both win — different problems, different layers. The real question is whether AAIF governance holds when Anthropic and Google inevitably disagree about direction. Foundations work until they don't — and they stop working the moment one member decides commercial interests outweigh collective good. 😾

My bet: MCP becomes the TCP/IP of agents — boring, universal, invisible. A2A becomes more like HTTP — important, but with competing implementations that fragment the experience. And three years from now, we'll all be arguing about A2A-Next versus A2A-Classic versus whatever Amazon ships.

The protocol wars aren't over. They just moved to a nicer conference room.

mcp, a2a, ai-agents, protocols, linux-foundation