Google's A2A Protocol: What It Actually Does (and What It Doesn't)

The Problem: Agent Isolation

Enterprise software runs on dozens of specialized systems. CRM, ERP, HRIS, ticketing, billing. Each is getting its own AI agent. Salesforce has Agentforce. SAP has Joule. ServiceNow has Now Assist. These agents are good at operating within their own system. They are bad at working together.

Every pair of systems that need to communicate requires a custom integration. With N systems, that is N*(N-1)/2 integrations. HTTP solved this problem for documents. SMTP solved it for email. A2A attempts to solve it for agent communication.

How A2A Works

A2A defines four primitives. Everything in the protocol is built from these.

The flow: client fetches a remote Agent Card, checks capabilities, creates a task via JSON-RPC. The remote agent processes it, optionally streaming results via SSE. If it needs more input, it enters input-required and waits.

Agent Cards: Machine-Readable Discovery

Agent Cards are the entry point to A2A. Before two agents can collaborate, they need to know about each other. An Agent Card is a JSON file that an agent publishes at a well-known URL, similar to how robots.txt works for web crawlers or how /.well-known/openid-configuration works for OAuth.

{
  "name": "Order Management Agent",
  "description": "Handles order lookups, status checks, and modifications",
  "url": "https://orders.example.com/a2a",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": true
  },
  "authentication": {
    "schemes": ["OAuth2"],
    "credentials": "https://auth.example.com/.well-known/oauth-authorization-server"
  },
  "defaultInputModes": ["text/plain", "application/json"],
  "defaultOutputModes": ["text/plain", "application/json"],
  "skills": [
    {
      "id": "order-lookup",
      "name": "Order Lookup",
      "description": "Look up order details by ID or customer email",
      "tags": ["orders", "lookup", "status"]
    },
    {
      "id": "order-modify",
      "name": "Order Modification",
      "description": "Cancel, update shipping, or change quantities",
      "tags": ["orders", "modify", "cancel"]
    }
  ]
}

The skills array is what makes discovery useful. A client scanning for "order status" capability matches against descriptions and tags. Without skills, the client guesses from the agent name alone.

Tasks and Lifecycle

A Task is the unit of work in A2A. Unlike a simple request-response call, a Task is stateful: ID, current status, message history, and metadata. Statefulness matters because agent work is often asynchronous and multi-turn.

The input-required state is what separates A2A from fire-and-forget RPC. An agent can pause, ask for clarification, and resume. This models real collaboration where agents negotiate rather than completing everything in one pass.

POST /a2a HTTP/1.1
Content-Type: application/json
Authorization: Bearer <token>

{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "id": "req-001",
  "params": {
    "id": "task-abc-123",
    "message": {
      "role": "user",
      "parts": [{ "type": "text", "text": "Status of order #ORD-2025-7891?" }]
    }
  }
}

For long-running tasks, tasks/sendSubscribe streams Server-Sent Events as the task progresses. No polling needed.

A2A vs MCP: Different Layers, Different Problems

This is the most common point of confusion. A2A and MCP are not competitors. They operate at different layers of the agent stack.

The mental model: MCP answers "what can I use?" A2A answers "who can I work with?" In practice, a well-architected agent system uses both. MCP for local tools. A2A for collaboration with other agents. The same agent can participate in both protocols simultaneously.

A2A vs ACP: Enterprise Orchestration vs Developer Workflow

ACP (Agent Communication Protocol) targets a different surface. A2A is about agents collaborating across organizational and vendor boundaries over HTTP. ACP is about agents operating within a developer's IDE via local protocols (stdio, IPC).

A2A: how does Salesforce's agent talk to SAP's agent? ACP: how does a coding agent interact with the editor? Different problems, different protocols.

Who Supports A2A

50+ launch partners spanning cloud providers, SaaS vendors, system integrators, and agent frameworks.

Getting Started with A2A

Google provides a Python SDK (google-a2a) and reference implementations.

