Google's AI Agent Protocol Just Found a New Home. It's Now Under the Same Roof as MCP.

Five days ago, Google confirmed that its Agent2Agent protocol — the open specification that defines how AI agents communicate with each other — would become a hosted project of the Agentic AI Foundation, moving from the Linux Foundation's broader portfolio into a home built specifically for the agentic AI ecosystem. The move was quiet. The implications are not.

What A2A Actually Does

If you've used Anthropic's Model Context Protocol, you have a rough map of what A2A is for — but they cover different territory. MCP handles the connection between an AI agent and the tools and data sources it works with: databases, APIs, file systems, external services. Think of it as the agent's plug-into-the-world standard.

A2A handles something different: how agents talk to each other. When one AI agent needs to delegate a task to another agent — across different vendors, different frameworks, different organizations — A2A defines how they discover each other's capabilities, exchange messages, and coordinate work without requiring custom integration code for every possible pairing.

Together, they cover the two foundational communication problems in multi-agent systems: agent-to-tool and agent-to-agent. They're designed to complement each other, not compete. The fact that they're now governed by the same foundation is a signal that the industry is treating them as a pair.

A Brief History of Where A2A Has Lived

Google introduced A2A in April 2025. Within two months, it transferred the protocol to the Linux Foundation, bringing IBM and a roster of enterprise software vendors into the governance structure. IBM's own Agent Communication Protocol — a competing approach to the same problem — merged into A2A in August 2025, an early sign that consolidation was underway.

Now, a year later, A2A is moving again — to the Agentic AI Foundation, an organization specifically focused on open infrastructure for agentic AI rather than open source broadly. The distinction matters: the Linux Foundation is a general-purpose home for open-source projects spanning many domains; the Agentic AI Foundation is purpose-built for the agent ecosystem. A2A now sits alongside MCP and other agent infrastructure standards under a governance structure designed specifically for this space.

Why This Move Matters

The practical reason for the migration is fragmentation. Multi-agent systems are proliferating faster than the standards for them are stabilizing. Developers building production-grade agent systems today have to navigate A2A for agent-to-agent communication, MCP for agent-to-tool communication, and a growing number of framework-specific conventions that don't interoperate cleanly.

Putting A2A and MCP under the same institutional roof doesn't merge them or eliminate that complexity — but it does create a governance structure where the people working on these standards can coordinate directly, resolve conflicts at the specification level rather than the implementation level, and signal to the industry that interoperability is being taken seriously by a dedicated organization.

For developers, the value proposition is straightforward: standardized protocols mean multi-agent systems built on different frameworks can eventually discover, delegate to, and communicate with each other without custom glue code. In a world where every enterprise AI deployment is becoming a mesh of cooperating specialized agents, that's a meaningful reduction in integration friction — and it's the kind of reduction that needs to happen at the protocol layer to be durable.

The Trust Problem No Standard Solves Yet

Here's the part that doesn't get resolved by governance structure: when agents treat information from other agents as inherently trustworthy, errors and instructions propagate through agent chains unchecked. An A2A-compliant agent can receive a malicious or mistaken instruction from another A2A-compliant agent and act on it faithfully. The protocol specifies how communication happens, not whether it should be believed.

This is the security problem that sits underneath agent interoperability standards, and it isn't being solved at the protocol layer. It's being worked on — in verification frameworks, attestation schemes, and trust hierarchies for agent systems — but it's a harder problem than the communication standard itself. As agent meshes grow in complexity and operate with greater autonomy, this gap is going to become more visible, and more consequential.

The developers building on A2A and MCP today are working ahead of the trust infrastructure that would make those systems verifiably safe. That's not an indictment of the protocols — it's a description of where the field is. The standards are maturing faster than the security layer, which is the normal order of operations in new infrastructure, and it's worth being clear-eyed about.

Where Interoperability Standards Go from Here

What's happening with A2A and MCP is the early stage of a standardization process that the web went through in the 1990s, APIs went through in the 2000s, and containerization went through in the 2010s. Each of those cycles involved competing approaches, consolidation under governance structures, and eventually broad adoption that changed what developers could take for granted as infrastructure.

The agentic AI ecosystem is early enough that the consolidation is still unfinished. A2A and MCP coexisting under the Agentic AI Foundation is progress, not completion. There are still competing approaches, still frameworks that don't interoperate, still organizational incentives to keep agents inside proprietary ecosystems rather than expose them to external coordination via open standards.

But the direction of travel is clear, and the pace is accelerating. For every developer building systems that need agents to coordinate across organizational or platform boundaries — which, if enterprise AI adoption forecasts are close to right, is most of them within the next few years — the consolidation of A2A and MCP under a shared governance structure is worth tracking as a meaningful step in a longer arc.

The boring-sounding governance news sometimes turns out to be the most important kind.

Sources

Axios, "Google's A2A Protocol Gets a New Home" (Aug 17, 2026): https://www.axios.com/2026/08/17/a2a-agentic-ai-foundation-open-ai-standards

Google Developers Blog, "Announcing the Agent2Agent Protocol (A2A)": https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/

Wikipedia, Agent2Agent: https://en.wikipedia.org/wiki/Agent2Agent

Techstrong.ai, "Google Moves A2A Under Agentic AI Foundation": https://techstrong.ai/articles/google-moves-a2a-under-agentic-ai-foundation/

DEV Community, "MCP vs A2A: The Complete Guide to AI Agent Protocols in 2026": https://dev.to/pockit_tools/mcp-vs-a2a-the-complete-guide-to-ai-agent-protocols-in-2026-30li