Use cases
One proof layer, from a single agent to a whole fleet.
Reticle reads program truth from inside your running React or Next app and returns a deterministic verdict with the exact file:line to fix. Here's where teams put it to work.
Flagship · most used
Multi-agent testing
Run a whole fleet of agents against one app, one browser, an isolated context each, no cross-talk.
16 flows across 8 concurrent contexts: 5.2s vs 35.4s one-at-a-time, 6.78× faster.Who it's for: Engineering leaders running agent swarms; platform teams running parallel suites.
How it works: The daemon keeps one headless Chromium and leases each agent its own isolated context (separate cookies, storage, DOM). A fleet verifies in parallel with zero per-agent browser startup, and a hung agent's lease is auto-reclaimed so one dead agent never starves the rest.
Agentic QA
Your agent becomes its own QA department, it checks its own work and only returns when it's actually verified.
Who it's for: Vibe-coders and solo builders who don't write tests; QA teams formalizing the long tail.
How it works: One assert call checks network + element + signal + console at once and returns a pass/fail verdict with evidence, and on a fail, the failing check and the file:line to fix, instead of a guess.
Dev-time testing
Gate every edit, not just every release, verification cheap enough to run inside the agent's loop.
Who it's for: Software engineers working agent-assisted who want “done” to mean done.
How it works: A full verify loop (query + observe + assert) costs ~100 tokens, so the agent can verify after every change instead of at the end, reading the program (network, store, signals, console, React commits), not a screenshot.
Headless testing
Drive verification from CI or a sandbox with no MCP and no human in the seat, gate the deploy on the verdict.
Who it's for: Platform/pipeline engineers; AI app-builder platforms; regulated teams wiring verify-before-merge.
How it works: `reticle serve --http --drive <url>` exposes a /verify endpoint (or one-shot `reticle verify <url>` that exits non-zero on fail). It replays saved flows and returns a stable, versioned artifact with repair packets to feed the fixer agent. A severed backend reads as fail, never a confident green.
React / Next web apps
A verdict pointed at the exact component and file:line to edit, purpose-built for React and Next.
Who it's for: Teams that own React 18/19 or Next.js (App or Pages router) apps.
How it works: The React adapter plus the babel/Next source-mapping plugins resolve a DOM ref → component → source file:line; live store/React state reads what the DOM never shows; the render meter catches wasted-render storms. One plugin line and a dev-only connect() (tree-shaken from production) wire it all.
Automation testing
Turn any flow into a deterministic regression test that re-runs with no model, your regression net, inside the loop.
Who it's for: QA/SDETs building a regression suite; fintech/regulated teams that need an auditable, repeatable gate.
How it works: Record a flow once, annotate the business outcome, and save it. After any change, every saved flow re-runs deterministically into one consolidated verdict, passing flows counted, only failures detailed with whatChanged, whereInSource, and a one-line nextAction. No LLM in the regression loop.
What a screenshot can't catch
The bugs that survive an agent's own review.
On its first pass against Reticle's own dashboard (before any instrumentation) it surfaced two live 500s the page hid behind a perfect render. A screenshot would have looked flawless.
Built for the way you work
Vibe-coders & solo builders
Stop being the agent's eyes, it checks every edit and fixes the break first.
Agent-assisted engineers
An in-loop verifier over network, state, signals and console that returns the file:line.
QA / SDETs
The “I just eyeball it” checklist becomes automated, same verdict every run.
Founders & eng leaders
Fewer broken things shipped, agents that prove their own work, bounded cost.
Platform / pipeline engineers
An un-hallucinatable “verified ✓” on every generated app, gating the deploy.
Who it's for
Teams that own the app an agent is building.
Healthcare & health-tech
Patient portals, clinical dashboards, scheduling, where a silent 500 or a UI-vs-store desync is a data-integrity and safety problem, not a cosmetic one. Dev-only, localhost-only, no telemetry: no PHI leaves the machine.
Fintech, payments & regulated
“Paying actually charges the customer,” “checkout fires exactly one charge,” “a must-never-fire endpoint never fired” map 1:1 to Reticle's net{count} and signal predicates. The verdict is mechanical, so it can't report green for something it never ran.
AI app-builder platforms
Lovable / Bolt / v0-style generators need to prove a generated app actually works before shipping it. Add the Perception SDK to the template once → every generated app is verifiable; drive it headless and self-heal on the verdict. The OEM/embedding fit.
SaaS & internal tooling
Behavior-heavy dashboards built fast with agents, and big Playwright estates that gate releases but can't gate edits. The bread-and-butter fit.
Security & compliance
Dev-only and localhost-only (127.0.0.1 bind), no telemetry, offline Ed25519 licensing. Network bodies aren't captured by default, and the prod-preview profile redacts source, state and bodies. SOC 2 is a GA-stage item, stated honestly.
Where Reticle doesn't win
Pixel and paint regressions belong to a screenshot. Trusted native input, cross-browser, multi-tab and network mocking belong to Playwright. A site you don't own belongs to Playwright or DevTools. Plenty of teams run both.