Skip to content

Agent-to-Agent (A2A) Protocol

The Agent-to-Agent (A2A) protocol is an open standard for communication and interoperability between AI agents built by different vendors, running on different frameworks, and deployed across different cloud environments. Where the Model Context Protocol (MCP) standardises how an agent connects to its tools, A2A standardises how agents connect to each other — enabling one agent to delegate tasks to, query, and hand off work to another agent it has never directly integrated with before.

A2A was originally developed at Google and publicly announced in April 2025 alongside a coalition of more than 50 technology partners including Atlassian, Cohere, LangChain, MongoDB, PayPal, Salesforce, SAP, ServiceNow, and Workday, plus major consulting firms (Accenture, BCG, Deloitte, PwC). It has since been donated to the Linux Foundation, and version 1.0 of the protocol reached stable status in April 2026. The reference implementation and specification live at github.com/a2aproject/A2A with 23,800+ stars, and official documentation is published at a2a-protocol.org.

Why Agent Interoperability Matters

In practice, multi-agent systems rarely exist within a single team or vendor stack. A procurement agent processing purchase requests may need to consult a compliance agent maintained by a partner team running an entirely different framework. A customer-service agent may need to escalate work to a specialised billing agent built in a different language by a different division. When each of these connections requires custom integration code, the cost of wiring agents together grows faster than the value they deliver.

A2A solves this the same way HTTP and REST solved web service integration: by providing a common language so that any compliant agent can talk to any other compliant agent, regardless of the language, framework, or model provider behind it. Agents remain opaque to each other — they do not share internal memory, tools, or proprietary logic — which preserves both security and intellectual property.

Design Principles

Five principles guided the design of A2A:

  1. Embrace agentic capabilities. Agents collaborate in unstructured, natural modalities, not by being reduced to a single tool call. Multi-turn, multi-step, long-running delegation is a first-class use case.
  2. Build on existing standards. The protocol uses HTTP, Server-Sent Events (SSE), JSON-RPC, and Protocol Buffers — infrastructure that enterprises already operate, load-balance, and monitor.
  3. Secure by default. Authentication parity with OpenAPI schemes, with v1 adding signed Agent Cards for cryptographic identity verification and multi-tenancy support.
  4. Support long-running tasks. From quick lookups to deep research tasks taking hours or days, A2A provides real-time feedback, notifications, and state updates throughout.
  5. Modality agnostic. Text, forms, audio streaming, and video are all supported.

How A2A Works

The Agent Card

Every A2A-compliant agent publishes an Agent Card — a JSON document served at the well-known path /.well-known/agent-card.json. The card describes the agent's name, capabilities, supported interface bindings and protocol versions, and authentication requirements. A client agent resolves this card before establishing a connection, enabling automatic capability discovery without any configuration exchange out-of-band.

Client and Server Roles

A2A interaction always involves two roles:

  • Client agent (A2A Agent): formulates and sends tasks to remote agents; discovers their capabilities via Agent Cards.
  • Remote agent / server (A2A Hosting): receives tasks, processes them with whatever internal logic it uses, and returns results — without revealing how it works internally.

Either role can itself be an agent with its own internal tools, memory, and model calls. A client agent becomes a server agent to the next caller up the chain, enabling arbitrarily deep delegation trees and group-chat topologies.

Task Lifecycle and Operations

The A2A protocol specification defines eleven core RPC methods:

Operation Purpose
SendMessage Single-shot request/response
SendStreamingMessage Streaming request via SSE
GetTask Poll task status
ListTasks Enumerate running tasks
CancelTask Terminate a running task
SubscribeToTask Push notification subscription
Create/Get/List/DeleteTaskPushNotificationConfig Webhook management
GetExtendedAgentCard Authenticated card with additional metadata

Three-Layer Architecture

The specification is organised into three layers to separate semantic concerns from transport concerns:

  1. Canonical Data Model (Protocol Buffer source of truth in specification/a2a.proto): defines core message types — Task, Message, Part, Artifact, AgentCard, SendMessageConfiguration.
  2. Abstract Operations (A2AService): describes what agents must be able to do, independent of how they expose it. The eleven RPC methods above live here.
  3. Protocol Bindings: concrete mappings of operations to HTTP+JSON (preferred in v1), JSON-RPC 2.0 over SSE/HTTP, and gRPC. Client and server can negotiate the binding; v1 prefers HTTP+JSON with JSON-RPC as a fallback.

Version 1.0 Milestone

