Lately, long posts about Jev have been flooding the entire internet, but there might still be friends out there looking totally confused, just wanting to know what exactly Jev can be used for?

I’ve put together 20 case studies to help everyone out. Some use it to check flight tickets and assign work orders, others have it play Mario or control simulated rocket landings. It’s a blooming garden of variety!

The GitHub repo and original post are linked below—feel free to check them out as needed.

1. Checking a flight takes about 7 seconds｜jev-ultrafast

A high-speed browser Agent built with Browser Use. Jev only decides “what to do, which element to click” at each step, calling a small model only when typing is needed. Searching a flight on Google Flights takes about 7 seconds, $0.0039.

https://github.com/browser-use/jev-ultrafast…

2. Cleaning up context for Claude Code｜fast-jev-compaction

Have Jev judge whether the content of each tool call is still useful, and delete what’s not. The remaining original text isn’t rewritten—it just decides which segments to delete and which to keep.

https://github.com/tamaratran/fast-jev-compaction…

3. For every new block, ask once: buy or sell｜jev-trader

Runs on Monad, with model latency around 81ms. See if the model can keep up with making a decision for every single block.

https://github.com/jarrodwatts/jev-trader…

4. Let Jev operate a Mac｜typesafe-computer-use

Uses OCR to read screen text, then has Jev pick the next action, calling the writing model only when typing is needed. The author reports about $0.0002 per step, compared to Opus 5 at about $0.032.

https://github.com/awlevin/typesafe-computer-use…

5. Reviewing chat messages, dispatching alerts｜jev-experiments

A collection of experiments by Nader Dabit. One handles Twitch-scale chat moderation, about 300 messages/second; the other is emergency dispatching, assigning 275 alerts within 180 seconds. These tasks all require processing large volumes of info continuously, judging each one.

https://github.com/dabit3/jev-experiments…

6. Have Jev watch over Codex while it works｜foreman

Codex is doing the work, Jev is supervising on the side: Is it really done? Did the tests run? Did it go off track or get stuck?

https://github.com/thruwire/foreman…

7. Before code review, pick out high-risk changes｜jev-review

First, let Jev scan the code changes and flag the high-risk parts, then hand them off to a more expensive large model or human for close inspection, complete with a local dashboard.

https://github.com/devagrawal09/jev-review…

8. Let Jev play Mario｜typesafe-mario

Reads structured state from the emulator’s RAM, then decides whether to run, jump, or dodge.

https://github.com/fhshaik/typesafe-mario…

9. Have Jev tap step-by-step on Android｜mobile-jev

A step-by-step clicking Agent on Android. The author demoed using it to navigate an Uber route, about 21 seconds, 9 steps.

https://github.com/droidrun/mobile-jev…

10. For this task, which model should handle it? Let Jev take a look first｜jev-router

First judge how difficult this round of programming tasks is, then decide which model to assign it to. Use cheap ones for simple stuff, stronger ones for complex tasks.

https://github.com/gargpratyush/jev-router…

11. Filter data in a database with natural language｜pg-jev

Embed Jev right into Postgres, using WHERE jev(…) to filter rows by natural language conditions—no need to build vector columns first.

https://github.com/realZachi/pg-jev…

12. Give Codex a skill for operating a computer｜Jev-cu

Jev picks the next action from screen text, with sensitive operations checked locally first.

https://github.com/Sac-Y/Jev-cu

13. 724 live-stream ads, analyzed in 40 seconds

@TheMattBerman handed 724 ads from 37 brands to Jev, analyzing hooks, formats, quotes, CTAs, awareness stages, and whether landing pages match, for about $0.09.

https://x.com/TheMattBerman/status/2100654891756589230…

14. Dig up your own 3,282 past posts for a review session

@iannuttall fed his cumulative ~100 million-view posts to Jev, asking 8 questions per post. Took 8 minutes 34 seconds, $0.13.

One result: How-to tutorial posts had a median of 150 likes, vs. 44 for all posts. At least in his batch, the difference is pretty clear.

