Jev Ultrafast GitHub: The Official Repo, How It Works, And The Models To Pair With It

The Jev Ultrafast GitHub repo is github.com/browser-use/jev-ultrafast, and it holds a free, MIT-licensed browser agent from Browser Use that uses TypeSafe's Jev model to choose every click.

It is not a new version of Jev, and it is not a download of the Jev model.

Browser Use wrote the agent, TypeSafe hosts the model, and you run the code on your own machine against your own Chrome browser.

It solves a simple problem, which is that most browser agents are slow because they write out a plan before every single click.

In this post I'll show you what is in the repo, how it works, how to set it up, how to use it and where it breaks.

What is in the Jev Ultrafast GitHub repo?

The repo describes itself on GitHub as the "Fastest and cheapest web agent".

These are the facts I checked on 11 October 2026.

The star count changes every day, so treat it as a snapshot.

The repo is small on purpose.

The README lists six core files, which cover the agent loop, the page reader, the browser connection, the model calls, the instructions and the local demo.

What Jev Ultrafast is, in plain English

Jev Ultrafast is a browser agent, which is a program that clicks, types and scrolls on websites for you.

You give it one goal in normal language.

The example in the repo is a one-way flight search from Zurich to London on a set date.

The agent then works through the page until matching flights are on screen.

Two models share the work.

Jev picks what to do next and which item on the page to do it to.

A small writing model is only called when a box needs text.

That split is the whole design, and it is why the agent is quick.

How Jev Ultrafast works step by step

Every time the page changes, the agent builds a fresh numbered table of the controls it can see.

A row might say that item 3 is a "Where to?" box and that it is empty.

Jev is then asked two things in one request, which are the operation and the target.

The agent only offers Jev the operations and targets that make sense on the current page.

It doesn't send screenshots to the model in its normal loop.

It sends a short text description of the visible controls instead.

The README is clear that the model's answer never becomes selectors, coordinates, shell commands or JavaScript.

Every action is tied to an element the agent has just observed.

How to set up Jev Ultrafast from GitHub

These are the commands from the official README.

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

Before you run the last command, open the new .env file and add two keys.

The first is TYPESAFE_API_KEY, and the second is TEXT_MODEL_API_KEY.

The example file already sets the Jev model to jev-latest and the writing model to inception/mercury-2.5 on OpenRouter.

Then open http://127.0.0.1:8766, click Start demo and click Run automatically.

The inspector shows the numbered elements, the probabilities Jev gave each operation and target, and the actions it took.

A Choose next button pauses before every action, which is the safest way to watch your first run.

Chrome connects through Browser Harness, and Chrome will ask you to allow remote debugging.

If that connection fails, run uv run browser-harness --doctor.

One detail is easy to miss.

I read the code, and it calls TypeSafe's own address directly, so the official version needs a real TypeSafe key.

The free OpenCode Zen model from my free Jev API key post will not plug in without a code change.

If you are still waiting for access, my Jev waitlist post covers where that stands.

How to use Jev Ultrafast in your own code

The repo doubles as a small Python library.

You import the Agent, pass it a starting page and a goal, and loop over the progress it reports.

from jev_ultrafast import Agent

with Agent(
    "https://en.wikipedia.org/wiki/Main_Page",
    "Find and open the Wikipedia article about Gödel's incompleteness theorems.",
) as agent:
    for state in agent.run():
        print(state["elapsed_ms"], state["status"])

You run it with uv run --env-file .env python your_script.py.

There is also a general runner at examples/run.py that takes a --url and a --goal.

The flights example searches and then checks the route, the date and the results.

The README states that it does not select or book a flight.

The speed numbers, and who measured them

I have not re-run these benchmarks myself.

Every figure here comes from Browser Use's performance report in the repo.

The timer starts after the first look at the page, so browser setup and the first page load are outside it.

Browser Use says in plain words that three pairs of runs on one task is not a general reliability benchmark.

As someone who runs a benchmark, I rate that honesty highly.

