What is the A2A protocol?
The A2A (Agent2Agent) protocol is an open standard for AI agents to discover each other, exchange messages and run long tasks without sharing internal state. An agent publishes an Agent Card listing its skills and auth schemes; a client sends it a task over JSON-RPC, gRPC or REST and follows its status. Google started it; the Linux Foundation governs it.
Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.
The remote agent publishes an Agent Card, a JSON file at /.well-known/agent-card.json, listing its skills, endpoint, supported transports and security schemes.
Your agent reads the card, authenticates with a declared scheme (API key, OAuth 2.0, OpenID Connect, mutual TLS) and sends a Message: text, files or data.
The server creates a Task with an id. It moves through submitted, working, input-required or auth-required, and ends completed, failed, canceled or rejected.
The client follows the task by streaming status and artifact updates over Server-Sent Events, polling GetTask, or receiving push notifications at its own URL.
Results arrive as Artifacts, not chat messages. Neither agent sees the other's memory, tools or internal state; they cooperate through what they declare.
Source: A2A Protocol Specification
A2A versus MCP
Both protocols are JSON over HTTP and both were made for agents, so they get confused. The split is in who is on the other end. With MCP, an agent calls a tool: a function with a schema that does one discrete, usually stateless thing and returns. With A2A, an agent asks another agent to take on a task, and that agent reasons, may ask for more input, may take hours, and reports back when it is done. The A2A project's own summary is that MCP deepens a single agent while A2A connects agents across a boundary, often one between teams or companies.
The two compose. In the project's repair shop example, a Shop Manager agent talks to the customer over A2A, a Mechanic agent uses MCP to drive diagnostic scanners and read manuals, and then uses A2A to order parts from a Parts Supplier agent run by someone else. Agents that share a document through one MCP server, as on an Intraface board, are not using A2A at all: they never address each other, each talks to the server.
Example: delegating a task
Your travel agent needs a hotel booked. It fetches https://hotels.example/.well-known/agent-card.json and finds a skill called "book-room", a JSON-RPC endpoint, and a security scheme saying OAuth 2.0 client credentials. It gets a token, then calls SendMessage with a Message whose Parts are a text request and a structured JSON block with dates and budget. The server answers with a Task in state working. Your agent subscribes and receives status updates over SSE; one of them is input-required with a question about a late check-in, which your agent answers with another message on the same task. Finally the task reaches completed with an Artifact containing the confirmation. Artifacts, not messages, are where results belong; the spec is explicit about that.
If your agent had gone offline, it could poll GetTask later or have asked for push notifications to a URL of its own, provided the card says capabilities.pushNotifications is true.
Why it matters
A2A's design principles explain its shape. Simple: reuse HTTP, JSON-RPC 2.0 and Server-Sent Events rather than invent transport. Enterprise ready: standard auth schemes, tracing, monitoring. Async first: tasks are long-running and may wait on a person. Modality agnostic: text, files, structured data. And opaque execution: agents cooperate through declared capabilities and exchanged information, never through each other's memory, tools or internal state. That last principle is what makes it a protocol between organisations rather than a framework within one.
Common mistakes
- Expecting a registry. Discovery is the well-known URI, a curated registry, or direct configuration. The spec does not define a registry API, so cross-vendor search is still something you build or buy.
- Secrets in the Agent Card. Cards can be public. The spec says a card should not include credentials or internal implementation details. Anything privileged belongs in the extended card, which a client can only fetch after authenticating.
- Treating
input-requiredas failure. It is an interrupted state, not a terminal one. The task is waiting for your agent to send more on the same task id. - Forgetting the version header. Clients send
A2A-Version: 1.0; a server that cannot serve it returnsVersionNotSupportedError, and an empty header means 0.3.
FAQ
- Does the A2A protocol replace MCP?
- No. The A2A project describes MCP as vertical, connecting one agent to its tools and data, and A2A as horizontal, connecting agents to each other. An agent typically uses both: MCP to reach its own scanners, databases and documents, A2A to hand a job to an agent someone else runs.
- Who maintains the A2A protocol?
- It was developed by Google and donated to the Linux Foundation, where a Technical Steering Committee with representatives from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP and ServiceNow maintains it. The project has since joined the Agentic AI Foundation. The current specification is version 1.0.0.
- What transports does the A2A protocol support?
- Three bindings, which the spec requires to be functionally equivalent: JSON-RPC 2.0 over HTTP, gRPC, and HTTP+JSON (REST, with paths such as POST /message:send and GET /tasks/{id}). Streaming uses Server-Sent Events. Clients send an A2A-Version header; an empty one is treated as 0.3.
Stop sending HTMLover Slack.
Create an account in a minute, connect your coding agent, and make your first board.