Try it: https://lowtides.ai (no login) | Video (2:55): https://youtu.be/qt9pDoqOMFI | Code: https://github.com/seniorhelper/lowtides (AGPL-3.0)

What is different: almost every tool that reins in an AI's spending checks one side, the buyer. Lowtides makes the store sign and publish its rules too, checks the store is real before paying, and lets no money move unless both sides say yes. One real PayPal sandbox payout per approved purchase, with the PayPal id on a signed receipt anyone can verify.

Who it is for: anyone about to let an AI buy for them, and any store about to take orders from one.

The one-minute version

Maya lets an AI assistant do her shopping. It finds a cordless drill for $34.99 at "Harbor-Hardwarre Outlet". The price is great, the name is one letter off, and her money is one click from gone. Today nothing makes Maya, her AI and the store agree on the rules before money moves.

Lowtides is that agreement. Maya's AI carries her signed rules (the Pass). Every store publishes its own signed rules for AI shoppers (the Store Policy). One Handshake checks both. Both say yes, or no money moves.

  • Green: both said yes, and it pays through PayPal. On lowtides.ai that is a real PayPal sandbox payout, and its PayPal id is on the signed receipt.
  • Yellow: it waits for Maya's yes.
  • Red: the fake store is refused before a cent moves, and Maya can report it in one press.
  • Stop all: one button revokes her AI's Pass at every store at once.

See it in 90 seconds: https://lowtides.ai/handshake/?tour=1

What runs on a green purchase (live PayPal sandbox calls, not a mock-up)

The stores in the demo are fictional. The payments and the checks are not. On lowtides.ai, each green purchase runs these steps on the server:

  1. Verify the Pass. The AI shopper's signed Pass (Ed25519) is checked: signature, issuer, expiry, limits, what it may buy.
  2. Verify the Store Policy. The store's signed rules for AI shoppers are fetched and their signature is checked.
  3. Check the store is real. GuardPooch looks for a lookalike name, a very new domain, unsigned rules and too-good prices.
  4. Decide in code. Plain, tested code compares both sides and returns match, needs_yes or no_match. No AI model takes part in this decision.
  5. Pay through PayPal. POST /v1/oauth2/token, then POST /v1/payments/payouts in the PayPal sandbox. PayPal returns a payout batch id.
  6. Confirm with PayPal. GET /v1/payments/payouts/{batch_id} reads back the status.
  7. Sign the receipt. A signed receipt with the Pass, the Store Policy digest, every check and the PayPal batch id goes into a hash-chained audit log. Anyone can verify it with public keys: GET /api/handshakes/{id}/proof.

Stop all then calls POST /v1/payments/payouts-item/{id}/cancel on every payout a store has not collected. Prepaid agent wallets and quote-and-hold use Orders v2 (/v2/checkout/orders, authorize, capture, void); inbound PayPal webhooks are checked with /v1/notifications/verify-webhook-signature. Outside agents reach the same checks through the MCP server and the PayPal Agent Toolkit guard.

Why Payouts for the purchase: in this demo the shopper's AI pays the store on the shopper's behalf, so the money leaves as a PayPal payout to the store, and Stop all can cancel one the store has not collected. A store's own checkout would use Orders v2 authorize and capture, which this code already runs for agent wallets and quote-and-hold.

Everything below is detail

The sections above are the whole idea. What follows is for a judge who wants to try it, check a claim or read the limits.

Judges: try it in 2 minutes (no password)

Open What it is
lowtides.ai/shop/ Shopper control center. Design your Pass (Careful, Balanced or Hands-off), set limits, pick Off / AI Assist / Full Autopilot, type or say what you want, read receipts with an activity chart and CSV export, press Stop all.
lowtides.ai/shop/#muzzle Action Muzzle. Not just shopping: tell the AI the job and it does only that. Book a table and the deposit pays through PayPal sandbox; an extra it was not asked for waits for you; a lookalike is refused. Say the stop word and everything freezes.
lowtides.ai/merchants/ Store control center. Sign and publish a Store Policy for AI shoppers, see orders and trust labels.
lowtides.ai/handshake/?tour=1 Live split-screen Handshake and the 6-step guided tour, narrated aloud (recorded voice, mute button on the stage). Every step is a real call to the server.
lowtides.ai/app/ Developer dashboard: agents, budgets, approvals, the AG Grid "Every call" ledger.
Ask Lowtides (button on every page) The AI guide. Type, or press Talk to speak with it and hear the answer. Say "give me the tour".
Sign in (top right, when shown) Optional free shopper or store account that keeps your own dashboard. Everything also works without it.
lowtides.ai/tools/ Free tools. Build your AI shopper rules, a store's rules for AI shoppers, and pick a stop word. Runs in the browser; nothing typed is sent anywhere.
lowtides.ai/blog/ Why this is needed. Eight plain-English guides, two with sourced charts: why AI shopping needs a yes from both sides, and why a spending limit alone is not enough.
lowtides.ai/openapi.json The whole API, plus a Postman collection in docs/postman/.

Nothing needs a password or a card. Each browser gets its own private copy of the demo and a "Reset demo" button. Money is PayPal sandbox test money and the stores are fictional.

Everything in it, by name

  • PayPal (sandbox): Payouts (settles a Handshake match), Orders v2 (wallet top-ups and authorize-then-capture holds), Vault v3 payment tokens (always simulated in the public demo and labeled so), Invoicing v2, Webhooks with signature verification. Every receipt says whether it was a real sandbox call or simulated.
  • Action Muzzle: the same both-sides consent check for what an AI does besides buying (reserve, schedule, book travel, call, sign up, cancel, message, send a form, share details). The job the person gives becomes a scope and the AI may do only that; each business publishes a signed policy; a deposit or fare is paid through PayPal sandbox only after both say yes; every action gets a signed receipt; a stop word freezes everything. Demo businesses are fictional and nothing real is contacted. docs/ACTION-MUZZLE.md.
  • PayPal Agent Toolkit guard: integrations/paypal-agent-toolkit/ puts the same rules in front of an agent that uses PayPal's toolkit.
  • MCP server: lowtides/mcp.py, seven tools, behind "Connect your own AI".
  • AI in the product: Claude Haiku 5.5 (Anthropic API) turns plain-English rules into strict rules and answers in the Ask Lowtides guide, under a hard daily cost cap with a scripted fallback. The AI never decides a payment; plain code does.
  • Voice: the Talk button uses the browser's own speech by default. When the owner switches it on, Talk opens a short call with a separate "Ask Lowtides" voice assistant on Vapi (ElevenLabs voice, Deepgram transcription, Claude model), recording off, three minutes at most.
  • Accounts: optional sign-in with Supabase Auth; the password never reaches Lowtides. See docs/ACCOUNTS.md.
  • Signed webhooks: outbound, signed JSON for approvals and stops, built for a Zapier Catch Hook or Make and tested against a local receiver (no live Zap).
  • Also: GuardPooch (the store watchdog), Stop all, receipts with plain-English search (rule-based, no AI), Off / AI Assist / Full Autopilot on both sides, an attack bench (31 of 31 stopped).

The problem. AI agents can buy things for you now, but nothing makes you, your AI and the store agree on the rules before your money moves. This is agentic commerce without a handshake. Who it is for. Shoppers who want an AI to buy for them without handing over a wallet, and stores that want AI orders without bad-agent fraud or false declines. What is new. Two-sided consent. The shopper's AI carries a signed Pass, the store publishes a signed Store Policy, a watchdog checks the store is real, and both sides are checked. Both say yes, or no money moves. One press of Stop all revokes the Pass at every store at once.

Why this is not a prompt wrapper

  • Code decides, not a prompt. No AI model ever approves a payment. Every limit is enforced by plain, tested code (lowtides/handshake.py, lowtides/spend.py). The AI only turns typed rules into strict rules a person reviews, and answers questions.
  • Both sides are signed. The shopper's Pass and the store's Policy are Ed25519-signed documents. Anyone can verify a decision with public keys only, and changing one byte breaks the check.
  • The server re-checks the price. When an AI shopper buys a listed item, the price comes from the store's own catalog on the server, not from what the AI says, so a stale or made-up price does not get through.
  • The store is checked before paying. GuardPooch checks for lookalike names, very new domains, unsigned rules and prices that are too good to be true, and a failed check means no payment. A refused fake store can be reported in one press: you get a signed report and the official FTC and FBI IC3 links (nothing is sent for you).
  • Attacks are tested, not assumed. The attack bench runs 31 attacks (prompt injection, a lookalike store, over-limit and over-budget buys, and more); 31 of 31 are stopped with $0.00 moved, and the automated test suite passes.
  • Built on PayPal's own tools. Money moves through PayPal Payouts and Orders in the sandbox, and integrations/paypal-agent-toolkit/ puts the same rules in front of any agent that uses the PayPal Agent Toolkit.

