MCP Explained: The Discovery Layer of Agentic Commerce

Of all the three-letter names in agentic commerce, MCP is the one you will meet most often — and the one most people explain wrong. It is not a payment protocol. It is not a checkout standard. It is the quiet layer underneath both: how an agent finds out what a store can do, and then does it.

Let me explain MCP in plain terms, and show why it keeps turning up everywhere.

The one idea behind MCP

An agent is only as useful as the tools it can reach. MCP — the Model Context Protocol — is a standard way to hand an agent a set of tools and say "here is what you can do, and here is how to call each one."

That is the whole idea. A store exposes tools like search_products or check_availability, describes them in a standard shape, and any MCP-speaking agent can discover those tools and call them. No custom integration per agent. No guessing. The agent asks "what can I do here?" and gets a clear answer.

This is why I call it the discovery layer. Before an agent can shop, pay, or do anything, it has to find out what is possible. That is MCP's job.

Where MCP came from

MCP was created by Anthropic and open-sourced in late 2024. It caught on fast, well beyond commerce — developers used it to connect agents to databases, file systems, internal tools, almost anything.

The important moment for trust came in December 2025, when MCP was donated to the Linux Foundation's Agentic AI Foundation, co-founded with Block and OpenAI. By then it already had more than 10,000 public servers. Neutral governance matters here: a standard that everyone depends on should not be owned by one company. (This is a pattern across the space — AP2 did the same thing, moving to the FIDO Alliance.)

What an MCP server actually is

In practice, "adding MCP" means running an MCP server: a small service that exposes your tools over a standard interface. An agent connects to it, asks what tools exist, and calls them.

A commerce MCP server might expose:

• search_products — find items.
• get_product — full detail on one item.
• check_availability — is this buyable right now?
• create_cart — build a basket.

Each tool has a name, a description, and a clear shape for its inputs and outputs. The agent reads those descriptions and knows how to use the tool without anyone writing custom glue code for it.

The thing people get wrong

Here is the misunderstanding worth clearing up: MCP does not move money.

It is tempting, once you have an MCP server, to add a "pay" tool and call it done. Do not. MCP is discovery and action — finding tools and calling them. The actual payment belongs to a different layer, behind proper authorization, with scoped tokens and a human's approval. Mixing payment into a raw MCP tool is how you hand autonomous software a blank cheque. (I wrote about exactly where I drew that line in which MCP tools I exposed.)

Keep the layers clean: MCP finds and calls; the payment layer moves money.

How MCP fits with ACP and UCP

This is where it gets satisfying, because MCP does not compete with the checkout protocols — it sits under them.

• UCP services are often exposed over MCP. When a store publishes its /.well-known/ucp profile, the services it lists frequently run as MCP tools. MCP is the most common transport there.
• ACP added MCP compatibility in its April 2026 release, so an ACP-aware agent can advertise and discover checkout capability through MCP tool discovery.

So the shape is: MCP is how the agent finds the store's tools, and ACP or UCP is how it completes the purchase through them. One layer discovers; the other transacts. (I lay out all the layers in the protocol stack.)

Why I keep coming back to MCP

If you build for agentic commerce, MCP is not optional and it is not glamorous. It is the floor. Get it right and every protocol above it has clean tools to call. Get it wrong — unclear tools, a payment button where it should not be — and nothing above it is safe.

That is why, when people ask where to start, I point at the discovery layer first. It is the least exciting part of the stack and the one that decides whether the rest works.

Key takeaway

MCP is the discovery layer of agentic commerce: an open standard for giving an agent a store's tools in a shape it can find and call. It came from Anthropic, it is now neutrally governed under the Linux Foundation, and it sits underneath ACP and UCP rather than competing with them. It finds and calls tools — it does not move money, and you should keep it that way.

For the full map, see the agentic commerce protocol stack; for a builder's view of exposing tools safely, see MCP for ecommerce.

Sources and further reading

• Model Context Protocol, Anthropic: https://modelcontextprotocol.io
• MCP specification and docs: https://modelcontextprotocol.io/specification
• Linux Foundation, Agentic AI Foundation (MCP donation, Dec 2025): https://www.linuxfoundation.org
• Agentic Commerce Protocol (ACP), April 2026 release adding MCP compatibility: https://www.agenticcommerce.dev
• Google Developers Blog, UCP and its transports: https://developers.googleblog.com

Note: MCP's spec and governance are evolving. Please check the primary sources above before relying on a specific version or detail.