Agentic Commerce API

What actually changed

Agentic commerce is not a new checkout button. It is a change in who reads the page. When a person shops, they sample three sellers, reconcile messy catalogues effortlessly, and supply from memory all the context a listing leaves out. When software shops, none of that is true.

• Comparison becomes exhaustive. A person checks three sellers; an agent checks forty — which multiplies the cost of a single bad product match rather than averaging it out.
• Reaction windows compress. A price that is re-checked on every query is effectively watched continuously, so stale data is punished harder than it used to be.
• The reader is structured. An agent reads markup and feeds, not layout. A product invisible to structured retrieval is invisible full stop, however well it ranks for humans.

The protocols, and what each is actually for

These solve different problems and get conflated constantly. ACP and UCP are checkout. MCP is tool access. Web Bot Auth is identity, and it is the one most people have not registered yet — it determines whether an agent can read a site at all.

The access shift nobody planned for

For anyone building an agent this inverts the usual advice. The durable position is not a better evasion stack — it is accreditation: registered keys, a published JWKS, a payment relationship, and a legitimacy record that compounds. Crawlers rot; accreditation does not.

Why agents fail at the actual decision

Presented with $198.00, an agent has no basis to judge it. It cannot construct ninety days of history inside a conversation, and the struck-through reference price beside it is a marketing decision rather than a fact. So it either accepts the first plausible option or burns enormous context trying to reconstruct information it cannot reach.

The fix is to give the agent a verdict rather than a number, with the distribution behind it so it can explain itself. An agent that says “fourth percentile of eighty-nine days, lowest since March” is one a person trusts. An agent that says “$198.00” is a search box.

price_context("sony wh-1000xm5")

→ { "verdict": "excellent",
    "current": "$198.00", "seller": "bestbuy",
    "percentile": 4.0, "covered_days": 89,
    "low": "$198.00", "median": "$319.99", "high": "$398.00" }

Metering, because nobody approves each call

One prompt fans into dozens of tool calls with no human reviewing any of them. That breaks the assumption behind most API billing. Tools should declare their cost so an agent can budget, and a metadata lookup must not bill like a live cross-seller comparison — otherwise agents learn to abuse the cheap one.

What this means if you sell things

Publish identity. GTIN, brand and MPN in structured markup and in a feed. Identity published at the source is what turns cross-retailer matching from a machine-learning problem into a join — which is good news for merchants and bad news for vendors whose moat was the matching model.

What an agent needs that a human shopper does not

A person browsing absorbs an enormous amount implicitly: that the photo shows a two-pack, that the seller name is unfamiliar, that the delivery date is after the birthday. An agent gets none of that unless it is a field. This is the actual design constraint in agentic commerce — not reasoning capability, but whether the facts an autonomous decision depends on are present, typed and carry a confidence.

The last row is the one most systems omit and the one that causes the worst failures. An agent optimising for lowest price with no risk signal does not find the best deal — it finds the listing most likely to be wrong, because implausibly low prices and bad offers occupy the same tail of the distribution.

The protocols, and what each actually settles

Several standards are converging on this space and they are frequently discussed as competitors when they mostly address different layers. It is worth being precise about which problem each one solves, because adopting the wrong one for your problem is an expensive way to discover the distinction.

• Model Context Protocol standardises how a model discovers and calls tools. It settles the interface between an agent and a capability, not what commerce data means.
• Agentic and universal commerce protocols standardise how a catalogue and its offers are expressed to machines — the vocabulary layer.
• Standard Webhooks settles how asynchronous events are delivered and verified, which matters because commerce state changes while an agent is not looking.
• Web Bot Auth addresses how an automated client proves who it is, which is the foundation for any relationship other than mutual suspicion.
• schema.org and GTIN remain the identity substrate underneath all of it, and are the oldest and least glamorous part of the stack.

Why checkout is the genuinely hard part

Search, comparison and decisioning are read operations — wrong answers are recoverable. Checkout is a write with money attached and no undo, which raises every requirement at once: authorisation that is scoped and revocable, a price the agent can rely on between decision and purchase, an audit trail explaining why a purchase happened, and a return path when it should not have. These are the reasons checkout is still being standardised while the read side is largely solved.

Questions

Common questions

Related