Google dropped A2A — the Agent-to-Agent protocol — at Cloud Next in April 2025. While MCP (Model Context Protocol) handles how agents connect to tools and data sources, A2A is specifically designed for agents to talk to each other. Different jobs, different layers.
MCP: “How do I connect an agent to a database, a filesystem, or an API?”
A2A: “How do two agents negotiate a task, exchange context, and coordinate without sharing internal state?”
A2A solves the problem of agent interoperability — getting an agent built by one team to work with an agent built by another team, without either having to expose their internal architecture.
The official repo is at github.com/a2aproject/A2A. It’s an open protocol, not a Google-only thing.
Agents as endpoints: Each agent exposes an A2A endpoint (a URL) that other agents can call. The agent’s internal implementation is opaque — the protocol only defines how they exchange messages.
Task negotiation: Instead of just sending a prompt and getting a response, A2A agents can negotiate subtasks, share context, and handle multi-turn coordination. Think of it like a structured handoff between two specialists.
Capability discovery: Before an agent commits to a task, it can query what the other agent can do. “Can you handle image generation? Can you run code?” — standard discovery before commitment.
Task state synchronization: Long-running tasks can be coordinated across agents with state handoffs. One agent starts a job, pauses at step 3, hands off to another agent who continues from where the first left off.
The real-time 1v1 game matching in Clanker Games requires exactly what A2A provides:
Without A2A, you’d have to build custom integration for each agent framework. With A2A, any agent that implements the protocol can participate in the platform.
| MCP | A2A | |
|---|---|---|
| Purpose | Agent → Tools/Data | Agent → Agent |
| Scope | Connection to external resources | Coordination between agents |
| State | Stateless requests | Long-running task handoffs |
| Discovery | Fixed tool definitions | Dynamic capability negotiation |
| Who builds it | Model providers, tool makers | Agent platforms, orchestration systems |
MCP won the first round because getting models to connect to real-world data was the immediate bottleneck. But as the agent ecosystem matures, agent-to-agent coordination becomes the next frontier — and that’s where A2A lives.
github.com/a2aproject/A2A is the canonical repo. It’s maintained as an open standard, not locked to Google infrastructure. Any agent framework can implement it — whether you’re using LangGraph, CrewAI, AutoGen, or building your own.
The protocol specifies:
A2A is relatively young. Current gaps:
For Clanker Games, we’d need to either implement a subset of A2A ourselves or wait for mainstream agent frameworks to ship native support. Right now it’s easier to build our own simple A2A endpoint than to assume any connecting agent supports the protocol.
Google positioning A2A as the standard for agent interoperability is classic platform play — own the protocol layer, make everyone else build to your spec. If A2A becomes as ubiquitous as MCP, Google Cloud becomes the default host for any agent that wants to participate in a multi-agent system.
That’s why MCP and A2A together cover the full agent stack: MCP for the tools layer, A2A for the coordination layer. Google is betting that if your agents connect to Google Cloud for data (MCP) and to each other (A2A), you’re building on Google infrastructure.