Short answer
The Agent2Agent protocol (A2A) is an open standard for communication between independent agents. Originated by Google, it lets one agent discover another's capabilities through an Agent Card, exchange messages, delegate tasks, and receive artifacts across vendor and framework boundaries. A2A reached v1.0 in March 2026 and joined the Agentic AI Foundation under the Linux Foundation in August 2026.
A2A governs communication between agents, not access from an agent to its tools. UHP is a younger, open, versioned standard for the separate application-to-harness boundary; it has a reference implementation, a local conformance suite, and at least one independent client implementation, and is still building its ecosystem. These layers can compose without implying that A2A or any other protocol endorses UHP.
- A2A is an open standard for communication between independent agents, using Agent Cards for capability discovery.
- It carries messages and tasks, uses context identifiers to group related interactions, returns artifacts, and supports streaming and long-running work.
- A2A reached v1.0 in 2026 and is hosted by the Agentic AI Foundation under the Linux Foundation.
- A2A is one boundary among several: it composes with MCP (agent-to-tools) and UHP (application-to-harness).
A2A in one sentence
The Agent2Agent protocol is an open standard that lets independent agents find each other, describe what they can do, and work together, so an agent from one vendor can delegate to an agent from another without a bespoke integration for each pairing.
What Agent2Agent standardizes
A2A standardizes how independent agents interoperate: how they advertise capabilities, how they send messages, how they hand off tasks, and how results come back as artifacts. It deliberately does not standardize how any single agent reasons internally, how it reaches its own tools, or how a product invokes the whole harness that runs it.
Agent Cards and capability discovery
The Agent Card is A2A's discovery mechanism: a structured description an agent publishes about what it can do, how to reach it, and how to authenticate. Another agent reads the card to decide whether and how to delegate. Signed Agent Cards let a consumer verify the publisher, which matters when agents from different organizations interact.
Messages, tasks, contexts, and artifacts
- Messages: the units of communication exchanged between agents.
- Tasks: units of delegated work one agent asks another to perform.
- Contexts: identifiers that group related messages and tasks across interactions.
- Artifacts: outputs an agent produces for a task, including outputs delivered incrementally while work is in progress.
Streaming and long-running work
Because delegated work can take time, A2A supports streaming updates and long-running tasks, so a requesting agent can follow progress rather than block on a single response. This makes it suitable for real multi-agent workflows where one agent's task may itself involve substantial work.
Protocol bindings and version negotiation
A2A v1.0 defines JSON-RPC, gRPC, and HTTP+JSON/REST bindings over the same canonical data model. Agent Cards advertise supported interfaces and protocol versions so clients can select a compatible binding and version.
Security, identity, and signed Agent Cards
When independent agents interact, identity and trust are first-order concerns. A2A addresses them through authentication described in the Agent Card and through signing, so a consuming agent can verify who published a card before delegating. As with any cross-organization protocol, the surrounding systems still own authorization and the handling of sensitive data.
A2A and MCP: different boundaries
A2A and MCP are complementary, not competing. MCP connects a single agent to its tools and data inside its own loop. A2A connects independent agents to each other. An agent can use MCP to reach a database while using A2A to delegate a subtask to another agent; the two never contend for the same edge.
What happened to IBM's ACP
There are two unrelated protocols abbreviated ACP. IBM's Agent Communication Protocol, which addressed agent-to-agent communication, became part of A2A under the Linux Foundation in August 2025. Zed's still-active Agent Client Protocol standardizes communication between code editors or IDEs and coding agents; it is unrelated to IBM's ACP and is covered on UHP vs ACP.
When to use A2A
Reach for A2A when independent agents, especially across teams or vendors, need to discover and delegate to each other. If you are wiring an agent to tools, look at MCP. Application-to-harness execution is a separate boundary, covered in the focused UHP vs A2A comparison.
When A2A is not the right layer
- An agent's internal reasoning, planning, memory, or tools.
- Tool and data access inside an agent.
- Frontend rendering rules.
- Application-to-harness execution and control.
FAQ
- What does A2A stand for in AI?
- A2A stands for Agent2Agent. It is an open standard for communication between independent agents, letting one agent discover another's capabilities through an Agent Card and then delegate tasks and exchange results.
- Is A2A owned by Google?
- A2A originated from Google but is now an open standard hosted by the Agentic AI Foundation under the Linux Foundation, with broad multi-vendor support rather than single-company control.
- What is an A2A Agent Card?
- An Agent Card is a structured description an agent publishes about what it can do, how to reach it, and how to authenticate. Other agents read the card to decide how to delegate, and signed cards let consumers verify the publisher.
- What is the difference between A2A and MCP?
- They govern different boundaries. MCP connects a single agent to its tools and data inside its own loop; A2A connects independent agents to each other. A system commonly uses both at once.
- Did A2A replace ACP?
- IBM's Agent Communication Protocol became part of A2A under the Linux Foundation in August 2025. It did not replace the unrelated, still-active Agent Client Protocol created by Zed for communication between editors or IDEs and coding agents.
- Does A2A standardize an agent's internal reasoning?
- No. A2A governs communication between agents, not how any single agent reasons or plans. Internal behavior lives in the model and harness, and invoking that harness from a product is UHP's boundary.
- How does A2A handle long-running tasks?
- A2A represents long-running work as tasks with lifecycle states. Clients can follow progress through streaming events, subscribe to an existing task, use push notifications, or retrieve the task later.
See the application-to-harness contract
A2A connects agents to each other. Invoking the harness that runs an agent is a different edge. See how it works.
Read the agent harness guide