How AI Agents Talk to Each Other: A2A, MCP, and the Emerging Protocols of the Agentic Web

We spent a decade teaching AI models to talk to humans. The next frontier is teaching AI agents to talk to each other. This is not a minor extension of existing capability — it requires an entirely new class of protocol, identity model, and trust architecture.

In 2025, we are in the middle of a Cambrian explosion of agent communication protocols. Some are standards; some are proposals; some are vendor lock-in dressed up as open specifications. Here is a comprehensive map of the landscape.

Why Agent-to-Agent Communication Is Hard

When a human calls an API, the interaction is simple: request, response, done. When an AI agent calls another AI agent, the interaction is fundamentally different. The calling agent may not know in advance what the responding agent is capable of. The responding agent may need to ask clarifying questions. Either agent may spawn sub-agents. The conversation may run for minutes or hours. And crucially, neither agent is directly supervised by a human who can intervene when something goes wrong.

This combination of dynamic capability discovery, conversational state, potential recursion, and reduced human oversight requires protocols that HTTP REST was never designed to handle.

The Major Agent Communication Protocols

A2A — Agent-to-Agent Protocol (Google)

Google's Agent-to-Agent protocol, announced in April 2025 and currently in active development, is the most ambitious attempt to standardise inter-agent communication at the enterprise level. A2A defines how agents discover each other through Agent Cards — structured JSON documents that describe an agent's capabilities, supported input/output modalities, authentication requirements, and pricing model.

The A2A communication model is task-centric. A client agent sends a Task object to a remote agent, which can respond in three modes: immediate synchronous response, streamed response for long-running tasks, or push notification when an asynchronous task completes. Tasks carry a unique ID, enabling the client agent to poll for status or subscribe to updates. Critically, A2A supports multi-turn conversations within a task — the remote agent can ask the client for more information before completing the task, modelling the natural back-and-forth of human-to-human delegation.

A2A uses standard HTTP transport with Server-Sent Events for streaming, making it compatible with existing infrastructure. Authentication is handled via standard OAuth 2.0 flows described in the Agent Card, which means enterprise security teams can apply existing identity and access management policies to agent interactions.

MCP — Model Context Protocol (Anthropic)

While A2A handles agent-to-agent communication, MCP (covered in depth in our earlier post) handles agent-to-tool communication. The distinction matters: MCP is for connecting an agent to data sources and functions it controls; A2A is for delegating a task to another autonomous agent that has its own reasoning loop. In a well-architected multi-agent system, both protocols are in use simultaneously — an orchestrator agent uses A2A to delegate to specialist agents, and each specialist agent uses MCP to access the data and tools it needs.

OpenAI Agents SDK and Handoff Protocol

OpenAI's Agents SDK, released in early 2025, introduced the concept of handoffs — a mechanism for one agent to transfer control of a conversation to another agent, along with the full conversation context. Unlike A2A, handoffs are not a network protocol but an in-process mechanism, making them most useful when all agents are running within a single application. The SDK defines a standard interface for agent handoffs that makes it easy to build swarms of specialised agents orchestrated by a central planner.

LangChain LangGraph — Graph-Based Agent Orchestration

LangGraph treats multi-agent systems as directed graphs where nodes are agents or tools and edges represent control flow. It is not a network protocol but a programming model for orchestrating agents within a single deployment. LangGraph's key contribution is making agent state explicit and persistent — the graph state is checkpointed at every node transition, enabling long-running workflows that survive process restarts and allowing human-in-the-loop approvals at defined points in the graph.

FIPA ACL — The Academic Ancestor

The Foundation for Intelligent Physical Agents Agent Communication Language, developed in the late 1990s, was the first serious attempt to standardise agent communication. FIPA ACL defined a rich vocabulary of communicative acts — inform, request, propose, agree, refuse, confirm — that mirror human speech acts. While FIPA ACL itself is not used in modern LLM-based agents, its conceptual framework deeply influenced A2A's task model and the broader field of agent communication design.

AutoGen Agent Protocol (Microsoft)

Microsoft's AutoGen framework, which underpins much of the Copilot ecosystem, defines its own inter-agent messaging model based on typed messages with a standardised schema. AutoGen agents communicate through a message bus where each agent subscribes to message types it can handle. This pub-sub model makes it easy to add new agents to a workflow without modifying existing ones — a significant advantage for enterprise deployments where agent capabilities evolve frequently.

The Emerging Consensus Architecture

Across these protocols, a common architecture is emerging for production multi-agent systems. An Orchestrator Agent receives the high-level task from a human or application and breaks it into sub-tasks. It uses A2A or an equivalent protocol to delegate sub-tasks to Specialist Agents. Each Specialist Agent uses MCP to access the data sources and tools it needs. Results flow back up to the Orchestrator, which synthesises them into a final response. Checkpointing at each layer provides recovery from failures.

• Orchestrator layer: receives goals, plans sub-tasks, coordinates specialist agents via A2A
• Specialist layer: domain-expert agents (code, research, analysis) that use MCP for data access
• Tool layer: MCP servers exposing databases, APIs, and file systems to specialist agents
• Memory layer: shared vector store and episodic memory accessible to all agents
• Governance layer: policy engine that enforces what any agent is permitted to do

What This Means for Software Architecture

If you are building software that will be consumed by AI agents — directly or indirectly — you need to design for machine callers now. That means well-typed, well-documented APIs, idempotent operations, structured error responses that an AI can interpret, and eventually an A2A or MCP server that exposes your system's capabilities to the agentic ecosystem.

“The internet was built for humans reading web pages. The agentic web is being built for AI agents calling AI agents. The protocols being standardised today will determine the architecture of computing for the next 20 years.”