The short answer: WebMCP is the part of agent commerce your customers' browser will handle — and UCP is the part that actually completes the sale. If you want to know whether your store is ready for the agents arriving through both, enter your domain here. It checks the commerce layer — the half that decides whether an agent can finish a checkout, not just start one.
The longer answer — what "WebMCP and UCP ready" actually means for a store, how the two fit together, and what to do about it — is what this post covers.
WebMCP (the Web Model Context Protocol) is a W3C Community Group draft from Google and Microsoft engineers that landed in February 2026 and shipped as an early preview in Chrome 146. It adds a browser-native API — navigator.modelContext
— that lets a web page hand an in-browser AI agent a set of structured, callable tools instead of forcing it to scrape the DOM.
In plain commerce terms: your search box, your filter panel, your add-to-cart button, and your checkout form stop being pixels an agent has to guess at, and become named tools the agent can call directly. There are two ways to expose them:
toolname
and tooldescription
attributes to the HTML forms you already have. A search form becomes a search_products
tool with almost no code.Crucially, WebMCP tools run inside the user's own authenticated browser session, with human-in-the-loop approval. The agent acts as the shopper, on the shopper's machine, with the shopper's login.
So "is my store WebMCP-ready?" is really two questions, and most merchants only think about the first:
This is the part that gets lost in the WebMCP hype. WebMCP is a transport for intent — it lets the agent say "add this variant, apply this code, check out." It does not define what a product, a cart, a payment handler, or an order confirmation is. That's UCP's job.
The clearest way to see it: WebMCP can hand an agent a checkout
tool, but if the agent calls it and your store can't return a structured cart, can't accept a delegated payment token, and can't confirm the order in a machine-readable way, the tool call fails. The agent had the button. The store couldn't honour the press.
The emerging consensus — including from people building this at the platform level — is that agent-ready commerce is a stack, not a single switch:
WebMCP makes your store operable. UCP makes it transactable. A store that's WebMCP-ready but not UCP-ready is a storefront with working buttons and no cash register.
If you're on Shopify, most of the UCP layer is being handled for you — Shopify has been [building UCP into the platform](https://ucpchecker.com/blog/shopify-ucp-guide-ai-agent-commerce) and [shipped its own UCP CLI](https://ucpchecker.com/blog/shopify-ucp-cli-explained). That's the half WebMCP doesn't cover, already moving. The open question for a Shopify merchant isn't "will I get a manifest" — it's "is my specific store's manifest valid, complete, and not silently broken by a theme or app change."
For WooCommerce, BigCommerce, and Magento merchants, more of that backend is on you. WebMCP support will arrive through the browser regardless of your platform — but the UCP layer that turns an agent's checkout tool-call into an order is the part you have to get right yourself. Our [platform monitoring data](https://ucpchecker.com/blog/agentic-commerce-optimization-ucp-readiness-data) shows that's exactly where most stores fall down.
WebMCP is still a Chrome-preview standard, and the page-side tooling is shifting week to week. The commerce layer underneath it, though, is live right now — and that's checkable in about a second.
Go to UCPChecker.com/check and enter your domain. It will:
/.well-known/ucp
from your storecheckout
tool needs on the backendIf your store can't complete an agent checkout, the failure almost always lives in one of those primitives — not in the page-side tooling everyone's talking about.
Verified — your commerce backend is valid and an agent that reaches your checkout tool can actually transact. Check the warnings for depth.
Invalid — the manifest exists but fails validation. Most invalid stores are one fix away — usually a missing required field.
Not Detected — no manifest. Your store is WebMCP-operable at best and un-transactable at worst. See the requirements.
Blocked — a robots.txt or firewall rule is hiding the manifest from agents.
Validation proves your manifest is correct. It can't prove an agent can complete a purchase end to end — for that you need UCP Playground, which runs real agent sessions against your store and shows you exactly where the flow breaks.
Your manifest is a live API. Theme updates, app installs, and CDN changes break it silently. UCP Alerts emails you the moment your status changes — before an agent's checkout tool call fails.
Client-side scanners now exist — Chrome extensions that score your page on tool detection, coverage, schema quality, and declarative-form setup. They're useful, and they answer the first of our two questions. What none of them check is whether a completed tool call can actually clear a purchase. So pair the page-side scan with this backend list:
toolname
/ tooldescription
to your search, filter, and add-to-cart forms.That last point is the whole argument: the page-side checklist is short and shipping. The backend it depends on is where readiness is actually won or lost.
The line between "operate" and "transact" may not stay fixed. In its 2026-05-08 session, the UCP Technical Council reviewed a proposal to use WebMCP as a UCP transport — letting an agent drive visible page state through WebMCP tools instead of firing disparate backend API calls. The appeal is real: the shopper watches the cart fill and the checkout advance in their own browser, in real time.
The council didn't approve it on the spot, and the reason is the most interesting part for merchants: UI synchronization. If an agent's backend call updates the order, the storefront has to emit the matching events so the visible interface reflects the new state at the same moment — otherwise the agent and the page drift apart. A dedicated deep dive was scheduled to work through that architecture.
It's worth watching, because if WebMCP becomes a sanctioned UCP transport, the two halves of "ready" start to converge. But the dependency direction doesn't change: WebMCP would be how the agent talks to your store; UCP is still what it's saying. The backend has to be right either way.
WebMCP went from proposal to Chrome preview in a single quarter. Browser support across Chrome and Edge is expected by late 2026, and once an agent can operate any page in the user's own session, the bottleneck stops being can the agent click and becomes can the store transact. That second half is UCP, it's live today, and across the stores in our growing directory it's still where most checkouts would fail.
Is my store WebMCP and UCP ready? The honest answer for most merchants is: the browser will make you operable for free — but only the commerce layer you control decides whether the sale actually closes. Check that half first.
UCP Checker is the independent validation and monitoring layer for the Universal Commerce Protocol. We crawl, validate and grade every public UCP manifest we can find — across Shopify, WooCommerce, BigCommerce, Magento and beyond — and run the cross-platform merchant directory, the UCP Score and live adoption stats. As WebMCP moves from preview to production, we track the commerce layer underneath it as it ships.
WebMCP will give every store a front door for agents. We measure whether the checkout behind it actually works.
Merchant and capability figures are live from the UCP Checker index and update every 24 hours; see the methodology.
Understand the protocol stack: MCP vs UCP vs AP2. Platform-specific setup: Shopify · WooCommerce · BigCommerce. Monthly ecosystem data: State of Agentic Commerce.