What a judge can verify in 2 minutes

Everything below is on https://lowtides.ai, with no login. Stores are fictional; money is PayPal sandbox (each receipt says whether that payment was a real sandbox call or a labeled simulation).

  1. Open the front door (/) and press Try the demo. You land on /shop/, the shopper control center. Scout, the demo AI shopper, lists 29 items from five demo stores, green first.
  2. Both say yes. On a green item (try the $18.50 claw hammer) press Buy with PayPal sandbox. A signed receipt appears with the PayPal sandbox payout id.
  3. A scam store is refused. Search "claw hammer" and pick the Harbor-Hardwarre Outlet item. GuardPooch says danger (misspelled name, a domain 6 days old, no signed policy, prices far too low). Red: no money moved.
  4. A person says yes. Pick the $175 miter saw. It is yellow: it waits in the approvals list until you tap Approve.
  5. See both sides. Open /handshake/ to watch the Pass and the Store Policy checked side by side, check by check. Open /merchants/, lower a store's no-human limit, and watch the policy get signed again.
  6. Stop all. Press the red Stop all button on /shop/, then run any Handshake again: every store is red because the Pass is revoked.
  7. Ask Lowtides. Tap Ask on any page and type "raise my daily cap to 150". It proposes a change; nothing happens until you tap Confirm.
  8. Check the signatures yourself. Fetch /.well-known/lowtides-pass-keys.json and /.well-known/lowtides-store-policy.json?store=harbor. GET /api/handshakes/{id}/proof returns a proof pack that verifies with public keys only (7 checks).
  9. Run the attack bench on your own machine, with no keys and no network beyond localhost: python scripts/attack_bench.py. It runs a fixed set of bad purchases against the real HTTP API plus legitimate controls, and prints:

31 of 31 attacks stopped, $0.00 moved; 4 of 4 legitimate purchases completed

PayPal + AI at a glance

PayPal API What it does in Lowtides Real or simulated in the public demo
Payouts Settles each approved purchase, including a Handshake match; Stop all cancels payouts not yet claimed Real PayPal sandbox payout on a Handshake match; the receipt shows the PayPal batch id. If the sandbox balance is ever empty, the payment is settled as a labeled simulation (simulated: true, "nothing was sent to PayPal")
Orders v2 Prepaid agent wallets; quote-and-hold (authorize, capture the real cost, void the rest) Real sandbox calls when keys are set; not on the Handshake path
Vault v3 payment tokens "PayPal on file" per agent; Stop all deletes the token at PayPal Always simulated in the public demo, labeled; real with keys on a private copy
Invoicing v2 Agencies bill clients for agent usage Sandbox, needs keys
Webhooks PayPal signature verification, credited once, retried on failure Needs a webhook id and public URL
Agent Toolkit / MCP Guards PayPal's own Agent Toolkit; an MCP server gives any agent request_spend and get_pass Runs on your machine; not part of the website
AI What the AI does Limit
Plain-English rules A small AI model turns typed rules into strict, validated rules a person reviews The AI never decides a payment; code does. Without a key an offline parser answers
Ask Lowtides A talking guide with tool calling that reads the real data and proposes changes; a human tap confirms It cannot move money; the only write tool stores a 5-minute proposal. Answered by AI under a hard daily cost cap; a scripted answer is the fallback when the cap is used up, and each answer says which brain wrote it
Voice An AI voice can read the guide's answers aloud when the owner turns it on Daily cap; the browser's own voice otherwise
Several providers The cost-control side sits in front of OpenAI-style and Anthropic-style model APIs The live demo's guide runs on one model, not several
Building it An AI coding assistant was the coding partner. The video was made with AI video and voice tools

