A2A and MCP: Start of the AI Agent Protocol Wars?

Google just released A2A (Agent2Agent)—a new open protocol for agent to agent communication—and it left people wondering if they just started a protocol war against MCP (Model Context Protocol).

Why AI Protocols Are a Battleground

AI is moving into ecosystems of tools and agents that reason, delegate tasks, and collaborate. As this happens, the need for standardized protocols is growing fast.

In Google’s A2A announcement: “Standard protocols are essential for enabling agentic interoperability, particularly in connecting agents to external systems.”

While introducing A2A, Google claims building AI agentic system demands two layers:

• Tools and data integration: Standard ways for agents/LLMs access external sources and tools
• Agent-to-agent communication: A standard way for determines how agents interact with one another

MCP focuses on the first category: organizing what agents, tools, or users send into the model, whereas A2A focuses on the second category: coordination between intelligent agents. On the other hand,

By separating tools from agents, Google is able to position A2A as complementary to — rather than in competition with — MCP. We’ll dig deeper into this point later.

Protocols don’t just define how systems communicate with one another — they define who builds what, which tools thrive, and how fast ecosystems connect.

What is Google’s A2A?

According to the docs and announcement, A2A says it does exactly what its name implies: it standardizes how AI agents communicate with one another.

According to Google’s announcement, A2A is designed to enable agents to:

• Communicate with each other directly
• Securely exchange information
• Coordinate actions across tools, services, and enterprise systems

How A2A Works: A Protocol for Multi-agent Systems

The A2A protocol defines how autonomous agents can discover and communicate with one another in a consistent and structured way. Agents make themselves discoverable by exposing a public card via HTTP. This card includes:

• Hosted/ DNS information: where the agent is accessible
• Version: which version of the agent is in use
• Skills: a structure list of what the agent can do

A2A supports multiple client-server communication methods based on task duration and interactivity:

• Request/ Response with Polling: Standard HTTP model, used when clients need to check the status of tasks and results
• SSE (Server-Sent Events): Used for short-running tasks
• Push Notifications: Used for long-running tasks that can notify the client once its finished

What is Anthropic’s MCP?

MCP (Model Context Protocol) is an open standard developed by Anthropic to standardize how applications provide context to LLMs and AI assistants. It enables secure, two-way connections between models and external tools and data systems.

MCP facilitates building agents and workflows on top of LLMs, by providing a standard to integrate with external data sources and tools like databases, APIs, business tools, repositories, development environments, and more. By connecting LLMs with external data systems, agents can return more intelligent, context-aware responses in complex AI workflows.

How MCP Works: A Protocol for Context-Driven Agent-Tool Communication

MCP works following a client-server model where host applications can connect to multiple servers:

• MCP Hosts: Programs like Claude Desktop, IDEs, or AI tools that access data through MCP
• MCP Servers: These are programs that expose specific capabilities through MCP. External tools or data sources — like file systems, development tools, business tools, and more implement the MCP protocol that allow LLMs to securely connect with them.
• MCP Clients: These are applications that connect to MCP servers. A typical example of an MCP client is an LLM-powered chatbot.
• Local data sources: Your computer’s files, databases, and services that MCP can access
• Remote services: External systems available over the internet—typically via an API—that MCP servers can access

MCP servers expose APIs and endpoints that allow MCP clients to connect and exchange information. Since its launch, MCP has gained massive traction as the standard for providing LLMs access to a broader tool ecosystem.

Check out MCP’s documentation.

Are A2A and MCP Addressing Different Use Cases?

Google carefully positioned A2A as a complementary protocol to MCP, explaining how each solve different problems in the multi-agent ecosystem. In the announcement, Google mentions, “A2A is an open protocol that complements Anthropic's MCP, which provides helpful tools and context to agents.”

In the A2A documentation, on a page titled A2A ❤️ MCP, Google provides an example of a car repair shop use case to demonstrate how A2A and MCP could work together:

MCP is the protocol to connect these agents with their structured tools (e.g. raise platform by 2 meters, turn wrench 4 mm to the right).

A2A is the protocol that enables end-users or other agents to work with the shop employees ("my car is making a rattling noise"). A2A enables ongoing back-and-forth communication and an evolving plan to achieve results ("send me a picture of the left wheel", "I notice fluid leaking. How long has that been happening?"). A2A also helps the auto shop employees work with other agents such as their part suppliers.

At face value, this positioning seems logical. However Google’s entire claim is based on a clear distinction between agents and tools. Are we really looking at two separate use cases, or is the difference between inter-agent communication and intelligent tool orchestration not so clear-cut?

Is Google Challenging MCP with A2A?

Do we actually need both MCP and A2A to build multi-agent systems? While Google has positioned A2A as a complementary protocol to MCP, some industry voices question that in practice A2A and MCP might clash.

In theory they can coexist, in practice I foresee a tug of war. Developers can only invest their energy into so many ecosystems.

As Hykes points out, the distinction between agents and tools is often not so clear-cut. Tools are evolving into more agent-like systems and, conversely, agents are increasingly relying on tools to function effectively.

Also, as he highlights, adoption drives use, and that’s where the real battle lies.

While both protocols might theoretically have their place in the AI ecosystem, the future will depend on adoption.

During its A2A announcement, Google made sure to include a whole collection of partners to show support in the ecosystem, noticeably Anthropic and OpenAI - who recently got onboard and adopted MCP - are both missing.

Why Did Google Build A2A?

According to the announcement, Google is building A2A:

To maximize the benefits from agentic AI, it is critical for these agents to be able to collaborate in a dynamic, multi-agent ecosystem across siloed data systems and applications. Enabling agents to interoperate with each other, even if they were built by different vendors or in a different framework, will increase autonomy and multiply productivity gains, while lowering long-term costs.

With A2A (Agent-to-Agent), Google is placing a bet: the future of AI will be driven by interoperable, multi-agent systems.

And the timing of this bet is interesting.

Just two weeks ago, OpenAI took the leap and publicly adopted MCP. A few days later, Google's CEO Sundar Pichai asked:

to MCP or not to MCP?

Then, just a day after A2A was released, Demis Hassabis, Google Deepmind’s CEO and co-founder, stated their plans to support MCP in Gemini models and SDK.

So now, two protocols are emerging from two AI heavyhitters. By launching A2A and publicy backing MCP, it seems Google is hedging its bets by supporting the community-back standard while pushing its own vision for how agents should coordinate.

It remains to be seen whether the community and the tech ecosystem will adopt A2A.

A2A or MCP? Simplicity Will Win

We’ve seen this before: the battle between similar technologies.

In the early days of web services, technologies like XML and SOAP were the standards. These were highly complex formats that offered a lot of capability for enterprise-level systems but were also cumbersome and difficult to work with.

The eventual winner in this space was JSON (JavaScript Object Notation), which, despite being simpler and less feature-rich, became the dominant format for web data exchange.

The open-source community helped drive its adoption, making it much easier to implement than SOAP or XML. The simplicity of JSON made it a more attractive option, even though it didn’t offer the extensive capabilities of its more complex counterparts.

An important lesson of this and the other tech wars: Simplicity and ease of use win out.

The Future of AI Protocols and Agents

How will Anthropic respond to A2A? Time will tell. I sure hope to see an answer soon.

By embracing both protocols, Google seems to be positioning itself to claim a stake in the agent communication space. It’ll be an uphill battle given the community-driven momentum behind MCP, and its strong adoption in the community.

The real battleground for AI protocols is about adoption. The protocol, or protocols, that win will be the one that develops use, tools support, and the ecosystem gets behind.