Key insights

• A2A handles agent-to-agent communication while MCP connects individual agents to tools and data — they solve different problems
• Both protocols use JSON-RPC over standard HTTP, making them compatible with existing web infrastructure
• A2A agents advertise capabilities through agent cards, enabling dynamic discovery without prior configuration

---

In Brief

AI agents can reason and generate content on their own, but connecting them to each other and to external tools has required custom integrations. Two open protocols aim to standardize this: A2A (Agent-to-Agent Protocol) handles communication between agents, while MCP (Model Context Protocol) connects individual agents to data sources and tools. In this IBM Technology video, Martin Keen and Anna Gutowska explain how each protocol works and why they complement rather than compete with each other.

---

What A2A does

Agent-to-Agent Protocol (A2A) is an open protocol originally created by Google that defines how AI agents exchange messages and task requests, regardless of which vendor or framework built them (0:59). If one team builds an agent using one framework and another team uses a different one, A2A lets them work together without custom integration code.

Agent cards

Each A2A agent publishes an agent card, a standardized descriptor that advertises what the agent can do (1:53). Other agents discover these cards dynamically, check what skills or services are offered, and decide how to divide work. Gutowska describes it as essentially a resume that other agents can read and act on (2:00).

Works across modalities

A2A messages are not limited to text. Agents can swap images, files, and structured data as part of the same flow (3:12). One agent could generate a design mockup, another could review it, and a third could handle client approval.

Transport and data format

A2A runs on plain HTTP, so any existing web server, API gateway (a server that acts as a single entry point for API requests), or infrastructure can host an A2A agent (3:38). The data format is JSON-RPC 2.0 (a lightweight standard for structured request-response communication between systems) (4:09). This means agents get routing, security layers, load balancing, and logging from existing web infrastructure.

Streaming for long-running tasks

For jobs that take time, A2A supports streaming updates via Server-Sent Events (SSE, a web technology that lets a server push updates to a client in real time) (4:57). One agent can push status updates and partial results to another without waiting for a final response.

---

What MCP does

Model Context Protocol (MCP), originally created by Anthropic, solves a different problem: how a single agent gets access to external data and tools (5:43). Without MCP, developers write custom code for each combination of model and tool. Swap the model or the tool, and you rebuild the integration (6:34).

Host and server architecture

MCP uses a two-layer design. The MCP host is the AI application where the agent runs. The MCP server sits below it and knows how to communicate with specific resources like file systems, code repositories, or databases (7:06). The server presents a uniform interface to the agent, hiding the complexity of each individual resource.

Three primitives

MCP servers expose three types of capabilities (7:44):

Transport depends on location

Like A2A, MCP uses JSON-RPC for its message format. But the transport layer depends on where the server lives (8:55):

• Local servers (same machine, like an IDE plugin): standard input/output (stdio)
• Remote servers (different machine): HTTP with streaming support

Write once, reuse everywhere

The key benefit: build an MCP server once and any MCP-compatible host can use it (9:32). Swap models or applications without rebuilding the integration. There are already pre-made MCP servers for file systems, Slack, GitHub, databases, and many other services (9:52).

---

How they work together

Keen and Gutowska close with a retail example that uses both protocols (10:07):

1. An inventory agent uses MCP to connect to product and stock databases
2. When stock runs low, the inventory agent uses A2A to notify an internal order agent
3. The order agent uses A2A to communicate with one or more external supplier agents

MCP gives the inventory agent access to data. A2A lets the agents coordinate across organizational boundaries. The two protocols address different layers of the stack: MCP handles the vertical connection between an agent and its tools, while A2A handles the horizontal connection between agents.

As Keen summarizes: "A2A for agents talking to agents and MCP for agents talking to tools and data" (11:17).

---

Practical implications

For developers building AI agents

Understanding the distinction between A2A and MCP helps avoid building unnecessary custom integrations. Use MCP to connect agents to tools and data sources. Use A2A when agents from different systems need to collaborate. Both use familiar web standards (HTTP, JSON-RPC), so they work with existing infrastructure.

For teams evaluating agent frameworks

When choosing agent frameworks, check whether they support A2A and MCP. Both protocols are open standards, meaning no single vendor controls the specification. Agents built on frameworks that support these protocols can interoperate without custom middleware.

---

Glossary

---

Sources and resources