On August 20, 2026, Google donated the A2A protocol to the Agentic AI Foundation, placing it alongside Anthropic's MCP under the same neutral governance body for the first time. MCP handles agent-to-tool connections; A2A handles agent-to-agent coordination. Together under AAIF, they now form the open standard for the full agentic stack.
I've been watching this play out since the AAIF launched in December 2025. The A2A move that happened last week is the thing that completes the picture -- and it's getting less attention than it deserves.
What happened on August 20, 2026?
Google transferred the Agent-to-Agent (A2A) protocol to the Agentic AI Foundation (AAIF), a Linux Foundation-directed body formed in December 2025. This puts A2A alongside MCP, goose, and AGENTS.md under the same neutral governance -- meaning no single vendor controls either protocol anymore. AAIF now holds both sides of the agent communication stack.
The timing matters. AAIF launched with 49 members in December 2025. Eight months later, it has more than 250 members -- including all eight Platinum signatories: AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI (Linux Foundation). That's not a small standards committee. That's the entire industry aligned on a single governance structure for the first time.
Google launched A2A in April 2025 with 50+ enterprise partners including Salesforce, Accenture, SAP, and Deloitte. It hit v1.0 in early 2026, then donated it to AAIF as the v1.0 production-readiness announcement landed. The move is less about Google being generous and more about the protocol needing multi-vendor buy-in to get the adoption numbers that make it useful. You can't build an interoperability standard inside a single company's GitHub repo.
For context: AAIF already governed MCP, which Anthropic donated at the Foundation's launch in December 2025. OpenAI donated AGENTS.md at the same time. Block contributed goose, its open source agent framework. Adding A2A closes the loop -- now every layer of the standard agent architecture has a governance home that's not controlled by any single vendor (TechCrunch).
What is the actual difference between MCP and A2A?
MCP connects an AI agent to external tools and data -- databases, file systems, APIs, search results. A2A connects AI agents to other AI agents, enabling structured delegation, task coordination, and interoperability across different frameworks and vendors. MCP gives each agent its toolbox. A2A lets agents work as a coordinated team.
The cleaner frame is vertical versus horizontal. MCP is the vertical layer: your agent reaching down into its capabilities. When Claude searches the web, queries a database, or reads a file -- that's MCP. A2A is the horizontal layer: your agent reaching out to peers it doesn't control. When an orchestrator agent delegates a legal research sub-task to a specialist agent running on a different vendor's infrastructure -- that's A2A.
In practice, non-trivial multi-agent systems use both simultaneously. Each specialist agent is an MCP client internally -- wired to the tools it needs. That same agent is also an A2A peer externally -- able to receive delegated tasks from an orchestrator and return results in a structured, protocol-compliant way. The phrase I keep seeing in production architecture writeups from 2026: "MCP gives your agent hands; A2A gives your agent colleagues." That's the pattern AAIF is now governing as a unified stack (NiteAgent).
Before August 20, you could combine them, but the governance was split -- Anthropic controlled MCP, Google controlled A2A. That created enterprise hesitation about long-term protocol stability and vendor lock-in risk. Both protocols are now under AAIF with the same Linux Foundation governance model, the same IP policy, and the same contribution process. The split is gone.
Why does unified governance matter for builders?
When both protocols sit under the same neutral body, security patches, spec updates, and compliance requirements propagate consistently across the full stack. Enterprise procurement teams can evaluate "AAIF-governed protocols" as a single category rather than running separate vendor risk reviews for two specs. This removes one of the main structural blockers to enterprise agent adoption -- not the technical barriers, the institutional ones.
The adoption numbers tell you the demand was already there. MCP crossed 97 million monthly SDK downloads by early 2026 -- up from 100,000 when it launched 16 months earlier, a 970x increase (DEV Community). A2A reached v1.0 with 150+ production organizations, SDKs across five languages, gRPC support, and signed Agent Cards for cryptographic identity. Both protocols were winning without neutral governance. With it, the last institutional objection to building on them goes away.
There's also a security alignment benefit that's easy to miss. When one foundation governs both protocols, a vulnerability at the boundary between MCP and A2A gets patched in one coordinated release, not on two independent vendor timelines. As multi-agent systems proliferate and the attack surface for agent manipulation grows, that coordination matters. The OpenAI Astra cybersecurity threshold news from last week makes this more urgent, not less.
For solo builders and small teams, the practical implication is simple: stop hedging on which protocol wins. Both win. Both are governed the same way. The question is which layer of your architecture each one belongs in -- and that question now has a clear, stable answer.
Get the AI Agent Briefing
One email per week. The best AI agent news, tutorials, and tools -- written by someone who actually builds with them.
Subscribe Free
What does A2A v1.0 look like in production?
A2A v1.0 shipped four features that unblocked enterprise adoption: signed Agent Cards for cryptographic identity, multi-tenancy support, multi-protocol bindings across JSON-RPC and gRPC, and version negotiation. These were the specific blockers that kept enterprise pilots from going to production -- without agent identity verification, you can't safely run untrusted third-party agents inside critical workflows.
Agent Cards are the piece worth understanding. Each A2A-compliant agent publishes a structured card describing its capabilities, authentication requirements, and supported task types. When your orchestrator receives a delegated task request, it reads the Agent Card to verify identity and scope before accepting work. That's what makes multi-vendor agent pipelines trustworthy enough for production. You're not sending tasks to a URL and hoping -- you're verifying the receiving agent's declared identity and capabilities first.
A concrete production architecture looks like this: an orchestrator running on Claude receives a user request and uses MCP to pull initial context from internal databases and search. It then delegates three parallel sub-tasks via A2A -- one to a legal research agent on a different vendor's infrastructure, one to a financial modeling agent, one to a document generation agent. Each specialist runs a different model and is built on a different framework. A2A makes delegation structured and cryptographically verifiable. MCP wires each specialist to the specific tools it needs.
That's the architecture AAIF is now governing under one roof. With 150+ production organizations already running this pattern on A2A v1.0, it's not experimental.
What to watch in the next few weeks
Three things are likely to move quickly in Q3 2026 now that both protocols share a governance home. First, framework convergence: LangChain, CrewAI, LlamaIndex, and the major agent SDKs are all actively adding A2A support. Neutral governance removes the last "who owns this spec" objection that was slowing complete A2A integration in third-party frameworks. Expect full A2A support across the major frameworks before end of Q3. Second, enterprise procurement will accelerate. Teams that stalled on multi-agent projects because of protocol fragmentation now have a clean answer to give legal and security. Third, tooling for observability and debugging across the combined MCP-plus-A2A stack will consolidate -- right now you need separate tools for each layer, which is friction the ecosystem will solve.
What does not change: neither A2A nor MCP resolves the harder coordination problems. Task planning across multiple agents, failure recovery when one agent in a chain breaks, cost attribution in a multi-agent pipeline, preventing agents from contradicting each other's outputs -- none of that is solved at the protocol layer. Unified governance is necessary infrastructure. The interesting engineering problems are still at the application layer, above both protocols.
There's also a governance evolution worth watching. AAIF has 250+ members and eight Platinum signatories who are simultaneously the biggest commercial stakeholders in both protocols. How the Foundation balances vendor interests against the open standard is worth tracking. The Linux Foundation's track record here is generally good -- Node.js, OpenJS, and similar efforts moved fast without vendor capture. But with the stakes this high across all eight Platinum members, that track record will get tested.
FAQ
What is the Agentic AI Foundation (AAIF)?
The Agentic AI Foundation is a Linux Foundation project launched December 9, 2025, to provide neutral governance for AI agent open standards. It now stewards MCP (donated by Anthropic), A2A (donated by Google), goose (donated by Block), and AGENTS.md (donated by OpenAI). As of August 2026, it has 250+ member organizations, with eight Platinum members: AWS, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft, and OpenAI.
What is the difference between MCP and A2A?
MCP (Model Context Protocol) is the vertical layer -- it connects an AI agent to its tools, APIs, and data sources. A2A (Agent-to-Agent) is the horizontal layer -- it enables AI agents to communicate, delegate tasks, and coordinate with other agents across different frameworks and vendors. Most production multi-agent systems in 2026 use both: MCP for each agent's tool access, A2A for cross-agent coordination and delegation.
Do I need to use both MCP and A2A?
Not necessarily. If your agent workflow is deterministic -- you know exactly which tools to call in which order -- you need MCP, not A2A. A2A adds real overhead (agent discovery, task lifecycle management, structured message passing) that is only worth it when you genuinely need autonomous delegation to agents you do not control, particularly across vendor boundaries where you need cryptographic identity verification before accepting work.
When did Google donate A2A to AAIF?
Google formally transferred A2A to the Agentic AI Foundation on August 20, 2026. Google originally launched A2A in April 2025 with 50+ enterprise partners including Salesforce, Accenture, SAP, and Deloitte. A2A reached v1.0 in early 2026, adding signed Agent Cards, gRPC bindings, and multi-tenancy support before the AAIF donation (Axios).
Get the AI Agent Briefing
One email per week. The best AI agent news, tutorials, and tools -- written by someone who actually builds with them.
Subscribe Free