Make your agentverify its own work

Not by asking it. Reticle opens the running app, walks the flow, and reads the network calls, the app's own state, and the console. The verdict is a fact your agent cannot talk its way around.

Start freeView on GitHub

No credit card required.

818
GitHub stars
24k+
installs a month
86 / 88
seeded bugs caught
2,500×
cheaper per re-run

Engineers and QA teams use Reticle at

IBMGrapevineGrapevine

Sound familiar?

Three ways your agent says “done”and isn't

It fixed the bug and broke the feature

You hand it one ticket. It ships the fix and quietly takes out the flow that worked yesterday, because nothing re-ran that flow. You find out from a user.

receipt: fixed: cart total · broke: guest checkout

It said it was working. It was mock data

Hardcoded response, green checkmark, a confident summary of work it never did. The agent was optimising to look done, and looking done is easier than being done.

receipt: return MOCK_ITEMS · agent: “verified ✓”

You are the test suite

Every change, you click through it yourself, find the thing it missed, and paste the failure back into the chat. Then you do it again. That is a QA job, and you did not apply for it.

receipt: you → agent → you → agent → …

Different symptoms, same cause: nothing checks the agent's work except you. The tools that could check it only see what reaches the screen, and a confident agent looks correct on screen. Reticle sits inside the running app and reads what actually happened underneath.

Playwright runs before you ship. Reticle runs after every edit.

Start freeView on GitHub

What it does

It checks your app the way you would, and it remembers how

Reticle's replay engine re-runs a recorded flow once and prints a verdict, instead of an LLM re-driving it and burning tokens

It remembers every flow

The first time your agent verifies a flow, say checkout, Reticle records it. After that it re-checks that flow on every change, and nobody has to remember to ask.

A page that looks shipped, with mock data, a dead click and a hidden 500 leaking underneath, all caught by Reticle and marked FAIL

Proof on every commit

Change one thing, break another. That is the bug that actually ships. Reticle re-runs every flow it remembers after each change and gets the same answer every time, which costs about 47 tokens for the whole set. That is cheap enough to run on every commit without thinking about it.

A broken Pay button traced to onPay.tsx line 46 and handed to the coding agent as a repair packet

It understands your user's journey

Reticle checks the outcome you actually care about. Did the order get placed, did the card get charged once instead of twice. When it fails, it names the file and the line.

Start freeView on GitHub

Evidence

See exactly why a check failed

A bare pass or fail does not tell an agent much. Reticle hands over the network trace, the app's own state at the moment it broke, and the line that did it, which is enough for the agent to reproduce the bug and then prove the fix. In our ablation that one change cut its fix-loop tool calls by 45%.

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.
Benchmark chart: re-running the recorded suite through Reticle's replay engine versus an LLM re-driving every flow.

Re-run the whole suite for pennies

You do not have to send the agent back through every flow and pay for those tokens again. Reticle replays the recording directly, so it costs about 47 tokens and returns the same verdict every time.

Start freeView on GitHub

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.

Critical bugs caught (of 26)

26
Reticle
9
Playwright

The bugs that corrupt data or hide a failure: silent 500s, UI-vs-store desync, dead handlers, double-submits. Across all 88 seeded bugs it is 86 vs 60. The gap is widest exactly where it hurts.

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 the comparison pages.

Start freeView on GitHub

The 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 moves as fast as its slowest step, and that step is checking every edit. Do it by hand and the release waits on you. Hand it to an LLM and every re-run shows up on your AI bill. Reticle replays the recording it already has, so the whole set costs about 47 tokens (roughly 2,500× cheaper) and gives the same verdict each time.

Start freeView on GitHub

The platform is live

The engine is free. The car is open

The open source SDK is yours, and it stays that way. app.reticle.sh is what we built around it: runs, history and failures for your whole team, without you running any of it. Free to start, and you can be in it before you finish reading this page.

Start freeView on GitHub

No credit card required. Read the docs or talk to us about enterprise.