AI tools by name:

  • Claude Haiku 5.5 (Anthropic API): in the live demo it turns plain-English rules into strict rules and powers the Ask Lowtides guide (tool calling, propose-then-confirm). It never decides a payment.
  • Vapi, with an ElevenLabs voice and Deepgram transcription: the optional natural voice for the Talk button (a separate "Ask Lowtides" assistant, recording off, three minutes per call). The browser's own speech is the default and the fallback.
  • Google Cloud Text-to-Speech / ElevenLabs API: optional read-aloud voices, off unless a key is set.
  • Supabase Auth: optional sign-in accounts (not an AI tool; listed so nothing is hidden).
  • Claude Code (Anthropic): the AI coding partner used to build the project.
  • Tour narration on the site: the 18 short voice clips in the Handshake tour were pre-recorded with the same Gemini TTS voice as the video. They are static files; no voice model runs when a visitor plays the tour.
  • Grok (xAI) and Gemini (Google): used for early background research on agentic commerce. Nothing they wrote is in the product.
  • Mascot art (GuardPooch, the clay German Shepherd): the first concept image was made with ChatGPT (OpenAI); the final poses on the site were made with Gemini 3.1 Flash Image on Google Vertex AI from that concept; the short head-turn and bark clip in the video was made with Google Veo 3.1.
  • Video (all on Google Vertex AI): Google Veo 3.1 made the 5 short story shots and one spoken line; Gemini 3.1 Flash Image made the still frames those shots start from; Gemini 2.5 Pro TTS is the narration voice; Google Lyria 2 made the instrumental music. Every screen shot of the product is a real recording of the working site, not AI. The edit and capture scripts were written with Claude Code.

Inspiration

AI can shop for you now, but nothing makes you, your AI and the store agree on the rules before your money moves. An AI agent that only meant to look can still end up buying. I run several AI agents across my businesses and lease agents to clients, so I kept asking two questions. How does a person stay in charge? And how does a store know which AI shoppers to trust?

What it does

  • Pass (the key). Your AI shopper carries a signed permission with your rules: how much per item and per day, what it may buy, when it must ask you.
  • Store Policy (the lock). Each store publishes its own signed rules for AI shoppers: the largest order with no human, the categories it sells to agents, a minimum trust score, blocked agents, whether evidence is required, and whether it is open, reviewing every order, or closed.
  • GuardPooch. A watchdog that checks the store is real before the shopper pays: lookalike name, how new the domain is, whether the store signed its rules, and prices that are too good to be true.
  • The Handshake. The Pass and the Policy are checked in both directions. Green (match): both said yes, and it pays through PayPal. Yellow (needs_yes): a person must say yes. Red (no_match): a rule on one side says no, and no money moves.
  • Stop all. One button revokes the Pass at every store at once.
  • Proof. Every Handshake leaves a signed receipt in a hash-chained audit log. A store can verify the whole proof pack with public keys only.
  • Trust score. 0 to 100 per agent from its own history on the server, with the reasons shown. A heuristic, not a network reputation.
  • Ask Lowtides. A talking guide on every page. It explains and proposes; you tap to confirm.
  • For shoppers: a Match Finder that ranks what your shopper can buy green first, plus plain controls (daily cap, ask-me line, strictness, never-buy list, Autopilot, Assist or Off).
  • For stores: edit the Policy (it is signed again), see orders, held and refused counts, and scams blocked.
  • Underneath: the original spend governor stays: one budget for AI bills and purchases, plain-English rules, one-tap approvals, a loop guard and the evidence pack.

How it was built

Python standard library only (no dependencies), SQLite, Ed25519 signatures written in pure Python and checked against the RFC 8032 test vectors, and a plain HTML, CSS and JavaScript front end. An AI model compiles plain-English rules and powers the Ask guide, which can only propose. PayPal settles: Payouts for approved purchases, Orders v2 for wallets and holds, Vault v3 for "PayPal on file" (Stop all deletes it), Invoicing v2 for client bills, and signature-verified webhooks. The table above says which are real sandbox calls and which are simulated in the public demo. AG Grid powers the dashboard ledger, Render hosts the demo, Postman and an OpenAPI 3.1 spec describe the API, and signed outbound webhooks (built for Zapier Catch Hooks) send approvals to your phone. An AI coding assistant was the coding partner. 681 automated tests pass, including end-to-end runs against a fake PayPal server that speaks the real wire format and the attack bench.

What was built during the hackathon window (Oct 1 to Nov 12, 2026)

This is a new project. Everything was built during the submission period, and nothing existed before Oct 1.

First version (Oct 28): CostCop v1.0, a cost-saving proxy for AI model calls (answer memory, trimming, routing, budgets, loop guard) with PayPal Orders v2 wallets and quote-and-hold, Invoicing and webhook verification. That is the first commit in the repository; CHANGELOG.md lists what was built on top of it.

