Backed byEntrepreneurs First

Make your agent verify its own work

AI verification for agent-written code: every change checked inside the running app, from the network, state and console. Run the open-source SDK on your machine, or let the platform test every preview and PR in a real browser and show your team what broke.

Start freeBook a demo

No credit card required.

600K+ npm downloads by developers worldwide, including engineers at

  • IBM
  • Toss

The numbers

What each number measures, and how to check it

1.2kGitHub stars
Developers who starred the open-source repo. Everything that runs on your machine is in it: the SDK, the verification engine and the benchmark harness behind the numbers on this page. Read the code you are trusting before you install it, and open an issue when it gets something wrong.
600K+npm downloads to date
All-time downloads across the twelve @reticlehq packages, counted from npm's public download API. We say downloads, not developers, because one install pulls several packages and CI downloads them again. It is the one number on this page you can check without asking us.
85 / 88seeded bugs caught
The benchmark plants 88 bugs that look fine on screen: mock data, a dead button, a 500 the page swallows, a store that disagrees with what is shown. Reticle caught 85; Playwright caught 59 on the same registry. Of the three Reticle misses, two are traps where the right answer is to pass, and one is a real miss we count against ourselves. Run pnpm bench to get the same numbers.
250×cheaper suite re-run vs an LLM
Once a flow is recorded, checking it again is a replay, not a conversation. A four-flow suite costs about 480 tokens with no model in the loop; an LLM agent re-driving the same four flows costs around 120,000. The replay gives the same verdict every time, which is what makes it cheap enough to run on every commit.

Sound familiar?

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

Most AI agent testing still means asking the agent whether it tested.

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 freeBook a demo

What it does

AI verification that checks your app the way you would, and remembers how

A lot of AI testing stops at the screen. Reticle reads what happened underneath.

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 480 tokens for a four-flow 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 freeBook a demo

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 a four-flow suite costs about 480 tokens and returns the same verdict every time.

Start freeBook a demo

Benchmark

AI testing, measured. Including where we lose

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

480tokens

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 85 vs 59. 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 4 flows for ~480 tokens

AI re-checking its own work is a fast-growing line on your AI invoice. Reticle makes each re-check of a 4-flow suite roughly 250× cheaper than an LLM re-driving it. Measured, and reproducible from the harness above.

Where we lose: pixel regressions, sites you don't own, source lines on Vue and Angular, and cross-browser rendering. The full head-to-head, losses included, lives on the comparison pages.

Start freeBook a demo

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 a four-flow set costs about 480 tokens (roughly 250× cheaper than an LLM re-drive) and gives the same verdict each time.

Start freeBook a demo

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 freeBook a demo

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.
Start free

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 freeBook a demo

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

AI verification is the step after your agent says it is done: checking, in the running app, that the change actually works. Reticle walks the flow your agent touched and reads the network calls, the app's state and the console, then returns a pass or fail with the evidence and, on React, the file and line to fix. Many AI testing tools judge a screenshot or ask a model whether the page looks right, and testing AI agents' work that way lets a confident agent pass itself. AI verification builds the verdict from what the app actually did.
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 240 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 works on React, Next.js, Vue, Svelte and Angular.
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 need app state or file:line on a site whose source you don't have. Reticle drives third-party sites, but those two need its SDK in your build.
  • 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 freeBook a demo

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 freeBook a demo

No credit card required.