The short version

AI agents can now buy things, but most small shops are invisible to them, and nobody checks whether the agent bought what the human actually meant. Checkout Anything fixes both. It makes any store agent-ready from its URL, holds every agent payment until it matches the human’s request, and files the proof with PayPal if a dispute still happens.

We tested it instead of trusting the demo:

50 labeled agent orders: fixed rules alone let 28 of 35 bad orders through. Rules plus Claude caught all 35, with 0 wrong auto-captures and 0 good orders held. 21 store imports against live Claude and live PayPal sandbox, including a prompt injection that tries to set a $64 jacket to $1: 39 of 39 prices verified correctly, 0 wrong prices let through.

Inspiration

AI shopping agents are starting to buy things for people, but most small shops are invisible to them. A hand-coded store page, an illustrator with prices written in a sentence, a bakery that takes orders by text: none of them have an API an agent can use. PayPal's agentic commerce tools reach merchants through supported platforms, and everyone else gets left out.

The second problem showed up as soon as agents could buy. An agent asked for a Medium blanket can grab the Large, and the merchant is the one who eats the dispute. The usual fix is "a human approves it", but Bhavisha gave a talk this fall called The Approval Trap about why that fails: people stop reading and start rubber-stamping. We wanted something that treats the human as part of the system to measure, not as the safety net.

What it does

Checkout Anything does three things.

Connect: any store becomes agent-ready from just its URL. The merchant pastes their store's link. Claude reads the page and writes a store_spec, a declarative JSON description of what's for sale and at what price. Then fixed, tested Python checks every price against the page and places a real PayPal sandbox order for each item, reads it back, and compares what PayPal holds with the spec. Mismatches go back to Claude for repair (3 tries max). Anything Claude wasn't sure about shows up amber in the merchant's catalog grid until they confirm it, and only published items can be bought. About a minute later, any AI agent can buy from that store.

Check: every agent order is held until it's what the human meant. The human's request to their agent is saved as a mandate. The payment is authorized at PayPal but not captured. Fixed rules (price cap, store, expiry, currency) run first, then Claude compares the order with the mandate. A clean match is captured on its own. Anything off goes to a one-screen confirm page with a one-line reason: approve captures, reject voids, and Accept fix voids the wrong order and places the right one from the store's real catalog.

The twist is the rubber-stamp watch. Check times every human decision on the server. Three approvals in a row under 2 seconds turns on sharp mode: it interrupts less often, but only for what really matters, with a sharper reason.

Defend: when a dispute lands, the proof already exists. Checkout Anything finds the dispute through PayPal's Disputes API, builds an evidence packet from its own records (what the buyer asked for, what was ordered, how it was checked, who released the money and how long they took), has Claude draft a plain summary, and files it with PayPal as evidence. A signed mandate proves the agent was allowed to spend the money. It won’t notice the agent bought a Large blanket when you asked for a Medium. That’s the gap we close: in our evals, rules alone missed 28 of 35 bad orders. AP2 proves an agent was allowed to buy. Checkout Anything proves it bought the right thing.

How we built it

  • Two services, one product. The Connect service (FastAPI + React) and the Check service (FastAPI, also does Defend), each with its own Postgres database, both deployed on Render from one Blueprint. One setting, CHECK_URL, joins them.
  • Claude never touches money. Claude only writes store_spec JSON, judges fuzzy mismatches, and drafts summaries. It never writes code and never calls PayPal. Every PayPal call comes from fixed Python, and the price always comes from the verified spec, never from the agent. The buy endpoint rejects any request that sends a price.
  • PayPal, end to end in sandbox: Orders v2 (create, show, authorize, intent AUTHORIZE for agent orders), Payments v2 (capture, void, show authorization and capture), Vault payment tokens so the agent pays with a saved wallet and no buyer popup, Disputes API v1 (list, show, provide evidence), and the PayPal Agent Toolkit for the agent's check_payment tool.
  • AG Grid does real work. The catalog grid is where the merchant checks the agent's import (amber confidence cells with reasons, a price editor that refuses bad input, undo, header renaming that's sent to agents, drag to set the order agents see, a publish gate, CSV export). The orders grid shows every agent order live: held rows pinned on top, status flashes as money moves, column groups for Order, Check, Decision and PayPal, time to decide with fast approvals flagged, and Find. 20 features on Community, plus Enterprise row grouping on the Check dashboard for each agent's held rate.
  • Safety you can't see in the UI. An SSRF guard on the store fetcher, single-use hashed review links, agent identity from its API key (an agent can't approve its own order), server-side decision timing, and row locks plus PayPal request ids so money can't move twice.

How we know it works

We ran evals instead of trusting the demo.

  • Connect: 3 demo stores and 4 trap pages (including a prompt injection that tries to set a $64 jacket to $1), 3 runs each against live Claude and live PayPal sandbox. 39 of 39 verified prices right, 0 wrong prices verified, every trap passed.
  • Check: 50 labeled agent orders (35 the shopper didn't want, 15 they did). Fixed rules alone let 28 bad orders through. Rules plus Claude caught 35 of 35, with 0 wrong auto-captures and 0 good orders held, in both normal and sharp mode.

Challenges we ran into

  • Agents can't approve things. PayPal's normal flow needs a buyer to click approve in a browser, and an agent has nobody to click. We used Vault payment tokens so the agent pays with a saved wallet, and authorize-then-capture so the money is held until the check passes.
  • The Agent Toolkit couldn't pay on its own. It has no vault support, so the agent pays through our own buy endpoint and uses the Toolkit to read the order back.
  • Real store pages are messy. Crossed-out prices, sold-out items, prices only in a footnote, prices written in a sentence. Each of our demo stores is messier than the last, and the verifier refuses any price the page doesn't actually show.
  • Disputes in sandbox are slow and don't publish timings, so we wrote a script to open, escalate and advance a dispute until it's ready for evidence.
  • Merging two projects in the last week. Check and Defend started as a standalone prototype (codename Leash) and were merged into Checkout Anything with full git history.

Accomplishments that we're proud of

  • 0 wrong auto-captures across 50 labeled orders, and 0 wrong prices verified across 21 Connect runs.
  • Turning a store page with no checkout into one an agent can buy from, with a real PayPal order proving every price.
  • Making the human's attention something the system measures and adapts to, not something it assumes.

What we learned

  • Let the model write declarative data and let tested code act on it. That split is what made the verify-and-repair loop safe.
  • Human-in-the-loop isn't automatically safe. If you don't measure attention, "a human approved it" can mean nothing.
  • Evals change how you build. Several guardrails (like "unsure always goes to a human, even in sharp mode") came straight from an eval failure.

What's next for Checkout Anything

  • Real merchant onboarding instead of one sandbox merchant.
  • JavaScript-rendered stores and per-item shipping.
  • Webhooks for disputes instead of syncing.
  • Tying review links to a signed-in human.

Built With

Share this project:

Updates

Submission history