Advanced

A2A Protocol: Agent-to-Agent Communication

The Agent-to-Agent (A2A) protocol, announced by Google in April 2025, is an open standard for how AI agents from different vendors discover and communicate with each other. As multi-agent systems become more common, the need for a standard inter-agent protocol - analogous to HTTP for web services - has become critical.

Why a Standard Protocol?

Without a standard, every multi-agent system uses proprietary communication patterns - a LangGraph agent cannot natively delegate to a CrewAI agent, and a Claude-based agent cannot discover a GPT-4o-based tool agent. A2A aims to make agent-to-agent communication as interoperable as REST APIs.

By June 2026, over 150 organisations including Salesforce, SAP, Atlassian, and Cohere have adopted or committed to A2A support. The spec is hosted at the A2A GitHub repository under an open Apache 2.0 licence.

Agent Cards

Every A2A agent publishes an Agent Card - a JSON document hosted at a well-known URL (/.well-known/agent.json) that describes what the agent can do. This allows client agents to discover server agents and understand their capabilities before initiating a task.

// Example Agent Card (simplified)
{
  "name": "DataAnalysisAgent",
  "version": "1.2.0",
  "description": "Analyses CSV datasets and produces summary statistics",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "analyse-csv",
      "name": "Analyse CSV",
      "description": "Accepts a CSV file, returns statistical summary",
      "inputModes": ["file", "text"],
      "outputModes": ["text", "json"]
    }
  ]
}

Transport: HTTP + SSE + JSON-RPC 2.0

A2A uses familiar web technologies for transport:

HTTP POST - client sends a task to the server agent's endpoint
JSON-RPC 2.0 - message envelope format for all requests and responses
Server-Sent Events (SSE) - for streaming task updates in real time
Push notifications - optional webhook for async long-running tasks

This design means A2A works over standard HTTP infrastructure - load balancers, API gateways, and firewalls all handle it transparently.

Task Lifecycle

Discover

Client fetches Agent Card from /.well-known/agent.json

Initiate

Client sends tasks/send JSON-RPC request with task payload

Stream (optional)

If streaming enabled, server pushes status updates and partial results via SSE

Complete

Server emits final result with status completed or failed

Human-in-loop (optional)

Server can pause with input-required status and await client response before continuing

A2A vs MCP

MCP (Model Context Protocol)

Connects an LLM to tools (files, databases, APIs, code). The LLM is the client; the tool is the server. Single-model, tool-access focused. Anthropic-initiated, donated to Linux Foundation Dec 2025.

A2A (Agent-to-Agent)

Connects agents to agents. One LLM agent delegates a subtask to another LLM agent. Multi-agent coordination focused. Google-initiated, widely adopted. Complements MCP - they address different layers of the stack.

A well-designed multi-agent system uses both: MCP for each agent's tool access, A2A for the coordination layer between agents.

Getting Started

The A2A spec and SDK are available at the official A2A GitHub organisation
Python and JavaScript reference implementations are provided
Many agent frameworks (LangGraph, CrewAI) are adding A2A-compatible agent endpoints
Start by exposing your existing agents as A2A servers with an Agent Card; then enable delegation