Robodepo: Checkout for Shopping Agents

A WebMCP shopping mall for agents, with one-click checkout that actually works.

Comment

Inspiration

Agents can't reliably complete checkout. They search fine, compare fine, even fill in a cart, but the step that actually spends money is where almost every agent attempt on the open web falls over. We set out to fix that one failure: a real store and a real purchase path first, because checkout is where agents fail, not discovery. Only then did we look for a tool surface an agent could use with nothing installed, an MCP-like layer that just lives on the page. That's when we found WebMCP.

What it does

Robodepo is being built as the world's largest shopping mall for agents: the best product information and a completed order, across millions of stores. An agent gets:

  • Better information to find the right product, not just a matching title: get_product already returns a cited evidence pack for this product; every product is the roadmap.
  • A short, checkout-ready shortlist instead of trawling thousands of irrelevant pages (search_by_activity on the roadmap).
  • A reliable checkout: one call runs the whole pre-purchase path (create_checkout).
  • A simple, Touch ID style confirmation before anything is spent: a presence check, not a payment authorisation (WebAuthn).

Responses that tell the agent what to do next. Every response carries a state to branch on, a message naming the field and fix, and next actions with the retry prefilled: an error is never a dead end. A real example, trimmed, from create_checkout given a wrong postcode:

{
  "status": "incomplete",
  "messages": [
    {
      "code": "address_not_accepted",
      "path": "$.shipping_address",
      "content": "Use the accepted sandbox address, then call create_checkout again."
    }
  ],
  "next_actions": [
    { "tool": "create_checkout", "why": "Retry with the accepted address." }
  ]
}

How this is different from what exists. Merchant tooling (Shopify, Google's UCP, Microsoft Copilot Checkout) asks every store to integrate first. Amazon's Buy for Me, Rye and Zinc automate one store's own checkout on the shopper's behalf. Robodepo aggregates instead: a store never integrates or joins anything. Robodepo lists it, discloses it as the source, and buys under the store's published rules on the human's behalf, so the same tools work across every store listed.

  • The shop does nothing.
  • The agent gets information it cannot get elsewhere: source and price side by side, evidence and a shortlist on the roadmap.
  • The human keeps the irreversible step by construction, not policy.
  • Completion is measured, not claimed: a sealed rig checks real agent runs.

The nearest things are protocols that ask every shop to integrate, or agents that scrape.

How we built it

Before the challenge: the store, its purchase API and confirmation page. Built for the challenge: everything at /agent, the 12-tool WebMCP catalogue, the one-call checkout, an in-page approval panel that turns into an order card in place (a separate approval page stays as fallback), the feedback endpoint, the tests, and the public repo.

Full write-up: https://robodepo.shop/agent/story.md

Each tool (8 working, 4 marked plainly as preview) carries a short description sized to Chrome's WebMCP guidance; the full guide lives at /agent/tools.json, callable on demand with get_tool_guide. We use both halves of the API: the scripted registerTool for the catalogue, and the declarative form attributes (toolname, tooldescription, toolparamdescription), which Chrome documents as an origin trial, on the feedback form.

The store is a tracer, instrumented so real agents run through it under sealed conditions. Premium levels are committed cryptographically before any run starts, every purchase record gets an independent LLM audit, the protocol is versioned, and a price-integrity check voids any run where prices differ. The rig has been through ten adversarial review passes. The boundary that matters for trust is not where an agent chooses to stop. It is proving, mechanically, that it cannot cross it, rather than asking nicely.

The rig runs real agents, ChatGPT, Codex, Claude and Claude Code, through the purchase path run after run. It taught us agents fail when a step is unexplained, so responses name the field, the fix and the next tool, and nine steps became one call. It found a checkout defect no local test could see. Next, it opens as a Test Track for agent developers.

The demo runs natively in ChatGPT's in-app browser: open robodepo.shop/agent and ask for a product. Code: https://github.com/Web3Zero/robodepo-webmcp

Challenges we ran into

The hardest part has been the testing rig and evaluation work behind the store: running real agents through the purchase path again and again, catching failures, fixing the store, re-running. That loop builds the moat: "it works for agents" becomes a checked result.

Writing tool descriptions an agent could act on without guessing was its own problem: short enough for a browser to show, full depth a call away. Getting create_checkout right took real care: several steps behind the scenes while looking like one clean call, refusing cleanly the moment an address or quantity doesn't match.

Accomplishments that we're proud of

A person can hand an agent a plain-English request and watch it search, price and prepare a real sandbox order, with a Touch ID style tap the only irreversible step. No tool can press it: the run cookie, a single-use security code, a single-use order key and a same-origin submission all protect it. The four preview tools say plainly what's coming instead of quietly claiming it's already there.

What we learned

Depth and brevity aren't opposites when split properly: a short description in the list, the full guide one call away. The boundary that matters for trust is not where an agent chooses to stop; it is proving, mechanically, that it cannot cross it, rather than asking nicely.

What's next for Robodepo

Robodepo's roadmap groups around what helps an agent buy well, every item already in the catalogue:

  • Search by need: a shortlist for the request instead of thousands of irrelevant pages (search_by_activity).
  • The best source of product truth: specs, care, review themes and permitted YouTube transcript evidence, cited, live today for this product through get_product's include_evidence option; every product is the roadmap.
  • Side by side comparison across products (compare_products).
  • One tool to transact across many merchants (get_shipping_options).
  • Continued assistance: replenishment reminders and price alerts (subscribe_replenishment_alerts).
  • A Test Track: the same harness, open for developers to prove their agents against a real checkout before going live.

Built With

Share this project:

Updates

Submission history