Understanding Google A2A Protocol - The Agent-to-Agent Communication Standard

The rise of AI agents has created an interesting challenge: how do we make agents from different vendors and frameworks work together? Google’s answer is the Agent2Agent (A2A) protocol, an open standard that enables AI agents to discover, communicate, and collaborate with each other. This article explores the A2A protocol in depth, covering its architecture, key concepts, and practical implications.

What is A2A Protocol?

The Agent2Agent (A2A) protocol is a communication protocol for AI agents, initially introduced by Google at Cloud Next on April 9, 2025. It functions as an open standard enabling different AI agents to interact regardless of their underlying framework or provider.

Think of A2A as a universal translator for AI agent ecosystems. Rather than agents being locked within proprietary systems, A2A allows them to communicate across boundaries. It acts as a messaging tier that lets these agents “talk” to each other despite their distinct agentic architectures.

The protocol was launched with support from over 50 technology partners including Salesforce, SAP, ServiceNow, Atlassian, Box, Cohere, MongoDB, PayPal, and major consulting firms like Accenture, Deloitte, and McKinsey. In June 2025, Google donated A2A to the Linux Foundation, further cementing its status as an open standard.

Core Design Principles

The A2A protocol was designed around five fundamental principles:

1. Embrace Agentic Capabilities

A2A focuses on enabling agents to collaborate in their natural, unstructured modalities. Unlike tool-based integrations, A2A enables true multi-agent collaboration without requiring shared memory, tools, or context. Agents can work together even when they don’t share internal state or proprietary implementations.

2. Build on Existing Standards

The protocol is built on top of existing, popular standards:

HTTP/HTTPS for transport
JSON-RPC 2.0 for message formatting
Server-Sent Events (SSE) for streaming
OpenTelemetry Protocol (OTLP) for observability

This approach makes integration with existing IT infrastructure straightforward.

3. Secure by Default

A2A is designed to support enterprise-grade authentication and authorization, with parity to OpenAPI’s authentication schemes. It supports:

API keys
OAuth 2.0
OpenID Connect Discovery
Short-lived tokens with minute-level expiration

4. Support for Long-Running Tasks

A2A supports scenarios from quick tasks to deep research that may take hours or even days when humans are in the loop. The protocol provides mechanisms for asynchronous updates via webhooks and real-time streaming.

5. Modality Agnostic

The protocol supports various content types including text, audio, video streaming, files, and structured JSON data.

A2A Architecture

The following diagram illustrates the high-level architecture of the A2A protocol:

Key Components

The A2A protocol comprises several architectural elements:

Component	Description
Client Agent	Initiates requests and formulates tasks to send to remote agents
Remote Agent	Processes tasks and responds with results
Agent Card	JSON metadata describing agent capabilities, endpoints, and authentication requirements
Tasks	Units of work with defined lifecycle states
Messages	Communication units exchanged between agents
Artifacts	Tangible outputs produced by task execution
Parts	Individual content pieces within messages (text, files, images)

Agent Cards: The Discovery Mechanism

Every A2A-compatible agent publishes a JSON file at a well-known location (/.well-known/agent.json) that describes:

Agent endpoint and capabilities
Supported authentication flows
Available skills and services
Supported data types and modalities

Here’s an example of an Agent Card structure:

{
  "name": "Currency Converter Agent",
  "description": "Converts currencies in real-time",
  "version": "1.0.0",
  "endpoint": "https://api.example.com/agent",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "skills": [
    {
      "name": "convert_currency",
      "description": "Convert between currencies",
      "inputSchema": { ... },
      "outputSchema": { ... }
    }
  ],
  "authentication": {
    "schemes": ["oauth2", "apiKey"]
  }
}

How A2A Works

The A2A protocol follows a structured communication flow. Here’s a sequence diagram showing the complete interaction:

Phase 1: Discovery

Client agents locate appropriate remote agents by fetching their agent cards. The discovery process involves:

Querying known agent registries or URLs
Fetching the /.well-known/agent.json file
Parsing capabilities and determining compatibility
Selecting the most suitable agent for the task

Phase 2: Authentication

Once a suitable agent is discovered, the client authenticates using methods specified in the agent card:

