<- all tokdocs
2026.09.18@github.awesome

Jev Ultrafast: Browser Use's DOM-Indexed Agent That Picks an Action and a Target in One Request

AI
Watch on TikTok

View on TikTok ->

Jev Ultrafast replaces the screenshot-and-reason loop of most browser agents with a numbered table of DOM elements and a single model call that returns both an operation and a target. The repo is browser-use/jev-ultrafast, MIT licensed, from the same organization behind the Browser Use library. The video shows the README scrolling past a Google Flights demo that books a Zürich to London search in 7.1 seconds. The repo's own measurement doc is more careful than the video is, and reading it changes what the number means.

How the loop actually works

Each cycle starts with a DOM snapshot rather than a screenshot. snapshot.js reads the page and produces an element table with integer indices, visible names, and current values. The README shows the shape of it:

[1] button    Change ticket type · Round trip
[2] combobox  Where from?       · San Francisco
[3] combobox  Where to?         · empty
[4] textbox   Departure         · empty

That table plus the goal goes to TypeSafe's Jev model as one request with two question heads: which operation to run, and which indexed element to run it on. The supported operations are CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED. Only elements compatible with the chosen operation appear in that operation's target distribution, so a CLICK head cannot return a text input. A separate small LLM generates free-form text only when the operation is TYPE_TEXT, which is how "Zurich" and "London" get written into the flight form.

The model never emits a CSS selector, an XPath, a coordinate pair, or executable JavaScript. It emits an index into a table the harness built, and the executor resolves that index back to the live DOM node it observed. The README states this directly: "Model output never becomes selectors, coordinates, shell commands, or executable JavaScript."

What TypeSafe's Jev is, and why it matters here

Jev is not a chat model with a JSON mode bolted on. TypeSafe's docs describe it as a "System One" model that answers typed questions against a state and returns probability distributions instead of prose. It exposes three primitives: Choice for picking from options, Score for numeric evaluation, and Noul for truth values from 0 to 1. Multiple questions evaluate in parallel inside one call, which the docs say "barely changes the response time."

That design is the whole reason the operation and target decision fits in one round trip. Asking a general LLM to return a structured action means generating tokens, waiting for them, and parsing the result. Asking Jev means getting back two distributions your code can branch on. The performance doc records a median Jev latency of 178 ms across the recorded run.

The 7.1 second number, unpacked

The video shows the timer counting up next to the Flights page and ends around the 7 second mark. The repo's performance doc gives the real methodology, and it is narrower than a benchmark.

Three matched pairs of runs, six runs total, on one Google Flights task with the same natural-language goal and a 1120x780 viewport. Median task time moved from 9.450 s to 7.092 s, a 25% reduction. Median browser protocol calls dropped from 1,092 to 101, which is the larger structural win. Median TypeSafe requests went from 22 to 17. The recorded run used jev-1.13.0 with Mercury 2.5 as the text helper, reasoning disabled, and the helper text calls cost $0.00006272.

The doc itself states the limit: "Three pairs are too few for a strong statistical claim (two-sided sign-test p = 0.25)." Timing also starts after initial page observation and excludes browser setup, initial navigation, and the post-run verification. The 7.1 seconds is real for that task on that profile. It is not a cross-site reliability benchmark, and the repo does not claim it is.

What the video leaves out

Two things worth knowing before you clone it. First, this needs two API keys, TYPESAFE_API_KEY and TEXT_MODEL_API_KEY. The Jev model is a hosted third-party service, so the speed claim is tied to TypeSafe's infrastructure rather than something you can reproduce with a local model. The text helper is OpenAI-compatible and the README says Gemini, GLM, and DeepSeek work there too.

Second, the DOM reader covers common HTML and ARIA controls, not the full accessible-name specification. The README lists what breaks: shadow roots, iframes, canvas, file uploads, pop-up tabs, nested scrolling, and arbitrary keyboard widgets. A canvas-heavy app or an iframe-wrapped checkout is outside what an indexed element table can see, and that is exactly the case where vision models still earn their latency.

The repo also includes a local inspector at http://127.0.0.1:8766 that shows numbered elements, operation probabilities, target probabilities, and executed actions, with a "Choose next" mode that pauses before each execution. That is the piece most worth running if you want to understand the loop rather than trust the demo.

Traction and provenance

The frames in the video show 2.3k stars, 125 forks, and a top commit from gregpr07 dated "yesterday." As of 19 September 2026 the repo shows 6.6k stars and 424 forks, so it roughly tripled in the days around this clip. gregpr07 is Gregor Žunič, co-founder of Browser Use with Magnus Müller. The same organization ships Browser Harness at 17.7k stars, which is what Jev Ultrafast uses to connect to Chrome over the DevTools Protocol.

Key Takeaways

  • The core idea is an indexed element table plus two parallel decision heads, so the model picks an operation and a compatible target in one request instead of writing out a selector or coordinate.
  • Browser protocol calls dropped from a median of 1,092 to 101, which is a bigger architectural change than the 25% wall-clock improvement suggests.
  • The 7.1 second Google Flights run is three matched pairs on one task, and the repo's own doc calls the sign-test result (p = 0.25) too weak for a strong statistical claim.
  • A general LLM is still in the loop for typing text, so TYPE_TEXT steps add a second model call on top of the Jev request.
  • Shadow DOM, iframes, canvas, uploads, and nested scrolling are unsupported, so this does not replace vision-based agents on every site.
  • Unverified: I could not independently confirm any third-party framing of a "90% cost reduction" that appears in aggregator coverage. The repo reports a per-run helper cost of $0.00006272 and does not publish a cost comparison against a screenshot baseline.
  • Unverified: TypeSafe's Jev latency and pricing come from the vendor's docs and the repo's own logs. I found no third-party reproduction of the 178 ms median.

Resources

Published September 18, 2026. Writeup generated from a favorited TikTok.