Agent2Agent (A2A) Protocol

A2A is a peer protocol between agents. A client agent finds a remote agent through its Agent Card, then sends a Message; the remote agent either answers with a Message or creates a Task and reports progress on it. Since v1.0 the normative definition is the Protobuf file a2a.proto, and the spec separates the abstract operations from their JSON-RPC, gRPC and HTTP+JSON/REST bindings, which must behave the same.

State lives with the remote agent. A Task has an ID, a status, message history and artifacts, and moves through submitted and working states to a terminal state (completed, failed, canceled, rejected) or an interrupted one (input required, auth required) that waits for the client. A contextId ties related tasks and messages into one conversation. Agents do not share memory, tools or internal reasoning; only messages, parts and artifacts cross the boundary.

The protocol does not prescribe an orchestration pattern: a client agent can call one or many remote agents in whatever order it chooses, and remote agents can be clients of others. The docs place A2A beside MCP, with A2A linking agents to each other and MCP linking each agent to its own tools. Governance: Google originally developed A2A and donated it to the Linux Foundation; a Technical Steering Committee with seats for Google, Microsoft, Cisco, AWS, Salesforce, ServiceNow, SAP and IBM oversees it.

A2A models human involvement through task states rather than a separate approval API. When the remote agent needs more information it moves the task to INPUT_REQUIRED and waits for the client's next message; when it needs authorization, including a human's approval before a destructive action, it moves the task to AUTH_REQUIRED with a status message, and the credential is delivered out of band unless an in-band method was negotiated. The client can also cancel a task with CancelTask. How the client presents these requests to a person is left to the client application.

pip install a2a-sdk

# Python SDK 1.x (spec 1.0). For this server: pip install "a2a-sdk[http-server]" uvicorn
import uvicorn
from starlette.applications import Starlette
from a2a.helpers import get_message_text, new_text_message
from a2a.server.agent_execution import AgentExecutor
from a2a.server.request_handlers import DefaultRequestHandler
from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
from a2a.server.tasks import InMemoryTaskStore
from a2a.types import AgentCapabilities, AgentCard, AgentInterface, AgentSkill
class EchoExecutor(AgentExecutor):  # message-only pattern: enqueue exactly one Message
    async def execute(self, context, event_queue):
        await event_queue.enqueue_event(new_text_message(f"echo: {get_message_text(context.message)}"))
    async def cancel(self, context, event_queue): raise NotImplementedError

card = AgentCard(name="Echo", description="Repeats your text", version="0.1.0", capabilities=AgentCapabilities(),
    default_input_modes=["text/plain"], default_output_modes=["text/plain"],
    supported_interfaces=[AgentInterface(protocol_binding="JSONRPC", url="http://127.0.0.1:9999", protocol_version="1.0")],
    skills=[AgentSkill(id="echo", name="Echo", description="Echo text back", tags=["demo"])])
handler = DefaultRequestHandler(agent_executor=EchoExecutor(), task_store=InMemoryTaskStore(), agent_card=card)
uvicorn.run(Starlette(routes=[*create_agent_card_routes(card), *create_jsonrpc_routes(handler, "/")]), port=9999)

• The example uses the Python SDK (Python 3.10+). The core package is a2a-sdk; HTTP servers need extras such as a2a-sdk[http-server] or a2a-sdk[fastapi], and gRPC needs a2a-sdk[grpc].
• v1.0 of the protocol is not wire-compatible with v0.3: JSON-RPC methods were renamed (message/send became SendMessage), enum values moved to SCREAMING_SNAKE_CASE, the kind discriminator and the final flag were removed, and compound IDs such as tasks/{id} became plain IDs.
• Clients must send A2A-Version: 1.0; agents treat a missing header as 0.3. The Python SDK 1.x keeps a 0.3 compatibility mode.
• SDK 1.x removed A2AStarletteApplication and the other app wrappers (use create_agent_card_routes / create_jsonrpc_routes), made agent_card a required argument of DefaultRequestHandler, and raises InvalidAgentResponseError if an executor mixes a Message with Task events or emits updates before the Task.

The latest release is v1.0.1 (May 2026), a bug-fix release on top of v1.0.0 (March 2026). The protocol version sent on the wire is Major.Minor, so it is 1.0.

The A2A docs describe them as complementary: MCP connects an agent to its own tools and resources, while A2A connects agents to each other. The spec does not define a formal mapping between the two.

A2A's own docs and repository do not mention AG-UI, so no relationship is defined from the A2A side.

Google developed it and donated it to the Linux Foundation. A Technical Steering Committee with representatives from Google, Microsoft, Cisco, AWS, Salesforce, ServiceNow, SAP and IBM oversees the project.

JSON-RPC 2.0 over HTTP(S), gRPC, and HTTP+JSON/REST, with SSE for streaming and webhooks for push notifications.