What Is the A2A Protocol? How AI Agents Work With Other Agents

The A2A protocol (Agent2Agent) is an open standard that lets an AI agent discover another agent, send it work, and get results back, even when the two were built by different teams on different frameworks and neither can see the other's memory, tools or code. One agent publishes an agent card describing what it can do, and another agent reads that card and sends it messages and tasks over HTTP.

That is the whole idea in two sentences. The rest of this guide covers how it works in the current spec, which changed a lot between version 0.3 and 1.0. Many explainers still describe the older version, so if you have read one before, check the 0.3 to 1.0 table further down.

Every protocol fact here links to the A2A specification or the official docs at a2a-protocol.org, read on 13 November 2026. If you want to pick an SDK rather than understand the protocol, read our companion guide, A2A protocol SDKs and frameworks compared.

What is A2A, in plain terms?

If you are asking "what is A2A", think of it as a common language for agents that need to delegate. The A2A spec repo calls it "an open protocol enabling communication and interoperability between opaque agentic applications." Opaque is the key word: a remote agent is a black box to the agent calling it. The caller sees what the agent says it can do, not how it does it.

The key concepts page names three actors:

• User: a human or an automated service that wants something done.
• A2A client (client agent): an app, service or agent that acts for the user and sends requests.
• A2A server (remote agent): an agent that exposes an HTTP endpoint implementing A2A and does the work.

A travel assistant (the client) might hand a booking to an airline's agent and a hotel's agent (two servers). It never needs their internal tools or prompts. It only needs their cards and the A2A message format.

A short history, with dates

• 9 April 2025: Google announced the Agent2Agent Protocol on the Google Developers Blog, "with support and contributions from more than 50 technology partners," and described it as complementing MCP.
• Later: the project moved to the Linux Foundation. The spec repo README describes it as "an open source project under the Linux Foundation, contributed by Google."
• Version 1.0.0: the spec site lists 1.0.0 as the latest released version, with 0.3.0, 0.2.6 and 0.1.0 before it (specification).
• 27 August 2026: the A2A blog announced that A2A was accepted as a Growth Stage project at the Agentic AI Foundation, the same foundation that hosts MCP and AGENTS.md.

The A2A agent card

An A2A agent card is a JSON document that an A2A server publishes so other agents can find it and learn how to call it. It is the discovery half of the protocol.

Where it lives. The agent discovery page recommends serving it at https://{agent-server-domain}/.well-known/agent-card.json, following RFC 8615. You will still see /.well-known/agent.json in older tutorials and code. If a client cannot find a card, check which path the server uses.

What it holds in v1.0. According to the specification, the main fields are:

Field	What it tells a client
name, description, version, provider	Who the agent is and who runs it
supportedInterfaces	One entry per endpoint: its url, protocolBinding (JSON-RPC, gRPC or HTTP+JSON) and protocolVersion
capabilities	Flags such as streaming, pushNotifications, extensions and extendedAgentCard
skills	What the agent can do: each skill has an id, name, description, tags, examples and input and output modes
defaultInputModes, defaultOutputModes	Media types it accepts and returns by default
securitySchemes, securityRequirements	How a client must authenticate (API key, HTTP auth, OAuth 2.0, OpenID Connect or mutual TLS)
signatures	Optional signatures over the card, using JWS (RFC 7515) and JSON canonicalisation (RFC 8785)

Public card, extended card. The public card can stay short. An agent that sets capabilities.extendedAgentCard can return a fuller card to authenticated clients through the GetExtendedAgentCard operation. The discovery page recommends this for anything sensitive, and "strongly recommends the use of out-of-band dynamic credentials rather than embedding static secrets within the Agent Card." In other words: never put an API key in a card.

Three ways to find agents. The discovery page lists a well-known URI (for public agents), curated registries (a catalogue you query by skill or tag), and direct configuration (a URL in a config file or environment variable). It also says the spec "does not prescribe a standard API for curated registries," so every registry works a little differently today.

How an A2A task works

Once a client has the card, the rest of the A2A protocol is about messages and tasks. These are the core objects in v1.0, from the specification:

• Message: one turn of conversation, from ROLE_USER (the client) or ROLE_AGENT (the server). It carries one or more parts.
• Part: a single piece of content. Each part holds exactly one of text, raw (bytes), url (a file reference) or data (structured JSON), plus an optional mediaType and filename.
• Task: a unit of work with an id, a contextId that groups related tasks, a status, a history of messages and any artifacts.
• Artifact: an output the agent produced, such as a document, an image or a JSON result, built from parts.

