For the past couple of years, building a shopping agent has felt like teaching someone to cook in a kitchen where the stove is behind glass. Your bot could read the menu, compare ingredients, and load up the basket. Then it hit the checkout and had to tap the human on the shoulder. Shopify just took the glass off the stove.
The company has extended WebMCP support to checkout, which means browser-based AI agents can now inspect a checkout, modify order details, and submit the order — as long as the buyer authorizes the purchase. Three new tools carry the weight: get_checkout, update_checkout, and complete_checkout. It’s rolling out to all eligible Shopify merchants, including stores on Shop Pay.
What changed, in plain terms
Shopify already supported WebMCP on storefronts and carts. Your agent could search a retailer’s inventory, look through products, and add items to a cart. That covered the discovery half of the job. The purchase half stayed out of reach, which meant every agent workflow ended the same way — a handoff, a paste, a human finishing the last twenty percent.
The three new tools close that gap in a way that maps cleanly onto how anyone actually builds this:
- get_checkout — read the current state. What’s in the order, what address is attached, which delivery option is selected.
- update_checkout — change things like the customer’s address or delivery option.
- complete_checkout — place the order, after the buyer authorizes it.
Read, write, commit. If you’ve built any kind of stateful agent loop, that shape is familiar. It’s the same pattern you’d design yourself if you were exposing a multi-step form to a model, which is a decent sign the design is sound rather than merely new.
Why the authorization step matters more than the tools
The interesting part of this release isn’t that an agent can complete a purchase. It’s that the buyer authorization sits inside the flow rather than bolted onto the outside of it.
When I’ve prototyped commerce agents before, the scariest failure mode was never a wrong product. It was a confidently wrong total — a shipping upgrade the model picked because it looked like the “best” option, or an address pulled from stale context. An agent that can write to a checkout and then stop, surfacing the result for a human to approve, turns those mistakes into a moment of friction instead of a refund request.
That’s a design lesson worth stealing even if you never touch Shopify. Put the write operations and the commit operation behind separate tools. Make the commit the one that requires a human. Your agent can be as chatty as it wants with update_checkout and still be safe, because nothing becomes real until someone says yes.
The traffic numbers explain the urgency
Shopify’s own framing of agentic commerce is straightforward — AI agents helping shoppers discover, compare, and purchase, all inside a conversation. The demand side is already showing up. In Q1 2026, AI-driven traffic to Shopify stores grew 8 times year over year. Since March 24, 2026, millions of Shopify stores have been discoverable inside ChatGPT, Microsoft Copilot, and other assistants.
Eight times is the kind of multiple that forces a platform’s hand. If that much traffic arrives through an agent and then dead-ends at checkout, the conversion math gets ugly fast. Opening checkout is less a bet on the future than a patch on a leak.
What I’d build first
If you’re experimenting with this, a few things I’d try before anything ambitious:
- A replenishment agent. Known products, known address, known delivery preference. The narrowest possible surface area for the model to get wrong, and the clearest value for a user who buys the same coffee every month.
- A delivery-option optimizer. Read the checkout, compare delivery choices against a deadline the user gave you, update, then hand back for approval. It never picks a product — it only picks a shipping method.
- A state-diff logger. Before anything else, just call
get_checkout, make a single change, and call it again. Log the difference. Understanding exactly what the platform considers mutable is worth more than any clever prompt.
I’d also build your own guardrails rather than trusting the authorization prompt to do all the work. A hard spend ceiling, an allowlist of domains, and a log of every update_checkout call your agent makes. Buyer approval protects against the agent doing the wrong thing once. It doesn’t protect against an agent that does slightly wrong things quietly and often.
Where this leaves the rest of us
The specifics of how the authorization surface behaves across browsers and agent frameworks are things I haven’t tested yet, and I’d be cautious about any tutorial that claims otherwise this early. What’s clear is the shape of the thing: a major commerce platform has decided that the checkout is a legitimate place for an agent to operate, with a human holding the final button.
For those of us building bots, that’s the permission slip we’ve been waiting on. The cart was always the easy part. Now the hard part has an API.
🕒 Published: