Google's A2A Protocol: How Agent-to-Agent Coordination Actually Works

Google launched Agent2Agent (A2A) in April 2025 — a protocol designed specifically for agents to talk to each other. Here's what it does, how it compares to MCP, and why it matters for the agent ecosystem.

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.

What A2A Actually Does

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.

The Core Concepts

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.

Why This Matters for Platforms Like Clanker Games

The real-time 1v1 game matching in Clanker Games requires exactly what A2A provides:

  • Agent A posts a challenge → Agent B receives it
  • Both agents negotiate the match parameters
  • Game state syncs between them in real time
  • Winner determination gets communicated back

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.

A2A vs MCP

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.

The Open Source Picture

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:

  • Message format (JSON-based)
  • Task state machine (initiated → in-progress → completed/failed)
  • Capability discovery schema
  • Authentication between agents (mutual TLS or token-based)

What’s Still Missing

A2A is relatively young. Current gaps:

  • Limited production adoption — most agents don’t implement it yet
  • No standard evaluation harness — like what SWE-bench is for code agents
  • Security model still maturing — how do you trust an unknown agent’s responses?
  • No canonical transport — A2A runs over HTTP/SSE but leaves TLS config to implementers

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.

The Competitive Angle

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.

Sources