System Atlas
the atlas
AI · AI & LLMs7 minApplied

MCP vs API vs A2A protocol

Three connectors for three different conversations — apps, models, and agents.

the gist

A traditional API lets two programs talk on fixed, hand-integrated contracts. MCP (Model Context Protocol) is a standard way to plug tools, data, and context into an LLM app so the model can discover and call them. A2A (Agent-to-Agent) lets autonomous agents coordinate as peers. They solve different layers and stack together rather than compete.

ANALOGY // APIs are like knowing a specific person's phone number and agreeing what to talk about; MCP is a universal power socket any appliance can plug into; A2A is two managers phoning each other to split up a project.
living diagram01 / 05
Traditional APIapp ↔ service, bespoke contract
MCPLLM app ↔ tools & data, standardized
A2Aagent ↔ agent coordination
Stacked togetherAPIs + MCP + A2A in one system
APIs connect two programs on a fixed, hand-built contract — the substrate everything else rides on.
01

The traditional API

An API is a contract between two programs: one exposes endpoints, the other calls them with an agreed request and response shape. It is powerful and universal, but each integration is bespoke — a developer reads the docs and writes glue code for that specific pairing. Scale that to an LLM that wants to use hundreds of tools and the hand-wiring explodes.

02

Why LLMs strained the model

A language model is only as useful as the tools and data it can reach, but wiring each tool in by hand, with a custom prompt format and parser, does not scale. Every new data source meant new bespoke integration code, and no two teams did it the same way. What was missing was a standard interface between models and the world of tools and context.

03

MCP standardizes model context

The Model Context Protocol defines one open standard for connecting an LLM application to external tools, data sources, and prompts. An MCP server exposes its tools and resources in a uniform, self-describing way, and any MCP-aware client can discover and call them at runtime without custom glue. Build a server once and every compatible model can use it.

04

A2A coordinates agents

Once you have many capable agents, they need to talk to each other, not just to tools. Agent-to-Agent protocols let autonomous agents advertise their skills, delegate sub-tasks, and exchange results as peers, with their own identity and lifecycle. This is coordination between minds, a layer above a model reaching for a single tool.

05

How the layers stack

The three are complementary layers, not rivals. Traditional APIs remain the transport most of this rides on; MCP standardizes how a model plugs into tools and context; A2A standardizes how agents coordinate. A real system uses all three — an agent calls tools over MCP, collaborates with peers over A2A, and both are ultimately HTTP APIs underneath.

the full picture
01

Three connectors, three conversations

As soon as software started being built around large language models, a naming muddle appeared: people talk about "APIs," "MCP," and "A2A" as if they were competing choices. They are not. They are connectors for three different kinds of conversation, and the clearest way to keep them straight is to ask *who is talking to whom*.

  • A traditional API connects an application to a service — two pieces of conventional software talking on a pre-agreed contract.
  • MCP connects a language model to the tools, data, and context it needs to be useful — a model reaching outward into the world.
  • A2A connects agents to each other — autonomous systems coordinating as peers.

Each solves a real problem the layer below it left open, and in a mature system all three operate at once. Treating them as rivals leads to bad architecture; seeing them as a stack is what makes an agentic system tractable.

02

The traditional API and where it strained

An API (application programming interface) is a contract: a service publishes endpoints with defined request and response shapes, and any client that follows the contract can call it. REST and gRPC APIs are the connective tissue of essentially all modern software, and they are wonderfully general. Nothing about them is wrong.

The friction is that every integration is bespoke. A developer reads the documentation for each service and hand-writes glue code — auth, request shaping, response parsing — specific to that one pairing. That is perfectly fine when an app talks to a handful of services. It breaks down when the "client" is a language model that could plausibly want to use hundreds of tools, each with its own format, and where you'd like to add a new tool without redeploying the model. Hand-wiring every model-to-tool connection, with a custom prompt template and output parser each time, is exactly the kind of N × M integration explosion that standards exist to kill.

03

MCP — a standard socket for model context

The Model Context Protocol answers that explosion with a single open standard for connecting an LLM application to external capabilities. It follows a client-server shape: an MCP server wraps some tool, data source, or prompt library and exposes it in a uniform, self-describing way, while an MCP client (inside the AI app) connects to any number of those servers.

Two properties make it more than "just another API":

  • Standardization — every MCP server speaks the same protocol, so an AI app integrates the protocol once and instantly gains access to the entire ecosystem of servers, instead of writing custom glue per tool.
  • Discoverability — a client can ask a server at runtime what tools, resources, and prompts it offers, and the model can then decide which to call. Capabilities are advertised, not hard-coded.

The payoff is that building an MCP server once makes a tool available to every compatible model — Claude, an IDE assistant, an internal agent — without any of them needing bespoke code. MCP is about a model reaching *down and out* to the world of tools and context in a uniform way.

04

A2A — coordination between agents

MCP solves how one agent reaches its tools. It says nothing about how *agents reach each other*, and that is the gap Agent-to-Agent protocols fill. Once you have several capable, autonomous agents — perhaps a research agent, a coding agent, and a planning agent, possibly built by different teams or vendors — you need a way for them to collaborate without being merged into one program.

A2A treats agents as first-class peers. An agent can publish a description of its skills (often called an agent card), another agent can discover it, delegate a sub-task to it, and receive results back, with each agent keeping its own identity, state, and lifecycle. The conversation is fundamentally different from a tool call: a tool is a passive function you invoke, whereas a peer agent is an active party that may itself reason, use its own tools, ask clarifying questions, and run for a long time. A2A is therefore concerned with things a tool protocol isn't — task delegation, negotiation, long-running collaboration, and trust between independent agents.

05

How they stack in practice

The three are best understood as layers rather than alternatives, and the tell is that the higher ones are built on the lower ones.

Underneath everything sit ordinary APIs and HTTP — MCP and A2A are themselves defined as protocols that ride over standard web transport, so "API vs MCP vs A2A" is partly a category error: MCP and A2A *are* specialized, standardized APIs for specific jobs. On top of that substrate, MCP gives a model a uniform, discoverable way to plug into tools and data. On top of *that*, A2A gives agents a uniform way to coordinate with one another.

A single production system uses all three at once. Picture a customer-support agent: it uses MCP to reach the ticket database, the search index, and the refund tool; it uses A2A to hand a billing dispute to a specialized finance agent; and both of those, plus the finance agent's own downstream calls, are ultimately HTTP APIs on the wire. The right mental model is a stack — apps talk over APIs, models reach tools over MCP, agents coordinate over A2A — and good agentic architecture comes from putting each concern on the layer built for it.

what to remember
01

Traditional API: app ↔ service on a bespoke contract, integrated by hand for each pairing.

02

MCP standardizes how an LLM app connects to tools, data sources, and context — one protocol, many servers.

03

MCP is discoverable: the model can ask a server what tools and resources it offers at runtime.

04

A2A operates one layer up — autonomous agents coordinate, delegate, and negotiate as peers.

05

They complement, not compete: an agent uses MCP to reach tools and A2A to reach other agents, both often over HTTP APIs underneath.

check yourself

Quick quiz

Q1

What problem does MCP primarily solve?

Q2

How do MCP and A2A relate?

follow the thread