Jev 101 logo
Jev 101

Guides / illustrated walkthrough

Ultra-Fast Browser Agents with Jev: 178ms DOM Loops & Dual Model Orchestration

How the Jev Ultrafast GitHub repo replaces VLM screenshot polling with filtered DOM snapshots, parallel sampler action mapping, RLCD-calibrated confidence, and dual System One / System Two orchestration.

Quick takeaway

Vision-language browser agents fail in production because screenshot polling and autoregressive JSON generation are slow and hallucination-prone. Jev Ultrafast captures a filtered DOM snapshot, maps parallel sampler outputs to indexed actions (178ms decision loop on Google Flights), calibrates confidence via RLCD, and delegates text generation to a System Two LLM while Jev handles clicks and scrolls.

Video source

Alex Hitt

8:48NFKHLhAvj1g
Visit channelWatch original

Step-by-step walkthrough

  1. 1

    Benchmark the sequential VLM loop against Jev Ultrafast

    A Zurich→London Google Flights task measured the old sequential perceive-and-generate loop at 9.45s end-to-end. Migrating to parallel Jev decisions cut total time 25% to 7.09s, with the internal AI decision loop at just 178ms. Protocol calls dropped ~90%, driving token cost to fractions of a cent per action—enabling continuous event-driven monitoring instead of hourly batch jobs.

    Google Flights browser agent benchmark overlay showing 178 millisecond Jev decision loop time after migrating from sequential VLM screenshot polling to parallel structured sampling.
    Google Flights benchmark: 178ms decision loop, 90% fewer protocol calls.Watch at 0:30
  2. 2

    Replace screenshot polling with filtered atomic DOM snapshots

    Traditional agents base64-encode screenshots every turn, triggering heavy layout passes. Jev Ultrafast runs a JavaScript utility that captures one atomic DOM snapshot—actionable elements, ARIA labels, state values—truncating offscreen nodes to preserve context window. Snapshots retain live references to browser memory nodes, eliminating fragile XPath/CSS selector generation. Trade-off: WebGL canvases and complex visualizations are invisible to this read path.

    Filtered atomic DOM snapshot array highlighting actionable Aria labels and on-screen element indices while offscreen nodes are truncated for Jev token efficiency.
    Structured DOM array: indexed targets with offscreen truncation for token budget.Watch at 1:55
  3. 3

    Map parallel sampler outputs to valid actions—zero hallucinated targets

    Autoregressive JSON invites invented selectors and malformed types. Jev ingests the state array in one parallel pass, emitting values across decision heads constrained to predetermined operations (click, scroll, type_text). Each action couples to a valid index from the snapshot—hallucinating a non-existent target is structurally impossible at the output layer. Sub-20ms inference trades generative freedom for type-safe state transitions.

    Jev parallel sampler architecture mapping decision heads to click and scroll actions indexed against valid DOM snapshot targets to prevent hallucinated CSS selectors.
    Parallel sampler: action head + DOM index—no free-form selector strings.Watch at 3:35
  4. 4

    Orchestrate dual models and physical execution guardrails

    System One Jev cannot generate open-ended text—if type_text is chosen, the loop pauses and a System Two LLM synthesizes "Zurich" before execution resumes. Production guardrails include click occlusion verification (block clicks covered by modals/sticky headers) and stale-page fingerprinting (retry when React hydration mutates the DOM mid-flight). A local inspector overlays live probability percentages on interactable elements for epistemic transparency.

    Dual model browser agent loop where System One Jev selects a type_text action then pauses for System Two LLM to generate Zurich before resuming the ultrafast execution cycle.
    Dual model: Jev decides action type; System Two LLM fills text fields.Watch at 6:05

Frequently asked questions

Why not just use a bigger vision model for browser agents?

Scaling parameters does not remove autoregressive generation latency. The flight-search benchmark shows sub-second loops require structured sampling over DOM state, not heavier screenshot encoders sending base64 frames each turn.

What blind spots does DOM snapshot filtering introduce?

WebGL scenes, HTML5 canvas games, and rich data visualizations outside standard HTML hierarchies may be invisible. The architecture intentionally trades comprehensive visual context for ingest speed—acceptable for form-heavy enterprise portals, risky for canvas-only UIs.

How does RLCD change confidence thresholds in browser automation?

RLCD aligns reported confidence with empirical success rates. When Jev outputs 90% confidence on a target button, aggregate accuracy should near 90%—enabling deterministic rules: auto-click above threshold, escalate to human or fallback model below.

What happens if a modal covers the target button?

Click occlusion verification inspects geometry before dispatch. If a sticky header or ad modal overlaps the node, execution is blocked proactively rather than firing a click into the wrong layer—pairing speed with physical safety on hostile modern web pages.

Related guides

Jev Classification Quickstart

OpenRouter API walkthrough for Choice, Score, and Noul primitives.

Read

Jev Trader: Subsecond Trading Bot

Market-making bot on Monad with an 18ms read loop and 300ms block window.

Read

Awesome Jev Projects

Community browser agents, routers, and ultrafast automation repos.

Read

More video walkthroughs