Your app is broken.Reticle makes sure it works.

It watches your running app while your agent codes, catches what breaks, and points to the exact line to fix.

Get the SDK on GitHub
Reticle catching a hidden failure and handing the agent the exact fix

The bugs that look like features

The bugs that hide behind a perfect screen

The order that never happened

The page looked perfect. Underneath, the order silently failed. A customer found it first.

receipt: POST /api/order → 500 · page rendered clean

The app that lied to itself

The screen says “Order placed.” The app's own records say there is no order. The cart is still full.

receipt: UI “Order placed” · store: cart.items = 3, order = null

The double charge

One click charged the customer twice. The screen showed one order, so every check passed. Your payment provider tells you eventually.

receipt: 1 click → 2× POST /charge

Other tools check your app from the outside, so they only see what reaches the screen. Reticle sits inside the running app and reads what actually happened: every request, every piece of internal state, every hidden error.

Playwright gates releases. Reticle gates edits.

What it does

It checks your app the way you would, then never forgets how.

state · network · dom

It remembers every flow

The first time your agent verifies a flow (sign-up, checkout, inviting a teammate), Reticle records it. From then on it re-checks that flow on every change, without being asked.

intent

Proof on every commit

Change one thing, break another: that's the bug that ships. Reticle re-verifies every remembered flow after each change and gets the same answer every time: 0% flake, about 47 tokens for the whole suite. Cheap enough to run on every commit.

checkout.tsx140141142143144:142

It understands your user's journey

Reticle checks the outcome your business needs: the order placed, the invite delivered, the card charged exactly once.

Built for agents.

Your agent is the user. It asks Reticle for proof, reads the verdict, and fixes its own work while you review finished results. Nothing for you to operate, nothing new to learn.

Evidence

See exactly why a check failed.

Go beyond pass or fail. Reticle hands the agent the real state, the network trace, and the failing line: the evidence it needs to reproduce, fix, and re-prove.

A UI that 'looks ok' is opened up; Reticle weighs the program truth (network 200, store updated, no console error) against the noise to reach a PASS/FAIL verdict.
Instead of an LLM re-driving a flow and burning a pile of tokens, Reticle's replay engine re-runs it once, no flake, and prints a verdict.

Re-run the whole suite for pennies.

No re-driving the agent through every flow and burning a pile of tokens. Reticle replays deterministically: same result every time, ~47 tokens, 0% flake.

Benchmark

Measured. Reproducible. Including where we lose.

Every number here comes from a committed harness. Clone the repo, run pnpm bench, get the same numbers, losses included.

47tokens

to re-run a 4-flow suite. Playwright spends ~120k, DevTools ~129k.

Program-truth bugs caught (of 10)

10
Reticle
0
Outside-in tools

On the bug classes only visible inside the running app (UI-vs-store desync, dead handlers, double-submits, silent console errors), outside-in tools score zero by construction. The data never reaches the screen.

0%flake

Every run, the same verdict. No sampling, no retries.

Reads the program, not the picture

Reticle asserts on DOM, network, state, and console. The others photograph the rendered surface and hope.

DOMorder #4812
networkPOST /charge → 200
statecart.items = 0
consoleno errors
vs the restReticlePWDevToolsReads real app state & signalsPoints to the source lineDeterministic, 0% flakeRe-runs for ~47 tokens

AI re-checking its own work is a fast-growing line on your AI invoice. Reticle makes each re-check roughly 2,500× cheaper. Measured, and reproducible from the harness above.

Where we lose: pixel regressions, sites you don't own, non-React frameworks, and cross-browser rendering. The full head-to-head, losses included, lives on /compare.

The real bottleneck

Your agent codes in minutes.
Then waits days for you.

re-checking by hand
~120k tokens / run
Researchagent · minutes
Codeagent · minutes
Testhuman · days
Feedbackhuman · days
Turn on Reticle
Agent writes the codefast
Human tests & respondsvery slow

The loop only runs as fast as its slowest step: verifying every edit. Do it by hand and releases wait on you; hand it to an LLM and each re-run is a growing line on your AI bill. Reticle replays the recorded suite for about 47 tokens (roughly 2,500× cheaper) and returns the same verdict every time.

Point it at your app

Pricing

Pay when your team needs the proof

Everything above is free and open source, forever. You pay at one boundary: a second person needs the agent's proof. CI re-running the recorded suite on every PR. A teammate checking what the agent verified. Flows shared across the team.

Team

Flat, per team, per month. Card swipe, no sales call, cancel whenever.

For the person who signs off

The AI bill
Agents re-checking their own work is a growing share of your AI spend. Reticle cuts the cost of each re-check ~2,500×. Measured, and reproducible from our public benchmark.
The incident
The expensive bug is the one a customer finds. In our benchmark Reticle caught 10 out of 10 planted bugs with zero false alarms, before anything shipped.
The overhead
No new hires, no procurement, no sales call. One flat monthly price on a card, cancel any month.

Straight answers

Playwright and hand-written end-to-end tests gate releases: you author spec files, maintain selectors, and run them in CI before you ship. Reticle gates edits. Your agent records a flow once, and Reticle re-runs it deterministically after every change for about 47 tokens, with no model in the loop and 0% flake. It also reads program state the DOM never shows (network, store, console, React commits), so it catches silent bugs a screenshot tool cannot see. Most teams keep Playwright as the release gate and add Reticle as the inner loop while the agent builds.
Paste one line into your agent and it installs the in-source SDK and sets itself up. From then on your agent asks Reticle for proof, reads the pass or fail verdict, and fixes its own work before moving on. There is nothing for you to operate. It works with Claude Code, Cursor, and any MCP agent, and it is React and Next today.
The SDK is free and open source, forever. You pay at one boundary: when a second person needs the agent's proof. CI re-running the recorded suite on every PR, a teammate checking what the agent verified, or flows shared across the team. That is the flat monthly Team tier: card swipe, no sales call, cancel any month.
Reticle runs inside your own app at development time and reads it locally. The free dev loop sends nothing anywhere, so your code, state, and traffic stay on your machine. The Team tier shares only the verdicts and flows you choose to share with your team.
Partially. We measured it. A strong verification prompt recovers roughly 3 to 4 of the 10 bug classes in our benchmark (silent failures reliably, dead buttons sometimes). No prompt reads your app's internal state or counts duplicate requests. The data never reaches the tool. The full head-to-head, losses included, ships on our public harness; if glue scores above 7 of 10, our paid tier is dead and we've said so on the record.
  • You don't own the app's source. Reticle lives inside the code.
  • You're not on React/Next yet. Adapters are on the roadmap, and we won't pretend otherwise.
  • You have a QA team you like. Reticle covers the gap between agent edits; your release process stays theirs.
  • You want a dashboard for humans to watch. The agent is the user.

Convinced? Start with the open-source SDK.

Get the SDK on GitHub

Catch your first false green today.

Get the SDK on GitHub