What is the A2A protocol.
A2A — Agent2Agent — is an open protocol that lets AI agents discover one another and delegate work over HTTP, no matter who built them or what framework they run. Every agent publishes an agent card describing its skills, and callers send tasks against those skills. This is the guide to how it works and why it matters.
open protocol · agent cards · task delegation
Agents that can't talk to each other aren't a system.
Most agents are islands. Each one is built on its own framework, exposes its own bespoke endpoints, and speaks its own ad-hoc format. To make two agents cooperate, someone reads a README and hand-wires an HTTP client per pair. That doesn't scale past a handful of integrations, and there's no shared way to describe what an agent can do or how to reach it.
A2A: a shared language for agents to find and delegate to each other.
A2A standardizes the parts that were bespoke — how an agent describes itself, how a caller discovers it, and how tasks and results flow between them. Here are the pieces every developer should understand.
An open protocol for agent interop
A2A (Agent2Agent) is an open protocol for one AI agent to discover and delegate work to another over HTTP, regardless of who built it or what framework it runs on. It standardizes the wire format so agents from different vendors can cooperate.
The agent card
Every A2A agent publishes an agent card — a machine-readable JSON document describing its identity, skills, endpoints, and how to authenticate. A client agent fetches the card to learn what a remote agent can do before it calls anything.
Skills as the unit of work
An A2A agent advertises named skills in its card. A caller sends a task targeting a skill; the remote agent runs it and returns results. Skills are how capabilities are described, discovered, and invoked across the boundary.
Tasks, messages, and artifacts
Work is modeled as a task with a lifecycle. Agents exchange messages within a task and return artifacts as output. The task carries state, so long-running and multi-turn collaborations survive across calls.
Streaming and long-running work
A2A supports streaming updates and push notifications so a caller can follow a task that takes seconds or hours, rather than blocking on a single request. Agents report progress instead of pretending everything is instant.
Built to complement MCP
A2A handles agent-to-agent coordination; MCP (Model Context Protocol) handles an agent's connection to its own tools and data. They solve different layers — a robust agent system uses both. See our A2A vs MCP explainer.
Bespoke integrations vs. an open A2A protocol.
Frequently asked.
What is the A2A protocol?
A2A (Agent2Agent) is an open protocol that lets AI agents discover and delegate tasks to each other over HTTP, independent of vendor or framework. Each agent publishes an agent card describing its skills and endpoints, and callers send tasks against those skills. It standardizes agent-to-agent communication the way HTTP standardized web requests.
What is an agent card in A2A?
An agent card is a machine-readable JSON document an A2A agent publishes to advertise itself: its identity, the skills it offers, its service endpoints, and how to authenticate. A client agent fetches the card first to learn what a remote agent can do before sending it any tasks.
How do A2A agents discover and call each other?
A calling agent retrieves the target's agent card to learn its skills and endpoints, then sends a task targeting a named skill. The remote agent runs the task and returns messages and artifacts, optionally streaming progress for long-running work. Discovery is driven by the standard card format rather than bespoke per-agent integration.
Is A2A the same as MCP?
No. MCP (Model Context Protocol) connects a single agent to its tools and data sources. A2A connects agents to each other for delegation and collaboration. They operate at different layers and are complementary — many production systems use both. See our A2A vs MCP page for a full comparison.
How does a2a cloud host A2A agents?
a2a cloud is A2A-native: when you deploy an agent, it automatically serves a valid agent card and A2A endpoints, with managed Postgres, authentication, scoped grants, and a signed receipt for every run. Your agent is discoverable and callable by other A2A agents without you wiring the transport yourself.
Related guides.
All guides live in the guides index.
Ship an agent other agents can call.
a2a cloud is A2A-native. Deploy any agent — LangGraph, OpenAI Agents SDK, CrewAI, or custom — and it comes with a valid agent card, A2A endpoints, managed Postgres, scoped grants, and a signed receipt for every run. It's discoverable and callable by other A2A agents on day one, and every skill is also exposed as an MCP tool. One deploy, the whole agent app, speaking the open protocol.