Agent-to-Agent Protocol (A2A)
An open protocol introduced by Google that defines a standard communication layer for autonomous AI agents to discover, invoke, and collaborate with one another across organizational and framework boundaries.
Definition
Agent-to-Agent Protocol (A2A) is an open specification released by Google in April 2025 that addresses a specific gap in the agent ecosystem: while protocols like MCP standardize how an agent connects to tools, A2A standardizes how an agent connects to other agents. It provides a vendor-neutral interface for agent discovery, task delegation, and result exchange across heterogeneous systems.
A2A is designed to be complementary to MCP: MCP handles agent-to-tool communication; A2A handles agent-to-agent communication.
Core Concepts
Agent Card
Every A2A-compliant agent publishes a machine-readable Agent Card — a JSON metadata document (typically served at /.well-known/agent.json) that describes:
- The agent's name, description, and provider.
- The capabilities and skills it exposes.
- The authentication schemes it accepts.
- The interaction modes it supports (text, files, structured data, streaming).
Agent Cards enable dynamic discovery: a client agent can fetch a provider's Agent Card to determine whether it can fulfill a given task before committing to a call.
Tasks
The fundamental unit of A2A interaction is a Task. A client agent sends a task to a remote agent specifying:
- A unique task ID.
- The request message (text, file attachments, or structured data).
- An optional session ID for multi-turn interactions.
The remote agent responds with a Task object containing its state (submitted, working, input-required, completed, failed, canceled) and one or more artifacts — the outputs of the task (documents, structured results, images).
Streaming and Long-Running Tasks
A2A supports Server-Sent Events (SSE) for streaming partial results and status updates during long-running tasks. This is critical for agentic workloads where a remote agent may take seconds or minutes to complete.
Human-in-the-Loop via input-required
When a remote agent needs clarification it cannot resolve itself, it transitions the task to input-required state. The client agent surfaces this to the user or supervisor agent, collects the input, and resumes the task. This makes HITL a first-class concept in the protocol.
How A2A and MCP Relate
| Dimension | MCP | A2A |
|---|---|---|
| Primary relationship | Agent ↔ Tool/Resource | Agent ↔ Agent |
| Capability unit | Tool, Resource, Prompt | Skill (via Agent Card) |
| Initiated by | Agent (client) | Agent (client) |
| Response style | Synchronous function result | Async Task with state machine |
| Discovery mechanism | Server connection | Agent Card at well-known URL |
In practice, a sophisticated agent system uses both: MCP to integrate with databases, APIs, and file systems; A2A to delegate to specialized remote agents that may themselves use MCP internally.
Why It Matters
As agent ecosystems mature, organizations will deploy dozens of specialized agents — a code-review agent, a data-analysis agent, a customer-support agent. A2A enables these agents to interoperate without tight coupling:
- A supervisor agent can delegate to the most capable available agent for a sub-task, regardless of which framework built it.
- Agents built on different stacks (LangGraph, CrewAI, Pydantic AI, custom) can collaborate through a common protocol.
- Trust boundaries are explicit: agents expose only the skills defined in their Agent Card, and authentication is enforced at the protocol level.
Ecosystem
A2A is maintained by Google with contributions from Atlassian, Salesforce, SAP, MongoDB, and others. Reference implementations are available in Python and JavaScript, and the spec is open for community extension.