Skip to the checkout gate
BUILT FOR THE WEBMCP CHALLENGE

Give your agent the cart,not the card.

Shopfront Copilot registers real tools on the page itself: document.modelContext.registerTool, so an AI agent searches, filters, compares and manages your cart through the exact code path the storefront’s own UI uses. The one thing it can never do is complete your purchase.

LIVE AGENT SESSIONRUNNING
▍
Every call above runs the same code path the storefront's own buttons run.
HOW IT WORKS

One page. One cart. One click that counts.

01

Tools live on the page

Every tool is registered through document.modelContext and calls the same functions the storefront’s own buttons call, no private backend, no parallel path to purchase.

02

You watch it happen

Search, filters, comparisons and cart changes render on the actual storefront in real time, the same shared session state whether your agent acted or you clicked yourself.

03

Only you can buy

checkout opens a confirmation modal and stops there. confirm_purchase is a plain click handler, it was never registered as a tool at all.

WHY THIS IS SAFE BY DESIGN

Your agent hits checkout.
You click it.

AGENT REACHHUMAN-ONLY
search · filter · compare · cartconfirm_purchase

The WebMCP spec’s own authors flagged this exact risk: an ambiguously named tool silently completing a purchase. So checkout never charges anything; it returns confirmation_required and opens a modal only a real click can act on.

No tool’s description promises more than its code delivers. Every mutation is reversible, except the one that isn’t, and that one was never a tool to begin with.

document.modelContext.getTools()
search_productsregistered
add_to_cartregistered
checkoutregistered
confirm_purchaseundefined
Structurally absent, there’s no tool object to construct a call around, adversarial or otherwise.
THE TOOLSET

Twelve rows. One asymmetry.

11 of 12 rows are registered as WebMCP tools an agent can call. confirm_purchase is not, it’s a plain click handler, structurally unreachable from document.modelContext.

ToolWhat it doesMutatesHuman-onlyLogged
search_productsKeyword search--yes
apply_filtersPrice / category / rating filter--yes
compare_productsStructured product comparison--yes
check_return_policyReturn/warranty text--yes
get_cartRead the shared cart--yes
get_product_detailsFull record for one product--yes
ask_humanPause and ask the shopper a question--yes
add_to_cartAdd product + quantity to cartyes-yes
remove_from_cartRemove an item from the cartyes-yes
track_price_dropWatch a product's priceyes-yes
checkoutOpens confirmation, never completes a purchaseyes-yes
confirm_purchaseCompletes the orderyesonly-
SELF-VERIFIABLE

Don’t take our word for it. Take the console’s.

The trust page renders document.modelContext.getTools() live, in your browser, right now, not a screenshot, not a claim from a video. If a browser supports WebMCP tool discovery, what you see is the real, current tool list this storefront registered.

VERIFY THIS YOURSELF: 5 SECONDS
document.modelContext.getTools()
  .then(tools => tools.find(t => t.name === "confirm_purchase"))
  .then(console.log); // undefined
Open DevTools on the trust page, paste that in the console, press enter. You should get undefined.
QUESTIONS

Judges usually ask these first.

Can the agent actually buy something?
No. checkout is the only path toward a purchase reachable from a tool, and it stops at a confirmation modal every time. Completing the order is a plain click handler that was never passed to registerTool.
Is this a real store?
No real payment processing, checkout is simulated. The catalog is a static, seeded set of 18 products. That's deliberate: the submission is about the tool-safety pattern, not building a commerce backend.
Do the agent and the shopper share one session?
Yes. Every tool calls the same cart functions the storefront’s own buttons call, reading and writing the same client-side session store, so an agent’s add_to_cart and a shopper’s own click land in the same cart, visibly, without a reload.
Where does this run?
Chrome with #enable-webmcp-testing, and tested against ChatGPT’s in-app browser. Built with Next.js, TypeScript and Tailwind, deployed on Vercel.

Ready to let your agent shop,
and let yourself decide?