pip install google-a2a

from a2a.types import AgentCard, AgentSkill, AgentCapabilities

card = AgentCard(
    name="Code Review Agent",
    description="Reviews PRs for security and performance issues",
    url="https://review-agent.example.com/a2a",
    version="1.0.0",
    capabilities=AgentCapabilities(streaming=True, push_notifications=False),
    skills=[
        AgentSkill(
            id="security-review",
            name="Security Review",
            description="Scan code changes for common vulnerabilities",
            tags=["security", "code-review"],
        ),
        AgentSkill(
            id="perf-review",
            name="Performance Review",
            description="Identify N+1 queries, memory leaks, bundle size",
            tags=["performance", "code-review"],
        ),
    ],
    default_input_modes=["text/plain"],
    default_output_modes=["text/plain", "application/json"],
)

from a2a.server import A2AServer, TaskHandler
from a2a.types import Task, TaskState, Message, TextPart

class ReviewHandler(TaskHandler):
    async def on_task_send(self, task: Task) -> Task:
        diff_text = task.messages[-1].parts[0].text
        findings = await run_security_review(diff_text)

        task.state = TaskState.COMPLETED
        task.messages.append(
            Message(role="agent", parts=[TextPart(text=findings)])
        )
        return task

server = A2AServer(card=card, handler=ReviewHandler())
# Run with: uvicorn server:server.app

The SDK handles Agent Card serving, task lifecycle, and JSON-RPC routing. You implement the task handler.

from a2a.client import A2AClient

client = A2AClient(url="https://review-agent.example.com/a2a")

# Discover capabilities
card = await client.get_agent_card()

# Send a task
task = await client.send_task(
    task_id="review-001",
    message=Message(
        role="user",
        parts=[TextPart(text="Review this diff:\n" + diff)],
    ),
)

print(f"Status: {task.state}")
print(f"Result: {task.messages[-1].parts[0].text}")

Limitations and Open Questions

A2A solves a real problem, but the protocol has constraints and unanswered questions that will shape its adoption trajectory.

Additional gaps: the protocol does not define distributed tracing or correlation IDs across agent boundaries, so debugging multi-agent workflows requires layering on OpenTelemetry or custom trace propagation. Authorization policies (what one agent can ask another to do) are left to implementations. And version negotiation between agents running different A2A spec versions is undefined in the current spec.

Frequently Asked Questions

What is the A2A protocol?

An open protocol from Google (April 2025) for agent-to-agent communication. HTTP + JSON-RPC transport. Agents publish Agent Cards describing capabilities and communicate through stateful Tasks.

What is the difference between A2A and MCP?

Different layers. MCP connects agents to tools and data (vertical, "what can I use?"). A2A connects agents to each other (horizontal, "who can I work with?"). They are complementary.

Who supports A2A?

50+ launch partners: Google, Salesforce, SAP, MongoDB, LangChain, CrewAI, Cohere, Intuit, Workday, Deloitte, Accenture. Anthropic, OpenAI, and Microsoft are not launch partners.

How does agent discovery work?

Agents host an Agent Card (JSON) at /.well-known/agent.json. The card lists capabilities, auth requirements, and endpoint URL. Client agents fetch the card before sending tasks.

Does A2A work offline?

No. HTTP-only. No local-first or offline mode. Designed for cloud-based enterprise deployments.

What is the difference between A2A and ACP?

A2A is agent-to-agent (cross-vendor enterprise orchestration). ACP is agent-to-editor (IDE and developer workflow integration).

What authentication does A2A support?

Three methods: did_auth, API keys, and OAuth2. Deployments choose one. The flexibility is intentional but requires per-deployment standardization.

Is A2A production-ready?

Published spec with Python and TypeScript SDKs, reference implementations, and 50+ partners. Core protocol is stable. Tooling and deployment patterns are still maturing. The missing Anthropic/OpenAI/Microsoft support is the biggest open question.