Agent2Agent Protocol

How agents
work together.

Agent2Agent gives independently built agents a common way to advertise skills, delegate work, follow its progress, and exchange results.

Specification 1.0.0

Agent-to-agent interaction
Research agentCaller
Request
Artifact
Comparison agentRemote service
DiscoverDelegateTrackDeliver

Overview

The objects agents exchange.

A2A defines how a client and a remote agent exchange messages and manage work. Each side can use its own model, framework, and internal tools. The contract between them describes the interaction over the network. [2]

AgentCard

Agent Card

A machine-readable profile describing the agent’s skills, accepted input and output media types, security requirements, and supported interfaces. A client can find the card through /.well-known/agent-card.json on a known domain, a registry, or direct configuration. [1]

Message

Message

A turn from a caller or remote agent. Messages carry parts such as text, files, or structured data. A context ID can group related interactions and a task ID can connect a follow-up to existing work. [2]

Task

Task

A server-managed record of work with an ID and a status. A short interaction can return a direct message. Work that needs tracking can return a task whose status the client can query. [2][3]

Artifact

Artifact

A deliverable associated with a task, such as a comparison, report, or structured result. Keeping artifacts separate from conversational messages gives the client a clear place to retrieve the output. [2]

Interactive example

From discovery to delivery.

A research agent delegates a comparison of two sample documents. Step through a fictional Agent Card, the JSON-RPC request, and the task returned by the remote agent. These examples illustrate the A2A 1.0 interface.

Protocol explorerIllustrative · Local only

Read the Agent Card

The card advertises the skill and declares the JSON-RPC interface. The interface’s protocolVersion identifies A2A 1.0, while the top-level version belongs to the agent implementation.

agent-card.json
{  "name": "Document Comparison Agent",  "description": "Compares two supplied documents.",  "supportedInterfaces": [    {      "url": "https://compare.example/a2a",      "protocolBinding": "JSONRPC",      "protocolVersion": "1.0"    }  ],  "version": "0.1.0",  "capabilities": {    "streaming": true  },  "defaultInputModes": [    "text/plain"  ],  "defaultOutputModes": [    "text/plain"  ],  "skills": [    {      "id": "compare-documents",      "name": "Compare documents",      "description": "Summarize changes between two supplied documents.",      "tags": [        "documents"      ]    }  ]}

Implementation

Integration decisions that matter.

Choose a binding and a task strategy before designing the rest of the client. Treat identity, access and retention as deployment decisions.

Select an advertised interface

A2A 1.0 specifies JSON-RPC, gRPC, and HTTP+JSON bindings. They express the same protocol operations through different wire interfaces. Pick an advertised URL, binding, and protocol version together. A method name from one binding or an older revision should never be assumed to work on another. [4]

Decide how to follow work

SendMessage can return a direct reply or a task. For a task, polling with GetTask is one way to follow progress. If supported, streaming can expose status and artifact updates, and push notifications can deliver updates to a registered callback. Treat streaming and push as advertised capabilities.

Working is an in-progress state. Input-required and auth-required interrupt work until the client supplies what is needed. Completed, failed, canceled, and rejected end the task. Build the client’s retry and resume behavior around that distinction. [2][3]

Separate discovery from authorization

An Agent Card describes where to connect and which security schemes apply. Authenticate the request to the selected service, check what the caller is allowed to do, and disclose only the information the task needs. A deployment can offer authenticated callers an extended Agent Card when that capability is advertised. [1][5]

The Agentlithic architecture

Where A2A fits.

In the Agentlithic architecture, A2A is the collaboration interface between independently hosted agents. A registry could help locate a service, and a permission gateway could enforce the owner’s policy before delegation. The remote agent can use MCP to retrieve authorized context or invoke tools while it completes the work.

Companion guideMCPModel Context Protocol

Sources

Specification 1.0.0
  1. Agent2Agent Protocol Specification, version 1.0.0

    A2A Protocol Working Group · §4.4 Agent Discovery Objects and §8 Agent Discovery and the Agent Card

  2. Agent2Agent Protocol Specification, version 1.0.0

    A2A Protocol Working Group · §4 Protocol Data Objects, including Task, TaskState, Message, Part, and Artifact

  3. Agent2Agent Protocol Specification, version 1.0.0

    A2A Protocol Working Group · §3 Protocol Operations and §6 Common Workflows & Examples

  4. Agent2Agent Protocol Specification, version 1.0.0

    A2A Protocol Working Group · §5 Protocol Bindings, §§9–11 binding definitions, and Appendix A Migration & Legacy Compatibility

  5. Agent2Agent Protocol Specification, version 1.0.0

    A2A Protocol Working Group · §13 Security Considerations and Appendix B Relationship to MCP