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
Step-by-step walkthrough
- 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 benchmark: 178ms decision loop, 90% fewer protocol calls.Watch at 0:30 - 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.
Structured DOM array: indexed targets with offscreen truncation for token budget.Watch at 1:55 - 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.
Parallel sampler: action head + DOM index—no free-form selector strings.Watch at 3:35 - 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: 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.