Blue and white fiber optic light visualizing agent-to-agent network communication

Agent-to-Agent (A2A) Protocol: How AI Systems Are Learning to Work Together in 2026

por

Rodrigo Gardin
em

| From

The Model Context Protocol solved half the problem: it gave AI agents a standard way to connect to tools. But what happens when agents need to talk to each other — across different frameworks, vendors, and organizational boundaries? That is the gap the Agent-to-Agent (A2A) Protocol was built to close, and one year in, it’s already running in production at over 150 organizations worldwide.

The problem MCP doesn’t solve

As enterprises move from single-agent setups to multi-agent architectures — where a planning agent delegates tasks to specialized sub-agents, which in turn coordinate with other agents — they hit a fundamental interoperability wall. An agent built with LangGraph can’t natively communicate with one built on Google ADK or Salesforce’s Agentforce. Each vendor speaks a different dialect. A2A is the universal translator.

The distinction is clean: MCP defines how an agent connects to data sources and tools (databases, APIs, file systems). A2A defines how agents coordinate with other agents — delegating tasks, sharing state, and receiving results — regardless of who built them or where they run.

Architecture: what’s under the hood

A2A is intentionally built on boring, proven infrastructure. According to the official A2A specification, the protocol uses three standard technologies:

  • JSON-RPC 2.0 over HTTP(S) — all requests and responses follow the JSON-RPC 2.0 spec, making A2A endpoints easy to implement in any language or framework.
  • Server-Sent Events (SSE) — for streaming incremental updates on long-running tasks. An orchestrating agent can receive real-time status updates from a downstream agent without polling.
  • Agent Cards — a standardized JSON document served at /.well-known/agent-card.json that describes an agent’s identity, capabilities, supported skills, and connection details. In version 1.2, Agent Cards support cryptographic signatures for domain verification.

Discovery works like DNS for agents: before an orchestrator delegates a task, it fetches the target agent’s Agent Card to understand what the agent can do and how to reach it. This eliminates hardcoded integrations and makes agent networks dynamically extensible, as IBM explains in their A2A overview.

From launch to 150 organizations in twelve months

Google announced A2A at Google Cloud Next in April 2025 with 50+ launch partners, including Atlassian, Salesforce, SAP, ServiceNow, PayPal, Microsoft, AWS, and IBM. The protocol was subsequently donated to the Linux Foundation, joining MCP under the Agentic AI Foundation (AAIF) — the same governance body that maintains the Model Context Protocol.

By April 2026, the one-year report confirmed 150+ organizations running A2A in production, with active deployments across supply chain automation, financial services, insurance claims processing, and IT operations. Microsoft, AWS, Salesforce, SAP, and ServiceNow are all running A2A in live environments.

MCP + A2A: the complete integration stack

The two protocols are complementary by design, as covered in the complete MCP vs A2A guide. A production multi-agent system typically uses both: MCP for the vertical connections (agent to tools, databases, APIs) and A2A for the horizontal connections (agent to agent). A customer support orchestrator might use MCP to pull ticket data from Jira and A2A to delegate specialized tasks to billing, shipping, and technical agents — each built by a different vendor on a different framework.

What engineering teams need to implement now

Making an agent A2A-compatible requires three concrete steps:

  • Publish an Agent Card — expose a /.well-known/agent-card.json endpoint that describes your agent’s skills, input/output schemas, and authentication requirements.
  • Implement JSON-RPC 2.0 endpoints — handle task delegation requests and return structured responses. The A2A SDK (available in Python, TypeScript, and Java) provides the scaffolding.
  • Add SSE support for long-running tasks — stream status updates so orchestrating agents don’t have to poll. This is particularly important for tasks that take seconds to minutes.

Teams already familiar with REST APIs will find A2A straightforward. The SDK documentation at github.com/a2aproject/A2A includes reference implementations and quickstart examples for each language.

Conclusion

The Agent-to-Agent Protocol solves the coordination problem that MCP left open. With 150+ organizations in production after just twelve months, neutral governance under the Linux Foundation, and deep integration across every major cloud platform, A2A has crossed the adoption threshold that matters. For engineering teams building multi-agent systems, the architecture question is no longer theoretical: MCP for tools, A2A for agents, and a standard stack that works across every vendor. The agentic integration layer is now complete.