diff --git a/.env.example b/.env.example
index ecaab8f..1546a8d 100644
--- a/.env.example
+++ b/.env.example
@@ -4,6 +4,8 @@
 # MODEL_SYNTH_MODEL=anthropic/claude-sonnet-5   # Strong synth model
 # MODEL_REVIEW_MODEL=google/gemini-3.8-flash    # Finish-review model
 # MODEL_SYNTH_ENABLED=1                         # Enable synth pass on finish
+# WEBPILOT_FAST_MODE=1                          # Jev picks browser actions (OpenRouter only)
+# JEV_MODEL=typesafe/jev-1.13                   # Jev decision model
 # MODEL_TIMEOUT_MS=120000                       # Per-call timeout (ms)
 
 # OpenRouter credentials (https://openrouter.ai/settings/keys)
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index baf8d12..0ba8b04 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -61,6 +61,23 @@ Dependabot opens a weekly grouped PR for `playwright` and `playwright-core` (sta
 3. Run one real task (`npm run agent:cli -- "Go to https://example.com and tell me the page heading."`) to confirm the snapshot format still parses.
 4. For releases, run the `Package Desktop` workflow to package and smoke-test the desktop app on every platform.
 
+## Fast Mode (Jev)
+
+Fast mode (`fastMode` in settings, `WEBPILOT_FAST_MODE=1`) puts TypeSafe's Jev decision model in charge of each browser step. Jev returns typed decisions with calibrated probabilities in ~0.3s instead of generating text, so it replaces the LLM wherever the question is really a choice. It is reached through OpenRouter with the same API key (`/api/v1/systemone`, model `typesafe/jev-1.13`, override with `JEV_MODEL`); it is not available with Ollama.
+
+Modules under `lib/jev/`:
+
+- `client.ts`: the decision API (`choice` and `noul` questions, retries, answer parsing).
+- `page.ts`: builds the page state from the accessibility snapshot alone (a numbered list of actionable elements with landmark info, plus a text excerpt). Every Playwright MCP `browser_evaluate` costs ~0.5-1s, so fast mode avoids them. Pages with more than ~250 elements are trimmed to the ones in main content that share words with the task.
+- `fast-mode.ts`: the step loop. One Jev call per step asks a flat `action` choice (`click_<ref>`, `type_<ref>`, scroll, back, done, blocked) plus `goal_done`, `stuck` and `submit_after_typing`. The LLM only writes text for inputs and phrases the final answer.
+- `gates.ts`: Jev yes/no gates in front of LLM calls. A preflight asks "needs the browser?" and "independent sites in parallel?" in one call, skipping the LLM router and split analysis when Jev is confident. An answer check accepts a supported final answer without the LLM reviewer; Jev never rejects on its own.
+
+Control returns to the LLM planner (with a summary of the steps taken) when Jev reports the task blocked or stuck, several actions in a row make no visible change, the next click looks irreversible (buy, pay, delete, send...), there is no starting page, or the step/time budget runs out. Actions that made no change are removed from the options before Jev decides again.
+
+Each Jev step is recorded with `source: "jev"`, and `stepN_jev.json` artifacts keep Jev's probabilities for tuning thresholds. `npm run bench:fast-mode` compares fast mode with the LLM-only agent on the same tasks.
+
+Privacy: in fast mode the page text excerpt, element labels and URLs of every step are sent to TypeSafe (through OpenRouter).
+
 ## Tool Schema Versioning
 
 The agent exposes a stable WebPilot browser tool schema from `lib/tool-schema.ts` instead of scattering raw provider payloads through the runtime. The current schema version is `webpilot.browser-tools.v1`.
diff --git a/README.md b/README.md
index 278a22c..09dfefd 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@ WebPilot is meant to be a hackable, local-first alternative to closed agentic br
 
 - Desktop app built with Electron and Next.js.
 - Browser automation through Playwright MCP, running on the latest stable Playwright.
+- Fast mode: TypeSafe's Jev decision model (through OpenRouter) picks each browser action in ~0.3s while the LLM only writes text, with automatic fallback to the LLM planner.
 - Model providers: OpenRouter (one key for Gemini, Claude, GPT, Qwen, DeepSeek and hundreds more) and local Ollama.
 - Runtime settings UI for provider, model, browser source, profile strategy, headless mode, and isolation.
 - Local run recording with logs, step traces, artifacts, timing, and final results.
@@ -79,6 +80,18 @@ MODEL_BASE_URL=http://127.0.0.1:11434/v1
 
 The settings UI can discover local Ollama models and hides known embedding-only models when Ollama reports enough metadata to identify them.
 
+## Fast Mode
+
+Turn on **Fast mode (Jev)** in Settings (OpenRouter only). Instead of asking the LLM to plan every click, WebPilot asks [Jev](https://openrouter.ai/typesafe/jev-1.13), a decision model that returns a choice with probabilities in about 0.3 seconds. The LLM still writes anything that needs text (search queries, the final answer), and the regular planner takes over whenever Jev is stuck, blocked, or about to click something irreversible.
+
+Measure it on your own tasks:
+
+```bash
+OPENROUTER_API_KEY=sk-or-... npm run bench:fast-mode
+```
+
+In fast mode the page text and element labels of each step are sent to TypeSafe through OpenRouter.
+
 ## Browser Modes
 
 The app supports these runtime browser modes:
@@ -103,6 +116,7 @@ npm run browsers:install
 npm run browser:smoke
 npm run health
 npm run agent:cli -- "Go to https://example.com and summarize the page"
+npm run bench:fast-mode
 npm run mcp:stdio
 npm run desktop:build
 ```
diff --git a/RUNNING.md b/RUNNING.md
index 9bc576a..cc26eed 100644
--- a/RUNNING.md
+++ b/RUNNING.md
@@ -64,6 +64,8 @@ Optional:
 - `MODEL_NAV_MODEL=...`
 - `MODEL_SYNTH_MODEL=...`
 - `MODEL_SYNTH_ENABLED=1`
+- `WEBPILOT_FAST_MODE=1` (Jev picks browser actions; OpenRouter only)
+- `JEV_MODEL=typesafe/jev-1.13`
 - `RUN_STORE_DIR=./agent_runs`
 - `THREAD_STORE_DIR=./agent_threads`
 - `MAX_STEPS=160`
diff --git a/TESTING.md b/TESTING.md
index 8a833bf..598ee8e 100644
--- a/TESTING.md
+++ b/TESTING.md
@@ -22,6 +22,18 @@ This verifies the versioned browser tool schema adapter against current WebPilot
 
 It also covers the OpenRouter/Ollama model client with a mocked `fetch`: request URLs and headers, tool-call round trips including `reasoning_details`, retries on rate limits, error messages, migration of legacy Gemini/OpenAI/Claude settings, and parsing of the OpenRouter models catalog. No API key or network access is needed.
 
+`tests/jev.test.ts` covers fast mode without network access: accessibility-snapshot parsing, candidate selection, the Jev client, the step loop against a fake browser (done, no-progress handoff, irreversible-click guard, typing with submit), and the Jev gates.
+
+## Fast Mode Benchmark
+
+```bash
+npm run browsers:install
+OPENROUTER_API_KEY=sk-or-... npm run bench:fast-mode
+npm run bench:fast-mode -- --only mosaic,voyager --modes fast --repeat 3
+```
+
+Runs a fixed set of public-web tasks (Wikipedia, MDN, example.com) headless in both the LLM-only mode and fast mode, checks each final answer against expected patterns, and writes JSON and Markdown reports with time, steps, LLM calls, Jev calls and fast-mode handoffs to `e2e_reports/`. Model latency on OpenRouter varies run to run, so compare medians over `--repeat 3` or more before drawing conclusions.
+
 ## Deterministic Browser Smoke
 
 ```bash
diff --git a/app/activity/[runId]/page.tsx b/app/activity/[runId]/page.tsx
index 95f3d83..e87ca11 100644
--- a/app/activity/[runId]/page.tsx
+++ b/app/activity/[runId]/page.tsx
@@ -135,6 +135,8 @@ const PERFORMANCE_LABELS: Record<string, string> = {
     synthDurationMs: "Synth time",
     coordinatorCallCount: "Coordinator calls",
     coordinatorDurationMs: "Coordinator time",
+    jevCallCount: "Jev decisions",
+    jevDurationMs: "Jev time",
 };
 
 function formatSize(sizeBytes?: number) {
diff --git a/components/settings/ProviderForm.tsx b/components/settings/ProviderForm.tsx
index 9505560..3a73952 100644
--- a/components/settings/ProviderForm.tsx
+++ b/components/settings/ProviderForm.tsx
@@ -502,6 +502,20 @@ export function ProviderForm() {
         label="Synthesis enabled"
       />
 
+      {provider === "openrouter" && (
+        <div className="min-w-0 space-y-1">
+          <Toggle
+            checked={runtime.fastMode === true}
+            onChange={(v) => update({ fastMode: v })}
+            label="Fast mode (Jev)"
+          />
+          <p className="text-[12px] leading-snug text-wp-text-secondary">
+            Jev, a fast decision model on OpenRouter, picks each browser action in about 0.3s and the navigation model only writes text.
+            It falls back to the normal planner when stuck. Page text and element labels are sent to TypeSafe for each step.
+          </p>
+        </div>
+      )}
+
       <div className="min-w-0 space-y-3 rounded-[var(--wp-radius)] border border-wp-border bg-wp-surface/30 p-3">
         <div className="flex min-w-0 flex-wrap items-center justify-between gap-2">
           <label className="text-xs font-medium text-wp-text-secondary uppercase tracking-wider">
diff --git a/electron/main.cjs b/electron/main.cjs
index 46982c8..ae7eadc 100644
--- a/electron/main.cjs
+++ b/electron/main.cjs
@@ -687,6 +687,7 @@ function runtimeSettingsDefaults() {
         synthModel,
         reviewModel,
         synthEnabled: boolFromInput(process.env.MODEL_SYNTH_ENABLED, true),
+        fastMode: boolFromInput(process.env.WEBPILOT_FAST_MODE, false),
         browser: sanitizeBrowserSettings(),
     };
 }
@@ -697,7 +698,7 @@ function sanitizeRuntimeSettings(value) {
     // Settings saved for Gemini/OpenAI/Claude migrate to OpenRouter defaults:
     // their API keys and model ids are not valid there.
     const input = isLegacyProvider(raw.provider)
-        ? { synthEnabled: raw.synthEnabled, browser: raw.browser }
+        ? { synthEnabled: raw.synthEnabled, fastMode: raw.fastMode, browser: raw.browser }
         : raw;
     const provider = normalizeProvider(input.provider || defaults.provider);
     const providerDefaults = defaultModelsForProvider(provider);
@@ -709,6 +710,7 @@ function sanitizeRuntimeSettings(value) {
         synthModel: typeof input.synthModel === "string" && input.synthModel.trim() ? input.synthModel.trim() : providerDefaults.synthModel,
         reviewModel: typeof input.reviewModel === "string" && input.reviewModel.trim() ? input.reviewModel.trim() : providerDefaults.reviewModel,
         synthEnabled: boolFromInput(input.synthEnabled, defaults.synthEnabled),
+        fastMode: boolFromInput(input.fastMode, defaults.fastMode),
         browser: sanitizeBrowserSettings(input.browser),
     };
 }
diff --git a/lib/agent.ts b/lib/agent.ts
index f68ffff..7975387 100644
--- a/lib/agent.ts
+++ b/lib/agent.ts
@@ -19,6 +19,7 @@ import {
     getRuntimeModelSummary,
     hasRuntimeCredentials,
     missingCredentialsMessage,
+    resolveJevConfig,
     resolveRuntimeModelConfig,
     type RuntimeModelConfig,
     type RuntimeModelOverrides,
@@ -33,6 +34,14 @@ import {
 import { buildThreadContext, ensureThread, updateThreadOnRunFinish, updateThreadOnRunStart } from "./threads";
 import { getBrowserToolDeclarations } from "./tool-schema";
 import { extractExplicitUrls } from "./goal-urls";
+import {
+    runFastMode,
+    summarizeFastModeForPlanner,
+    writeFastModeAnswer,
+    type FastModeBrowser,
+} from "./jev/fast-mode";
+import { parsePage } from "./jev/page";
+import { jevCheckAnswer, jevPreflight, type PreflightResult } from "./jev/gates";
 
 // Env vars
 const DEFAULT_CDP_HTTP = "http://127.0.0.1:9222";
@@ -70,6 +79,8 @@ export interface PerformanceSummary {
     synthDurationMs: number;
     coordinatorCallCount: number;
     coordinatorDurationMs: number;
+    jevCallCount: number;
+    jevDurationMs: number;
 }
 
 export interface AgentState {
@@ -196,9 +207,21 @@ function buildPerformanceSummary(logs: LogEntry[], stepCount: number, wallClockM
     let synthDurationMs = 0;
     let coordinatorCallCount = 0;
     let coordinatorDurationMs = 0;
+    let jevCallCount = 0;
+    let jevDurationMs = 0;
 
     for (const entry of logs) {
         const durationMs = logDurationMs(entry);
+        if (entry.action === "jev_decision") {
+            jevCallCount += 1;
+            jevDurationMs += durationMs;
+            continue;
+        }
+        if (entry.action === "fast_mode_text_written" || entry.action === "fast_mode_start_url" || entry.action === "fast_mode_answer_written") {
+            llmCallCount += 1;
+            llmDurationMs += durationMs;
+            continue;
+        }
         if (routeActions.has(entry.action)) {
             llmCallCount += 1;
             llmDurationMs += durationMs;
@@ -237,6 +260,8 @@ function buildPerformanceSummary(logs: LogEntry[], stepCount: number, wallClockM
         synthDurationMs,
         coordinatorCallCount,
         coordinatorDurationMs,
+        jevCallCount,
+        jevDurationMs,
     };
 }
 
@@ -894,7 +919,40 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
             if (runCtx && plannerThreadContext) {
                 await saveTextArtifact(runCtx, "thread_context.txt", plannerThreadContext);
             }
-            const routeDecision = await routeUserRequest(userGoal, modelConfig, plannerThreadContext);
+            const jevSetup = modelConfig.fastMode ? resolveJevConfig(modelConfig) : null;
+            const fastModeEnabled = !!jevSetup && "jev" in jevSetup;
+            if (jevSetup && "unavailable" in jevSetup) {
+                log("warn", "fast_mode_unavailable", { reason: jevSetup.unavailable });
+            }
+
+            // Fast mode: one Jev call answers "needs the browser?" and "split across
+            // sites?" before any LLM call; the LLM router/coordinator only run when
+            // Jev is not confident.
+            let preflight: PreflightResult | null = null;
+            if (jevSetup && "jev" in jevSetup) {
+                try {
+                    preflight = await jevPreflight(jevSetup.jev, userGoal, plannerThreadContext);
+                    log("info", "jev_decision", {
+                        gate: "preflight",
+                        needsBrowser: Number(preflight.needsBrowserProbability.toFixed(3)),
+                        parallel: Number(preflight.parallelProbability.toFixed(3)),
+                        durationMs: preflight.latencyMs,
+                    });
+                } catch (e: any) {
+                    log("warn", "jev_preflight_failed", { error: shortErr(e) });
+                }
+            }
+
+            // Follow-ups ("now do the same for Firefox") need the LLM router to turn
+            // the message into a complete browser task, so the shortcut is first-turn only.
+            const routeDecision: RequestRouteDecision = preflight?.browse && !plannerThreadContext
+                ? {
+                    mode: "browse",
+                    assistantReply: "",
+                    browserGoal: userGoal,
+                    reason: `Jev preflight: needs_browser=${preflight.needsBrowserProbability.toFixed(2)}`,
+                }
+                : await routeUserRequest(userGoal, modelConfig, plannerThreadContext);
             if (runCtx) {
                 await saveTextArtifact(runCtx, "request_route.json", JSON.stringify({
                     routedAt: nowIso(),
@@ -921,7 +979,11 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
             // COORDINATOR: LLM decides whether goal can be parallelized
             // ================================================================
             let parallelResult: ParallelResult | null = null;
-            parallelResult = await tryParallelExecution(agentGoal, runCtx!, modelConfig, plannerThreadContext, browserSettings);
+            if (preflight?.parallel === false) {
+                log("info", "coordinator_skipped", { reason: `Jev preflight: parallel_sites=${preflight.parallelProbability.toFixed(2)}` });
+            } else {
+                parallelResult = await tryParallelExecution(agentGoal, runCtx!, modelConfig, plannerThreadContext, browserSettings);
+            }
             if (parallelResult) {
                 // Parallel execution handled everything
                 state.finalResult = parallelResult.result;
@@ -1184,8 +1246,30 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
             // TOOL: FINISH
             // ================================================================
             const tool_finish = async ({ result }: { result: string }) => {
-                const review = await reviewFinishResult(
-                    `Original user request:\n${userGoal}\n\nBrowser agent task:\n${agentGoal}`,
+                const reviewTask = `Original user request:\n${userGoal}\n\nBrowser agent task:\n${agentGoal}`;
+                let review: FinishReviewDecision | null = null;
+                if (jevSetup && "jev" in jevSetup && latestObservationSnapshot) {
+                    const observed: NormalizedSnapshot = latestObservationSnapshot;
+                    try {
+                        const check = await jevCheckAnswer(jevSetup.jev, reviewTask, result, observed.url, observed.text || "");
+                        log("info", "jev_decision", {
+                            gate: "answer_check",
+                            supported: Number(check.supportedProbability.toFixed(3)),
+                            durationMs: check.latencyMs,
+                        });
+                        if (check.accept) {
+                            review = {
+                                accept: true,
+                                reason: `Jev answer check: answer_supported=${check.supportedProbability.toFixed(2)}`,
+                                retryInstruction: "",
+                            };
+                        }
+                    } catch (e: any) {
+                        log("warn", "jev_answer_check_failed", { error: shortErr(e) });
+                    }
+                }
+                review ??= await reviewFinishResult(
+                    reviewTask,
                     result,
                     latestObservationSnapshot,
                     modelConfig,
@@ -1282,7 +1366,7 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
                 preUrl,
             }: {
                 name: string;
-                source: "llm" | "seed" | "direct";
+                source: "llm" | "seed" | "direct" | "jev";
                 args: Record<string, unknown>;
                 result: unknown;
                 durationMs?: number;
@@ -1336,9 +1420,152 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
                         preUrl: navigatePreUrl,
                     });
 
+                    // Fast mode reads the page from the accessibility snapshot itself;
+                    // the full observe (two ~1s page evaluations) is only for the planner.
+                    if (!fastModeEnabled) {
+                        state.step++;
+                        const observePreUrl = lastKnownUrl || undefined;
+                        const observeArgs = { maxTextChars: 2800, maxElements: 50 };
+                        const observeStart = Date.now();
+                        initialObservation = await tool_observe(observeArgs);
+                        await recordToolStep({
+                            name: "observe",
+                            source: "seed",
+                            args: observeArgs,
+                            result: initialObservation,
+                            durationMs: Date.now() - observeStart,
+                            preUrl: observePreUrl,
+                        });
+                    }
+                } catch (e: any) {
+                    log("warn", "goal_seed_navigation_failed", { error: shortErr(e) });
+                }
+            }
+
+            // ================================================================
+            // FAST MODE: Jev picks actions, the LLM only writes text
+            // ================================================================
+            let fastModeHandoff = "";
+            if (jevSetup && "jev" in jevSetup) {
+                const writer = createModelClient(modelConfig);
+                const snapshotText = async () => mcpText(await callMcpTool("browser_snapshot", {}));
+                const fastBrowser: FastModeBrowser = {
+                    snapshot: snapshotText,
+                    click: async (ref, element) => mcpText(await callMcpTool("browser_click", { ref, element })),
+                    type: async (ref, element, text, submit) => mcpText(await callMcpTool("browser_type", { ref, element, text, submit, slowly: false })),
+                    pressKey: async (key) => mcpText(await callMcpTool("browser_press_key", { key })),
+                    back: async () => mcpText(await callMcpTool("browser_navigate_back", {})),
+                };
+
+                // Jev can only act on the page in front of it, so give it a starting page.
+                if (!goalUrl && !/^https?:/i.test(lastKnownUrl)) {
+                    const startUrlStart = Date.now();
+                    try {
+                        const suggestion = await withTimeout(
+                            writer.generateText({
+                                model: modelConfig.navModel,
+                                systemInstruction: "You pick the starting web page for a browser automation task. Reply with one absolute https URL and nothing else.",
+                                prompt: `Task: ${agentGoal}\n\nBest page to start from (a site's home or search page is fine):`,
+                            }),
+                            modelConfig.timeoutMs,
+                            "Fast mode start URL"
+                        );
+                        const startUrl = extractExplicitUrls(suggestion)[0] || "";
+                        log("info", "fast_mode_start_url", { url: startUrl || undefined, durationMs: Date.now() - startUrlStart });
+                        if (startUrl) {
+                            state.step++;
+                            const navigateResult = await tool_navigate({ url: startUrl });
+                            await recordToolStep({
+                                name: "navigate",
+                                source: "jev",
+                                args: { url: startUrl },
+                                result: navigateResult,
+                                durationMs: Date.now() - startUrlStart,
+                            });
+                        }
+                    } catch (e: any) {
+                        log("warn", "fast_mode_start_url_failed", { error: shortErr(e) });
+                    }
+                }
+
+                if (/^https?:/i.test(lastKnownUrl)) {
+                    log("info", "fast_mode_started", { jevModel: jevSetup.jev.model, url: lastKnownUrl });
+                    const fast = await runFastMode({
+                        task: agentGoal,
+                        jev: jevSetup.jev,
+                        browser: fastBrowser,
+                        writer,
+                        writerModel: modelConfig.navModel,
+                        writerTimeoutMs: modelConfig.timeoutMs,
+                        log,
+                        checkStop: checkStopOrPause,
+                        onStep: async (step) => {
+                            state.step++;
+                            state.lastAction = step.target ? `${step.operation} ${step.target.description}` : step.operation;
+                            lastKnownUrl = step.page.url || lastKnownUrl;
+                            await recordToolStep({
+                                name: step.operation === "scroll_down" || step.operation === "scroll_up" ? "scroll" : step.operation,
+                                source: "jev",
+                                args: {
+                                    ...(step.target ? { ref: step.target.ref, element: step.target.description } : {}),
+                                    ...(step.text !== undefined ? { text: step.text, submit: step.submit } : {}),
+                                    ...(step.operation.startsWith("scroll") ? { direction: step.operation === "scroll_down" ? "down" : "up" } : {}),
+                                },
+                                result: { ok: step.ok, error: step.error, url: step.page.url, title: step.page.title },
+                                durationMs: step.durationMs,
+                                preUrl: step.preUrl,
+                            });
+                            if (runCtx) {
+                                await saveTextArtifact(runCtx, `step${state.step}_jev.json`, JSON.stringify({
+                                    operation: step.operation,
+                                    target: step.target,
+                                    outcome: step.outcome,
+                                    model: step.decision.model,
+                                    latencyMs: step.decision.latencyMs,
+                                    answers: step.decision.answers,
+                                }, null, 2));
+                            }
+                        },
+                    });
+                    for (const visited of fast.pages) {
+                        pageSummaries.push({ url: visited.url, title: visited.title, textSnippet: visited.text });
+                    }
+
+                    if (fast.outcome === "done") {
+                        const finalPage = parsePage(await snapshotText(), 12000);
+                        latestObservationSnapshot = {
+                            url: finalPage.url,
+                            title: finalPage.title,
+                            text: finalPage.text,
+                            elements: [],
+                            evidence: { dueMentions: [], keyLines: [], instructionBlocks: [] },
+                        };
+                        const answerStart = Date.now();
+                        const answer = await withTimeout(
+                            writeFastModeAnswer(writer, modelConfig.navModel, agentGoal, fast, finalPage.text),
+                            modelConfig.timeoutMs,
+                            "Fast mode answer"
+                        );
+                        log("info", "fast_mode_answer_written", { durationMs: Date.now() - answerStart, resultLength: answer.length });
+                        state.step++;
+                        const finishResult = await tool_finish({ result: answer });
+                        await recordToolStep({
+                            name: "finish",
+                            source: "jev",
+                            args: { result: answer },
+                            result: finishResult,
+                            durationMs: Date.now() - answerStart,
+                            preUrl: lastKnownUrl || undefined,
+                        });
+                        if (finishResult.ok) return;
+                        fastModeHandoff = `${summarizeFastModeForPlanner(fast)}\nFast mode proposed this answer, but review rejected it: ${finishResult.error || "unsupported by the page"}\nProposed answer: ${answer.slice(0, 1000)}`;
+                    } else {
+                        fastModeHandoff = summarizeFastModeForPlanner(fast);
+                    }
+
+                    // The planner needs element refs and page evidence for the current page.
                     state.step++;
-                    const observePreUrl = lastKnownUrl || undefined;
-                    const observeArgs = { maxTextChars: 2800, maxElements: 50 };
+                    const observeArgs = { maxTextChars: 2800, maxElements: 80 };
                     const observeStart = Date.now();
                     initialObservation = await tool_observe(observeArgs);
                     await recordToolStep({
@@ -1347,10 +1574,10 @@ export async function startAgent(goal: string, runtimeOverrides: RuntimeModelOve
                         args: observeArgs,
                         result: initialObservation,
                         durationMs: Date.now() - observeStart,
-                        preUrl: observePreUrl,
+                        preUrl: lastKnownUrl || undefined,
                     });
-                } catch (e: any) {
-                    log("warn", "goal_seed_navigation_failed", { error: shortErr(e) });
+                } else {
+                    log("warn", "fast_mode_handoff", { reason: "No starting page for fast mode." });
                 }
             }
 
@@ -1418,7 +1645,7 @@ Tips:
                     : "";
                 response = await withTimeout(
                     chat.sendMessage(
-                        `Start.\nCurrent request: ${agentGoal}\nOriginal user request: ${userGoal}\n${plannerThreadContext ? `${plannerThreadContext}\n` : ""}${initialObservationText}`
+                        `Start.\nCurrent request: ${agentGoal}\nOriginal user request: ${userGoal}\n${plannerThreadContext ? `${plannerThreadContext}\n` : ""}${fastModeHandoff ? `${fastModeHandoff}\n` : ""}${initialObservationText}`
                     ),
                     modelConfig.timeoutMs,
                     "Initial planner call"
diff --git a/lib/desktop-client.ts b/lib/desktop-client.ts
index 3c1c1b0..148e4b4 100644
--- a/lib/desktop-client.ts
+++ b/lib/desktop-client.ts
@@ -36,6 +36,8 @@ export interface RuntimeSettings {
     synthModel: string;
     reviewModel: string;
     synthEnabled: boolean;
+    /** Fast mode: Jev picks each browser action (OpenRouter only). */
+    fastMode: boolean;
     browser: BrowserRuntimeSettings;
 }
 
@@ -78,6 +80,7 @@ export const DEFAULT_RUNTIME_SETTINGS: RuntimeSettings = {
     baseUrl: defaultBaseUrlForProvider("openrouter"),
     ...defaultModelsForProvider("openrouter"),
     synthEnabled: true,
+    fastMode: false,
     browser: DEFAULT_BROWSER_RUNTIME_SETTINGS,
 };
 
@@ -120,7 +123,7 @@ function normalizeRuntimeSettings(value: unknown): RuntimeSettings {
     // Gemini/OpenAI/Claude settings migrate to OpenRouter defaults; their keys
     // and model ids are not valid there.
     const input: Partial<RuntimeSettings> = isLegacyProvider(raw.provider)
-        ? { synthEnabled: raw.synthEnabled, browser: raw.browser }
+        ? { synthEnabled: raw.synthEnabled, fastMode: raw.fastMode, browser: raw.browser }
         : raw;
     const provider = normalizeProvider(input.provider);
     const modelDefaults = defaultModelsForProvider(provider);
@@ -132,6 +135,7 @@ function normalizeRuntimeSettings(value: unknown): RuntimeSettings {
         synthModel: typeof input.synthModel === "string" && input.synthModel.trim() ? input.synthModel.trim() : modelDefaults.synthModel,
         reviewModel: typeof input.reviewModel === "string" && input.reviewModel.trim() ? input.reviewModel.trim() : modelDefaults.reviewModel,
         synthEnabled: typeof input.synthEnabled === "boolean" ? input.synthEnabled : DEFAULT_RUNTIME_SETTINGS.synthEnabled,
+        fastMode: typeof input.fastMode === "boolean" ? input.fastMode : DEFAULT_RUNTIME_SETTINGS.fastMode,
         browser: sanitizeBrowserRuntimeSettings((input as { browser?: unknown }).browser),
     };
 }
@@ -352,6 +356,7 @@ export function buildRuntimeOverrides(runtime: RuntimeSettings): Record<string,
         synthModel: runtime.synthModel.trim(),
         reviewModel: runtime.reviewModel.trim(),
         synthEnabled: runtime.synthEnabled,
+        fastMode: runtime.fastMode,
     };
     if (runtime.apiKey.trim()) {
         payload.apiKey = runtime.apiKey.trim();
diff --git a/lib/jev/client.ts b/lib/jev/client.ts
new file mode 100644
index 0000000..dfb5a9a
--- /dev/null
+++ b/lib/jev/client.ts
@@ -0,0 +1,179 @@
+/**
+ * Client for TypeSafe's Jev "System One" decision model.
+ *
+ * Jev does not generate text. It takes a JSON `state` plus named, typed
+ * questions and returns typed answers with calibrated probabilities in a
+ * single fast call (typically 0.2-0.5s). Reached through OpenRouter with the
+ * same key as the chat models, or directly at api.typesafe.ai.
+ */
+
+export const DEFAULT_JEV_MODEL = "typesafe/jev-1.13";
+
+export type JevCriteria = Record<string, string>;
+
+export interface JevChoiceQuestion {
+    type: "choice";
+    instructions: string;
+    /** Option id -> description. At most 255 options. */
+    criteria: JevCriteria;
+}
+
+export interface JevNoulQuestion {
+    type: "noul";
+    instructions: string;
+    criteria?: { true?: string; false?: string };
+}
+
+export type JevQuestion = JevChoiceQuestion | JevNoulQuestion;
+
+export interface JevChoiceAnswer {
+    type: "choice";
+    choice: string;
+    probabilities: Record<string, number>;
+    confidence: number;
+}
+
+export interface JevNoulAnswer {
+    type: "noul";
+    noul: number;
+}
+
+export type JevAnswer = JevChoiceAnswer | JevNoulAnswer;
+
+export interface JevDecision {
+    model: string;
+    answers: Record<string, JevAnswer>;
+    inputTokens: number;
+    cost?: number;
+    latencyMs: number;
+}
+
+export interface JevClientConfig {
+    apiKey: string;
+    /** OpenRouter (`https://openrouter.ai/api/v1`) or TypeSafe (`https://api.typesafe.ai/v1`). */
+    baseUrl: string;
+    model: string;
+    timeoutMs: number;
+}
+
+export const JEV_MAX_CHOICE_OPTIONS = 255;
+
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 529]);
+const MAX_RETRIES = 2;
+
+function systemOneUrl(baseUrl: string): string {
+    const clean = baseUrl.trim().replace(/\/+$/, "");
+    return clean.endsWith("/systemone") ? clean : `${clean}/systemone`;
+}
+
+function parseAnswer(raw: unknown): JevAnswer | null {
+    if (!raw || typeof raw !== "object") return null;
+    const answer = raw as Record<string, unknown>;
+    if (answer.type === "choice" && typeof answer.choice === "string") {
+        const probabilities: Record<string, number> = {};
+        if (answer.probabilities && typeof answer.probabilities === "object") {
+            for (const [key, value] of Object.entries(answer.probabilities as Record<string, unknown>)) {
+                if (typeof value === "number" && Number.isFinite(value)) probabilities[key] = value;
+            }
+        }
+        return {
+            type: "choice",
+            choice: answer.choice,
+            probabilities,
+            confidence: typeof answer.confidence === "number" ? answer.confidence : 0,
+        };
+    }
+    if (answer.type === "noul" && typeof answer.noul === "number") {
+        return { type: "noul", noul: answer.noul };
+    }
+    return null;
+}
+
+export function validateQuestions(questions: Record<string, JevQuestion>) {
+    for (const [name, question] of Object.entries(questions)) {
+        if (question.type !== "choice") continue;
+        const count = Object.keys(question.criteria).length;
+        if (count < 2) throw new Error(`Jev choice "${name}" needs at least 2 options.`);
+        if (count > JEV_MAX_CHOICE_OPTIONS) {
+            throw new Error(`Jev choice "${name}" has ${count} options; the limit is ${JEV_MAX_CHOICE_OPTIONS}.`);
+        }
+    }
+}
+
+export async function decide(
+    config: JevClientConfig,
+    state: unknown,
+    questions: Record<string, JevQuestion>
+): Promise<JevDecision> {
+    validateQuestions(questions);
+    const started = Date.now();
+    const deadline = started + config.timeoutMs;
+    const body = JSON.stringify({ model: config.model, state, questions });
+
+    for (let attempt = 0; ; attempt++) {
+        const response = await fetch(systemOneUrl(config.baseUrl), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${config.apiKey}`,
+                "HTTP-Referer": "https://github.com/ahamSel/WebPilot",
+                "X-OpenRouter-Title": "WebPilot",
+            },
+            body,
+            signal: AbortSignal.timeout(Math.max(1, deadline - Date.now())),
+        });
+
+        if (!response.ok) {
+            const delay = Math.min(1000 * 2 ** attempt, 4000);
+            if (RETRYABLE_STATUSES.has(response.status) && attempt < MAX_RETRIES && Date.now() + delay < deadline) {
+                await response.body?.cancel().catch(() => {});
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                continue;
+            }
+            const text = await response.text().catch(() => "");
+            let message = text;
+            try {
+                const parsed = JSON.parse(text) as { error?: { message?: string } | string };
+                message = typeof parsed.error === "string" ? parsed.error : parsed.error?.message || text;
+            } catch {
+                // Keep the raw body.
+            }
+            throw new Error(`Jev request failed (${response.status}): ${message.slice(0, 300)}`);
+        }
+
+        const json = await response.json() as Record<string, unknown>;
+        const rawAnswers = (json.answers && typeof json.answers === "object" ? json.answers : {}) as Record<string, unknown>;
+        const answers: Record<string, JevAnswer> = {};
+        for (const name of Object.keys(questions)) {
+            const parsed = parseAnswer(rawAnswers[name]);
+            if (!parsed) throw new Error(`Jev response is missing an answer for "${name}".`);
+            answers[name] = parsed;
+        }
+        const usage = (json.usage && typeof json.usage === "object" ? json.usage : {}) as Record<string, unknown>;
+        return {
+            model: typeof json.model === "string" ? json.model : config.model,
+            answers,
+            inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+            cost: typeof usage.cost === "number" ? usage.cost : undefined,
+            latencyMs: Date.now() - started,
+        };
+    }
+}
+
+export function choiceAnswer(decision: JevDecision, name: string): JevChoiceAnswer | undefined {
+    const answer = decision.answers[name];
+    return answer?.type === "choice" ? answer : undefined;
+}
+
+export function noulAnswer(decision: JevDecision, name: string): number {
+    const answer = decision.answers[name];
+    return answer?.type === "noul" ? answer.noul : 0;
+}
+
+/** Options ordered from most to least likely. */
+export function rankedChoices(answer: JevChoiceAnswer | undefined): string[] {
+    if (!answer) return [];
+    const entries = Object.entries(answer.probabilities);
+    if (!entries.length) return [answer.choice];
+    return entries.sort((left, right) => right[1] - left[1]).map(([key]) => key);
+}
diff --git a/lib/jev/fast-mode.ts b/lib/jev/fast-mode.ts
new file mode 100644
index 0000000..cfbcdcb
--- /dev/null
+++ b/lib/jev/fast-mode.ts
@@ -0,0 +1,395 @@
+/**
+ * Fast mode: Jev picks each browser action, an LLM only writes text.
+ *
+ * Every step makes one Jev call that answers several typed questions at once
+ * (operation, click target, type target, submit, goal done, stuck). The LLM
+ * is used only to write text for inputs and to phrase the final answer. When
+ * Jev is stuck, blocked, repeating itself, out of budget, or about to take an
+ * irreversible action, the loop hands control back to the LLM planner.
+ */
+
+import type { ModelClient } from "../model-client";
+import {
+    choiceAnswer,
+    decide,
+    noulAnswer,
+    rankedChoices,
+    type JevClientConfig,
+    type JevDecision,
+    type JevQuestion,
+} from "./client";
+import {
+    describeElement,
+    hasSnapshot,
+    parsePage,
+    selectCandidates,
+    type PageElement,
+    type PageModel,
+} from "./page";
+
+export interface FastModeBrowser {
+    snapshot(): Promise<string>;
+    click(ref: string, element: string): Promise<string>;
+    type(ref: string, element: string, text: string, submit: boolean): Promise<string>;
+    pressKey(key: string): Promise<string>;
+    back(): Promise<string>;
+}
+
+export interface FastModeStep {
+    step: number;
+    operation: Operation;
+    target?: { ref: string; description: string };
+    text?: string;
+    submit?: boolean;
+    ok: boolean;
+    error?: string;
+    outcome: string;
+    preUrl: string;
+    page: PageModel;
+    decision: JevDecision;
+    durationMs: number;
+}
+
+export interface FastModeOptions {
+    task: string;
+    jev: JevClientConfig;
+    browser: FastModeBrowser;
+    writer: ModelClient;
+    writerModel: string;
+    writerTimeoutMs: number;
+    maxSteps?: number;
+    timeBudgetMs?: number;
+    log: (level: "debug" | "info" | "warn" | "error", action: string, details?: unknown, duration?: number) => void;
+    checkStop: () => Promise<void>;
+    onStep?: (step: FastModeStep) => Promise<void>;
+}
+
+export interface FastModeResult {
+    outcome: "done" | "handoff";
+    reason: string;
+    page: PageModel;
+    history: HistoryEntry[];
+    steps: number;
+    pages: Array<{ url: string; title: string; text: string }>;
+}
+
+interface HistoryEntry {
+    step: number;
+    action: string;
+    outcome: string;
+}
+
+type Operation = "click" | "type" | "scroll_down" | "scroll_up" | "back" | "done" | "blocked";
+
+/** Jev choices allow 255 options; element actions plus page actions share them. */
+const MAX_ACTION_OPTIONS = 250;
+const DONE_THRESHOLD = 0.85;
+const STUCK_THRESHOLD = 0.85;
+const DEFAULT_MAX_STEPS = 20;
+const DEFAULT_TIME_BUDGET_MS = 120_000;
+const MAX_NO_PROGRESS = 2;
+const HISTORY_LIMIT = 10;
+/** Clicks on controls like these go to the LLM planner instead of being taken on Jev's say-so. */
+const IRREVERSIBLE_ACTION = /\b(buy|purchase|pay|place order|checkout|check out|confirm|delete|remove account|unsubscribe|send|transfer|submit order|book now|reserve)\b/i;
+
+const PAGE_ACTION_CRITERIA: Record<"scroll_down" | "scroll_up" | "back" | "done" | "blocked", string> = {
+    scroll_down: "scroll down: only when the page loads more content as you scroll (feeds, lazy lists) and nothing listed helps yet. Every element on the page is already listed, including ones below the fold.",
+    scroll_up: "scroll up: only to reload content near the top of a lazily loaded page.",
+    back: "go back to the previous page because the current page is a wrong turn.",
+    done: "the task is complete: the current page already shows everything needed to answer, or the requested action is finished.",
+    blocked: "the task cannot continue here: a login wall, CAPTCHA, paywall, error page, or missing page blocks it.",
+};
+
+/** Option ids in the single "action" choice: click_<ref>, type_<ref>, or a page action. */
+function actionCriteria(
+    clickables: PageElement[],
+    typeables: PageElement[],
+    pageActions: Array<keyof typeof PAGE_ACTION_CRITERIA>,
+    pageUrl: string
+): Record<string, string> {
+    const criteria: Record<string, string> = {};
+    for (const element of typeables) criteria[`type_${element.ref}`] = `type into ${describeElement(element, pageUrl)}`;
+    for (const element of clickables) criteria[`click_${element.ref}`] = `click ${describeElement(element, pageUrl)}`;
+    for (const action of pageActions) criteria[action] = PAGE_ACTION_CRITERIA[action];
+    return criteria;
+}
+
+function describeOutcome(before: PageModel, after: PageModel): string {
+    if (after.url !== before.url) return `now on "${after.title || after.url}"`;
+    if (after.signature !== before.signature) return "page content changed";
+    return "no visible change";
+}
+
+function cleanTypedText(raw: string): string {
+    const firstLine = raw.split("\n").map((line) => line.trim()).find(Boolean) || "";
+    return firstLine.replace(/^["'`]+|["'`]+$/g, "").trim();
+}
+
+async function writeFieldText(
+    options: FastModeOptions,
+    page: PageModel,
+    field: string,
+    history: HistoryEntry[]
+): Promise<string> {
+    const started = Date.now();
+    const raw = await options.writer.generateText({
+        model: options.writerModel,
+        systemInstruction: "You fill in a single browser form field for an automation agent. Reply with only the exact text to type, on one line, with no quotes or explanation.",
+        prompt: `Task: ${options.task}
+
+Current page: ${page.title} (${page.url})
+Field: ${field}
+Steps so far:
+${history.map((entry) => `- ${entry.action} -> ${entry.outcome}`).join("\n") || "- none"}
+
+Page text excerpt:
+${page.text.slice(0, 800)}
+
+Text to type:`,
+    });
+    options.log("info", "fast_mode_text_written", { field, durationMs: Date.now() - started });
+    return cleanTypedText(raw);
+}
+
+function buildQuestions(
+    clickables: PageElement[],
+    typeables: PageElement[],
+    pageActions: Array<keyof typeof PAGE_ACTION_CRITERIA>,
+    pageUrl: string
+): Record<string, JevQuestion> {
+    const questions: Record<string, JevQuestion> = {
+        action: {
+            type: "choice",
+            instructions: "Choose the single next browser action that makes the most progress toward completing the task. Prefer clicking or typing into an element that leads directly toward the goal. Use the history to avoid repeating actions that did not help.",
+            criteria: actionCriteria(clickables, typeables, pageActions, pageUrl),
+        },
+        goal_done: {
+            type: "noul",
+            instructions: "Is the task already complete on the current page, so that no further browser action is needed? Answer true only if the page text shows the information or result the task asks for.",
+        },
+        stuck: {
+            type: "noul",
+            instructions: "Is the agent stuck: repeating the same actions without progress, or on a page where no available element can move the task forward?",
+        },
+    };
+    if (typeables.length) {
+        questions.submit_after_typing = {
+            type: "noul",
+            instructions: "If text is typed into the chosen field, should Enter be pressed right after to submit it (as for a search box)? Answer false for fields that are part of a larger form that still needs other fields filled.",
+        };
+    }
+    return questions;
+}
+
+interface ChosenAction {
+    operation: Operation;
+    target?: PageElement;
+    probability: number;
+}
+
+/** Most likely action whose target has not already failed on this page state. */
+function chooseAction(decision: JevDecision, elements: PageElement[], avoid: Set<string>): ChosenAction {
+    const answer = choiceAnswer(decision, "action");
+    for (const option of rankedChoices(answer)) {
+        const probability = answer?.probabilities[option] ?? 0;
+        const elementMatch = option.match(/^(click|type)_(.+)$/);
+        if (elementMatch) {
+            if (avoid.has(option)) continue;
+            const target = elements.find((element) => element.ref === elementMatch[2]);
+            if (target) return { operation: elementMatch[1] as Operation, target, probability };
+            continue;
+        }
+        if (avoid.has(option)) continue;
+        return { operation: option as Operation, probability };
+    }
+    return { operation: "blocked", probability: 0 };
+}
+
+export async function runFastMode(options: FastModeOptions): Promise<FastModeResult> {
+    const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
+    const deadline = Date.now() + (options.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS);
+    const history: HistoryEntry[] = [];
+    const pages: FastModeResult["pages"] = [];
+    // Actions that errored or changed nothing, per URL; skipped when re-deciding.
+    // Keyed by URL rather than page content: dynamic pages (ads, counters) change
+    // their content between snapshots, which would otherwise forget the failure.
+    const failedActions = new Map<string, Set<string>>();
+    let noProgress = 0;
+    let navigated = false;
+
+    const remember = (page: PageModel) => {
+        if (pages[pages.length - 1]?.url !== page.url) pages.push({ url: page.url, title: page.title, text: page.text });
+    };
+    const finish = (outcome: FastModeResult["outcome"], reason: string, page: PageModel, steps: number): FastModeResult => {
+        options.log(outcome === "done" ? "info" : "warn", outcome === "done" ? "fast_mode_done" : "fast_mode_handoff", { reason, steps });
+        return { outcome, reason, page, history: history.slice(), steps, pages };
+    };
+
+    let page = parsePage(await options.browser.snapshot());
+    remember(page);
+
+    for (let step = 1; step <= maxSteps; step++) {
+        await options.checkStop();
+        if (Date.now() > deadline) return finish("handoff", "Fast mode time budget exceeded.", page, step - 1);
+
+        const failedHere = failedActions.get(page.url) || new Set<string>();
+        const pageActions: Array<keyof typeof PAGE_ACTION_CRITERIA> = ["scroll_down", "scroll_up"];
+        if (navigated) pageActions.push("back");
+        pageActions.push("done", "blocked");
+        const typePool = selectCandidates(
+            page.elements.filter((element) => element.kind === "type" && !failedHere.has(`type_${element.ref}`)),
+            options.task,
+            Math.min(40, MAX_ACTION_OPTIONS - pageActions.length)
+        );
+        const clickPool = selectCandidates(
+            page.elements.filter((element) => element.kind === "click" && !failedHere.has(`click_${element.ref}`)),
+            options.task,
+            MAX_ACTION_OPTIONS - pageActions.length - typePool.selected.length
+        );
+
+        const state = {
+            task: options.task,
+            current_page: { url: page.url, title: page.title },
+            page_text_excerpt: page.text,
+            element_list_truncated: clickPool.truncated || typePool.truncated,
+            history: history.slice(-HISTORY_LIMIT),
+        };
+
+        const decisionStart = Date.now();
+        const decision = await decide(options.jev, state, buildQuestions(clickPool.selected, typePool.selected, pageActions, page.url));
+        const chosen = chooseAction(decision, [...clickPool.selected, ...typePool.selected], failedHere);
+        const operation = chosen.operation;
+        const goalDone = noulAnswer(decision, "goal_done");
+        const stuck = noulAnswer(decision, "stuck");
+        options.log("info", "jev_decision", {
+            step,
+            action: chosen.target ? `${operation}_${chosen.target.ref}` : operation,
+            element: chosen.target ? describeElement(chosen.target, page.url).slice(0, 80) : undefined,
+            probability: Number(chosen.probability.toFixed(3)),
+            confidence: choiceAnswer(decision, "action")?.confidence,
+            goalDone: Number(goalDone.toFixed(3)),
+            stuck: Number(stuck.toFixed(3)),
+            candidates: clickPool.selected.length + typePool.selected.length,
+            inputTokens: decision.inputTokens,
+            cost: decision.cost,
+            durationMs: decision.latencyMs,
+        });
+
+        if (operation === "done" || goalDone >= DONE_THRESHOLD) {
+            return finish("done", `Jev judged the task complete (goal_done=${goalDone.toFixed(2)}).`, page, step - 1);
+        }
+        if (operation === "blocked") return finish("handoff", "Jev reported the task is blocked on this page.", page, step - 1);
+        if (stuck >= STUCK_THRESHOLD && step > 2) return finish("handoff", `Jev reported being stuck (stuck=${stuck.toFixed(2)}).`, page, step - 1);
+
+        const before = page;
+        const target: PageElement | undefined = chosen.target;
+        let text: string | undefined;
+        let submit: boolean | undefined;
+        let actionLabel: string = operation;
+        let resultText = "";
+        let ok = true;
+        let error: string | undefined;
+
+        try {
+            if (operation === "click" && target) {
+                const description = describeElement(target, page.url);
+                if (IRREVERSIBLE_ACTION.test(target.name)) {
+                    return finish("handoff", `Next click looks irreversible (${description}); handing to the planner.`, page, step - 1);
+                }
+                actionLabel = `click ${description}`;
+                resultText = await options.browser.click(target.ref, description);
+            } else if (operation === "type" && target) {
+                const description = describeElement(target, page.url);
+                text = await writeFieldText(options, page, description, history);
+                if (!text) return finish("handoff", `Could not decide what to type into ${description}.`, page, step - 1);
+                submit = noulAnswer(decision, "submit_after_typing") >= 0.5;
+                actionLabel = `type "${text}" into ${description}${submit ? " and press Enter" : ""}`;
+                resultText = await options.browser.type(target.ref, description, text, submit);
+            } else if (operation === "scroll_down" || operation === "scroll_up") {
+                resultText = await options.browser.pressKey(operation === "scroll_down" ? "PageDown" : "PageUp");
+            } else if (operation === "back") {
+                resultText = await options.browser.back();
+            }
+        } catch (actionError) {
+            ok = false;
+            error = actionError instanceof Error ? actionError.message.slice(0, 200) : String(actionError);
+        }
+
+        page = parsePage(hasSnapshot(resultText) ? resultText : await options.browser.snapshot());
+        remember(page);
+        if (page.url !== before.url) navigated = true;
+        const outcome = ok ? describeOutcome(before, page) : `failed: ${error}`;
+        history.push({ step, action: actionLabel, outcome });
+
+        const madeProgress = ok && page.signature !== before.signature;
+        if (madeProgress) {
+            noProgress = 0;
+        } else {
+            noProgress += 1;
+            const failed = failedActions.get(before.url) || new Set<string>();
+            failed.add(target ? `${operation}_${target.ref}` : operation);
+            failedActions.set(before.url, failed);
+        }
+
+        await options.onStep?.({
+            step,
+            operation,
+            target: target ? { ref: target.ref, description: describeElement(target, before.url) } : undefined,
+            text,
+            submit,
+            ok,
+            error,
+            outcome,
+            preUrl: before.url,
+            page,
+            decision,
+            durationMs: Date.now() - decisionStart,
+        });
+
+        if (noProgress > MAX_NO_PROGRESS) {
+            return finish("handoff", "Several actions in a row made no visible progress.", page, step);
+        }
+    }
+
+    return finish("handoff", `Fast mode step budget (${maxSteps}) reached.`, page, maxSteps);
+}
+
+/** Phrases the final answer from what fast mode saw; Jev itself cannot write text. */
+export async function writeFastModeAnswer(
+    writer: ModelClient,
+    model: string,
+    task: string,
+    result: FastModeResult,
+    fullPageText: string
+): Promise<string> {
+    const visited = result.pages
+        .map((page, index) => `--- Page ${index + 1}: ${page.title} (${page.url}) ---\n${page.text.slice(0, 1500)}`)
+        .join("\n\n");
+    return writer.generateText({
+        model,
+        systemInstruction: "You write the final answer for a browser automation agent. Answer only from the page content provided. If the content does not contain the answer, say what is missing.",
+        prompt: `Task: ${task}
+
+Actions taken:
+${result.history.map((entry) => `- ${entry.action} -> ${entry.outcome}`).join("\n") || "- none (the answer was already on the first page)"}
+
+Current page: ${result.page.title} (${result.page.url})
+${fullPageText.slice(0, 12000)}
+
+Earlier pages:
+${visited.slice(0, 6000)}
+
+Final answer:`,
+        thinkingBudget: 512,
+    });
+}
+
+export function summarizeFastModeForPlanner(result: FastModeResult): string {
+    const steps = result.history.map((entry) => `- ${entry.action} -> ${entry.outcome}`).join("\n");
+    return `Fast mode (Jev) already worked on this task and handed control to you.
+Reason: ${result.reason}
+Steps taken:
+${steps || "- none"}
+Current page: ${result.page.title} (${result.page.url})
+Continue from the current browser state. Do not repeat steps that already failed.`;
+}
diff --git a/lib/jev/gates.ts b/lib/jev/gates.ts
new file mode 100644
index 0000000..453529a
--- /dev/null
+++ b/lib/jev/gates.ts
@@ -0,0 +1,87 @@
+/**
+ * Jev gates in front of LLM calls that are really yes/no decisions.
+ *
+ * Each gate returns a confident answer when Jev's probability is clearly on
+ * one side, and `undefined` in the uncertain middle so the caller falls back
+ * to the LLM. Jev answers in ~0.3s; the LLM calls these replace take 2-15s.
+ */
+
+import { decide, noulAnswer, type JevClientConfig } from "./client";
+
+export interface PreflightResult {
+    /** true: browse without asking the LLM router; undefined: ask the router. */
+    browse?: boolean;
+    /** false: skip the LLM split analysis; undefined: run it. */
+    parallel?: boolean;
+    needsBrowserProbability: number;
+    parallelProbability: number;
+    latencyMs: number;
+}
+
+const BROWSE_THRESHOLD = 0.8;
+const PARALLEL_SKIP_BELOW = 0.35;
+const ACCEPT_THRESHOLD = 0.8;
+
+export async function jevPreflight(jev: JevClientConfig, message: string, conversationContext: string): Promise<PreflightResult> {
+    const decision = await decide(
+        jev,
+        {
+            user_message: message,
+            conversation_context: conversationContext.slice(0, 4000) || "none",
+            app: "WebPilot is an agentic browser. It can chat with the user directly or control a web browser to navigate, click, type, read pages, and extract information.",
+        },
+        {
+            needs_browser: {
+                type: "noul",
+                instructions: "Does answering the user's current message require controlling a web browser: visiting websites, reading live web pages, clicking, filling forms, or extracting information from the web? Answer false for greetings, questions about the app itself, or requests the assistant can answer from the conversation alone.",
+            },
+            parallel_sites: {
+                type: "noul",
+                instructions: "Does the message ask for two or more independent sub-tasks on different websites that could run at the same time without needing each other's results (for example, compare prices on two different stores)? Answer false for single-site tasks and for steps that depend on each other.",
+            },
+        }
+    );
+    const needsBrowser = noulAnswer(decision, "needs_browser");
+    const parallel = noulAnswer(decision, "parallel_sites");
+    return {
+        browse: needsBrowser >= BROWSE_THRESHOLD ? true : undefined,
+        parallel: parallel < PARALLEL_SKIP_BELOW ? false : undefined,
+        needsBrowserProbability: needsBrowser,
+        parallelProbability: parallel,
+        latencyMs: decision.latencyMs,
+    };
+}
+
+export interface AnswerCheck {
+    /**
+     * true: accept without the LLM reviewer; undefined: ask the reviewer.
+     * Jev never rejects on its own: a wrong rejection sends the task back to
+     * the slow planner loop, so an unconvinced Jev defers to the LLM instead.
+     */
+    accept?: true;
+    supportedProbability: number;
+    latencyMs: number;
+}
+
+export async function jevCheckAnswer(jev: JevClientConfig, task: string, answer: string, pageUrl: string, pageText: string): Promise<AnswerCheck> {
+    const decision = await decide(
+        jev,
+        {
+            task,
+            proposed_answer: answer.slice(0, 3000),
+            page: { url: pageUrl, text: pageText.slice(0, 12000) },
+        },
+        {
+            answer_supported: {
+                type: "noul",
+                instructions: "Does the proposed answer complete the task, with every factual claim in it supported by the page text? Answer false if the answer is speculative, contradicts the page, misses part of what the task asked for, or relies on information that is not on the page.",
+            },
+        }
+    );
+    const supported = noulAnswer(decision, "answer_supported");
+    return {
+        accept: supported >= ACCEPT_THRESHOLD ? true : undefined,
+        supportedProbability: supported,
+        latencyMs: decision.latencyMs,
+    };
+}
diff --git a/lib/jev/page.ts b/lib/jev/page.ts
new file mode 100644
index 0000000..8ef0d2c
--- /dev/null
+++ b/lib/jev/page.ts
@@ -0,0 +1,282 @@
+/**
+ * Turns a Playwright MCP accessibility snapshot into the compact page state
+ * Jev decides on: a numbered list of actionable elements plus a short text
+ * excerpt. Built from the snapshot alone (no extra page evaluation), because
+ * every browser_evaluate call costs ~1s in Playwright MCP.
+ */
+
+export type ElementKind = "click" | "type";
+
+export interface PageElement {
+    ref: string;
+    role: string;
+    name: string;
+    kind: ElementKind;
+    url?: string;
+    value?: string;
+    checked?: boolean;
+    /** Inside a navigation/banner/footer landmark rather than main content. */
+    chrome: boolean;
+    /** Position in document order. */
+    index: number;
+}
+
+export interface PageModel {
+    url: string;
+    title: string;
+    elements: PageElement[];
+    text: string;
+    /** Changes whenever the actionable content of the page changes. */
+    signature: string;
+}
+
+const CLICK_ROLES = new Set([
+    "link",
+    "button",
+    "checkbox",
+    "radio",
+    "tab",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "option",
+    "switch",
+    "treeitem",
+]);
+const TYPE_ROLES = new Set(["textbox", "searchbox", "combobox", "spinbutton"]);
+const CHROME_LANDMARKS = new Set(["navigation", "banner", "contentinfo", "complementary"]);
+const TEXT_ROLES = new Set(["text", "paragraph", "heading", "listitem", "cell", "generic", "strong", "emphasis", "blockquote", "caption", "term", "definition", "code"]);
+
+interface YamlLine {
+    indent: number;
+    role: string;
+    name: string;
+    attrs: Record<string, string>;
+    text: string;
+}
+
+function unquoteYaml(line: string): string {
+    // Lines whose content contains quotes are emitted as YAML single-quoted
+    // scalars: - 'link "\"Title\"" [ref=e1]':
+    const match = line.match(/^(\s*-\s+)'(.*)'(:?)(.*)$/);
+    if (!match) return line;
+    return `${match[1]}${match[2].replace(/''/g, "'")}${match[3]}${match[4]}`;
+}
+
+function parseLine(raw: string): YamlLine | null {
+    const line = unquoteYaml(raw);
+    const match = line.match(/^(\s*)-\s+([a-zA-Z]+)(?:\s+"((?:[^"\\]|\\.)*)")?((?:\s*\[[^\]]*\])*)\s*(?::\s*(.*))?$/);
+    if (!match) return null;
+    const attrs: Record<string, string> = {};
+    for (const attr of (match[4] || "").matchAll(/\[(\w+)(?:=([^\]]*))?\]/g)) {
+        attrs[attr[1]] = attr[2] ?? "true";
+    }
+    let text = (match[5] || "").trim();
+    if (text.startsWith("\"") && text.endsWith("\"") && text.length > 1) text = text.slice(1, -1);
+    return {
+        indent: match[1].length,
+        role: match[2],
+        name: (match[3] || "").replace(/\\"/g, "\""),
+        attrs,
+        text,
+    };
+}
+
+function yamlBlock(snapshotText: string): string[] {
+    const lines = snapshotText.split("\n");
+    const start = lines.findIndex((line) => line.trim() === "```yaml");
+    if (start < 0) return [];
+    const end = lines.findIndex((line, index) => index > start && line.trim() === "```");
+    return lines.slice(start + 1, end < 0 ? undefined : end);
+}
+
+function pageField(snapshotText: string, field: string): string {
+    const match = snapshotText.match(new RegExp(`^- Page ${field}:\\s*(.+)$`, "m"));
+    return match ? match[1].trim() : "";
+}
+
+function hashString(value: string): string {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index++) {
+        hash = ((hash << 5) + hash + value.charCodeAt(index)) | 0;
+    }
+    return (hash >>> 0).toString(36);
+}
+
+export function hasSnapshot(snapshotText: string): boolean {
+    return snapshotText.includes("```yaml");
+}
+
+export function parsePage(snapshotText: string, maxTextChars = 1500): PageModel {
+    const lines = yamlBlock(snapshotText);
+    const elements: PageElement[] = [];
+    const landmarkStack: Array<{ indent: number; role: string }> = [];
+    const mainText: string[] = [];
+    const otherText: string[] = [];
+    let lastElement: PageElement | null = null;
+    let lastElementIndent = -1;
+    // Links/buttons without an accessible name (e.g. `- link [ref=e9]:` wrapping
+    // `- code: Array.prototype.map()`) are named from their descendants' text.
+    const unnamed: Array<{ element: PageElement; indent: number }> = [];
+
+    for (const raw of lines) {
+        const trimmed = raw.trim();
+        if (trimmed.startsWith("- /url:")) {
+            const url = trimmed.slice("- /url:".length).trim().replace(/^"|"$/g, "");
+            if (lastElement && lastElement.role === "link" && !lastElement.url) lastElement.url = url;
+            continue;
+        }
+        const parsed = parseLine(raw);
+        if (!parsed) continue;
+
+        while (landmarkStack.length && landmarkStack[landmarkStack.length - 1].indent >= parsed.indent) {
+            landmarkStack.pop();
+        }
+        while (unnamed.length && unnamed[unnamed.length - 1].indent >= parsed.indent) {
+            unnamed.pop();
+        }
+        const childText = parsed.text || parsed.name;
+        if (childText && unnamed.length) {
+            for (const open of unnamed) {
+                if (open.element.name.length < 100) {
+                    open.element.name = `${open.element.name} ${childText}`.trim();
+                }
+            }
+        }
+        if (CHROME_LANDMARKS.has(parsed.role) || parsed.role === "main") {
+            landmarkStack.push({ indent: parsed.indent, role: parsed.role });
+        }
+        const inChrome = landmarkStack.some((landmark) => CHROME_LANDMARKS.has(landmark.role));
+        const inMain = landmarkStack.some((landmark) => landmark.role === "main");
+
+        const ref = parsed.attrs.ref;
+        const isClick = CLICK_ROLES.has(parsed.role);
+        const isType = TYPE_ROLES.has(parsed.role);
+        if (ref && (isClick || isType) && !parsed.attrs.disabled) {
+            const name = parsed.name || (isType ? "" : parsed.text);
+            {
+                const element: PageElement = {
+                    ref,
+                    role: parsed.role,
+                    name,
+                    kind: isType ? "type" : "click",
+                    value: isType && parsed.text ? parsed.text : undefined,
+                    checked: parsed.attrs.checked === "true" ? true : undefined,
+                    chrome: inChrome,
+                    index: elements.length,
+                };
+                elements.push(element);
+                lastElement = element;
+                lastElementIndent = parsed.indent;
+                if (!name && isClick) unnamed.push({ element, indent: parsed.indent });
+            }
+        } else if (lastElement && parsed.indent <= lastElementIndent) {
+            lastElement = null;
+        }
+
+        // Link names are part of the running text ("a web browser on a [computer]").
+        const textValue = parsed.role === "heading" || parsed.role === "link" ? parsed.name : parsed.text;
+        if (textValue && (TEXT_ROLES.has(parsed.role) || parsed.role === "heading" || parsed.role === "link")) {
+            (inMain && !inChrome ? mainText : otherText).push(textValue);
+        }
+    }
+
+    const collapse = (parts: string[]) => {
+        const out: string[] = [];
+        for (const part of parts) {
+            const clean = part.replace(/\s+/g, " ").trim();
+            if (clean && clean !== out[out.length - 1]) out.push(clean);
+        }
+        return out.join(" ");
+    };
+    // Clickables that never found a name (icon-only buttons) give Jev nothing to go on.
+    const named = elements.filter((element) => element.kind === "type" || element.name);
+    named.forEach((element, index) => {
+        element.name = element.name.replace(/\s+/g, " ").trim();
+        element.index = index;
+    });
+    elements.length = 0;
+    elements.push(...named);
+
+    const text = collapse(mainText.length ? mainText : otherText).slice(0, maxTextChars);
+    const url = pageField(snapshotText, "URL");
+    const signature = `${url}|${elements.length}|${hashString(
+        `${elements.map((element) => `${element.role}:${element.name}:${element.value || ""}:${element.checked ? 1 : 0}`).join(",")}|${text}`
+    )}`;
+
+    return {
+        url,
+        title: pageField(snapshotText, "Title"),
+        elements,
+        text,
+        signature,
+    };
+}
+
+function shortUrl(url: string | undefined, pageUrl: string): string {
+    if (!url) return "";
+    try {
+        const base = new URL(pageUrl);
+        const target = new URL(url, base);
+        return target.host === base.host ? `${target.pathname}${target.search}${target.hash}` : `${target.host}${target.pathname}`;
+    } catch {
+        return url;
+    }
+}
+
+export function describeElement(element: PageElement, pageUrl: string): string {
+    const name = element.name.length > 90 ? `${element.name.slice(0, 87)}...` : element.name;
+    let description = name ? `${element.role} "${name}"` : element.role;
+    if (element.role === "link") {
+        const target = shortUrl(element.url, pageUrl);
+        if (target) description += ` -> ${target.slice(0, 80)}`;
+    }
+    if (element.kind === "type") {
+        description += element.value ? ` = "${element.value.slice(0, 60)}"` : " (empty)";
+    }
+    if (element.checked) description += " (checked)";
+    if (element.chrome) description += " · site navigation";
+    return description;
+}
+
+function tokens(text: string): Set<string> {
+    return new Set(
+        text
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .filter((token) => token.length > 2)
+    );
+}
+
+/**
+ * Picks at most `limit` elements to offer Jev. When a page has more (Wikipedia
+ * articles have ~500 links), prefer main-content elements that share words
+ * with the task, then keep document order so the list still reads like the page.
+ */
+export function selectCandidates(elements: PageElement[], taskText: string, limit: number): { selected: PageElement[]; truncated: boolean } {
+    const unique: PageElement[] = [];
+    const seen = new Set<string>();
+    for (const element of elements) {
+        const key = `${element.kind}|${element.role}|${element.name}|${element.url || ""}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        unique.push(element);
+    }
+    if (unique.length <= limit) return { selected: unique, truncated: false };
+
+    const taskTokens = tokens(taskText);
+    const score = (element: PageElement) => {
+        let value = element.chrome ? 0 : 1;
+        for (const token of tokens(`${element.name} ${element.url || ""}`)) {
+            if (taskTokens.has(token)) value += 3;
+        }
+        return value;
+    };
+    const selected = unique
+        .map((element) => ({ element, score: score(element) }))
+        .sort((left, right) => right.score - left.score || left.element.index - right.element.index)
+        .slice(0, limit)
+        .map((entry) => entry.element)
+        .sort((left, right) => left.index - right.index);
+    return { selected, truncated: true };
+}
diff --git a/lib/model-client.ts b/lib/model-client.ts
index 22caebf..80b35d0 100644
--- a/lib/model-client.ts
+++ b/lib/model-client.ts
@@ -1,3 +1,4 @@
+import { DEFAULT_JEV_MODEL, type JevClientConfig } from "./jev/client";
 import {
     defaultBaseUrlForProvider,
     defaultModelsForProvider,
@@ -21,6 +22,9 @@ export interface RuntimeModelOverrides {
     synthModel?: string;
     reviewModel?: string;
     synthEnabled?: boolean;
+    /** Fast mode: Jev picks each browser action; the LLM only writes text. */
+    fastMode?: boolean;
+    jevModel?: string;
     timeoutMs?: number;
     browser?: BrowserRuntimeOverrides;
 }
@@ -34,6 +38,8 @@ export interface RuntimeModelConfig {
     synthModel: string;
     reviewModel: string;
     synthEnabled: boolean;
+    fastMode: boolean;
+    jevModel: string;
     timeoutMs: number;
 }
 
@@ -44,6 +50,8 @@ export interface RuntimeModelSummary {
     synthModel: string;
     reviewModel: string;
     synthEnabled: boolean;
+    fastMode: boolean;
+    jevModel?: string;
     baseUrl?: string;
     hasApiKey: boolean;
 }
@@ -464,6 +472,8 @@ export function resolveRuntimeModelConfig(overrides: RuntimeModelOverrides = {})
             overrides.synthEnabled ?? process.env.MODEL_SYNTH_ENABLED,
             true
         ),
+        fastMode: boolFromInput(overrides.fastMode ?? process.env.WEBPILOT_FAST_MODE, false),
+        jevModel: String(optionalTrimmedString(overrides.jevModel) || optionalTrimmedString(process.env.JEV_MODEL) || DEFAULT_JEV_MODEL),
         timeoutMs: toTimeoutMs(
             overrides.timeoutMs ?? process.env.MODEL_TIMEOUT_MS,
             120000
@@ -479,6 +489,8 @@ export function getRuntimeModelSummary(config: RuntimeModelConfig): RuntimeModel
         synthModel: config.synthModel,
         reviewModel: config.reviewModel,
         synthEnabled: config.synthEnabled,
+        fastMode: config.fastMode,
+        jevModel: config.fastMode ? config.jevModel : undefined,
         baseUrl: config.baseUrl || undefined,
         hasApiKey: !!config.apiKey,
     };
@@ -497,6 +509,25 @@ export function missingCredentialsMessage(config: RuntimeModelConfig): string {
         : "Missing Ollama base URL. Check the Ollama settings.";
 }
 
+/**
+ * Jev is reached through OpenRouter with the same key as the chat models.
+ * Returns why fast mode cannot run when it is unavailable.
+ */
+export function resolveJevConfig(config: RuntimeModelConfig): { jev: JevClientConfig } | { unavailable: string } {
+    if (config.provider !== "openrouter") {
+        return { unavailable: "Fast mode needs OpenRouter; Jev is not available for local Ollama models." };
+    }
+    if (!config.apiKey) return { unavailable: "Fast mode needs an OpenRouter API key." };
+    return {
+        jev: {
+            apiKey: config.apiKey,
+            baseUrl: config.baseUrl,
+            model: config.jevModel,
+            timeoutMs: Math.min(config.timeoutMs, 20_000),
+        },
+    };
+}
+
 export function createModelClient(config: RuntimeModelConfig): ModelClient {
     return new ChatCompletionsModelClient(config);
 }
diff --git a/lib/recorder.ts b/lib/recorder.ts
index be33839..5a93a7b 100644
--- a/lib/recorder.ts
+++ b/lib/recorder.ts
@@ -32,7 +32,7 @@ export interface RunMetadata {
 export interface StepRecord {
     step: number;
     name: string;
-    source?: "llm" | "seed" | "direct";
+    source?: "llm" | "seed" | "direct" | "jev";
     args: unknown;
     ok: boolean;
     error?: string;
@@ -230,6 +230,8 @@ function sanitizePerformance(value: unknown) {
         "synthDurationMs",
         "coordinatorCallCount",
         "coordinatorDurationMs",
+        "jevCallCount",
+        "jevDurationMs",
     ]);
     return Object.fromEntries(
         Object.entries(value as Record<string, unknown>).filter(([key]) => allowed.has(key))
@@ -271,12 +273,23 @@ const PUBLIC_LOG_ACTIONS = new Set([
     "coordinator_analyzing",
     "coordinator_failed",
     "coordinator_not_parallel",
+    "coordinator_skipped",
     "coordinator_split_response",
     "dispatch_tool",
+    "fast_mode_answer_written",
+    "fast_mode_done",
+    "fast_mode_handoff",
+    "fast_mode_start_url",
+    "fast_mode_started",
+    "fast_mode_text_written",
+    "fast_mode_unavailable",
     "finish",
     "finish_evidence_check",
     "goal_seed_navigation",
     "goal_seed_navigation_failed",
+    "jev_answer_check_failed",
+    "jev_decision",
+    "jev_preflight_failed",
     "launching_browser",
     "mcp_auto_launching",
     "mcp_connected",
diff --git a/package.json b/package.json
index f148ae5..9b3ed57 100644
--- a/package.json
+++ b/package.json
@@ -20,6 +20,7 @@
     "mcp:cli": "node scripts/mcp-cli.js",
     "agent:cli": "node scripts/agent-runner.js",
     "agent:e2e": "node scripts/agent-e2e.js",
+    "bench:fast-mode": "tsx scripts/bench-fast-mode.ts",
     "browser:smoke": "node scripts/browser-smoke.mjs",
     "browsers:install": "node scripts/prepare-playwright-browsers.mjs",
     "desktop:dev": "node scripts/electron-dev.mjs",
diff --git a/scripts/bench-fast-mode.ts b/scripts/bench-fast-mode.ts
new file mode 100644
index 0000000..6d4ebe3
--- /dev/null
+++ b/scripts/bench-fast-mode.ts
@@ -0,0 +1,237 @@
+/**
+ * Compares the LLM-only agent with fast mode (Jev) on the same tasks.
+ *
+ * Usage:
+ *   npm run bench:fast-mode                    # every task, both modes, once
+ *   npm run bench:fast-mode -- --repeat 3      # repeat each task/mode pair
+ *   npm run bench:fast-mode -- --only mosaic,voyager --modes fast
+ *
+ * Needs OPENROUTER_API_KEY (fast mode reaches Jev through OpenRouter) and a
+ * Playwright Chromium (`npm run browsers:install`). Runs headless and writes
+ * JSON + Markdown reports to e2e_reports/. Each task costs a few cents at most.
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getAgentState, requestStop, startAgent } from "../lib/agent";
+
+interface BenchTask {
+    id: string;
+    goal: string;
+    /** Every pattern must match the final answer. */
+    expect: RegExp[];
+}
+
+type Mode = "llm" | "fast";
+
+interface BenchResult {
+    task: string;
+    mode: Mode;
+    run: number;
+    passed: boolean;
+    status: string;
+    wallClockMs: number;
+    steps: number;
+    llmCalls: number;
+    llmMs: number;
+    jevCalls: number;
+    jevMs: number;
+    fastModeOutcome: "done" | "handoff" | "not used";
+    handoffReason?: string;
+    finalResult: string;
+    error?: string;
+}
+
+const TASKS: BenchTask[] = [
+    {
+        id: "example",
+        goal: "Go to https://example.com and tell me the page heading.",
+        expect: [/Example Domain/i],
+    },
+    {
+        id: "mosaic",
+        goal: "Go to https://en.wikipedia.org/wiki/Web_browser and click the link to the Mosaic browser article, then tell me the year Mosaic was released.",
+        expect: [/\b1993\b/],
+    },
+    {
+        id: "voyager",
+        goal: "Search Wikipedia for the Voyager 1 article and tell me its launch date.",
+        expect: [/September 5,? 1977|5 September 1977/i],
+    },
+    {
+        id: "lovelace",
+        goal: "Go to https://en.wikipedia.org, use the search box to find Ada Lovelace, and tell me the year she was born.",
+        expect: [/\b1815\b/],
+    },
+    {
+        id: "openai_founding",
+        goal: "Go to https://en.wikipedia.org/wiki/OpenAI and return the founding year and headquarters city.",
+        expect: [/\b2015\b/, /San Francisco/i],
+    },
+    {
+        id: "altman_drilldown",
+        goal: "Go to https://en.wikipedia.org/wiki/OpenAI, then open Sam Altman's article and tell me his birth year.",
+        expect: [/\b1985\b/],
+    },
+    {
+        id: "apollo11",
+        goal: "Go to https://en.wikipedia.org/wiki/Apollo_11 and tell me who the mission commander was.",
+        expect: [/Armstrong/i],
+    },
+    {
+        id: "mdn_map",
+        goal: "Go to https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array and open the page for the map() method, then tell me what map() returns.",
+        expect: [/new array/i],
+    },
+];
+
+const RUN_TIMEOUT_MS = Number(process.env.BENCH_RUN_TIMEOUT_MS || 240_000);
+
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const value = (flag: string) => {
+        const index = args.indexOf(flag);
+        return index >= 0 ? args[index + 1] : undefined;
+    };
+    const only = value("--only")?.split(",").map((item) => item.trim()).filter(Boolean);
+    const modes = (value("--modes")?.split(",") || ["llm", "fast"]).filter((mode): mode is Mode => mode === "llm" || mode === "fast");
+    return {
+        repeat: Math.max(1, Number(value("--repeat") || 1)),
+        tasks: only?.length ? TASKS.filter((task) => only.includes(task.id)) : TASKS,
+        modes,
+        model: value("--model"),
+    };
+}
+
+async function waitForRun(): Promise<boolean> {
+    const deadline = Date.now() + RUN_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const status = getAgentState().status;
+        if (status !== "running" && status !== "stopping" && status !== "paused") return true;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    requestStop();
+    for (let i = 0; i < 40 && getAgentState().status === "running"; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return false;
+}
+
+async function runOnce(task: BenchTask, mode: Mode, run: number, model?: string): Promise<BenchResult> {
+    await startAgent(task.goal, {
+        provider: "openrouter",
+        ...(model ? { navModel: model, reviewModel: model } : {}),
+        synthEnabled: false,
+        fastMode: mode === "fast",
+        browser: { mode: "managed", headless: true },
+    });
+    const finished = await waitForRun();
+    // Let the run's finally block write the performance summary.
+    for (let i = 0; i < 20 && !getAgentState().performance; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    const state = getAgentState();
+    const performance = state.performance;
+    const logs = state.logs;
+    const handoff = logs.find((entry) => entry.action === "fast_mode_handoff");
+    const done = logs.some((entry) => entry.action === "fast_mode_done");
+    const finalResult = String(state.finalResult || "");
+    const passed = finished && state.status === "done" && task.expect.every((pattern) => pattern.test(finalResult));
+
+    return {
+        task: task.id,
+        mode,
+        run,
+        passed,
+        status: finished ? state.status : "timeout",
+        wallClockMs: performance?.wallClockMs ?? 0,
+        steps: state.step,
+        llmCalls: performance?.llmCallCount ?? 0,
+        llmMs: performance?.llmDurationMs ?? 0,
+        jevCalls: performance?.jevCallCount ?? 0,
+        jevMs: performance?.jevDurationMs ?? 0,
+        fastModeOutcome: done ? "done" : handoff ? "handoff" : "not used",
+        handoffReason: handoff ? String((handoff.details as { reason?: unknown })?.reason || "") : undefined,
+        finalResult: finalResult.slice(0, 500),
+        error: state.lastError || undefined,
+    };
+}
+
+function median(values: number[]): number {
+    if (!values.length) return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}
+
+function seconds(ms: number): string {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function markdownReport(results: BenchResult[], modes: Mode[]): string {
+    const lines: string[] = [];
+    lines.push("| Task | Mode | Pass | Median time | Steps | LLM calls | Jev calls | Fast mode |");
+    lines.push("|---|---|---|---|---|---|---|---|");
+    const taskIds = [...new Set(results.map((result) => result.task))];
+    for (const taskId of taskIds) {
+        for (const mode of modes) {
+            const rows = results.filter((result) => result.task === taskId && result.mode === mode);
+            if (!rows.length) continue;
+            const passes = rows.filter((row) => row.passed).length;
+            const fastOutcome = mode === "fast"
+                ? rows.map((row) => row.fastModeOutcome === "handoff" ? `handoff (${row.handoffReason})` : row.fastModeOutcome).join("; ")
+                : "";
+            lines.push(`| ${taskId} | ${mode} | ${passes}/${rows.length} | ${seconds(median(rows.map((row) => row.wallClockMs)))} | ${median(rows.map((row) => row.steps))} | ${median(rows.map((row) => row.llmCalls))} | ${median(rows.map((row) => row.jevCalls))} | ${fastOutcome} |`);
+        }
+    }
+    lines.push("");
+    for (const mode of modes) {
+        const rows = results.filter((result) => result.mode === mode);
+        if (!rows.length) continue;
+        lines.push(`**${mode}**: ${rows.filter((row) => row.passed).length}/${rows.length} passed, median ${seconds(median(rows.map((row) => row.wallClockMs)))}, total ${seconds(rows.reduce((sum, row) => sum + row.wallClockMs, 0))}`);
+    }
+    return lines.join("\n");
+}
+
+async function main() {
+    if (!process.env.OPENROUTER_API_KEY && !process.env.MODEL_API_KEY) {
+        throw new Error("Set OPENROUTER_API_KEY to run the benchmark.");
+    }
+    const options = parseArgs();
+    const results: BenchResult[] = [];
+
+    for (let run = 1; run <= options.repeat; run++) {
+        for (const task of options.tasks) {
+            for (const mode of options.modes) {
+                process.stdout.write(`[bench] ${task.id} · ${mode} · run ${run} ... `);
+                let result: BenchResult;
+                try {
+                    result = await runOnce(task, mode, run, options.model);
+                } catch (error) {
+                    result = {
+                        task: task.id, mode, run, passed: false, status: "error", wallClockMs: 0, steps: 0,
+                        llmCalls: 0, llmMs: 0, jevCalls: 0, jevMs: 0, fastModeOutcome: "not used", finalResult: "",
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+                results.push(result);
+                console.log(`${result.passed ? "PASS" : "FAIL"} ${seconds(result.wallClockMs)} (${result.status}, llm ${result.llmCalls}, jev ${result.jevCalls}${result.fastModeOutcome === "handoff" ? `, handoff: ${result.handoffReason}` : ""})`);
+            }
+        }
+    }
+
+    const reportDir = process.env.E2E_REPORT_DIR || path.join(process.cwd(), "e2e_reports");
+    await fs.mkdir(reportDir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const markdown = markdownReport(results, options.modes);
+    await fs.writeFile(path.join(reportDir, `bench-fast-mode-${stamp}.json`), JSON.stringify(results, null, 2));
+    await fs.writeFile(path.join(reportDir, `bench-fast-mode-${stamp}.md`), `${markdown}\n`);
+    console.log(`\n${markdown}\n\nReports written to ${reportDir}`);
+    process.exit(0);
+}
+
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});
diff --git a/tests/jev.test.ts b/tests/jev.test.ts
new file mode 100644
index 0000000..128473e
--- /dev/null
+++ b/tests/jev.test.ts
@@ -0,0 +1,312 @@
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { decide, rankedChoices, validateQuestions, type JevClientConfig } from "../lib/jev/client";
+import { describeElement, parsePage, selectCandidates, type PageElement } from "../lib/jev/page";
+import { runFastMode, type FastModeBrowser } from "../lib/jev/fast-mode";
+import { jevCheckAnswer, jevPreflight } from "../lib/jev/gates";
+import type { ModelClient } from "../lib/model-client";
+
+const realFetch = globalThis.fetch;
+afterEach(() => {
+    globalThis.fetch = realFetch;
+});
+
+const JEV: JevClientConfig = {
+    apiKey: "sk-or-test",
+    baseUrl: "https://openrouter.ai/api/v1",
+    model: "typesafe/jev-1.13",
+    timeoutMs: 5000,
+};
+
+interface JevRequest {
+    url: string;
+    body: { model: string; state: Record<string, unknown>; questions: Record<string, { type: string; criteria?: Record<string, string> }> };
+}
+
+/** Each queued responder receives the request and returns Jev `answers`. */
+function mockJev(responders: Array<(request: JevRequest) => Record<string, unknown>>) {
+    const requests: JevRequest[] = [];
+    globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+        const request: JevRequest = { url: String(input), body: JSON.parse(String(init?.body)) };
+        requests.push(request);
+        const responder = responders.shift();
+        if (!responder) throw new Error("Unexpected Jev call");
+        return new Response(JSON.stringify({ model: "typesafe/jev-1.13-test", answers: responder(request), usage: { input_tokens: 100 } }), {
+            status: 200,
+            headers: { "Content-Type": "application/json" },
+        });
+    }) as typeof fetch;
+    return requests;
+}
+
+function choice(option: string, probabilities: Record<string, number> = { [option]: 1 }) {
+    return { type: "choice", choice: option, probabilities, confidence: 0.9 };
+}
+
+function noul(value: number) {
+    return { type: "noul", noul: value };
+}
+
+function snapshot(url: string, title: string, yaml: string): string {
+    return `### Page\n- Page URL: ${url}\n- Page Title: ${title}\n### Snapshot\n\`\`\`yaml\n${yaml}\n\`\`\``;
+}
+
+const HOME = snapshot("https://example.org/", "Home", [
+    "- generic [ref=e1]:",
+    "  - navigation \"Site\" [ref=e2]:",
+    "    - link \"About us\" [ref=e3] [cursor=pointer]:",
+    "      - /url: /about",
+    "  - main [ref=e4]:",
+    "    - heading \"Welcome\" [level=1] [ref=e5]",
+    "    - paragraph [ref=e6]: Read about our",
+    "    - link \"Pricing plans\" [ref=e7] [cursor=pointer]:",
+    "      - /url: https://example.org/pricing",
+    "    - textbox \"Search\" [ref=e8]: shoes",
+    "    - checkbox \"Remember me\" [checked] [ref=e9]",
+    "    - 'link \"\\\"Quoted\\\" title\" [ref=e10] [cursor=pointer]':",
+    "      - /url: https://other.org/story",
+    "    - button \"Buy now\" [ref=e11] [cursor=pointer]",
+    "    - button \"Disabled\" [disabled] [ref=e12]",
+].join("\n"));
+
+const PRICING = snapshot("https://example.org/pricing", "Pricing", [
+    "- main [ref=e1]:",
+    "  - heading \"Pricing\" [level=1] [ref=e2]",
+    "  - paragraph [ref=e3]: The Pro plan costs $10 per month.",
+].join("\n"));
+
+test("parsePage extracts actionable elements, landmarks, links and text", () => {
+    const page = parsePage(HOME);
+    assert.equal(page.url, "https://example.org/");
+    assert.equal(page.title, "Home");
+
+    const byRef = new Map(page.elements.map((element) => [element.ref, element]));
+    assert.deepEqual([...byRef.keys()], ["e3", "e7", "e8", "e9", "e10", "e11"]);
+    assert.equal(byRef.get("e3")?.chrome, true);
+    assert.equal(byRef.get("e7")?.chrome, false);
+    assert.equal(byRef.get("e7")?.url, "https://example.org/pricing");
+    assert.equal(byRef.get("e8")?.kind, "type");
+    assert.equal(byRef.get("e8")?.value, "shoes");
+    assert.equal(byRef.get("e9")?.checked, true);
+    assert.equal(byRef.get("e10")?.name, "\"Quoted\" title");
+    assert.ok(!byRef.has("e12"), "disabled controls are not offered");
+
+    assert.match(page.text, /Welcome Read about our Pricing plans/);
+    assert.doesNotMatch(page.text, /About us/, "main-content text is preferred over navigation");
+
+    assert.equal(describeElement(byRef.get("e7")!, page.url), "link \"Pricing plans\" -> /pricing");
+    assert.equal(describeElement(byRef.get("e3")!, page.url), "link \"About us\" -> /about · site navigation");
+    assert.equal(describeElement(byRef.get("e8")!, page.url), "textbox \"Search\" = \"shoes\"");
+    assert.equal(describeElement(byRef.get("e10")!, page.url), "link \"\"Quoted\" title\" -> other.org/story");
+});
+
+test("page signature changes with content but not with identical snapshots", () => {
+    assert.equal(parsePage(HOME).signature, parsePage(HOME).signature);
+    assert.notEqual(parsePage(HOME).signature, parsePage(HOME.replace("shoes", "boots")).signature);
+});
+
+test("selectCandidates keeps task-relevant main content when it must truncate", () => {
+    const elements: PageElement[] = Array.from({ length: 30 }, (_, index) => ({
+        ref: `e${index}`,
+        role: "link",
+        name: index === 25 ? "Mosaic" : `Link ${index}`,
+        kind: "click" as const,
+        chrome: index < 10,
+        index,
+    }));
+    elements.push({ ...elements[25], ref: "dup", index: 30 });
+
+    const { selected, truncated } = selectCandidates(elements, "open the Mosaic browser article", 5);
+    assert.equal(truncated, true);
+    assert.equal(selected.length, 5);
+    assert.ok(selected.some((element) => element.name === "Mosaic"));
+    assert.ok(selected.every((element) => !element.chrome), "navigation links rank below content");
+    assert.deepEqual(selected.map((element) => element.index), [...selected.map((element) => element.index)].sort((a, b) => a - b));
+
+    const all = selectCandidates(elements, "anything", 100);
+    assert.equal(all.truncated, false);
+    assert.equal(all.selected.length, 30, "duplicate elements are collapsed");
+});
+
+test("Jev client validates questions, parses answers and ranks choices", async () => {
+    assert.throws(() => validateQuestions({ q: { type: "choice", instructions: "x", criteria: { only: "one" } } }), /at least 2/);
+
+    const requests = mockJev([() => ({ pick: choice("b", { a: 0.2, b: 0.7, c: 0.1 }), yes: noul(0.9) })]);
+    const decision = await decide(JEV, { s: 1 }, {
+        pick: { type: "choice", instructions: "pick", criteria: { a: "A", b: "B", c: "C" } },
+        yes: { type: "noul", instructions: "yes?" },
+    });
+    assert.equal(requests[0].url, "https://openrouter.ai/api/v1/systemone");
+    assert.equal(requests[0].body.model, "typesafe/jev-1.13");
+    assert.deepEqual(rankedChoices(decision.answers.pick.type === "choice" ? decision.answers.pick : undefined), ["b", "a", "c"]);
+    assert.equal(decision.answers.yes.type === "noul" && decision.answers.yes.noul, 0.9);
+});
+
+function fakeBrowser(pages: Record<string, string>, start: string) {
+    let current = start;
+    const calls: string[] = [];
+    const browser: FastModeBrowser = {
+        snapshot: async () => pages[current],
+        click: async (ref) => {
+            calls.push(`click ${ref}`);
+            if (ref === "e7") current = "pricing";
+            return "### Ran Playwright code";
+        },
+        type: async (ref, _element, text, submit) => {
+            calls.push(`type ${ref} ${text} ${submit}`);
+            return "### Ran Playwright code";
+        },
+        pressKey: async (key) => {
+            calls.push(`key ${key}`);
+            return "";
+        },
+        back: async () => {
+            calls.push("back");
+            current = start;
+            return "";
+        },
+    };
+    return { browser, calls };
+}
+
+const noWriter = { generateText: async () => "", createToolChat: () => { throw new Error("unused"); } } as unknown as ModelClient;
+
+function fastModeOptions(browser: FastModeBrowser, writer: ModelClient = noWriter) {
+    return {
+        task: "Find the price of the Pro plan",
+        jev: JEV,
+        browser,
+        writer,
+        writerModel: "test-model",
+        writerTimeoutMs: 5000,
+        log: () => {},
+        checkStop: async () => {},
+    };
+}
+
+test("fast mode clicks through to the answer and reports done", async () => {
+    const requests = mockJev([
+        () => ({ action: choice("click_e7"), goal_done: noul(0.02), stuck: noul(0.1), submit_after_typing: noul(0.5) }),
+        () => ({ action: choice("done"), goal_done: noul(0.97), stuck: noul(0.02) }),
+    ]);
+    const { browser, calls } = fakeBrowser({ home: HOME, pricing: PRICING }, "home");
+    const result = await runFastMode(fastModeOptions(browser));
+
+    assert.equal(result.outcome, "done");
+    assert.deepEqual(calls, ["click e7"]);
+    assert.equal(result.page.url, "https://example.org/pricing");
+    assert.equal(result.history[0].outcome, "now on \"Pricing\"");
+    assert.deepEqual(result.pages.map((page) => page.title), ["Home", "Pricing"]);
+
+    const criteria = requests[0].body.questions.action.criteria || {};
+    assert.equal(criteria.click_e7, "click link \"Pricing plans\" -> /pricing");
+    assert.equal(criteria.type_e8, "type into textbox \"Search\" = \"shoes\"");
+    assert.ok("done" in criteria && "blocked" in criteria && !("back" in criteria));
+    assert.ok("back" in (requests[1].body.questions.action.criteria || {}), "back is offered after navigating");
+});
+
+test("fast mode skips actions that did nothing and hands off after repeated no-progress", async () => {
+    const requests = mockJev(Array.from({ length: 4 }, () => () => ({
+        action: choice("click_e3", { click_e3: 0.6, click_e9: 0.3, scroll_down: 0.1 }),
+        goal_done: noul(0.05),
+        stuck: noul(0.2),
+        submit_after_typing: noul(0.5),
+    })));
+    const { browser, calls } = fakeBrowser({ home: HOME }, "home");
+    const result = await runFastMode(fastModeOptions(browser));
+
+    assert.equal(result.outcome, "handoff");
+    assert.match(result.reason, /no visible progress/);
+    assert.deepEqual(calls, ["click e3", "click e9", "key PageDown"], "each failed action is removed before re-deciding");
+    assert.ok(!("click_e3" in (requests[1].body.questions.action.criteria || {})));
+});
+
+test("fast mode hands irreversible clicks to the planner", async () => {
+    mockJev([() => ({ action: choice("click_e11"), goal_done: noul(0.1), stuck: noul(0.1), submit_after_typing: noul(0.5) })]);
+    const { browser, calls } = fakeBrowser({ home: HOME }, "home");
+    const result = await runFastMode(fastModeOptions(browser));
+
+    assert.equal(result.outcome, "handoff");
+    assert.match(result.reason, /irreversible/);
+    assert.deepEqual(calls, []);
+});
+
+test("fast mode asks the LLM for typed text and Jev for submit", async () => {
+    mockJev([
+        () => ({ action: choice("type_e8"), goal_done: noul(0.05), stuck: noul(0.1), submit_after_typing: noul(0.9) }),
+        () => ({ action: choice("blocked"), goal_done: noul(0.05), stuck: noul(0.1), submit_after_typing: noul(0.5) }),
+    ]);
+    const writer = { generateText: async () => "\"pro plan price\"\nextra line", createToolChat: () => { throw new Error("unused"); } } as unknown as ModelClient;
+    const { browser, calls } = fakeBrowser({ home: HOME }, "home");
+    const result = await runFastMode(fastModeOptions(browser, writer));
+
+    assert.deepEqual(calls, ["type e8 pro plan price true"]);
+    assert.equal(result.outcome, "handoff");
+    assert.match(result.reason, /blocked/);
+});
+
+test("Jev gates only shortcut the LLM when confident", async () => {
+    mockJev([
+        () => ({ needs_browser: noul(0.95), parallel_sites: noul(0.05) }),
+        () => ({ needs_browser: noul(0.5), parallel_sites: noul(0.6) }),
+        () => ({ answer_supported: noul(0.9) }),
+        () => ({ answer_supported: noul(0.05) }),
+    ]);
+    const confident = await jevPreflight(JEV, "Go to example.com", "");
+    assert.equal(confident.browse, true);
+    assert.equal(confident.parallel, false);
+
+    const unsure = await jevPreflight(JEV, "hmm", "");
+    assert.equal(unsure.browse, undefined);
+    assert.equal(unsure.parallel, undefined);
+
+    assert.equal((await jevCheckAnswer(JEV, "task", "answer", "https://x", "text")).accept, true);
+    assert.equal((await jevCheckAnswer(JEV, "task", "answer", "https://x", "text")).accept, undefined, "Jev never rejects on its own");
+});
+
+test("links without an accessible name are named from their child text", () => {
+    const page = parsePage(snapshot("https://docs.example/Array", "Array", [
+        "- main [ref=e1]:",
+        "  - term [ref=e2]:",
+        "    - link [ref=e3] [cursor=pointer]:",
+        "      - /url: /docs/Array/map",
+        "      - code [ref=e4]: Array.prototype.map()",
+        "  - definition [ref=e5]:",
+        "    - paragraph [ref=e6]: Returns a new array.",
+        "  - button [ref=e7] [cursor=pointer]:",
+        "    - img [ref=e8]",
+    ].join("\n")));
+
+    const link = page.elements.find((element) => element.ref === "e3");
+    assert.equal(link?.name, "Array.prototype.map()");
+    assert.equal(link?.url, "/docs/Array/map");
+    assert.ok(!page.elements.some((element) => element.ref === "e7"), "icon-only buttons with no text are dropped");
+    assert.deepEqual(page.elements.map((element) => element.index), page.elements.map((_, index) => index));
+});
+
+test("fast mode does not retry a failing click when the page content keeps changing", async () => {
+    let counter = 0;
+    const requests = mockJev(Array.from({ length: 3 }, () => () => ({
+        action: choice("click_e3", { click_e3: 0.5, click_e7: 0.4, scroll_down: 0.1 }),
+        goal_done: noul(0.05),
+        stuck: noul(0.2),
+        submit_after_typing: noul(0.5),
+    })));
+    const calls: string[] = [];
+    const browser: FastModeBrowser = {
+        // Every snapshot differs (e.g. a live counter), like a dynamic page.
+        snapshot: async () => HOME.replace("Read about our", `Read about our (${counter++})`),
+        click: async (ref) => {
+            calls.push(`click ${ref}`);
+            if (ref === "e3") throw new Error("Timeout 5000ms exceeded");
+            return "";
+        },
+        type: async () => "",
+        pressKey: async () => "",
+        back: async () => "",
+    };
+    await runFastMode({ ...fastModeOptions(browser), maxSteps: 2 });
+
+    assert.deepEqual(calls, ["click e3", "click e7"]);
+    assert.ok(!("click_e3" in (requests[1].body.questions.action.criteria || {})));
+});