A2A and MCP Are Now Under One Roof: What AAIF Means

Google’s Agent2Agent protocol joined the Agentic AI Foundation on August 20, placing A2A alongside Anthropic’s Model Context Protocol under a single Linux Foundation-governed body for the first time. For anyone building multi-agent systems, this is the news you’ve been waiting for: the era of “which protocol wins” is officially over. Both survive. Both are needed. The two-layer stack is now the reference architecture, backed by AWS, Anthropic, Google, Microsoft, OpenAI, and 250-plus organizations that apparently agree on at least this one thing.

Stop Confusing These Two Protocols

Here is the thing developers keep getting wrong: MCP and A2A are not competing. They never were. They operate at entirely different layers of the stack, and conflating them has led to some genuinely bad architectural decisions.

MCP is vertical. It standardizes how an agent connects to tools — databases, APIs, file systems, search results. The model calls a function; the function returns a result. Stateless, transactional, fast. If your agent needs to query Postgres, read a file, or hit a SaaS API, that’s MCP territory.

A2A is horizontal. It handles how one agent talks to another — task delegation, capability discovery, identity exchange, and long-running state across organizational boundaries. When your orchestrator agent needs to hand off work to a specialist agent in a different system, that’s A2A’s job.

The cleanest way to hold this distinction: MCP gives your agent hands. A2A gives your agents colleagues.

The Reference Architecture You Should Be Using

With both protocols under AAIF governance, the three-layer agent stack is now official:

1. WebMCP — structured web access for agents
2. MCP — agent-to-tool connections (databases, APIs, services)
3. A2A — agent-to-agent orchestration (task delegation, coordination)

A concrete workflow: an orchestrator agent uses A2A to delegate a data validation task to a specialist. The specialist uses MCP to pull records from Snowflake and run quality checks. The result comes back through A2A to the orchestrator. Both layers do what they were designed for — neither is being bent to cover the other’s job.

This is what Google illustrated in A2A’s original announcement: a hiring agent that uses A2A to coordinate specialist agents for candidate sourcing, scheduling, and background checks, while each specialist uses MCP to talk to its own data sources. Clean separation, clear responsibilities.

Why Governance Is the Actual News Here

The technical architecture was already understood by teams paying attention. What changes with the AAIF move is the governance — and that matters more than most developers realize.

Before August 20, both protocols had a single-vendor problem. If Anthropic deprioritized MCP, the spec’s future was uncertain. If Google shifted focus from A2A, same story. Enterprise teams building long-lived systems on top of either protocol were betting on corporate priorities staying stable — not a safe bet in 2026.

Under AAIF, changes to either protocol now require an RFC, a Technical Steering Committee review, and a public comment period — the same process governing OpenAPI and GraphQL. Projects under Linux Foundation governance do not disappear because a backer pivots strategy. This is the kind of institutional stability that lets you commit to a stack without hedging.

Harrison Chase, LangChain’s co-founder and one of the earliest A2A supporters, put it plainly at the protocol’s initial launch: “We are excited to be collaborating with Google Cloud to come up with a shared protocol which meets the needs of the agent builders and users.” The AAIF move makes that collaboration structurally permanent rather than contingent on goodwill.

The Numbers Confirm This Is Not Experimental

MCP has hit 110 million monthly SDK downloads. There are 9,652 servers in the official registry and more than 15,000 GitHub repositories tagged as MCP servers. Seventy-eight percent of enterprise AI teams report MCP in production. The time to integrate a new SaaS tool using MCP has dropped from roughly 18 hours of custom code to 4.2 hours.

A2A v1.0 is live. Salesforce Agentforce, ServiceNow Now Assist, and Google’s own Agent Development Kit all implement it. Gartner projects that 40 percent of enterprise applications will include task-specific AI agents by the end of 2026 — up from less than five percent in 2025. That’s the market these protocols are being built for.

What Developers Should Do Now

If you’re building agents and haven’t committed to this stack yet, the answer is now clear. Start with MCP for tool access — the ecosystem is mature, the SDKs are solid, and the registry gives you a head start on integration. Add A2A when your system needs agents coordinating with other agents across service boundaries.

Do not build custom protocols. Do not try to make MCP cover A2A’s responsibilities or vice versa. Pin your protocol versions and test on the same release channels you use in CI. And if you’re in an enterprise context, AAIF membership now carries real weight — 250-plus organizations, including every major cloud provider and AI lab, are co-governing this infrastructure.

The protocol wars are over. The stack is settled. Build something.