FIND THE BUGS
BEFORE YOUR
USERS DO
Jevitate explores your web app like a relentless user: goal-directed one run, exploratory the next, adversarial when you ask. Every failure it finds becomes a deterministic, replayable 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, then parameterize it, promote it, and replay it deterministically. No model in the loop at run time.
Policy-gated self-healing
Fail-closed by default. Hybrid and full modes allow a scoped re-learn under policy. Steps that write, that are irreversible, or that send for real never auto-heal, in any mode.
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 and every Jev-driven testing mode below run today — each is badged so you always know exactly what ships.
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 runs today. Every action produces 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 by 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. Available 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
Every point on the spectrum ships today — deterministic replay, programmatic exploration, and the Jev-directed and goal-based ends alike. Jev is an optional director, never required — explore a whole state space with no model at all.
Bugs turn into tests, automatically
A discovered anomaly never becomes a test on its own. Jevitate reproduces it, minimizes the trace to the smallest reliable sequence, and commits it as a deterministic, replayable Recording — the exact repro to hand a coding model. Direct Playwright export is a candidate for a later slice.
$ jevitate explore --url http://localhost:3000 --strategy adversarial --real ↳ failure: console_error on step 27 → failing recording emitted $ jevitate regression capture --from ./failing.recording.json --id checkout-001 ↳ reproduced 3/3 · minimized 27→6 steps ↳ committed checkout-001.recording.json (+ .meta.json) — flaky failures are labeled, not committed
The repro is a deterministic Recording built from durable, semantic descriptors (test-id, role + name, label). It never leans on Jev or 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 # or let Jev test it: $ jevitate explore --url http://localhost:3000 --goal "upgrade to Pro" --success urlIncludes:/pro --real