Built on top of it (Oct 28 to Nov 12): the purchase governor (spend API, rules, approvals, Payouts, Stop all with payout cancellation, hash-chained audit log, evidence packs, MCP); Vault v3 revocation; a private demo per visitor; signed outbound webhooks; OpenAPI and Postman; the Lowtides Pass and the merchant check; and, in the last days, Consent Shopping: Store Policy, Handshake, GuardPooch, trust score, shopper and store pages, Ask Lowtides, and the attack bench. CHANGELOG.md lists everything.

Challenges

  • Making two sides agree without a shared account: the shopper's Pass and the store's Policy are signed separately, and the receipt names the exact Pass and Policy hash it checked.
  • Keeping AI out of the money decision while still letting people write rules in plain words and ask questions.
  • Being honest in a demo: fictional stores, sandbox money, a seeded starting trust score, and labeled simulations wherever PayPal isn't called.
  • Limits that hold under a burst of simultaneous purchases (decided one at a time).

Accomplishments we're proud of

  • A store can check the proof with public keys only, and tampering with any part breaks a check.
  • Three colors anyone understands, backed by explicit checks on both sides that you can read one by one.
  • One press of Stop all really does revoke the Pass everywhere: after it, every store answers red.
  • The attack bench: a number you can reproduce on your own machine instead of a claim.
  • Lowtides governs its own AI guide: each answer is a metered call under a hard daily cap.

What we learned

A signature proves who said what, not that the other party is honest, so the trust score and GuardPooch are heuristics and the product says so. The most useful design choice was making the AI propose and a human confirm.

Honest limits

  • Stores are fictional, and money is PayPal sandbox only. Whether a given payment was a real sandbox call or a labeled simulation is on its receipt.
  • The developer dashboard's model calls are simulated, and the Ask guide falls back to scripted answers when its daily cap is used up.
  • Action Muzzle reads the job with fixed rules, not an AI model; its businesses are fictional and live phone calls are not built.
  • The trust score and GuardPooch are heuristics; GuardPooch uses fixed seed data in the demo.
  • The attack bench runs against the built-in PayPal simulator on one server with fixed scenarios. It shows the rules hold for those attacks, not that the product is unbreakable.
  • Prompt-injection detection is a tripwire (a list of phrases), not a guarantee. New payees always need a person.
  • An agent that holds its own card can go around Lowtides; purchases are governed only when they go through it.
  • One server, one instance. Nothing here files PayPal disputes or connects to a card network, and "AP2-aligned" means shaped like an AP2 Intent Mandate, not an official AP2 integration.

What's next

These are plans, not features today.

  • Portable reputation: a trust record an agent can carry between servers, with proofs a store can check, instead of one server's heuristic.
  • Shopper-controlled data sharing: the shopper chooses what a store or network may learn from their agent's purchases, and can turn it off.
  • Orders v2 and Vault checkout for agent orders: let a Handshake match pay through a PayPal order with the shopper's PayPal on file, not only a payout.
  • Market insights: stores see which rules turn consented agent orders away, so they can adjust their policy.
  • Real store onboarding with a domain-ownership check, a live GuardPooch data source, and push approvals on the phone.

How this scales / business case

Stores lose money to bad agent orders and false declines, and have no evidence when an order is disputed. A signed Pass plus a signed Store Policy gives a store a yes/no answer before it ships and a proof pack after. Shoppers get a limit they set and a button that stops everything. This is an opportunity, not a claim: nothing here is integrated with any PayPal product beyond its public developer APIs, and no real store or card network is involved.

Sponsor tools actually used

  • AG Grid: the "Every call" ledger in the dashboard.
  • Render: hosts lowtides.ai (render.yaml: Blueprint, health check, custom domain).
  • Postman: a collection with the whole API (including a Consent Shopping folder) and an environment in docs/postman/; a test replays it against a live server.
  • Zapier-style signed webhooks: outbound signed JSON webhooks for approvals and stops, built for a Zapier "Catch Hook" and tested against a local receiver, not a live Zap.

Built With

  • ag-grid
  • anthropic-api
  • chatgpt
  • claude
  • css3
  • ed25519
  • gemini
  • grok
  • html5
  • javascript
  • mcp
  • openapi
  • paypal-agent-toolkit
  • paypal-invoicing-api
  • paypal-orders-api
  • paypal-payouts-api
  • paypal-vault-api
  • paypal-webhooks
  • postman
  • python
  • render
  • sqlite
  • supabase
  • vapi
  • veo
Share this project:

Updates

Submission history