Identity for AI

What is Agent2Agent Protocol (A2A)?

Whereas Model Context Protocol (MCP) defines how agents interact with tools, Google’s Agent2Agent Protocol (A2A) defines how agents interact with each other.

In an ecosystem where agents exist in different domains and are built upon different frameworks, A2A defines a standardized way for agents to collaborate as autonomous peers. In practice, this means an HR agent could securely call out to a payroll agent to adjust a salary, or a travel agent could ask a calendar agent to reschedule meetings, all under a trusted, reliable framework.

Why use A2A?

To make agent-to-agent communication as streamlined as possible, A2A is designed around the following core principles:

Discovery: Agents can find other agents with the desired permissions and capabilities.

Interoperability: Agents can pass goals, intents, and structured requests regardless of which framework they’re built on.

Delegation and Chaining: Agents can hand off tasks to better-suited agents without the end user needing to manually orchestrate it.

Trust and Identity: As with tools, agents need to authenticate with each other. A2A defines how identity and permissions are enforced when agents collaborate.

How A2A works

An A2A interaction involves the following components:

Agent card

A discoverable JSON file that acts as an agent’s public profile. It advertises the agent’s identity, capabilities, supported data modalities, and authentication requirements.

This allows other agents to determine the most suitable agent to interact with.

Task

The fundamental unit of work. A task has a unique ID and progresses through a defined lifecycle, such as working, completed, or input required.

Message and artifact

Messages are the units of communication exchanged between agents to manage a task, while artifacts are the final, tangible outputs generated upon task completion.

Workflow

The typical A2A workflow involves a client agent discovering an agent card, authenticating as required, and then monitoring tasks through a series of API exchanges until the remote agent delivers the artifacts to the end user.

  1. A client agent, acting on behalf of the user, discovers an agent card. This could be through open discovery, a curated registry, or private API endpoints.

  2. The client agent authenticates and receives a token from the remote agent’s authorization server.

  3. The client agent invokes the POST /sendMessage API to send details about the task along with its access token to the remote agent.

    The remote agent can respond with a Message object to negotiate the scope of a request or with a Task object if the agent accepts the task request, containing the contextId and taskId.

  4. The client agent invokes the POST /sendMessageStream API with the remote agent for real-time updates of long-running tasks using Server-Sent Events (SSE).

    When the task is complete, the remote agent responds with the artifacts and the taskId in completed status.

Learn more

Use the following resources to learn more about implementing A2A:

Together, MCP defines how agents call tools, while A2A defines how agents call each other. Both rely on strong Identity for AI to ensure that every request, whether to a tool or to another agent, is authenticated, authorized, and auditable. Learn more about how MCP and A2A interact in A2A and MCP: Complementary Protocols for Agentic Systems.