How AI agents talk to each other.

The A2A protocol, short for Agent2Agent, is an open standard that lets one AI agent find another, hand it a task and get the result back, even when different companies built them on different frameworks. Google launched it in April 2025. Version 1.0, the first stable release, shipped in March 2026, and since August 2026 A2A has lived in the Linux Foundation’s Agentic AI Foundation, next to MCP.

The quickest way to keep the two apart: MCP connects an agent to its tools, and A2A connects agents to each other.

01What is the A2A protocol?

Companies now run agents inside many products: a support agent in one tool, a sales agent in another, your own agent in your app. Without a shared standard, each pair needs custom glue code to cooperate. A2A is that shared standard.

That last point is the design idea. The specification says agents collaborate “without needing to share their internal thoughts, plans, or tool implementations.” A vendor can offer an agent without exposing its prompts, tools or data. You see what it can do and what it returns, not how.

Jobs can also be long. Google’s launch post said tasks may take hours or even days, so A2A lets agents report progress and ask for more input along the way. If you are new to agents working together, multi-agent systems covers when splitting a job pays off.

02How A2A works: agent cards, tasks and artifacts

1. 01

   Discover the agent

   The client fetches the remote agent’s Agent Card from /.well-known/agent-card.json on its domain. The card lists the agent’s skills, the address to call, the protocol versions it speaks and how to sign in.

2. 02

   Send a message

   The client sends a message made of parts: text, a file or structured data. The agent can answer at once with a message, or open a task for longer work.

3. 03

   Follow the task

   A task moves through states: submitted, working, input required, auth required, and finally completed, failed, canceled or rejected. The client can poll, stream updates as they happen, or register a webhook for push notifications.

4. 04

   Collect the artifacts

   Results come back as artifacts, the finished outputs of the task, made of the same kinds of parts.

Here is what that looks like on the wire. We ran a toy agent built on the official Python SDK (a2a-sdk 1.1.5), with no AI model behind it, and asked it for its card:

curl -s localhost:9999/.well-known/agent-card.json | jq .

{
  "name": "Distance converter",
  "description": "Converts kilometres to miles.",
  "supportedInterfaces": [
    {
      "url": "http://localhost:9999/",
      "protocolBinding": "JSONRPC",
      "protocolVersion": "1.0"
    }
  ],
  "version": "1.0.0",
  "capabilities": {
    "streaming": false
  },
  "defaultInputModes": [
    "text/plain"
  ],
  "defaultOutputModes": [
    "text/plain"
  ],
  "skills": [
    {
      "id": "km-to-miles",
      "name": "Kilometres to miles",
      "description": "Give a distance in km, get it in miles.",
      "tags": [
        "units",
        "conversion"
      ],
      "examples": [
        "How far is 42.195 km in miles?"
      ]
    }
  ]
}

Then we sent it a message and kept only the task’s status and artifacts from the reply:

curl -s localhost:9999/ \
  -H 'Content-Type: application/json' -H 'A2A-Version: 1.0' \
  -d '{"jsonrpc":"2.0","id":1,"method":"SendMessage","params":{"message":{"messageId":"m1","role":"ROLE_USER","parts":[{"text":"How far is 42.195 km in miles?"}]}}}' \
  | jq '.result.task | {status, artifacts}'

{
  "status": {
    "state": "TASK_STATE_COMPLETED",
    "timestamp": "2026-09-23T07:45:07.783542Z"
  },
  "artifacts": [
    {
      "artifactId": "4714f536-bb4b-4d80-9f64-105991ab114e",
      "name": "result",
      "parts": [
        {
          "text": "42.195 km is 26.22 miles"
        }
      ]
    }
  ]
}

03A2A vs MCP: what is the difference?

Both are open protocols, and both now live in the same foundation. They solve different problems. If MCP is new to you, start with what MCP is.

The A2A docs use a car repair shop as the example. Customers talk to a shop manager agent over A2A, and the manager hands jobs to mechanic agents. Each mechanic uses MCP to reach its own diagnostic scanners and repair manuals, and A2A to order parts from a supplier’s agent. In the docs’ words: “A2A connects the agents to each other; MCP connects each agent to its own tools.”

04Who runs A2A, and what changed in 1.0?

Google created A2A, then gave it to the Linux Foundation in June 2025. A technical steering committee with one voting member each from Google, Microsoft, Cisco, AWS, Salesforce, ServiceNow, SAP and IBM runs it. It works by consensus and votes when it has to. The license is Apache 2.0.

1. April 2025Google announces A2A with more than 50 technology partners
2. June 2025Google donates A2A to the Linux Foundation, with more than 100 companies supporting it
3. July 2025Version 0.3 adds signed Agent Cards and the agent-card.json path
4. August 2025IBM’s Agent Communication Protocol (ACP) merges into A2A
5. March 2026Version 1.0, the first stable release
6. April 2026More than 150 supporting organizations, per the Linux Foundation
7. August 2026A2A joins the Agentic AI Foundation as a Growth Stage project, alongside MCP, goose and AGENTS.md

Version 1.0 was a real break from 0.3, not a rename. The main changes:

• Separate transport mappings. One agent can be offered over JSON-RPC, gRPC and REST from the same definition.

• Verifiable Agent Cards. Version 1.0 spells out how to sign a card and check the signature, so a client can verify who published it.

• Multi-tenancy. Requests can name a tenant, so one endpoint can serve several separate customers or agents.

• Modern sign-in. The OAuth implicit and password flows were removed, and device code and PKCE were added.

• Task listing. A new method lists tasks with filters and pages.

05Who actually uses A2A in 2026?

Support in big platforms is real. Microsoft built A2A into Azure AI Foundry and Copilot Studio. Amazon Bedrock AgentCore Runtime hosts A2A servers and serves their Agent Cards at the standard path. The A2A project also lists Google Cloud, enterprise use at ServiceNow, Salesforce, Atlassian and SAP, and support in frameworks such as LangGraph, CrewAI, Pydantic AI, AG2 and IBM BeeAI.

Read those numbers carefully. “150 organizations” counts supporters, not live systems. The Linux Foundation’s first-year release names sectors, such as supply chain, financial services and insurance, rather than customers. We found few public case studies of agents from different companies working together over A2A. Most documented examples run inside one company or one cloud.

06Do you need A2A?

Probably not yet, if all your agents live in one app. Subagents that you start and call inside your own code can talk through plain function calls. Tools and data belong on MCP, and our list of MCP servers worth installing is a better first step.

A2A starts to pay off when:

• Other people’s agents need to call yours. Publishing an Agent Card turns your agent into a service anyone with access can discover.

• You must call an agent you do not control, such as a partner’s or a platform vendor’s.

• Teams use different frameworks. A2A lets a LangGraph agent and one built with Google’s Agent Development Kit work together without a custom bridge.

That fifth point matters more with agents. A message from another agent is still text your agent reads, so it can carry prompt injection. Give an agent reachable over A2A only the permissions its skills need.

07FAQ

Next, learn how MCP connects agents to tools, or see when several agents beat one.