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.
Free and open source. It runs on your machine and your code stays there.
- 86 / 88
- seeded bugs caught
- 0
- false alarms
- 0%
- flaky results
Engineers and QA teams use Reticle at
Grapevine
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.
What it does
It checks your app the way you would, and it remembers how.
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.
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.
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.
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%.
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.
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.
to re-run a 4-flow suite. Playwright spends ~120k, DevTools ~129k.
Critical bugs caught (of 26)
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.
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.
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.
The bottleneck
Your agent codes in minutes.
Then waits days for you.
~120k tokens / run
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.
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.
Pricing
The engine is free. You pay for the car around it.
The part one developer needs is open source and will stay that way. A team needs more than that: memory that survives a restart, infrastructure so running the whole suite is not one laptop's job, and a read on which failures are really the same failure.
For developers
Free, forever
Open source, runs on your machine, no account needed. You can take it to work without asking anyone first.
- The Perception SDK, Apache-2.0, shipped inside your app
- The verification engine: network, state, console, React commits
- Record a flow, replay it deterministically, read the verdict
- MCP server for Claude Code, Cursor, and any agent that speaks it
- Runs on localhost with no account, and your app's data never leaves the machine
For teams and enterprises
Talk to us
Priced on the size of your team and your suite. Startups and enterprises both start with a conversation, because the setups are not the same.
- Context and memory that persist across sessions, branches, and machines
- Managed infrastructure to run the suite, so it is not one laptop's job
- Parallel execution: the whole recorded suite at once instead of one flow at a time
- Recorded flows shared across the team and replayed in CI on every PR
- Issue determination: what broke, what it touches, and how failures relate to each other
- SSO, audit trail, and a named engineer on your account
Straight answers
- 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.
Catch your first false green today.
The SDK is free and open source. When your team outgrows one laptop and needs the shared memory and infrastructure around it, come talk to us.