https://x.com/iannuttall/status/2100668908227162567…

15. Today’s news—which ones relate to my brand?

@SUOHA_AI used the day’s news feed to judge “can we piggyback?” for 15 brands. The author reports Jev processed 428 items in 28 seconds, while DeepSeek Flash did 6 in the same time.

https://x.com/SUOHA_AI/status/2101000339948282090…

16. 500 e-commerce work orders—see who assigns fastest

@NFT_Chen ran a comparison on the same order-dispatching task: Jev handled 500 in 83 seconds, $0.01; DeepSeek V4.1 Flash did 173 in the same time, $0.06.

https://x.com/NFT_Chen/status/2101253568774697099…

17. Given a random URL, fill out a 16-question survey in 38 seconds

Another from @SUOHA_AI. Jev decides “what to click here,” with the small model only writing for fill-ins; the demo was fully hands-off.

https://x.com/SUOHA_AI/status/2101640575812239406…

18. Even simulated rocket landings got a try

@uttkarsh_42 handed a Falcon 9-level simulated booster to Jev, deciding whether to ignite, how many engines to fire, when to deploy legs.

Landed after 12 trials, 245 calls, $0.04.

https://x.com/uttkarsh_42/status/2100690568947159309…

19. Use voice to direct browser clicks｜jev-voice-browser

A demo by @moritzkremb: Speak, transcribe, Jev returns probabilities in about 300ms, then Playwright clicks. About $0.0002 per decision, and the repo is open-source too.

https://x.com/moritzkremb/status/2100577979021832365…

https://github.com/moritzkremb/jev-voice-browser…

20. Jev official explanation

The original post by Jev author @CompleteSkeptic. If you want to figure out exactly what it’s doing, start here: It doesn’t chat, doesn’t write text, just makes judgments for programs.

https://x.com/CompleteSkeptic/status/2099925682726002904…

Plus two more case study collection links—if you want even more examples, head there:

https://hermes-ai.net/zh/jev/

https://github.com/MrJev/awesome-jev…

browser-use/jev-ultrafast

Source: https://github.com/browser-use/jev-ultrafast

Jev Ultrafast ⚡

The Browser Use Cloud waitlist is open. Get early access to ultrafast browser agents in the cloud. Join the waitlist →

A browser agent with a dynamic, indexed action space.

Give it one goal. TypeSafe’s Jev picks an operation and an element. A small LLM writes text only when the operation is TYPE_TEXT.

Zürich → London on Google Flights in 7.1 seconds. One natural-language goal, actual text generation, and loading waits included.

Watch the MP4 · Measurements · Read the loop

The action space

Every observation produces a new element table:

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

The operations are CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED. Only supported operations and targets are offered.

                      one TypeSafe request
                     ┌───────────────────────────┐
page → element table → operation                 │
                     │ click_target              │
                     │ type_text_target          │
                     │ select_target, if present │
                     └─────────────┬─────────────┘
                         use the matching target
                                   │
                    CLICK [7] ─────┤──→ browser
                TYPE_TEXT [3] ─────┘
                          ↓
                   small LLM → text → browser

Target questions are speculative. If the operation is CLICK, only click_target can execute. Two decisions, one network round trip. Each target head contains only compatible elements. Native dropdown choices carry an observed element/option index.

There are no site-specific action scripts or prepared field strings in the policy. The Flights example supplies a goal and independently verifies the outcome. The screenshot renderer adds labels afterward; it does not drive the browser.

Try it

git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast
uv sync
cp .env.example .env
# Add TYPESAFE_API_KEY and TEXT_MODEL_API_KEY.
uv run jev

Open http://127.0.0.1:8766 and click Start demo → Run automatically. The inspector shows numbered elements, operation probabilities, target probabilities, and executed actions. Choose next pauses before execution.

Chrome connects through Browser Harness, installed by uv sync. Run uv run browser-harness --doctor if it needs connecting. Allow remote debugging in Chrome when prompted.