Read authentication requirements from the agent card
Obtain appropriate tokens (OAuth 2.0, API key, etc.)
Tokens are typically short-lived (minute-level TTL) for security
Include authentication in subsequent requests

Phase 3: Task Exchange

Communication happens over HTTPS using JSON-RPC 2.0:

Synchronous Tasks:

POST /task/send

Used for immediate request/response patterns.

Streaming Tasks:

POST /task/sendSubscribe

Opens a Server-Sent Events stream for long-running operations with real-time status updates.

Phase 4: Observability

Every request includes trace IDs and structured logs in OpenTelemetry Protocol format. This enables:

Distributed tracing across agent interactions
Integration with existing monitoring tools (Grafana, Prometheus)
Complete audit trails for compliance

A2A vs MCP: Complementary Protocols

A common question is how A2A relates to Anthropic’s Model Context Protocol (MCP). The following diagram illustrates how these protocols work together:

The key distinction:

Aspect	A2A	MCP
Focus	Agent-to-Agent communication	Agent-to-Tool communication
Purpose	Enable collaboration between autonomous agents	Provide tools and context to agents
Analogy	The “internet” for AI agents	The “USB port” for AI agents
Use Case	Multi-agent orchestration	Tool integration

MCP standardizes how an agent connects to its tools, APIs, and resources to get information. It’s like giving an agent a set of tools it can use.

A2A standardizes how agents communicate with each other. It enables agents to delegate subtasks, exchange findings, and coordinate complex workflows.

An inventory agent might use MCP to access product databases, then use A2A to coordinate with supplier agents. These protocols are complementary, not competing.

Real-World Use Cases

Enterprise Hiring Workflow

Consider a hiring workflow enabled by A2A:

A recruiter’s agent discovers candidate sourcing agents
Coordinates interviews with scheduling agents
Engages background check agents
Aggregates results and presents recommendations

All of this happens within a unified interface, with agents from different vendors collaborating seamlessly.

Supply Chain Management

A supply chain scenario might involve:

Demand forecasting agent (using proprietary ML models)
Inventory management agent (connected to warehouse systems)
Supplier coordination agent (communicating with external vendors)
Logistics optimization agent (planning shipments)

Each agent maintains its proprietary logic while collaborating through A2A.

Getting Started with A2A

Available SDKs

The A2A project provides official SDKs for:

Python
JavaScript/TypeScript
Java
C#/.NET
Golang

Quick Start (Python)

Install the SDK:

pip install a2a-sdk

Create a simple agent:

from a2a import Agent, AgentCard, Task

# Define agent capabilities
card = AgentCard(
    name="My Agent",
    description="A simple A2A agent",
    skills=[...]
)

# Create and run the agent
agent = Agent(card)
agent.serve()

Interact with remote agents:

from a2a import Client

client = Client()
remote_agent = client.discover("https://example.com/.well-known/agent.json")

# Send a task
result = await remote_agent.send_task(
    task=Task(
        skill="convert_currency",
        input={"from": "USD", "to": "EUR", "amount": 100}
    )
)

Current State and Future Outlook

Adoption Challenges

Despite Google’s backing and technical sophistication, A2A has faced adoption challenges. By late 2025, MCP has emerged as the more widely adopted standard among individual developers. Key factors:

Developer Experience: MCP prioritized individual developer experience over enterprise orchestration
Immediate Utility: MCP integrated with existing AI assistants from day one
Simplicity: MCP solved immediate problems (file access, API integration) that developers faced daily
Community Momentum: MCP captured developer mindshare with grassroots adoption

Where A2A Shines

A2A remains compelling for enterprise scenarios requiring:

Multi-agent orchestration across organizational boundaries
Secure collaboration without exposing proprietary implementations
Long-running tasks with human-in-the-loop workflows
Complex enterprise integrations

Conclusion

The A2A protocol represents an ambitious vision for agent interoperability. While it faces adoption challenges compared to simpler alternatives like MCP, its enterprise-focused design makes it valuable for complex multi-agent scenarios.

For developers building multi-agent systems, understanding A2A provides insight into how agent ecosystems might evolve. The protocol’s emphasis on security, observability, and long-running tasks addresses real enterprise needs that simpler protocols don’t fully solve.

Whether A2A achieves widespread adoption or influences future standards, its design principles offer valuable lessons for anyone building agent-based systems.