There's a moment every shopping agent hits. The user says "find me some running shoes," and the agent has to decide which store to walk into — and it has no idea which ones will let it buy anything. So it guesses, scrapes a catalogue that was rendered for a browser, and hands back a checkout it can't complete.

Update — 1 September 2026. We've refactored the MCP server from a router to a resolver.

The two write tools it shipped with, add-to-cart and build-bundle, came out of early research into what agent orchestration over UCP could actually look like — whether an agent could get from a plain-language intent to a filled basket, across several stores at once, using nothing but published manifests. It could, and building them was how we found that out. That line of work now lives in UCP Playground, which runs real agent sessions against live stores and watches every tool call.

So the server here is read-only: eight tools that resolve which verified stores can serve an intent and report their observed state, and you transact with the merchant directly. The flow below is otherwise unchanged. Server version is now 2.0.0.

The Universal Commerce Protocol fixes that at the store: a business publishes what it supports at /.well-known/ucp, and an agent that reads it knows exactly which capabilities it can call. What's been missing is the step before that — knowing which stores have actually done it, and done it well. That's what we measure. As of today, an agent can get the answer in one snippet.

#One snippet, no key

ucpchecker.com/docs is the new API & MCP documentation. Its quickstart is a tab per client — Claude Code, Cursor, Claude Desktop, ChatGPT or VS Code — and one snippet puts the UCP Checker tools in your agent's tool tray:

claude mcp add --transport http ucp-checker https://ucpchecker.com/mcp

That's it. The server is keyless. Eight tools come with it, and the docs document each one — parameters, types, what's required — generated from the running server's own schemas so the reference can't drift from what /mcp serves: check-domain to see whether any domain supports UCP; list-stores and list-categories to browse the verified fleet by category and score; search-catalog and search-all for live products on one store or across all of them at once; search-policies for returns and shipping before you commit; get-product-details for a product's full declared detail; and discover-store to see what a merchant's own endpoint exposes. Every one of them is a read. The server never carts, never checks out and never handles payment — it resolves the store and gets out of the way.

Every store the resolver will return is one we've verified: a valid profile, a public listing, a benchmark score above the floor, and a fresh check within the last day. If it isn't in that set, it doesn't appear. That refusal is the point of connecting here rather than guessing.

The rest of the docs is what you'd expect from an API reference and a little more: authentication and rate limits by tier, the REST endpoints with curl examples and response codes, the discovery endpoints described below, and three guides — how to build a shopping agent in six calls, how the UCP score is computed (the weights and grade bands are read from the scorer itself, so the page and the number can't disagree), and how the score model is versioned. That last one matters if you consume the record over time: the model is versioned, history is never rescored, and every number says which model produced it.

#Discoverable by standard, not just by us

The bigger change is one most people connecting a client won't see. UCP Checker is now an Agentic Resource Discovery (ARD) discovery service — the open, federated standard for how an agent asks "what's available for this task?" before it invokes anything. ARD is being developed by a working group with participants from Microsoft, Google, Hugging Face and GoDaddy, and its connectors already ship for Claude Code, ChatGPT, Copilot, Gemini and Cursor.

What it means in practice: POST https://ucpchecker.com/ard/search with {"query": {"text": "running shoes"}} returns verified storefronts as standard catalogue entries — each with the store's UCP profile, its MCP endpoint, the capabilities it declares, and a trustManifest that links to its public conformance record. An ARD-aware agent can find a store it can transact with without ever having heard of UCP Checker. We think that's the right shape for a reference: the record should be reachable by the standard route, not only by ours.

Two details we held ourselves to. The relevance score on a search result is relevance only — the standard is explicit that it must never read as a trust or quality rating, so the UCP score lives in the entry's metadata where it belongs. And the index is the resolver's own list and nothing else: nothing private, nothing unverified, nothing longitudinal transits the surface. We ran the standard's own conformance suite against production; both the manifest and the registry pass.

The capability manifest is at /.well-known/ai-catalog.json, the MCP server card at /.well-known/mcp/server-card.json, and the server is listed in the official MCP Registry as com.ucpchecker/ucp-checker.

#Skills for the agents doing the building

Two skills ship alongside, served live at /.well-known/agent-skills/index.json so a spec version never bakes into an agent's memory:

• ucp-checker — for shopping agents: how to find stores through ARD, read a domain's record, and resolve a store to buy from, in that order.
• ucp-agent-ready — for coding agents asked to "make this store agent-ready": a check → fix → re-check loop over the public API, the minimum conformant profile, the bot-access rules that trip real stores, and a CI gate.

The second one matters to merchants as much as to developers. Most of what stops a store being agent-ready is small and mechanical — a robots rule, a missing signing key, a namespace that isn't in the spec. A coding agent with the skill loaded can find and fix it against the same validator we run every day.

#Why this, why now

We've said before that we look at agentic commerce from two vantages: what a business declares, and what happens when an agent actually shows up. The connect page and the ARD finder put the first vantage where agents already are — in their tool tray, in their discovery layer — instead of on a web page they'd have to be told about.

For a merchant, being in that list is the shortest route to being shoppable by the agents that matter. For a developer, it's four tool calls from "I need running shoes" to a verified store that will actually complete the sale. And for anyone measuring this space, it means the reference is now something an agent can query as easily as a person can read.

Connect it, run list-stores, and see what's there. If your store isn't, check it — the skill will tell you why.

#About UCP Checker

UCP Checker is the independent validation and observability layer for the Universal Commerce Protocol. We crawl, validate and grade every public UCP manifest we can find, run the merchant directory, the UCP Score, live adoption stats and the authority-bound vendor map, and track the spec as it evolves so you don't have to. For agents and developers, the docs put all of it behind one keyless MCP server and API. For businesses, the UCP Checker app turns the one-time check into continuous observability — daily conformance monitoring against the live spec, break alerts the moment agent access degrades, and benchmarking against the stores you compete with — measured from two vantages (what a business declares, and what actually happens when an agent transacts), the same way for everyone, without picking winners.

• Connect your agent (docs): ucpchecker.com/docs
• Check your store: ucpchecker.com/check
• Grade it (UCP Score): ucpchecker.com/score
• Monitor it continuously (UCP Checker app): app.ucpchecker.com
• Find stores an agent can transact with (ARD): POST ucpchecker.com/ard/search

#Sources

• API & MCP documentation — ucpchecker.com/docs
• Agentic Resource Discovery specification (v0.9)
• ARD connectors for Claude Code, ChatGPT, Copilot, Gemini and Cursor
• Official MCP Registry
• UCP Checker capability manifest — /.well-known/ai-catalog.json
• Related coverage: Build an AI shopping agent · Why we built UCP Playground