A2A Protocol Guide 2026: How Agent-to-Agent Communication Actually Works

If 2024 was the year of single agents and 2025 was the year of MCP, 2026 is the year multi-agent systems stopped being a research demo. The protocol behind that shift — quietly, while everyone argued about which frontier model would win — is A2A, the Agent-to-Agent specification originally proposed by Google in April 2025 and now stable at v1.2 with more than 150 organisations running it in production.

This guide is the long-form explainer we wish existed when we first hooked an A2A-capable agent into our own stack. We will walk through what A2A is, what problem it solves, the four primitives at the heart of the spec, how it differs from (and complements) the Model Context Protocol, and a practical walkthrough of wiring two agents together.

The Short Version

A2A is the open protocol that lets agents from different vendors and frameworks discover, negotiate with, and delegate tasks to one another. It defines:

• Agent Cards — the manifest that tells the world what an agent can do, where to reach it, and how to authenticate.
• Tasks — the unit of work one agent gives another, with explicit lifecycle states.
• Messages — the structured exchanges that flow inside a task.
• Artifacts — the typed outputs an agent produces.

It runs over HTTPS using JSON-RPC 2.0 with Server-Sent Events for streaming. It is open, free, and supported natively by Google ADK, LangGraph, CrewAI, LlamaIndex Agents, Semantic Kernel, and AutoGen, with first-party gateways from Microsoft, AWS, Salesforce, SAP, ServiceNow, Workday, and IBM.

If MCP is how an agent talks to tools, A2A is how an agent talks to other agents. You will end up using both.

Why A2A Exists

Until the middle of 2025, every multi-agent system was a bespoke integration. If your sales agent needed to hand a deal to a finance agent, somebody wrote glue code. If you swapped the finance agent for a different vendor, you rewrote the glue. The pattern collapsed at any kind of scale.

There were three half-solutions in the wild:

• Function-calling each other directly — fast but brittle, with no shared task model, no streaming, and no shared identity.
• Calling each other’s chat APIs — works for a couple of agents, falls apart when one of them needs to push intermediate state.
• Running them all inside the same framework — works only if everyone agrees on the framework, which never happens at company scale.

A2A’s contribution is to standardise the interaction model so that any two agents that speak A2A can collaborate without a custom integration. You discover an agent’s Agent Card, post a Task to it, exchange Messages while it works, and collect Artifacts when it finishes. The transport, the lifecycle, the auth headers, and the error semantics are all in the spec.

The Four Primitives

Agent Cards

An Agent Card is a JSON document, served from a well-known URL (/.well-known/agent.json by convention), that advertises an agent’s identity and capabilities. A typical card has:

• name, description, version
• url — the JSON-RPC endpoint that accepts A2A traffic
• capabilities — feature flags like streaming, multi_turn, push_notifications, state_transitions
• skills — a list of named, schemata-described things the agent can do
• authentication — supported auth schemes (api_key, oauth2, mTLS, none)
• default_input_modes and default_output_modes — media types the agent expects

The Agent Card is what makes A2A discoverable. A client (which is itself often an agent) fetches the card, decides whether the remote agent has the skill it needs, and then opens a task.

Tasks

A Task is a long-running unit of work. It has an id, a status, and a list of messages and artifacts. Status transitions follow a strict lifecycle:

submitted → working → input_required (optional, may loop) → completed
                                                          → failed
                                                          → canceled

The strict lifecycle is the part that everybody underestimates. Once you have a real lifecycle, observability tools can plot it, retry logic can reason about it, and governance tools can audit it. We have seen multi-agent systems triple their reliability simply by moving off ad-hoc state to A2A’s task states.

Messages

Messages are the in-task exchanges. Each Message has a role (user, agent), a list of parts, and optional metadata. Parts are typed: text, file, data, and (since v1.1) tool_call_result. That last one is how A2A and MCP interoperate cleanly — when a remote agent calls a tool over MCP, it can return the structured result as a tool_call_result part in an A2A message without losing type information.

Artifacts

Artifacts are the things the remote agent produces for keeps — a generated report, a written file, a database row, a Slack message reference. Each artifact has an id, a name, a list of parts, and a list of index positions that let a client reassemble streamed artifacts in order.

Separating artifacts from messages is the second design decision that pays off in practice. Messages are conversational, ephemeral, and indexed by turn. Artifacts are durable, addressable, and indexed by name. You can attach the same artifact to multiple tasks. We have built audit dashboards that only render artifacts and skip messages — A2A gives you that affordance for free.

How A2A Differs From MCP

The single most common question we get is “isn’t this just MCP?” It is not. They solve adjacent problems.

Question	MCP	A2A
Who is the client?	A model / agent	A model / agent
Who is the server?	A tool (filesystem, database, API)	Another agent
What does the server do?	Executes a single action	Runs a stateful, possibly multi-turn task
Identity model	Client trusts server tools	Mutual; agents authenticate each other
Lifecycle	Request/response	submitted → working → completed
Streaming	Optional	First-class
Multi-turn	No (each call is independent)	Yes (input_required state)

The clean mental model: MCP is for capabilities, A2A is for collaborators. Your agent uses MCP to call a database, send an email, or read a file. It uses A2A to ask another agent — possibly run by a different team or company — to do something on its behalf.

In real production stacks, the two protocols compose. We have systems where the orchestrator is an A2A client of three specialist agents; each specialist agent is, in turn, an MCP client of a dozen tools. The orchestrator never sees the tools, and the specialists never see each other’s tools.

The Transport

A2A v1.2 ships three transport modes:

