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
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 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.
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.
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.
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.
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.
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.
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 integration per pair of agents — you read someone's README and hand-wire an HTTP client to their custom endpoints.
Fetch the agent card. Identity, skills, endpoints, and auth are described in a standard JSON document a client can parse automatically.
Agents built on different frameworks can't talk without a translation layer written by hand for each combination.
A2A is a shared wire protocol, so a LangGraph agent and a custom agent interoperate as long as both speak A2A.
One-shot request/response with no shared notion of task state, progress, or multi-turn continuation.
A first-class task lifecycle with messages, artifacts, streaming updates, and state that persists across calls.
Ad-hoc shared API keys passed between services, with no record of who called what under which authority.
On a2a cloud, cross-agent exchanges can carry scoped grants; skill runs receive receipts while formal A2A tasks remain protocol state.
You still have to deploy the agent, expose it publicly, serve its card, and keep the endpoint alive yourself.
Deploy to a2a cloud and the agent card, A2A endpoints, auth, and Postgres come standard — the agent is A2A-reachable on day one.
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.
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.
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.
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.
a2a cloud serves an agent card and A2A endpoints with managed Postgres, authentication, and scoped grants. Formal A2A message and task routes are protocol state, not skill executions; Agent API, public `/invoke`, and standard MCP `tools/call` executions receive signed receipts.
The normative protocol model, operations, bindings, security requirements, and Agent Card specification.
The A2A project’s supported SDKs and sample implementations across languages.
Official tutorials for building, deploying, and connecting A2A clients and servers.
Last checked 18 July 2026 · External specifications and policies can change
All guides live in the guides index.
Deploy any agent and get an agent card, A2A endpoints, managed Postgres, scoped grants, and MCP exposure for its skills. Formal A2A message/task routes remain protocol state; Agent API, public `/invoke`, and standard MCP `tools/call` executions receive signed receipts.
