If you run a store, the agentic-commerce wave probably arrived in your inbox this spring as a Shopify changelog, not a strategy memo. Shopify's Spring '26 release shipped Agentic Storefronts and, with Google, the Universal Commerce Protocol (UCP) — an open standard (backed by Amazon, Meta, Microsoft, Salesforce, Stripe, Etsy, Target, Wayfair) that lets an AI agent discover products, build a cart, and complete checkout on a shopper's behalf. If you're on Hydrogen, every storefront now exposes an MCP endpoint at /api/mcp with proxyStandardRoutes on by default. The old Storefront Catalog MCP folded into UCP, with the legacy endpoints maintained only through June 15.

That's a genuinely big deal, and if you sell on Shopify you should make sure your catalog is flowing through it. But it's worth being precise about what UCP actually makes agent-operable, because the headline ("your store is now an AI agent endpoint") quietly oversells it.

What UCP covers — and where it stops

UCP standardizes commerce primitives: search the catalog, build a cart, create a checkout, hand off the buyer, track the order, settle payment (via AP2). Those are the operations every store shares, so it makes sense to standardize them once and let every agent speak them.

The flip side of "standardized" is "only the standardized parts." UCP makes the commodity surface of your store agent-operable — the parts that look the same on every Shopify store. It does not cover the parts that make your storefront yours:

• a bundle builder or product configurator ("build your own 6-pack", "spec this bike")
• a gift-finder or fit quiz that narrows the catalog by answering questions
• "book a fitting / a consultation / a demo" scheduling
• subscription management, reorder, or a B2B quote / net-terms request
• store locator, warranty registration, returns initiation, loyalty redemption
• account self-service that isn't a checkout

None of those are "search the catalog and check out." They're bespoke interactive flows you built on top of (or beside) the catalog — and they're frequently the reason a customer chose you over a generic listing. An agent driving your store through UCP can buy a SKU it already knows it wants. It cannot reliably run the quiz that helps it figure out which SKU, or start the warranty claim, or request the B2B quote — because UCP doesn't describe those, and nothing else tells the agent they exist.

And that's the Shopify-on-Hydrogen case, where you inherit /api/mcp for free. Two large groups don't:

1. Custom / non-Hydrogen headless storefronts. "Truly headless on your own front end" means you don't get the standard routes for free — you're rebuilding the agent surface yourself.
2. Everyone not on Shopify. Most of the web sells, books, or onboards without Shopify's data graph underneath it at all.

For all three — the custom flows on a Shopify store, headless front ends, and non-Shopify sites — the question isn't "is my catalog in UCP." It's "can an agent operate the interactive parts of my site the same way a person can?"

That's the WebMCP-shaped gap

WebMCP (the navigator.modelContext API, in a Chrome 149 origin trial as of June 2026) is the complement, not the competitor, to UCP. Where UCP standardizes commerce operations across stores, WebMCP lets a single site declare its own tools — whatever they are — so an agent in the browser can call them directly instead of guessing at your DOM.

The mental model that's held up for me:

UCP is the shared commerce rails. WebMCP is the tool surface for everything your storefront does that isn't a generic commerce primitive.

They compose cleanly. The agent uses UCP to buy the thing; it uses your WebMCP tools to do the bespoke work that decides what to buy and what happens around the purchase. A configurator becomes a configure_bundle tool. The fit quiz becomes recommend_size. The B2B flow becomes request_quote. Each is a thin, typed front door to a function your UI already calls:

if ("modelContext" in navigator) {
  navigator.modelContext.registerTool({
    name: "recommend_size",
    description: "Recommend a size from height, weight, and fit preference",
    inputSchema: {
      type: "object",
      properties: {
        heightCm: { type: "number" },
        weightKg: { type: "number" },
        fit: { type: "string", enum: ["slim", "regular", "relaxed"] },
      },
      required: ["heightCm", "weightKg"],
    },
    async execute(args) {
      const size = await sizeEngine(args); // the same fn your quiz UI calls
      return { content: [{ type: "text", text: `Recommended size: ${size}` }] };
    },
  });
}

Two things make this cheap and safe, and they're the same two that make UCP adoption sane:

• Feature-detected. The whole surface sits behind if ("modelContext" in navigator). In every browser without the API — which today is nearly all of them — it's a no-op. Nothing breaks.
• Reuse, don't rebuild. A WebMCP tool should call the exact function your existing UI calls (sizeEngine, productSearch, startReturn). If you're writing new business logic for the agent, you've taken on the expensive version that drifts out of sync. Don't.

The honest caveat (same as for UCP)

As of June 2026, no mainstream agent calls navigator.modelContext on your page yet — not ChatGPT Agent, not Claude, not Gemini. (UCP is further along on the commerce side, because the agent and the protocol are being built by the same companies, but the general browser tool-call path isn't wired up in shipping agents either.) So this isn't "do it today or lose sales tomorrow." It's: the agentic-commerce buildout is clearly happening top-down from the platforms, the cost of exposing your custom flows as feature-detected tools is an afternoon, and the payoff lands exactly when you can't predict the date.

The one thing I'd add: instrument it. Log every tool invocation — which tool, sanitized args, success, latency — from day one. Whether an agent arrives via UCP checkout or a direct WebMCP call, you want to find out from a dashboard, not from a billing anomaly six months later. "Are agents operating my store yet, and which flows do they use?" is the only question that turns this from a guess into a managed bet.

Bottom line

If you sell on Shopify, get your catalog into UCP — that's the commerce rails, and they're real now. But don't mistake "my catalog is agent-buyable" for "my store is agent-operable." The flows that differentiate your storefront — the configurators, quizzes, bookings, B2B, post-purchase — live outside UCP's standardized primitives, and on custom/non-Shopify sites so does everything else. That's the WebMCP-shaped half of the problem. Expose those flows as typed tools, reuse your own handlers so they can't drift, and meter them so you see the first agent that walks in.

Disclosure: I work on Latch, an open-source (MIT) one-line script that does the WebMCP half of the above — it exposes your site's existing search, cart, forms, and custom flows as feature-detected navigator.modelContext tools (valid schemas, reusing your own handlers), and the optional hosted tier is the meter: it shows which agents call your tools and what they do. If you just want the standard, the WebMCP guide is vendor-neutral and the code is on GitHub. It complements UCP rather than replacing it — happy to compare notes in the comments, especially with anyone running a headless or non-Shopify storefront.