A2A — the protocol
that connects agent to agent

What A2A is and why it is needed

A2A — Agent-to-Agent Protocol — is an open standard launched by Google in April 2025, for passing messages and tasks between independent AI agents. The idea: in a world where every company builds agents, you need a shared language that lets one agent discover another, understand what it can do, and delegate a task to it — without manual integration for every pair.

Think of it like this: your sales agent needs to schedule a meeting. Instead of writing code that talks directly to the calendar system, it simply talks to the calendar agent over A2A — sends it a task, gets a result. The two agents can be from entirely different sources, and still collaborate.

A2A vs MCP — not competitors, complementary

The most common confusion: "so A2A replaces MCP?" Not at all. They deal with two entirely different connections, and in a real system you use both together:

The 2026 agent protocol stack

A2A and MCP are just two layers of a whole stack that took shape in 2026. Each layer solves a different connection, and they all complement each other:

How A2A works — Tasks, messages and Streaming

A2A runs over HTTP with JSON-RPC 2.0, so it fits into any existing web infrastructure. The three key concepts:

• Agent (Server / Client) — every agent can act as a server (receiving tasks) or a client (sending tasks). In one interaction agent A is the client and agent B is the server.
• Task — the unit of work. The client has a message/send to open a task; every Task has an ID and a lifecycle (submitted → working → completed / failed / input-required).
• Message & Parts — messages are made of Parts: text, files or structured data (JSON). This lets you pass not just text but also artifacts.

For long-running tasks, A2A supportsstreaming (Server-Sent Events) for progress updates, andpush notifications (webhooks) for agents that work for minutes or hours. If a task requires more input, the server returns an input-required state and the client provides it.

Agent Card — the agent's business card

How does an agent discover what another agent can do? Through theAgent Card — a JSON file the agent publishes (usually at/.well-known/agent-card.json) that describes its name, capabilities, endpoint URL, and authentication method. This is the basis for discovery.

{
  "name": "Calendar Agent",
  "description": "Schedules meetings and manages availability",
  "url": "https://calendar.example.com/a2a",
  "version": "1.0.0",
  "capabilities": { "streaming": true, "pushNotifications": true },
  "skills": [
    {
      "id": "schedule-meeting",
      "name": "Schedule a meeting",
      "description": "Finds a free slot and books a meeting between participants",
      "tags": ["calendar", "scheduling"]
    }
  ]
}

Who adopts it, and when it is worth it for you

A2A shipped a stable v1.0 in March 2026 and moved to governance by theAgentic AI Foundation Linux Foundation together with MCP. Over 150 organizations support it — including AWS, Google, Microsoft, Salesforce and SAP. This is no longer an experiment, but industry infrastructure.

When A2A is relevant for you

• Multi-agent systems — when you have several specialized agents that need to coordinate (Research → Write → Review), A2A is the glue between them.
• Cross-organization agents — when your agent needs to work with a vendor's or partner's agent, without manual integration.
• A Supervisor / Workers architecture — a supervisor agent that delegates to independent workers, each with its own Agent Card.