What you get on the free plan

  • Every run, kept. History that survives a restart and a laptop.
  • The whole suite off your machine, so it is not one laptop's job.
  • Failures grouped, so twenty red runs read as the one bug they are.
  • Your team in one place, with the same verdicts in front of all of them.
Create your account

Free to start. No credit card required.

Trust

Built to pass your security review

Reticle reads your running application, so we designed it for the person whose job is to say no to that.

Nothing leaves your machine

It sends us no code, no DOM, no network traffic, no console output and no file paths. The SDK is dev and preview only, tree-shaken out of production builds, and the bridge binds to 127.0.0.1 behind a token. The CLI does send anonymous usage events (which command ran, did a verdict pass) so we know what to build; turn it off for good with `reticle telemetry disable`.

Licensing is offline

Keys are signed with Ed25519 and verified locally. License checks never phone home, so an outage on our side cannot stop your build.

You can audit it yourself

The SDK is Apache-2.0 and the server is source-available. Go read the tree-shaking, the bind, and the license verify before you sign anything.

Your artifacts stay yours

Runs and flows are written to your disk under .reticle, with atomic writes and bounded retention. Export or delete them without asking us.

Start freeView on GitHub

Talk to us

Some questions need a person

Most of what Reticle does you can find out in ten minutes without us. The rest is specific to your team, your suite and whoever has to approve it, and that is a conversation rather than a page.

You get one of the founders. No SDR, no qualification call before the call, and no deck unless you ask for one. If we are the wrong fit we will tell you on the call instead of booking a second one.

Book a callEmail us instead

Pick any slot that works. Every email gets an answer.

  • Your suite outgrew one laptop

    Runs that take an afternoon on one machine, a team waiting on them, and nobody sure which failures are the same failure.

  • Procurement needs answers we cannot put on a page

    SSO, an audit trail, a signed agreement, a named engineer on the account. Bring the questionnaire, we will fill it in.

  • You want to see it on your own app first

    Not a demo of our app. Yours, with your flows, before you decide anything.

Straight answers

They run at different moments. Playwright and hand-written end-to-end tests run before you ship: you author spec files, maintain selectors, and run them in CI. Reticle runs after every edit your agent makes. Your agent records a flow once, and Reticle re-runs that recording on each change for about 47 tokens, with no model in the loop and the same verdict every time. 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 to 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 Apache-2.0 and the verification engine is open source, free forever, because we build for developers and a developer should never have to file a purchase request to try a tool. You pay for the platform around the engine: context and memory that persist across sessions and machines, managed infrastructure to run the suite, parallel execution, flows shared with your team and replayed in CI, and issue determination that shows how failures relate to each other. Teams, startups, and enterprises all start with a conversation, so we can price it against your team and your suite rather than a made-up seat count.
The embeddable SDK is Apache-2.0 and safe to ship inside your apps. The server, CLI, and MCP packages are source-available under FSL-1.1-ALv2, free for any use except reselling Reticle itself, and they convert to Apache-2.0 after two years. Enterprise features are source-available under our own license with a key required in production. Keys are signed with Ed25519 and verified offline, so license checks never phone home and our uptime is never a dependency of your build. Your security team can read every one of those claims in the repo before you sign anything. Book a call and we will walk your reviewers through it.
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. On our 10-bug scripted detection set, a strong verification prompt recovers roughly 3 to 4 (silent failures reliably, dead buttons sometimes). No prompt reads your app's internal state or counts duplicate requests, because the data never reaches the tool. That ceiling is why Playwright catches 0 of the 8 state bugs and 0 of the 6 business-logic bugs in our 88-bug registry. The full head-to-head, losses included, ships on our public harness; if glue scores above 7 of 10 on that scripted set, 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.

Still have a question? Ask us directly.

Start freeView on GitHub

Catch your first false green today

Start free in the app, or install the open source SDK and run it on your own machine. Either way, nothing is stopping you today.

Start freeView on GitHub

No credit card required.