TEXT_MODEL_API_KEY is an OpenRouter key in the example configuration. The current demo uses inception/mercury-2.5 with reasoning disabled. Gemini, GLM, and DeepSeek can also use the OpenAI-compatible text helper; configure the appropriate model, endpoint, and reasoning setting.

Use the library

from jev_ultrafast import Agent

with Agent(
    "https://www.google.com/travel/flights?hl=en",
    "Find one-way flights from Zurich to London on September 20, 2026, "
    "for one adult in economy. Stop when matching flight options are visible.",
) as agent:
    for state in agent.run():
        print(state["elapsed_ms"], state["status"])

Run with uv run --env-file .env python your_script.py. The same policy can run a different task:

uv run --env-file .env python examples/run.py \
  --url https://en.wikipedia.org/wiki/Main_Page \
  --goal 'Find and open the Wikipedia article about Gödel’s incompleteness theorems.'

uv run --env-file .env python examples/flights.py --keep-open performs the flight search, checks the actual route/date/results, and saves its trace. It does not select or book a flight.

Why it moves

• One request per decision cycle. Operation and target heads share the same observed state.
• No screenshots in the default agent loop. Jev consumes structured state. The inspector opts into screenshots; the video uses a separate continuous screencast.
• One browser call per snapshot. Read visible controls, their names, values, and text atomically. Keep references to the actual DOM nodes.
• Validate the selected target. Clicks check the document, form values, target, and nearby context. Animation alone does not force another prediction. Resolve current geometry and reject covered controls before input.
• Wait for useful state. After typing into a combobox, wait for visible suggestions, capped at 200 ms. Other interactions get at most two animation frames or 50 ms. These reads happen after execution is logged.
• Keep hidden tabs rendering. Focus emulation prevents background animation throttling without switching Chrome’s visible tab.
• Send visible text. Offscreen article bodies and footers do not fill the model context.
• Reuse an interrupted text request. A generated value survives a stale-page retry only if the entire text-helper input is unchanged.

Every executed target is resolved from an observed node. The executor rechecks page freshness and click occlusion. Model output never becomes selectors, coordinates, shell commands, or executable JavaScript. Text-helper output must parse as a small JSON object before typing.

Small enough to read

Evidence and limits

The current video is a 7,073 ms Google Flights run. Timing starts after initial page observation and includes model calls, generated text, browser work, stale decisions, and loading waits. A fresh independent check verifies the one-way setting, Zürich, London, September 20, 2026, and visible flight options. The video plays at 1×, with no opening hold and a 0.5-second final hold.

In six alternating runs with identical models and settings, both versions passed 3/3. Median task time went from 9.450 s → 7.092 s, a 25% reduction; median browser protocol calls went from 1,092 → 101. This is three repeats of one task on one browser profile, not a general reliability benchmark.

The same policy opened the requested Wikipedia article in 2.798 s and passed a local hotel search/filter task in 1.896 s. Runs, failures, source hashes, and measurement boundaries are in performance.md.

A DONE choice still requires independent outcome verification. The DOM reader handles common HTML and ARIA controls, not the full accessible-name specification. Shadow roots, frames, canvas, uploads, pop-up tabs, nested scrolling, and arbitrary keyboard widgets remain outside this MVP. Owned tabs share the existing Chrome profile.

Development

uv run ruff check .
uv run pytest
node --check jev_ultrafast/static/app.js
node --check jev_ultrafast/snapshot.js
uv build

Tests are offline. uv run python scripts/check_guards.py checks real controls in a local browser without model calls. Live examples and recording scripts make paid API calls. scripts/record_flights.py <new-folder> captures original browser timestamps; scripts/render_demo.py <recording-folder> renders that verified run at 1× and crops out the Google account strip. Credentials and raw traces stay ignored.

Browser Use · Browser Harness · TypeSafe speculative fan-out

金尘马 (@jinchenma_ai): 纯口喷解读。继文字、图片、音频、视频模型之后，又一个可能改变 Agent 格局的新模型类型来了！System One Models