AgentProtocol.ai
Protocol selectorCompare protocols
//the standards

Agent2Agent protocol (A2A)

Agent2Agent (A2A) is an open protocol for communication and task delegation between independent AI agents — potentially built by different teams or vendors. This guide explains agent cards, tasks and messages, and when A2A is the right layer.

Layer: agent ↔ agentStatus: emerging

What is the Agent2Agent protocol?

Agent2Agent (A2A) is an open protocol, introduced by Google, that lets independent AI agents talk to one another. Where MCP connects an agent to its tools, A2A connects an agent to other agents — so one can delegate work to another even if they were built separately.

The goal is a world where a specialist agent (say, a travel-booking agent) can be discovered and called by a generalist agent, without either side hard-coding knowledge of the other.

How A2A works

A2A builds on familiar web foundations — HTTP, JSON-RPC-style messages and server-sent events for streaming. A few concepts do most of the work:

  • Agent card — a machine-readable document advertising an agent's identity, capabilities and endpoint, so others can discover what it can do.
  • Task — a unit of work one agent asks another to perform, with a lifecycle (submitted, working, completed, failed).
  • Message — the exchange of content between agents during a task, including intermediate updates.
  • Artifact — an output produced by the receiving agent and returned to the caller.
agent-card.json
json
// A simplified agent card advertising capabilities
{
  "name": "Flight Booking Agent",
  "description": "Searches and books flights",
  "url": "https://agents.example.com/flights",
  "capabilities": { "streaming": true },
  "skills": [
    { "id": "search_flights", "name": "Search flights" },
    { "id": "book_flight", "name": "Book a flight" }
  ]
}
Discovery before delegation
The agent card is what makes cross-vendor delegation possible: a calling agent reads the card to learn what a remote agent can do, then sends a task. No shared codebase required.

When to use A2A

  • You're building a multi-agent system where agents specialise and hand work to one another.
  • You want agents from different vendors or teams to interoperate.
  • You need agents to discover capabilities at runtime rather than via hard-coded integrations.
Still emerging
A2A is newer and less battle-tested than some alternatives, and the spec is evolving. If you adopt it early, pin to a specific version and track changes against the official documentation.

A2A alongside MCP

A2A and MCP are complementary. A common pattern: each agent uses MCP to reach its own tools and data, and A2A to delegate sub-tasks to peer agents. See how they line up in the full comparison, or read about the broader goal on AI agent interoperability.

//questions

Frequently asked questions

What is the difference between A2A and MCP?

MCP connects a single agent to tools, data and context. A2A connects independent agents to each other for task delegation. They operate at different layers and are frequently used together.

Who maintains A2A?

Agent2Agent was introduced by Google as an open protocol. AgentProtocol.ai is independent and not affiliated with Google; always confirm current details against the official A2A documentation.

Is 'A2A' the same as 'agent-to-agent'?

A2A is a specific named protocol for agent-to-agent communication. 'Agent-to-agent' is also used generically for any communication between agents. See our agent-to-agent protocol page for the general concept.

// AgentProtocol is independent and not the official source for any protocol named here.