[ OPEN SOURCE · MIT · POWERED BY JEV ]
Break it.
Prove it.
Keep the test.
Autonomous browser testing that turns discovered bugs into deterministic regression tests.
Jevitate explores your web app in a real browser and reports only what the browser can prove: HTTP 5xx responses, uncaught exceptions, hangs, failed checks, broken rules you declare. Each defect comes with a replay that reproduces it, verifies the fix, and runs in CI.
Nondeterministic discovery. Deterministic verification.
npm install -g @jevitate/cli · Node 22+ · your first
run needs no API keys
A form that lies. Caught, proven, locked in.
A profile form says “Saved” while the server returns HTTP 500. Jevitate finds it, reproduces it 3/3, commits a regression, and verifies the fix.
Recorded by Jevitate. Every frame is its own output: the captioned Journey demo, the defect evidence clip and the verify-fix replay.
- 01 · Explore
jevitate explore --strategy adversarial --url http://127.0.0.1:5190/demo/profile --invariants apps/example-site/demo-invariants.json --fake-aiDouble submits, boundary and unicode values, reloads mid-edit. Finds an HTTP 500, and a broken rule: the page said “Saved” but the server kept the old name. Add --evidence-video for a captioned clip of each defect.
- 02 · Reproduce
jevitate verify-fix --result "$RESULT" --fingerprint "$FP_500"Replays the finding in 3 fresh browser sessions. Still reproduces.
- 03 · Commit a regression
jevitate regression capture --from "$RECORDING" --result "$RESULT" --fingerprint "$FP_INV" --id saved-means-storedWrites a Recording plus its oracle you can check in.
- 04 · Verify the fix
jevitate regression run saved-means-storedFails while the bug is there. Passes once it's fixed.
No API keys needed. It runs against the example app in the repository, and the walkthrough shows the real output of every step.
Find the tests you didn't write
Keep your E2E suite. It checks the paths someone thought of. Jevitate goes looking for the ones nobody did, and hands each failure back as a deterministic artifact.
Your E2E tests
- You write each path and each assertion.
- They catch the failures you anticipated.
- Deterministic, and they stay that way.
Jevitate
- Explores paths nobody scripted: goals, misuse, state coverage.
- Reports a failure only on evidence, decided by code.
- Hands back a replay: reproduce it, verify the fix, gate CI.
- Explore
- Detect with evidence
- Reproduce
- Commit a regression
- Verify the fix
Intelligence proposes. Evidence decides.
A model is good at deciding what to try. It isn't trusted to decide whether your software works. Jevitate keeps those two jobs apart.
What to try next
In goal and usability runs, Jev (TypeSafe's judgment model) picks among the controls code found. Adversarial, coverage, exploratory and feature runs plan their actions in code. Jev's opinion there is advisory.
A real browser
Chromium through Playwright, only on origins you authorize. After every action: responses, console, uncaught exceptions, failed requests, DOM state, hangs.
Code-adjudicated oracles
A defect is concluded only from hard signals, your success checks, your declared invariants or your backend-log matchers. A model's “looks broken” never decides.
Deterministic artifacts
Each finding carries a Recording and a stable fingerprint. verify-fix replays it in fresh sessions, regression capture commits it, and jevitate check gates CI.
Honest outcomes: every run ends as clean, defects-found, inconclusive, hang or intermittent, each with its own exit code. A run that couldn't do its work is inconclusive, never clean. A fix counts only when the signal is absent on every replay.
Lab-tested
We planted the bugs ourselves, then counted how often Jevitate called it right.
Goal-run precision
of the problems a goal run reports, how many are real
Usability precision
of the problems a usability run reports, how many are real
Planted defects found
every seeded defect reported, by both strategies, on every run the host could judge, silent data loss included
How it's measured: a seeded-defect lab, a small app with known ground truth. It has a clean variant, variants with one planted defect each (a failed save behind a success message, a Send that does nothing, a disabled Import with no reason, a message or import that says it worked but keeps nothing), and a working flow padded with extra steps. Goal and usability runs execute each job six times (108 runs), and every verdict is scored against the ground truth. The lab ships with Jevitate, so you can rerun it. Method and results
Try it in a minute
Node 22+ · runs locally · headless by default · MIT licensed
1 · Install and set up (once)
npm install -g @jevitate/cli npx playwright install chromium # the browser Jevitate drives jevitate init # run it at your repo root
init asks for TYPESAFE_API_KEY and OPENROUTER_API_KEY at a terminal (skip them with --skip-keys; step 2 needs none), checks each key live with its provider, installs skills for the coding agents it finds, registers the MCP server, and creates the repo's .jevitate/.
2 · Try to break a form (no API keys)
jevitate explore --strategy adversarial \ --url http://localhost:3000/settings --fake-ai
Point it at a page of your running dev server. It double-submits, feeds boundary and unicode values, reloads mid-edit. It prints the outcome, each defect with its fingerprint, and a next: step. Exit 0 clean · 1 defects found · 2 inconclusive.
3 · Ask a question, or drive to a goal (with keys)
# Ask a question: the answer must be grounded in text the run saw (read-only by default) jevitate explore --url http://localhost:3000/pricing \ --goal "find out which plans are offered and report their prices" --real # Drive to a goal: it passes only if code sees the save sent and the value survive a reload jevitate explore --url http://localhost:3000/profile --goal "set the last name to Litmus and save" \ --success 'requestMade:PUT /api/profile' \ --success 'reloadThen:valueEquals:[data-testid=last-name]|Litmus' --real
Jev picks what to try next; code decides the outcome. Results and Recordings go to .jevitate/logs/<date>/. Add --json for the machine envelope.
Then
Give your coding agent a QA loop
Your agent changes the code. Jevitate tells it, with evidence, whether the app still works: run a bounded mission, read a typed result, re-check a finding after the fix.
Skills that teach the CLI
jevitate init installs a skill set into the agents it detects: Claude Code (~/.claude/skills/), Codex (a block in ~/.codex/AGENTS.md), Cursor (.cursor/rules/), and .agent/skills/ plus an AGENTS.md block for any other agent. They cover getting started, exploring, scoping tests from a diff, running and recording Journeys, demos, verifying fixes, CI checks, whole-release test campaigns, load tests and usability reviews. The agent shells out and reads the result.
An allowlisted MCP server
jevitate mcp serves domain tools only, one per CLI command: run_exploration, queue_exploration, get_mission_result, verify_fix, run_journey, annotate_journey, create_demo, run_check and more. Raw browser tools like browser_click or page_evaluate are forbidden, and approving or cancelling an inbox item stays human-only.
$ npm install -g @jevitate/cli $ jevitate init --dry-run # what it would install and register $ jevitate init # keys, skills, MCP registration, .jevitate/ $ jevitate mcp --print-config claude # or cursor | codex | json: print the snippet only
init registers the server in the project's .mcp.json (Claude Code),
.cursor/mcp.json and ~/.codex/config.toml,
and never overwrites an entry you changed without --force. Run
without a terminal, it never prompts for keys: it reports which ones are missing.
MCP & CLI reference
Then paste a prompt
After jevitate init, with your dev server running:
Use the jevitate-explore skill to run an adversarial mission against http://localhost:3000/settings with --fake-ai. List each defect with its fingerprint and the code it points at. After you fix one, re-check it with jevitate verify-fix and show me the verdict.
Follow the jevitate instructions in AGENTS.md: scope testing for this branch's diff, run the promoted Journeys it touches with jevitate journey run, and report any failure with its evidence.
Using the jevitate MCP tools, run an adversarial exploration of http://localhost:3000/settings (run_exploration with fakeAi), then verify_fix each defect once I have fixed it.
With the jevitate MCP server: find_capabilities for "checkout", then run_journey on the match with env "staging" and recordVideo, and give me the videoPaths.
The test is also the demo
A Journey that replays deterministically can also be shown: live, recorded, or rendered as a captioned video and a step-by-step guide for sales, onboarding and user docs. Because it is a replay, a demo that goes stale fails like a test.
Watch any run
Runs stay headless, CI included. --headed opens a visible browser slowed by --slow-mo, with an on-page overlay jevitate itself never sees. --record-video records it, headless too.
One Journey, every environment
Name where your app runs in .jevitate/environments.json (committed, no secrets) and pick one with --env. A step on any other origin is refused before a browser opens.
A narrated demo from a Journey
The Journey's goal as a title card, each step's objective as the caption. Writes a WebM video, .vtt subtitles and a Markdown guide with a screenshot per step. A Journey that no longer replays fails the command.
Or from one sentence
Explores a named non-production environment, keeps only the steps that matter (verified by replay), annotates them and renders a DRAFT. demo approve is the one human step that promotes it.
# Watch it: a visible browser, slowed down, with an overlay jevitate explore --strategy adversarial --url http://localhost:3000/settings --fake-ai --headed # Draft each step's intent on playback, review it, approve it jevitate journey annotate checkout --env staging --real jevitate journey annotate checkout --approve # Video + .vtt subtitles + a Markdown guide with screenshots jevitate journey demo checkout --env staging --video demos/checkout.webm --guide demos/checkout.md # From one sentence: explore -> clean path -> Journey -> annotate -> DRAFT demo jevitate demo "check out with a saved card" --env staging --success 'urlIncludes:/order/confirmed' --real jevitate demo approve demo-check-out-with-a-saved-card
Registered secrets are masked in the pixels of every video and screenshot, and a capture whose
mask can't be proven is not written. demo refuses an environment
flagged "production": true.
Journeeze: what people think
Jevitate proves what the browser can prove. Journeeze adds what only people can tell you: what they like, dislike, and don't understand, anchored to the same journeys and clustered into GitHub issues.
Reviewers switch on a feedback mode in your app, point at an element, react (like, dislike, understood, confused) and comment. Inputs are masked and nothing is captured without consent.
Capabilities
Goal missions
A plain-English goal plus independent checks: URL, text, values, network, persistence after reload, computed style.
Adversarial missions
Form-aware misuse: double submits, boundary and unicode values, cancel then save, acting while a save is pending.
Coverage & feature missions
Breadth-first, novelty-first or capability-scoped state frontiers, contained to the scope you give.
App-declared invariants
Your own rules over DOM, network and read-only probes, checked around every action. A violation is a defect.
Verify & regress
verify-fix replays in fresh sessions. regression capture commits a failure, and regression run replays it.
CI gate
jevitate check runs a suite within a budget and writes JUnit and SARIF. report and diff dedupe findings against a baseline.
Real, logged-in apps
Storage-state logins, secrets typed by code, TOTP, fixtures that reset state around every replay.
Repeats, personas, actors
Vote across repeated runs, diff roles for RBAC candidates, check cross-tenant isolation.
Missions from inside a Journey
Replay a promoted Journey to a named anchor, then explore, attack or review from the live page. Campaigns run many anchored missions into one deduped report.
Browser extensions
--extension loads an unpacked extension; its side panel, popup and options pages are navigable, and replays refuse a different build.
Shares the machine
A machine-wide browser cap, a per-run memory ceiling and adaptive throttling. A run over its ceiling is inconclusive, never a crash or a false finding.
Journeys
Author a replayable flow from a goal, give it intent, run it on any named environment, self-heal under policy, load-test it, share it.
Watch or record any run
Headless by default. --headed and --slow-mo show the browser with an on-page overlay; --record-video records it, headless too.
Narrated demos
journey demo renders a Journey as a captioned video, .vtt subtitles and a Markdown guide. demo "<aspect>" drafts one from a sentence.
Evidence you can attach
Per defect, a captioned repro clip and before/at screenshots, linked from issue drafts, report, JUnit and SARIF. Secrets masked in the pixels.
Seven ways to point it at your app
All seven run today. Usability review ships as both an offline pass over a saved Recording and a
live exploration strategy. Every card is badged so you always know what ships.
Five of these cards (goal, feature, explore, adversarial, usability) plus a sixth,
coverage — not shown here — are the jevitate explore modes; see
Testing Modes for the exact --strategy /
--feature breakdown. Regression and automate are separate, later stages of the
pipeline, not additional explore modes.
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
Every finding carries a Recording that reproduces it. verify-fix replays it in fresh sessions, and regression capture commits failed checks and broken invariants as regressions, minimized where it can. It is the exact hand-off to a coding model.
Author once, run it forever
Author a Journey from a goal (or record a flow by demonstration), promote it, and replay it deterministically with no model in the loop, on any environment you name. Render it as a narrated demo when you need to show it.
Review the experience, not the mechanics
Usability findings that ask whether the user got the job done and where the experience gets in the way. Each finding is a claim code verified: a destructive control that deletes without asking (an opt-in, fail-safe guard probe), a price or next step that contradicts your product facts, or friction the run actually hit. Jev only categorizes and grades; it never writes a finding on its own, so the review stays advisory and never gates a pass or fail. Runs offline over a saved Recording or live as an exploration strategy (--strategy usability).
Safe by default
Read the safety model
Jevitate assumes you're testing systems you're authorized to test. Page text is untrusted data,
never instructions, and model prompts carry a prompt-injection guard. Every write request a run
fires is listed in its result, and registered secrets are masked in the pixels of every video and
screenshot. --allow-destructive and --deny change the click policy.
Secondary use: the same Journeys as browser automation
A promoted Journey is a deterministic, parameterized replay with no model in the loop. Agents can call it over MCP, it can repair a drifted step under review, and it runs inside the same safety boundaries. See Beyond tests.
Back-office workflows
Prepare an approved reply or a form entry and stop before Send, for a person to finish.
Data entry
One Journey, many records: pass each value as a --param.
Discover, then act
Chain a discover Journey into a per-record action Journey with journey chain.
Recurring operational tasks
Replay the same promoted Journey on any named environment with --env.
jevitate journey run invite-teammate --env staging --param email=a@example.testOpen source, in the open
Jevitate is MIT licensed and developed on GitHub. Every capability on this page is in the repository, with the tests that hold it to its guarantees.
Bug reports, ideas and pull requests welcome