A2A v1.0, released in April 2026, is the first stable production-ready version of the protocol. Key changes from the pre-release v0.3 draft:

  • Stability guarantee: the core spec (protobuf definitions) is now stable; breaking changes follow a formal deprecation lifecycle.
  • Signed Agent Cards: cryptographic identity verification for enterprise multi-party environments.
  • Multi-tenancy support: isolation keys for per-user session management.
  • Restructured Agent Card schema: v1 separates capability declarations, interfaces, and authentication more cleanly than the flat v0.3 structure.
  • Protocol binding clarity: HTTP+JSON becomes preferred; JSON-RPC is an explicit fallback. Both can coexist on the same server.
  • Backward compatibility layer: the official SDKs (Python and Go) include a compatibility bridge so v1 clients can talk to v0.3 servers and vice versa during mixed-version deployments.

The SDK packages implementing the spec are still in preview even though the spec itself is stable.

Microsoft .NET Implementation

The Microsoft Agent Framework (part of Microsoft Foundry) ships two NuGet packages for A2A v1:

  • A2A Agent (client-side): wraps any remote A2A endpoint as a standard AIAgent for use in the Agent Framework's workflow model.
  • A2A Hosting (server-side): exposes any existing AIAgent built on Azure OpenAI, OpenAI, Anthropic, AWS Bedrock, or other providers as an A2A endpoint with minimal code.

The design intention is that A2A interop is "free" — you do not restructure your agent code to enable it. A remote A2A agent is just an AIAgent in calling code, using the same RunAsync / RunStreamingAsync methods as local agents.

Discovering and Calling a Remote Agent

using A2A;
using Microsoft.Agents.AI;

// Resolve the agent card and create an AIAgent in one step.
A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));
AIAgent agent = await resolver.GetAIAgentAsync();

// Use it like any other AIAgent.
Console.WriteLine(await agent.RunAsync("What is the weather in Brussels?"));

Streaming

A2ACardResolver resolver = new(new Uri("https://a2a-agent.example.com"));
AIAgent agent = await resolver.GetAIAgentAsync();

await foreach (var update in agent.RunStreamingAsync("Summarise this document."))
{
    if (!string.IsNullOrEmpty(update.Text)) Console.Write(update.Text);
}

Hosting Your Own Agent

// 1. Register your agent as a keyed singleton.
builder.Services.AddKeyedSingleton<AIAgent>("my-agent", (sp, _) =>
    new AIProjectClient(new Uri("https://your-project.azure.com"), new DefaultAzureCredential())
        .AsAIAgent(model: "gpt-4o-mini", instructions: "You are helpful.", name: "my-agent"));

// 2. Register the A2A server.
builder.AddA2AServer("my-agent");
var app = builder.Build();

// 3. Map A2A endpoints.
app.MapA2AHttpJson("my-agent", "/a2a/my-agent");

// 4. Publish the Agent Card for discovery.
app.MapWellKnownAgentCard(new AgentCard
{
    Name = "MyAgent",
    SupportedInterfaces = [new AgentInterface
    {
        Url = "https://your-host/a2a/my-agent",
        ProtocolBinding = ProtocolBindingNames.HttpJson,
        ProtocolVersion = "1.0"
    }]
});
app.Run();

This agent is now reachable by any A2A-compliant client regardless of its language or framework.

A2A vs. MCP

A2A and MCP address different layers of the agentic stack and are designed to be complementary:

Concern Protocol
Agent connects to tools, APIs, resources MCP (Model Context Protocol)
Agent delegates tasks to other agents A2A (Agent-to-Agent)

An agent can use MCP to call a database, a calendar API, or a code-execution sandbox, and use A2A to call a specialist agent (e.g. a compliance checker, a translation service) that runs on a different platform. Frameworks like LangChain, Google ADK, CrewAI, Semantic Kernel, and Cisco agntcy all work with both protocols.

Governance and SDKs

The A2A Technical Steering Committee includes representatives from AWS, Cisco, Google, IBM Research, Microsoft, Salesforce, SAP, and ServiceNow. Official SDKs are available in Python, JavaScript, Java, C#/.NET, and Go. A free introductory course is available via DeepLearning.AI in partnership with Google Cloud and IBM Research.

Limitations

  • The A2A SDK packages are still in preview even though the protocol specification itself is v1-stable. Production deployments should plan for SDK-level breaking changes.
  • The v0.3 → v1.0 migration introduces breaking changes to the Agent Card schema and server registration API (see Microsoft migration guide for .NET). Teams with mixed-version deployments must use the SDK compatibility bridge.
  • Long-running tasks rely on SSE or webhook push; environments that block outbound SSE or cannot receive webhooks require architectural workarounds.
  • Discovery assumes well-known URI access: the /.well-known/agent-card.json path must be publicly or VPN-reachable from the client agent.

Changelog

2026-05-18 — Page created from https://a2a-protocol.org/latest/ (Type A, confidence 82). Sources: official spec, Google Developers Blog, Microsoft Agent Framework devblog, GitHub a2aproject/A2A (23.8k stars), Google Developer forum v1.0 milestone post.