A2A 1.0 standardizes HTTP, SSE, agent cards, and task lifecycles for multi-agent systems. Use this 2026 reference to deploy portable agents. Read now.
What A2A 1.0 Standardizes
A2A gives agents a shared way to talk to each other over infrastructure teams already run. Instead of every framework inventing its own message envelope and transport, the protocol settles on plain HTTP for request/response and Server-Sent Events (SSE) for streaming updates back to a caller. That choice matters because it means an agent is reachable the same way any web service is: no special client library, no proprietary socket layer, and no assumptions about which language or runtime lives on the other side.
The goal is portability. When two agents agree on how requests are shaped, how work is described, and how progress is reported, you can swap one implementation for another without rewriting the caller. A2A defines that contract so a multi-agent system can be assembled from parts built by different teams.
Agent Cards and Discovery
An agent card is the machine-readable description an agent publishes about itself: what it can do, how to reach it, and what inputs it expects. A calling agent reads the card to decide whether the target is a fit for a given task, rather than hard-coding assumptions about its behavior. This turns discovery into a lookup instead of a guess.
Treat the card as a public interface. Keep it accurate to what the agent actually does, and version it deliberately when capabilities change, because other agents route decisions off of it. A few things worth being explicit about:
- The concrete skills or task types the agent handles, so callers don't send work it will reject.
- The endpoint and transport details a caller needs to open an HTTP connection or subscribe to an SSE stream.
- Any input structure the agent requires, so requests are well-formed on the first try.
Task Lifecycles and Streaming
A2A models work as a task with a lifecycle rather than a single blocking call. A caller submits a task, the receiving agent accepts it and moves it through states as it works, and the caller observes those transitions. This fits agent work well, where a request may take seconds or minutes and produce intermediate results before a final answer. SSE carries those updates as they happen, so the caller sees progress instead of waiting silently for one response.
Designing around explicit states also makes failure handling honest. Because each task has a status a caller can inspect, you can distinguish "still running" from "failed" from "done," retry only what needs retrying, and surface partial output to a user while the rest completes.
Deploying Portable Agents
To get the portability A2A promises, keep your agent's HTTP surface conformant and its agent card truthful, and let the task lifecycle be the single source of truth for status. Avoid leaking framework-specific behavior into the interface; anything a caller depends on should be described by the card and the protocol, not by out-of-band knowledge of your internals.
Start by making one agent speak A2A cleanly and confirm another can discover it, call it, and consume its streamed updates end to end. Once that round trip works, adding more agents becomes a matter of publishing cards and wiring endpoints rather than re-solving how agents communicate each time.