• Synchronous JSON-RPC 2.0 over HTTPS — for tasks that complete in under a few seconds.
• Server-Sent Events — the default for streaming intermediate messages, artifact chunks, and state transitions back to the caller.
• Push notifications via webhook — for tasks that take minutes to hours; the client supplies a webhook URL at task creation, and the agent pushes updates as the lifecycle advances.

Authentication is delegated to standard HTTPS headers — typically Authorization: Bearer … for API keys and OAuth2, or mTLS for service-to-service. The spec does not define an identity model of its own, which is intentional and important: you reuse your existing IdP.

Walking Through a Real Exchange

Here is a minimal, real example that shows the protocol on the wire. A sales-pipeline agent wants a finance agent to produce a quote.

1. Discovery. The sales agent fetches the finance agent’s card:

GET https://finance.example.com/.well-known/agent.json

The card includes a skills array with an entry called generate_quote and a url of https://finance.example.com/a2a.

2. Task creation. The sales agent posts a JSON-RPC tasks/send:

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "tasks/send",
  "params": {
    "id": "task-9f3...",
    "skill": "generate_quote",
    "message": {
      "role": "user",
      "parts": [{ "type": "text", "text": "Quote for 50 seats of plan Pro, 12-month term, Acme Corp." }]
    }
  }
}

The finance agent responds with status working and an SSE stream URL.

3. Streaming progress. The finance agent emits status updates and intermediate messages over SSE: state=working, then a message part "Pulling pricing tables...", then state=input_required with a question about discount eligibility, then state=working once the sales agent answers.

4. Artifact emission. Once the quote is ready, the finance agent emits an artifact:

{
  "artifact": {
    "id": "artifact-quote-2026-06-09-001",
    "name": "Quote.pdf",
    "parts": [
      { "type": "file", "mimeType": "application/pdf", "uri": "https://finance.example.com/files/q-2026-06-09-001.pdf" },
      { "type": "data", "data": { "total_usd_cents": 5400000, "expires_at": "2026-07-09T00:00:00Z" } }
    ]
  }
}

5. Completion. Task transitions to completed. The sales agent now has the structured data it needs to attach the quote to the CRM record.

The same exchange could have taken hours instead of seconds with push-notification transport, and the sales agent’s code would barely have changed.

Security and Governance

A2A’s security story rests on three pillars:

• Mutual identity — agents authenticate each other; there is no anonymous traffic in any of the production deployments we have seen.
• Scoped permissions — the Agent Card declares scopes, and the calling agent’s token must carry matching claims.
• Auditable lifecycles — every state transition is loggable, and the artifact registry gives you durable evidence of what was produced.

For enterprise rollouts we strongly recommend pairing A2A with an agent governance platform, since the protocol gives you the substrate but not the policies. Several vendors now ship A2A-aware governance products that intercept the JSON-RPC traffic, enforce per-skill quotas, and feed everything into your SIEM.

The Ecosystem in June 2026

Native A2A is in:

• Google ADK and Google Cloud’s Agent Engine — the reference implementation.
• LangGraph — first-class server and client decorators.
• CrewAI — multi-agent crews can expose themselves and consume external agents as full A2A participants.
• LlamaIndex Agents — Agent Cards generate from the existing agent metadata.
• Microsoft Semantic Kernel and AutoGen — both shipped A2A bindings in their 2026 spring releases.

First-party A2A gateways are in Salesforce Agentforce, SAP Joule, ServiceNow, Workday Illuminate, IBM watsonx, and Microsoft Copilot Studio. The interop story is real: we have demonstrated a Salesforce agent calling a Workday agent calling a CrewAI agent calling a Google-hosted Gemini agent inside a single task tree, with consistent observability end-to-end.

What to Build First

If you are new to A2A and want to put it into your own systems, start small:

1. Expose one of your internal agents as an A2A server. Even if no one else calls it, you immediately get a typed lifecycle and an Agent Card that your own services can consume.
2. Wrap one of your tools as an MCP server first. If you have not done this, do it before adding A2A. Tools and agents are easy to confuse; building each in isolation clarifies which is which. See our MCP guide.
3. Call one third-party A2A agent from one of yours. Salesforce Agentforce and ServiceNow are the easiest because their Agent Cards are public and well documented.
4. Add a governance layer before you have a hundred agents, not after. Pick one of the agent governance tools and put it in the path.

Common Pitfalls

• Skipping the Agent Card. People want to start with task semantics and add discovery later. Do the card first. The card forces you to name your skills, which forces you to think clearly.
• Conflating MCP and A2A. We keep saying this because we keep seeing it. Tools are not agents.
• Treating tasks as request/response. The lifecycle exists for a reason. If your client only ever expects completed on the first response, you have lost A2A’s biggest advantage.
• Bolting A2A onto a single-agent monolith and hoping for the best. If your “agent” is a chat endpoint with no internal state model, A2A will expose that. Fix the internal model first.

The Future

The A2A working group’s roadmap for the rest of 2026 covers cross-agent memory (agent memory tools are converging fast), capability-typed payments (so an agent can quote a price and receive funds for a task), and a formal evaluation harness — independent of any framework — for testing A2A compliance. The last one is what will move A2A from “widely adopted” to “boring infrastructure,” which is what every successful protocol eventually becomes.

If your 2026 includes more than two agents, you will be using A2A. The earlier you start, the less interop pain you inherit.

Further Reading

• Model Context Protocol guide 2026 — A2A’s tool-side counterpart.
• Best AI agent platforms 2026 — full lineup of products built on these protocols.
• Best AI agent frameworks 2026 — frameworks with native A2A support compared.
• Claude Managed Agents guide 2026 — Anthropic’s take on shipping production agents.
• Best AI agent governance tools 2026 — putting policy in front of agent traffic.