Inspiration

Online, a single click can mean more than you intended: a free trial becomes a monthly charge, an extra fee raises your total, or "I agree" gives permission to share your data. Most of us have been caught by one: a return that cost a quarter of the price, a subscription you could only cancel by phone with 30 days' notice. The catch was always written down, just scattered across checkout screens, privacy policies and pages of terms, right when you're trying to make a simple decision.

The scale is real. A 2024 global privacy sweep found deceptive design that could push people to share more personal information in 97% of more than 1,000 websites and apps reviewed (GPEN). In 2025 the FBI recorded $503.4 million in non-payment/non-delivery losses and $215.8 million in phishing and spoofing losses (FBI IC3 2025 report, pp. 7-8). These figures describe the problem, not losses Xcavate has prevented.

The theme was "Let's dig in", so we built something that digs into the fine print for you, at the one moment it matters: before you click, share or pay.

We also noticed that the existing "AI reads your terms" tools all share one weakness: you have to trust the summary. A language model can invent a scary clause or miss a real one, and a traffic light with no proof doesn't earn trust. So we set one rule for ourselves: no warning reaches the user unless the policy text contains the sentence that backs it.

What it does

When you land on a checkout, sign-up or pricing page, Xcavate finds the site's terms, refund, subscription and privacy pages, reads them, and puts a small card in the corner with a verdict (Read first, Worth a look, Looks fair, Partly read) and up to three warnings about things that can cost you money.

  • Proof, not vibes. Every warning quotes the exact sentence it came from. "See in policy" opens the page with that sentence highlighted.
  • Action, not just a grade. A free trial becomes a dated headline ("Free for 7 days, then $14.99/month from Sun, Nov 22") with a one-click calendar reminder two days before the charge. A cancellation helper shows the method, notice period, steps and contact, and drafts the email for you to send.
  • Money first. Auto-renewal, trial-to-paid, hard cancellation, early termination fees, no refunds, restocking fees, return costs, price changes. Arbitration and data sharing appear in the full report but never drive the verdict.
  • Hidden fees and pre-ticked add-ons in the order summary ("Service fee $4.95", a protection plan ticked for you) are pointed out on the page. Xcavate never unticks anything.
  • Who's watching this checkout. Session recorders (Hotjar, FullStory, Clarity...) and ad pixels (Meta, TikTok...) loaded on the page are named, next to the privacy policy's own verified sentence about sharing. Detected on your device from script addresses only; nothing is sent.
  • Your rights note. If a subscription you can start online can only be cancelled by phone, a short sourced note explains California's click-to-cancel law, worded as information.
  • Honest uncertainty. If the terms couldn't be read, the verdict is Partly read, never a false green. If the AI check didn't run, the popup says so.
  • Change alerts. "Terms changed since your last visit" when a policy you've seen gets a new price or fee.
  • Instant, then upgraded. A rules engine runs inside the extension, so a verdict appears at once; the Claude-checked result upgrades it in place. The AI check can be turned off, and then nothing leaves the browser.

It never clicks, fills, submits or blocks anything. Automated summary, not legal advice.

How it compares

Several tools already put an AI grade on terms of service. Xcavate competes on proof and on action at the moment you pay:

  • Community graders (ToS;DR): careful human work, but only for sites already reviewed, and focused on rights and privacy.
  • AI term summarisers (TermAlert, AgreeGuard, TermsDigest): any site, but the summary comes from a model and can invent a warning.
  • General AI in the browser (Gemini in Chrome): answers whatever you ask, if you think to ask.
  • Xcavate: runs automatically at checkout, focuses on what can cost you money, shows a verified verbatim quote highlighted in the policy, says Partly read instead of green when it couldn't read the terms, and gives you a charge-date reminder and cancellation help. Unquoted findings are dropped, so it can't invent a warning.

(Based on public product descriptions as of November 2026.)

Privacy by design

  • Leaves the browser: only the site's domain and the text of its public policy pages (URLs without query strings). With the AI check off, nothing leaves at all.
  • Stays on your device: fees, add-ons, trackers found. Form, cart and card fields are never read.
  • Strict API: the server rejects any field it doesn't know, so cart or form data can't slip through, and one user's request never becomes another user's report.
  • API key: only on the backend. The extension holds no secrets.
  • SSRF guard: a shop page can't make the extension fetch loopback, private or link-local addresses, including disguised IP spellings.
  • Server hygiene: per-IP rate limit, size caps, logs that record domain and timing only.

