FIND THE BUGS
BEFORE YOUR
USERS DO
Jevitate explores your web app like a relentless user — goal-directed, exploratory, and adversarial — and turns every failure into a deterministic Playwright regression that runs in CI.
Model decisions are hypotheses to verify — runtime evidence decides pass or fail. The same Journeys it tests, it can also run as automation.
The Journey engine ships now
Journey lifecycle
Record by demonstration, parameterize, promote, and replay deterministically — no model in the loop at run time.
Fail-closed self-healing
On divergence a run stops and quarantines; write, irreversible, and real-send steps never auto-heal.
Load & throughput
A seeded pool of virtual actors drives a Journey concurrently and emits an honestly-labeled capacity report.
MCP capabilities
Agents call promoted Journeys via find_capabilities / run_journey — never raw click, fill, or selector tools.
Secrets & handback
Visible-handback or external-manager autofill, origin-bound, nothing stored at rest — secrets never reach a model.
Distributed sources
Federated Journeys from pinned, content-hash-bound sources behind a trust + terms-of-use run-gate.
Six ways to point it at your app
The Journey engine ships today. The Jev-driven testing modes below are in active development — each is badged so you always know what runs now versus what's coming.
Give it a goal in plain English
“Upgrade the account to Pro.” Jev drives toward the goal and confirms it from observable application state — never just because a model returned DONE.
Name a feature, not the steps
“Test checkout.” It discovers the relevant UI paths dynamically and exercises multiple valid routes through the capability.
Map every state
No destination. It maximizes new states and transitions, surfaces undocumented paths, and detects dead ends and loops within a fixed budget.
Break it on purpose
Ordering violations, rapid actions, navigation during pending async, boundary inputs — all bounded by your safety policy.
Every bug becomes a repro
Reproducible failures are minimized to the smallest trigger and kept as a deterministic, replayable Recording — the exact hand-off to a coding model.
Record once, run it forever
Record a Journey by demonstration, parameterize it, promote it, and replay it deterministically — with no model in the loop. Available today.
A loop that verifies everything
The Jev-driven exploration loop is in active development. Every action will produce an observable transition or an explicitly recorded no-op, and every failure ties back to the exact states and actions that produced it.
- Observe
capture page state atomically
- Enumerate
index actionable elements
- Decide
Jev picks a typed action
- Act
one browser operation
- Measure
console, network, DOM
- Verify
evidence, not a claim
- Record
trace + coverage graph
- Repeat
The rule: a model claim never constitutes proof. Success and failure are decided by runtime evidence — browser exceptions, failed requests, dead ends, broken invariants — or an explicit assertion you define.
One Journey,
two lives
Everything produces or consumes a Journey — a parameterized, deterministic, replayable recording. Discovery can be nondeterministic; the product never is.
Human-driving. Available Step through your app; Jevitate records it as a Journey you can replay and parameterize.
LM-driving. Roadmap Jev makes typed driving decisions; a generative model supplies text only — never a real recipient for a real send.
Publish once. A promoted Journey becomes one allowlisted MCP action agents can call — no raw browser tools ever cross the line.
Direction spectrum
Deterministic replay and programmatic exploration ship today; the Jev-directed and goal-based ends are in development. Jev is an optional director, never required — explore a whole state space with no model at all.
Bugs turn into tests, automatically
The planned flow: a discovered anomaly never becomes a test on its own. Jevitate reproduces it, minimizes the trace to the smallest reliable sequence, and keeps it as a deterministic, replayable Recording — the exact repro to hand a coding model — with Playwright export under consideration.
# planned interface — see the roadmap $ jevitate explore --url http://localhost:3000 --strategy adversarial ↳ failure: console_error on step 27 → recording saved (exact repro) $ jevitate journey run .jevitate/runs/checkout-001/recording.json ↳ replays deterministically — fails on the bug, passes after the fix
The repro is a deterministic Recording built from durable, semantic descriptors (test-id, role + name, label) — never Jev, never ephemeral DOM indices — so it replays anywhere. Flaky failures are labeled, not silently promoted. Direct Playwright export is a candidate for a later slice.
Safe by default
Read the safety modelJevitate assumes you're testing systems you're authorized to test. Prompt-injection guard is always on — page text is untrusted data, never instructions. Pacing is realism, never detection-evasion.
Run your first Journey
Local-first · Node 20+ · MIT licensed
$ npm install -g @jevitate/cli $ jevitate init # set up a local profile $ jevitate journey run <id> # replay a Journey deterministically # in development: $ jevitate explore --url http://localhost:3000 --goal "upgrade to Pro"