What Jev Ultrafast costs

The code is free under the MIT licence.

TypeSafe lists Jev at $0.042 per million input tokens, and output tokens are free.

OpenRouter lists Mercury 2.5 at $0.04 per million input tokens and $0.15 per million output tokens.

The recorded flights run sent 90,558 input tokens to TypeSafe, which is well under one cent at the listed price by my own maths.

The report says the two text calls in that run cost $0.00006272.

Live examples and recording scripts make paid calls, so watch your usage page.

Limits of the Jev Ultrafast GitHub project

The README lists its own limits, and they are worth knowing before you build on it.

I would give it a clean Chrome profile of its own.

I would also keep it away from pages full of private data until you are happy with where the page text is sent.

Lookalike repos to watch for

A GitHub search for the name returned more than 50 repositories when I ran it.

Only browser-use/jev-ultrafast is the official project.

Most of the others are personal forks with no stars.

A few are community ports that clearly say they are unofficial, such as ipenywis/laya-ultrafast, chy4pro/jev-for-chrome and jiawei686/jev-ultrafast-mcp.

I have not tested any of those ports.

The Laya port is interesting because it swaps the hosted Jev call for a local model on Apple Silicon.

Its README says it had to add extra rules, because Laya is weaker at the open question of what the browser should do next.

My test notes on Laya as a decision model are in my run Jev locally post.

Is there a cloud version?

The README links to a Browser Use Cloud waitlist for ultrafast browser agents.

On 11 October 2026 that page was headed "SUPERFAST mode" and said it is coming soon to Browser Use Cloud.

It lists no price and no date, so I am not going to guess either.

The models behind Jev Ultrafast, and what the bench says

This is the part where GoldieBench is useful, so I have kept it for the end.

Jev Ultrafast doesn't ship its own model.

It borrows two, and your wider setup usually adds a third.

I want to be straight about what the board can and cannot tell you.

GoldieBench scores one-shot builds, such as games and apps, on a 0 to 10 scale.

It does not score browser clicking, and it does not score decision models.

So there is no Jev score and no Jev Ultrafast score, and I am not going to invent one.

What the board can do is help you choose the models around it.

Picking a text helper

The README says Gemini, GLM and DeepSeek models can do the typing job through the same helper.

Two models from those families have scored averages on the board.

Keep those numbers in context.

Typing "Zurich" into a search box is a far easier job than building a game in one shot.

The Gemini models Browser Use probed in its report were Gemini 2.5 Flash Lite and Gemini 3.1 Flash Lite, which are not the Gemini on our board.

So read the table as a guide to the model families, and not as proof of how they type into forms.

Picking the planner above it

The planner is the model that decides which browser jobs exist and writes the goal sentence.

This is where a strong build score matters, because the planner does the real thinking.

If you want the local route

The community Laya port shows an offline setup that uses a Gemma 4 model through Ollama for the text job.

On our board, Gemma 4 12B MLX averages 3.98 across 42 scored tasks, and Qwable 5 27B Coder averages 7.14 across 41 scored tasks.

Those are build scores, so they tell you how each one copes as a general worker and not how it fills in a form.

You can compare every local option on the local models page.

My take

Jev Ultrafast is a real, readable and well-documented browser agent from a team that knows browsers.

It is also version 0.1.0, it needs two keys, and it has clear gaps on complex pages.

Clone the official repo, run the demo in Choose next mode, and test one simple goal in a clean Chrome profile.

Also On Our Network

• Agent Operatorsthe step-by-step Jev Ultrafast setup for operators
• AI Income Deskseven ways a business could use Jev Ultrafast
• AI Tool Verdictevery Jev Ultrafast feature, with a verdict and scores
• agentos.guidewhere Jev Ultrafast fits in an Agent OS
• agentos.guideJulian's own voice browser built on Jev

So the answer is simple: use the official Browser Use repo, pair it with models you have checked, and verify every result, which is all you need from the Jev Ultrafast GitHub project.