On August 20, Google's A2A protocol formally joined the Agentic AI Foundation, the Linux Foundation-directed body that Anthropic, OpenAI, and Block launched in December 2025. That puts MCP and A2A — the two protocols handling most of the agentic infrastructure work developers are actually building on today — under the same neutral umbrella. AAIF now has over 250 member organizations, including AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, OpenAI, Shopify, Cisco, Salesforce, SAP, and ServiceNow.

I want to explain why that's more significant than it sounds before I get into what it means for your roadmap.

MCP and A2A solve different problems. MCP is Layer 1: your agent connects to a tool. A database, a Slack integration, a code execution sandbox, a payment API. MCP defines how the two sides speak. By March 2026, MCP had reached 97 million monthly SDK downloads — comparable to React's npm package count but achieved in 16 months instead of three years. A2A is Layer 2: your agent delegates a subtask to another agent. Different problem, different protocol, completely orthogonal. Except for the last eight months they lived under different governance structures — one neutral (AAIF), one under Google's direct control.

That mattered. When two complementary protocols live in different governance houses, the risk isn't technical incompatibility today. It's divergence over time, and the chilling effect on builders who don't want to build deep on a protocol that one company can change unilaterally. The August 20 move reduces that risk.

Source spread

• Linux Foundation — AAIF formation press release [hype] — official framing; positions this as the open-standards moment for agentic AI
• Axios — AI agents inch toward interoperability [builder] — production-level context on what AAIF actually does and what adoption looks like
• AAIF blog — A2A joins [builder] — the protocol architecture breakdown; clearest writing on what MCP handles vs A2A
• AI Magazine — Why did Google's A2A join? [skeptic] — asks whether neutral governance prevents fragmentation or just defers it

Pros & cons

What's real:

• MCP and A2A are genuinely orthogonal. Combining them under AAIF doesn't collapse the distinction — each protocol can still evolve on its own track — but it removes the governance misalignment that was making combined MCP+A2A stacks feel risky to depend on. That's worth a lot.
• A2A v1.0, the first stable spec, shipped in March 2026. Stable spec plus neutral governance is what enterprise procurement is waiting for before signing off on building against either protocol seriously. The August 20 move makes that sign-off easier.
• 97 million monthly MCP SDK downloads by March 2026 is a protocol that already won adoption. AAIF isn't trying to convince the market — it's standardizing what the market already chose. That's the strongest possible starting position for a governance body.
• The Linux Foundation model has a real track record. This is where TCP/IP governance and the Linux kernel ended up. Neutral hosting works when the participants have competing incentives in the same stack. Anthropic and Google definitely have competing incentives in the same stack.

What deserves a side-eye:

• ACP (IBM's Agent Communication Protocol) and ANP (Alibaba's Agent Network Protocol) are still outside AAIF. Either they join eventually, or "we standardized agent protocols" has two significant carve-outs — IBM enterprise deployments and Alibaba Cloud infrastructure. Neither is irrelevant.
• "250 member organizations" is a metric that can mean anything. Linux Foundation projects routinely have hundreds of signatories, most watching. The meaningful signal is who's writing spec PRs and who's blocking each other's PRs, not who signed the membership page.
• The Linux Foundation's history is to host things that are already converging. AAIF governance doesn't guarantee the protocols stay compatible as they evolve. It gives a place for that argument to happen in public instead of in competing press releases. That's better, but not a guarantee.

97M

→ Source: Forkast News

Samwise's take

What builders need to know

• MCP = tool-calling (Layer 1). A2A = agent delegation (Layer 2). They're complementary, not competing. If your agent both calls tools and spawns subagents, you need both protocols. Build with that assumption now rather than choosing between them.
• A2A v1.0 is the stable spec as of March 2026. AAIF governance adds the neutral layer that makes it safer to depend on long-term. The spec is unlikely to break backwards compatibility with 250 stakeholders watching.
• The MCP spec RC from July 28 and A2A joining on August 20 are connected. Both moves pull the foundational agent infrastructure into a neutral space where no single lab has unilateral control. The direction is clear.
• ACP and ANP are the wildcard. If you're building for IBM-heavy enterprise environments or deploying on Alibaba Cloud, watch whether these converge with AAIF or stay separate. For cloud-native builders on AWS, GCP, or Azure, build on MCP + A2A today.
• The SDK download rate matters more than the member count. 97 million monthly MCP downloads tells you what builders chose before anyone asked them to. The governance move is confirming what adoption already decided.

Further reading

• Linux Foundation — AAIF formation press release — neutral governance structure and member details
• AAIF — A2A joins AAIF — protocol architecture and what each layer covers
• Axios — AI agents inch toward interoperability — production-level context on what this means for builders
• Atlan — Agent interoperability protocols: MCP, A2A, OSI explained — the technical breakdown of Layer 1 vs Layer 2
• Forkast News — Google's A2A joins AAIF — comprehensive coverage of the announcement and its context