Shopify announced AI-powered purchasing in ChatGPT this morning. Six hours later, a WooCommerce store completed a fully autonomous AI purchase — identity linked, wallet debited, order in processing — using an open protocol anyone can implement.
No partnership deal. No platform exclusivity. Just a spec, a plugin, and a real order.
What happened this morning
At 09:37 AM today, an AI agent (Claude Sonnet 4.5) completed an autonomous purchase on houseofparfum.nl, a 40,000 SKU WooCommerce perfume store.
Here's the full session replay:
UCPPlaygroundhouseofparfum.nl via Claude Sonnet 4.5 - UCPPlayground
Checkout Reached in 43.6s. Watch the full agent session replay.
ucpplayground.com
What the agent did, without any human intervention:
- Searched for a perfume under €30
- Created a checkout session
- Selected the Terrawallet wallet payment instrument (surfaced from the linked identity)
- Selected flat-rate shipping
- Called
complete_checkoutwith an idempotency key - The wallet was debited €22.93
- WooCommerce order #82244 was created with status
processing
8 turns. 79,152 tokens. Schema Quality: A (99).
The difference from Shopify
Shopify's ChatGPT integration is impressive. But it's a bilateral deal between two platforms. Shopify stores work in ChatGPT. That's it.
What happened today uses the Universal Commerce Protocol (UCP) — an open specification that any store, any agent, and any platform can implement independently.
The same flow that worked in UCPPlayground today will work in any UCP-compliant agent host. Claude, GPT, Gemini, Grok — any model. Any platform that implements the MCP transport binding can discover houseofparfum.nl's capabilities, link buyer identity, and complete a purchase.
No bilateral agreement required. No platform partnership. Just a spec.
What makes this technically interesting
Identity linking — the agent authenticated via OAuth 2.0 Authorization Code + PKCE against the store's own OAuth server (RFC 8414, RFC 7591). The bearer token resolved to WooCommerce customer ID 1. Name, email, phone, billing address, shipping address — all pre-populated from the WC account. The agent never asked for any of it.
Autonomous payment — Terrawallet store credit was surfaced as a payment instrument because the linked identity had a wallet balance. The agent selected it, called complete_checkout, and the wallet was debited server-side. No browser redirect. No payment form. No human in the loop.
UCP protocol compliance — every response carried ucp.capabilities in the correct keyed-object format. The MCP transport binding used bare tool names (complete_checkout, not ucp_complete_checkout). The idempotency store prevented duplicate orders on retry. Schema Quality A (99) from UCPChecker.
The stack
- Plugin: UCPReady (FREE WooCommerce plugin by Zologic)
- Protocol: Universal Commerce Protocol 2026-01-23
- Transport: MCP (Model Context Protocol) JSON-RPC 2.0
- Test platform: UCPPlayground by Ben Fisher / UCPChecker
- Store: houseofparfum.nl (live production, 40k+ SKUs, Redis)
UCPReady was validated by Ben Fisher (UCPChecker) as "the most spec-complete non-Shopify UCP implementation tested." It also exposed 4 bugs in the UCPPlayground embedded checkout during interop testing — all fixed the same day.
What this means for WooCommerce merchants
If you run a WooCommerce store today, you are one plugin install away from being discoverable and purchasable by any AI agent that implements UCP.
Not "AI-assisted checkout." Not "AI product recommendations." Fully autonomous purchase — the agent finds the product, builds the session, collects buyer details from linked identity, selects payment, and completes the order. You get a WooCommerce order in processing status, attributed to the linked customer account, with full order history.
The same infrastructure that powers Shopify's ChatGPT integration — agentic discovery, session management, identity linking, autonomous payment — is now available to every WooCommerce store via an open protocol.
What's next
Ben Fisher is adding multi-item cart flow to UCPPlayground today. The cart capability (dev.ucp.shopping.cart) is already declared in houseofparfum.nl's /.well-known/ucp manifest and the tools are live. Once the Playground wires up the cart flow, agents will be able to browse, build multi-item carts, compare products, and convert to checkout — the full pre-purchase exploration flow.
The UCP Technical Committee nomination window closes April 3. If you're building on UCP or have a perspective on how the protocol should evolve, now is the time to get involved: https://github.com/Universal-Commerce-Protocol/ucp
Try it
-
Live store endpoint:
https://houseofparfum.nl/.well-known/ucp - UCPPlayground: ucpplayground.com — connect houseofparfum.nl and run your own session
- UCPReady: https://zologic.nl/product/ucpready-ai-agent-commerce-for-woocommerce/
- UCP Spec: ucp.dev/latest/specification
UCPReady is built by Zologic. The autonomous purchase milestone was achieved in collaboration with Ben Fisher (UCPRails/UCPPlayground/UCPChecker) who has been validating UCP implementations across the ecosystem.
Top comments (5)
This was a wild day to ship. For context, I'm the Benji Fisher mentioned in the post — I built UCP Playground and UCP Checker, and worked with Almin on the interop testing that led to this session.
The thing that stood out to me wasn't just that it worked, but how it broke before it worked. We hit real protocol-level bugs — OAuth token storage mismatches, wallet instrument format validation, model serialisation issues — and every one of them showed up in the session replay data. That's what UCP Playground was built for: making the failure modes visible so they can be fixed.
The Shopify/ChatGPT news the same morning was genuinely good timing. It validated the category. But the difference is that this ran on an open spec, on a live production store, with a real wallet debit — and any agent host can do the same thing tomorrow without a partnership deal.
Next up is multi-item cart flow. The tools are already live on houseofparfum.nl, just needs the orchestration wired up. We also published the full writeup with the embedded session replay here: ucpchecker.com/blog/first-autonomo...
Strong development. Autonomous purchasing is moving from concept to real-world execution.
Completely agree — this is the missing layer.
What we demonstrated here is that once the agent knows what to buy, the transaction can be executed end-to-end without friction. But in practice, most of the complexity sits upstream in how intent is translated into a concrete product selection.
Keyword search breaks down quickly in agent-driven flows because the input is not a query, it’s a constraint space (preferences, context, exclusions). That requires a different interface than traditional catalog search — something closer to structured or semantic retrieval.
What’s interesting is that these layers are decoupled.
UCP standardizes the execution layer (discovery → session → checkout → payment), but it doesn’t prescribe how discovery is solved. That means semantic search, embeddings, or even external recommendation systems can plug in upstream — as long as they resolve to a product that can be passed into the protocol.
So the stack becomes:
intent resolution → product selection → UCP execution
We focused on proving the execution layer works in production. The next phase is making the discovery layer agent-native.
Fascinating milestone. The autonomous purchase flow solves the "complete the transaction" layer — but there's an earlier problem: finding the right product in the first place. A 40k SKU store with keyword search still returns zero results for "something woody but not too heavy for a first date." Semantic search at the discovery layer + UCP at the checkout layer = the full agentic commerce stack.
Those failure modes were the most valuable part of yesterday. Shipping a happy path is easy — building a protocol that holds under OAuth mismatches and serialization edge cases in production is where the real work happens.
The fact that we could identify, fix, and re-verify issues across two independent stacks in a single afternoon is exactly why open protocols win — the feedback loop compounds.
Ready for the multi-item cart flow. That’s where this moves from a single transaction to a full agentic shopping experience.