A task moves through states. In v1.0 they are named in upper case:

State	Meaning
TASK_STATE_SUBMITTED	Received, not started
TASK_STATE_WORKING	In progress
TASK_STATE_INPUT_REQUIRED	Paused: the agent needs more from the client
TASK_STATE_AUTH_REQUIRED	Paused: the agent needs the client to authenticate
TASK_STATE_COMPLETED	Finished, artifacts available
TASK_STATE_FAILED	Ended with an error
TASK_STATE_CANCELED	Cancelled by the client
TASK_STATE_REJECTED	The agent declined the task

The two "required" states are what make A2A different from a one-shot API call. An agent can stop halfway, ask a question, and carry on in the same task when the answer arrives.

Three ways to get results

The key concepts page describes three delivery patterns:

1. Request and poll. Send a message with SendMessage, then check progress with GetTask.
2. Streaming. SendStreamingMessage returns Server-Sent Events over an open HTTP connection, with status and artifact updates as they happen. SubscribeToTask reconnects to a running task.
3. Push notifications. For long jobs, the client registers a webhook and "the server calls a client-provided webhook on a significant task update." Write your webhook handler so a repeated notification does no harm.

The v1.0 operations

Operation	What it does
SendMessage	Send a message, start or continue a task
SendStreamingMessage	Same, with a live event stream
GetTask	Read a task's status, history and artifacts
ListTasks	List tasks, with cursor-based pagination (new in 1.0)
CancelTask	Ask the agent to stop
SubscribeToTask	Re-attach to a running task's stream
CreateTaskPushNotificationConfig (plus Get, List and Delete)	Manage webhooks for a task
GetExtendedAgentCard	Fetch the fuller card after authenticating

Each operation is available over three bindings: JSON-RPC 2.0, gRPC and HTTP+JSON (REST). In the REST binding, sending a message is POST /message:send. Authentication happens at the HTTP layer: the key concepts page says credentials such as OAuth tokens and API keys "are typically passed through HTTP headers, separate from the A2A protocol messages themselves."

What changed in A2A 1.0

Explainers written for 0.2 or 0.3 predate these changes. The official What's New in v1.0 page lists several breaking changes from 0.3. If you are reading an older tutorial, or two agents refuse to talk to each other, check these first.

Area	In 0.3	In 1.0
Method names	message/send, message/stream, tasks/get, tasks/cancel, tasks/resubscribe	SendMessage, SendStreamingMessage, GetTask, CancelTask, SubscribeToTask
Listing tasks	Not available	ListTasks, cursor-based
Task states	submitted, input-required, completed and so on	TASK_STATE_SUBMITTED, TASK_STATE_INPUT_REQUIRED, TASK_STATE_COMPLETED and so on
Roles	user, agent	ROLE_USER, ROLE_AGENT
Parts	Separate TextPart, FilePart, DataPart, told apart by a kind field	One unified Part; the kind field is removed; mediaType replaces mimeType
Endpoints on the card	Top-level url, preferredTransport, additionalInterfaces	One supportedInterfaces[] list, each entry with its own protocolVersion
Extended card flag	supportsAuthenticatedExtendedCard	capabilities.extendedAgentCard
Extended card method	agent/getAuthenticatedExtendedCard	GetExtendedAgentCard
Stream events	final flag on status updates	final removed; events wrapped as statusUpdate or artifactUpdate
OAuth flows	Implicit and password flows allowed	Implicit and password removed; device code (RFC 8628) added; pkce_required on authorization code
REST paths	/v1 prefix	No /v1 prefix
Multi-tenancy	None	tenant field on requests and interfaces

Several official SDKs keep a 0.3 compatibility mode while the ecosystem moves over, as we noted in the SDK guide. When you connect two agents, compare the protocolVersion on each entry in their supportedInterfaces before you debug anything else.

A2A vs MCP

A2A vs MCP is the most common question about the protocol, and the official docs answer it directly. The A2A and MCP page says "MCP is vertical. It deepens a single agent," while "A2A is horizontal. It connects agents across that boundary." Put shortly: A2A connects agents to each other, and MCP connects each agent to its own tools.

	A2A	MCP