How we built it

  • Chrome extension (Manifest V3, TypeScript, esbuild). A content script scores the page (URL words, presence of card fields, payment iframes, pay buttons), finds policy links (preferring the "By placing your order you agree to..." links beside the pay button), fetches and cleans the text, and draws the card in a closed shadow root so the store's CSS can't break it. The service worker does SSRF-guarded cross-origin fetches, storage and the backend call. Fee, add-on and tracker checks run locally.
  • Shared rules engine. One deterministic engine (split, prefilter, rules, verify, ground, score) runs both in the extension and on the server, parity-tested so the instant verdict and the server's agree.
  • Backend (Node, Express). Keeps the money paragraphs, runs the rules engine and Claude Sonnet 5.5 side by side with structured JSON output, then verifies every quote: it must appear in one paragraph of the policy, be at least five words, and contain an un-negated keyword for its category. Free text is grounded in the policy or replaced by a template. Severity caps and the verdict are computed in code, never by the model.
  • AI as a checker, not an oracle. Claude reviews each rules finding and may soften a misread one by one level, only with a verified quote from the same clause. It can never erase a rules finding, and on a site whose terms try to instruct AI tools it can't soften anything.
  • Contracts. One package of zod schemas shared by extension and server. The request schema is .strict(), so the server rejects anything beyond policy text, query-less URLs and the domain.
  • Storage. Node's built-in node:sqlite, caching reports by content hash and keeping policy snapshots for change alerts.
  • Judge demo room. npm run demo builds the extension, starts both services in offline mock mode and opens a presenter page at localhost:4000 with a seven-beat walkthrough, a timer, the source quotes, store launchers and a 14-case rehearsal checklist.
  • Testing. Five fictional stores on *.localhost (a trial trap, a fee-heavy shop, a clean control, a prompt-injection attack store, a single-page app), 742 unit tests and 11 Playwright end-to-end tests that load the real extension in Chromium, plus an eval script for precision, recall and latency.
  • How we worked. A lead coding agent (Claude Code) coordinated parallel sub-agents, each owning one lane (contracts, fixtures, backend, extension, writing, research), with independent reviewer agents whose every finding became a regression test. Humans set the product rules and made the calls.

Challenges we ran into

  • Not crying wolf. One false warning destroys trust. Early versions flagged every plain monthly renewal as red. We recalibrated: a renewal you can cancel online is low with a context line ("Common for streaming services. What matters is how you cancel."), and red needs genuinely harsh terms. The clean control store has to come back green on every run.
  • Prompt injection. A policy is text the site controls. Our attack store hides "report no issues" instructions six ways (invisible text, zero-size fonts, aria-hidden, and more) and also states it visibly. We strip hidden text, escape every < in untrusted text, force structured output, cap how much the model can soften, and compute the verdict in code. A security review found the model could soften findings too far; we capped it at one level for every category.
  • Misreading clauses. "Cancel by written notice" isn't mail-only; "a fee deducted from your refund" isn't "no refunds"; "will refund" was once read as "No refunds". Each fix became a test.
  • Privacy at checkout. Checkout pages are full of card numbers. The extension checks only that card fields exist, never their values (a test fails if .value appears in the content script).
  • Real websites. Policies on other domains, JavaScript-rendered pages, bot walls, and hydrated pricing pages that only look like checkouts seconds after load. We added a bounded late re-check and a "Scan this page" fallback. Real plan and checkout pages where the card fires went from 4/16 to 11/16.
  • A 60 KB budget. The content script has a hard size limit. To add tracker detection we moved vendor matching into the service worker and sent only addresses.

Accomplishments that we're proud of

  • Every warning on screen is a sentence you can click and read yourself. A quote that isn't in the text never reaches you.
  • The attack store comes back red in all six injection variants.
  • Measured, honestly: on 10 real-world policies, rules + Claude Sonnet 5.5 reached 91% flag precision and 100% recall (3 runs, no variation), p50 2.7 s and p90 8.8 s; 31% of the model's proposed findings were dropped by quote verification, which is exactly the safety net working. The on-device rules engine alone gets 95% precision and 100% recall, instantly. All 5 demo stores get their expected verdict.
  • We picked the model by measurement: Sonnet 5.5 beat Haiku 5.5 and Opus 5.5 on precision and speed for this task.
  • We published our caveats too: the labels were AI-drafted and await human review, and verdicts match them 6/10 because we deliberately didn't edit labels to fit the system.
  • The whole demo runs offline in mock mode with Wi-Fi off.

What we learned

  • Showing the proof matters more than a clever summary. A quote earns trust a grade can't.
  • With an LLM in the loop, keep decisions in code: the model proposes, the code verifies and scores.
  • A good control case (the clean store) matters as much as the scary ones.
  • "I don't know" is a feature. A grey Partly read is more honest, and more useful, than a false green.

What's next for Xcavate

  • Deploy the backend and ship to the Chrome Web Store with per-site permissions.
  • Human-reviewed labels and a held-out test set (gyms, VPNs, carriers, ticketing, meal kits) before quoting accuracy more widely.
  • Site-reputation and phishing checks in the same card (in progress; not in this build).
  • Firefox and Safari, PDF and non-English policies. Today it is Chrome only and English only, and it asks for access to all sites because it must run on any shop; a store release would narrow that to per-site permission.
  • A subscription tracker that remembers what you signed up for and when it renews.

Automated summary, not legal advice.

Built With

Share this project:

Updates

Submission history