Connects	Agent to agent	Agent (or AI app) to tools and data
The other side is	An agent that reasons, plans and can ask questions back	A tool or resource with defined inputs and outputs
Discovery	Agent card at /.well-known/agent-card.json	The client's MCP config, or a registry
Long work	Tasks with states, streaming and push notifications	Mostly request and response tool calls
Visibility	Remote agent is opaque	The client sees each tool's schema
Governance (as of 13 Nov 2026)	Agentic AI Foundation, Linux Foundation	Agentic AI Foundation, Linux Foundation

They are designed to be used together. A typical system has a coordinating agent that talks to specialist agents over A2A, and each specialist uses MCP servers for its database, files and APIs. If MCP is new to you, start with what an MCP server is and MCP vs API.

One more name that gets mixed up with these: ACP, the Agent Client Protocol, connects a code editor to a coding agent. It is neither A2A nor MCP. Our agent protocols hub covers all of them, including x402 and AP2 for agent payments.

Try it: talk to an A2A agent

Check the current SDK version. Run on 13 November 2026, this returned a2a-sdk (1.3.0) from PyPI and 1.3.0 for the JavaScript SDK on npm:

pip index versions a2a-sdk
npm view @a2a-js/sdk version

Fetch an agent's card. This is the standard discovery request, written for this post from the discovery page; it was not run against a live agent:

curl -s https://AGENT-DOMAIN/.well-known/agent-card.json

Read supportedInterfaces to see which bindings and protocol versions it speaks, and skills to see what it does.

Run the official hello world. Quoted from the A2A Python SDK README, not run for this post:

pip install a2a-sdk
git clone https://github.com/a2aproject/a2a-samples.git
cd a2a-samples/samples/python/agents/helloworld
uv run .
# in a second terminal, same folder
uv run test_client.py

To inspect any agent from a browser, the A2A Inspector fetches a card, detects whether it is v1.0 or v0.3, checks it against the spec and shows every request. For the full list of open-source A2A projects we track, see the A2A directory.

Before you connect your agent to someone else's

A2A makes it easy to hand work to an agent you do not control, which is exactly why you should look before you connect. A remote agent is opaque by design, so the card is most of what you get. Some checks that need no special tools:

• Does the card ask for credentials the right way? It should declare securitySchemes and expect credentials out of band. A card with a key pasted in it is a red flag.
• Is the card signed? v1.0 supports signatures. An unsigned card is common today, but a signed one lets you check it has not been altered.
• What will you send it? Everything in your messages and parts leaves your system. Do not pass data the remote agent does not need.
• If it is open source, what can it touch? For agents and SDKs listed on AgenticMart, the listing page has a "What it can touch" section, and you can read our checklist for judging an AI agent.

If you are building agents or tools around A2A, the AgenticMart developer API, MCP endpoint and CLI let you search the directory from your own code or AI app.

FAQ

What is A2A in AI?

A2A, short for Agent2Agent, is an open protocol for AI agents to discover each other and work on tasks together. Google announced it in April 2025, and it is now a Linux Foundation project under the Agentic AI Foundation. Agents built on different frameworks can cooperate without exposing their internal tools or memory.

What is an A2A agent card?

An A2A agent card is a JSON file that describes an agent: its name, endpoints, skills, capabilities and how to authenticate. It is usually served at /.well-known/agent-card.json on the agent's domain. Client agents read it to decide whether and how to call the agent.

A2A vs MCP: what is the difference?

MCP connects one agent to tools and data, such as a database or an API. A2A connects one agent to another agent that can reason, ask questions and run long tasks. The A2A docs describe them as complementary, and many systems use both.

Is the A2A protocol open source?

Yes. The specification and the official SDKs are published under the Apache 2.0 licence in the a2aproject GitHub organisation. Governance sits with the Linux Foundation through the Agentic AI Foundation.

What is the current version of the A2A protocol?

As of 13 November 2026, the spec site lists 1.0.0 as the latest released version, and the Python and JavaScript SDKs are at 1.3.0 (SDK versions are numbered separately from the spec). Version 1.0 renamed methods and task states, so code written for 0.3 needs updating or a compatibility mode.

Do I need A2A if I only have one agent?

Probably not. A2A is for handing work between agents, especially agents run by different teams or companies. A single agent that calls tools needs MCP or plain APIs.

List your A2A agent or SDK

Built an A2A agent, SDK or tool? Developers looking for agents to connect to browse the A2A directory and agents on AgenticMart. You can list free now, paid selling opens soon. List your project, or read how selling on AgenticMart will work.