agentos.guide › blog

Jev Ultrafast GitHub: The Real Repo, The Quick Start, And Where It Fits In Your Agent OS

By Julian Goldie · 11 October 2026 · agentos.guide

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

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

Browser Use built it, TypeSafe supplies the model over an API, and you run the agent on your own machine against your own Chrome.

Below is the quick start, what it costs, the limits, and exactly where I would slot it into an Agent OS.

What the Jev Ultrafast GitHub repo actually is

Jev Ultrafast is a small open-source project that controls a real Chrome browser from one plain-English goal.

You tell it what you want, such as a flight search for a set route and date.

It reads the page, works out what it can click, and keeps going until the goal is done.

The name confuses people, so here is the clean version.

• Jev is a decision model from TypeSafe AI that launched on 15 September 2026.
• Jev Ultrafast is a browser agent from Browser Use that uses that model.
• Jev's weights are not on GitHub, because TypeSafe has not released them.
• The Ultrafast code is on GitHub, and anybody can read it, run it and change it.

Here are the facts in one table.

Star counts change daily, so read that number as a snapshot.

How Jev Ultrafast works in plain English

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

One line might say that item 2 is a "Where from?" box holding San Francisco.

Another line might say that item 3 is a "Where to?" box that is empty.

Jev then answers two questions in one request.

The first answer is the operation, and the second answer is the numbered target.

A small writing model is only called when the operation is TYPE_TEXT.

That is the trick that makes it quick.

Jev doesn't write words, so it answers in a fraction of a second, and the writing model only works when a box needs filling.

The agent doesn't send screenshots to the model in its normal loop either.

It sends a short text description of what is visible, which keeps each request small.

The README also says the model's answer never becomes selectors, coordinates, shell commands or JavaScript.

The agent can only act on something it has just seen on the page.

Jev Ultrafast GitHub quick start

These are the commands from the official README.

You need Python 3.12 or newer, uv and Google Chrome before you begin.

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

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

• The first key is TYPESAFE_API_KEY, which pays for the Jev decisions.
• The second key is TEXT_MODEL_API_KEY, which pays for the small writing model.

The example file sets the Jev model to jev-latest.

It sets the writing model to inception/mercury-2.5 on OpenRouter with reasoning switched off.

The README says Gemini, GLM and DeepSeek models can do the writing job through the same OpenAI-style helper.

Once uv run jev is running, open http://127.0.0.1:8766 in your browser.

Click Start demo, then click Run automatically.

The inspector shows the numbered elements, the probability Jev gave each operation and target, and every action it took.

There is a Choose next button that pauses before each action, and that is the mode I would start in.

Chrome connects through Browser Harness, which uv sync installs for you.

Chrome will ask you to allow remote debugging the first time.

If the connection fails, the README gives you this command.

uv run browser-harness --doctor

🔥 Want the exact Jev Ultrafast browser agent setup I run inside my Agent OS?

Inside the AI Profit Boardroom you get the installable Agent OS, step-by-step video tutorials, four coaching calls a week and 3,400+ members building real automations.

→ Get access here

The one thing that trips people up: the key

I read the code, and it sends its Jev requests straight to TypeSafe's own address.

That means you need a real TypeSafe key for the official version.

The free OpenCode Zen model name I covered in my free Jev API key post will not work here unless you change the code yourself.

If you are still waiting on TypeSafe access, my Jev waitlist post explains where that stands.

Keep your .env file private, because it holds both keys.

How to use it in your own scripts

The repo also works as a tiny Python library.

You import the Agent, give it a starting page and a goal, and loop over its progress.

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 your script with uv run --env-file .env python your_script.py.

There is also a ready-made runner at examples/run.py that takes a --url and a --goal from the command line.

The flights example searches, checks the route and date, and saves a trace.

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

How fast is it, and who measured it?

I have read the code and the performance report, but I have not re-run the flight benchmark myself.

So every number in this table belongs to Browser Use.

The report gives a middle Jev response time of 178 milliseconds for the flights run.

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

Browser Use says plainly that three pairs on one task is not a general reliability benchmark.

I respect that, because most launch posts would have left that line out.

What it costs to run

The code is free under the MIT licence.

The running cost comes from the two models.

• 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.

That works out at well under one cent at the listed price by my own maths.

The report says the two text calls cost $0.00006272.

The README warns that live examples and recording scripts make paid API calls, so keep an eye on your usage page.

🔥 Want the exact Jev Ultrafast browser agent setup I run inside my Agent OS?

Inside the AI Profit Boardroom you get the installable Agent OS, step-by-step video tutorials, four coaching calls a week and 3,400+ members building real automations.

→ Get access here

Where Jev Ultrafast fits in an Agent OS

This is the part I care about most.

A browser agent on its own is a party trick.

A browser agent with a planner above it and a checker below it is a worker.

Here is how I would slot it into the stack.

In my own Agent OS, the big models do the thinking and Jev handles the small decisions in between.

I have already used Jev that way for inbox sorting, lead grading and model routing.

I also built a voice-steered browser on Jev, which you can see in my Jev voice browser guide.

So I know Jev can steer a browser on my own machine.

Jev Ultrafast is Browser Use's take on the same idea, and it is a tidy one.

The workflow I would build first

Start with one boring, repeatable browser job that has a clear finish line.

• The planner writes the goal as one sentence with a clear stopping point.
• Jev Ultrafast runs the goal in a separate Chrome profile.
• Your checker reads the final page and confirms the result independently.
• Anything that involves a payment, a booking or a sent message stops and asks you first.
• Every run saves its trace, so you can see what happened when something goes wrong.

The flights example in the repo follows exactly that shape.

It runs the search, then a fresh independent check confirms the route, the date and the visible results.

Limits you should know before you build on it

The README has a section called "Evidence and limits", and I would read it before anything else.

• A DONE choice still needs independent checking.
• The page reader covers common HTML and ARIA controls, and not the full range of web components.
• Shadow roots, frames, canvas, uploads, pop-up tabs, nested scrolling and custom keyboard widgets are outside this version.
• The tabs it opens share your existing Chrome profile.
• A valid operation can still be the wrong one.

The Chrome profile point matters most.

The agent can reach any site that profile is logged into, so give it a clean profile of its own.

Remember as well that page text goes to TypeSafe and to your text-model provider.

Do not point it at pages full of private customer data until you have thought that through.

Is there a version that runs without TypeSafe?

No, there is no official version that runs without TypeSafe.

A community project called ipenywis/laya-ultrafast ports the agent to make its decisions locally with Laya.

Its README says it is Apple Silicon only, that it credits Browser Use for the original work, and that it had to add extra rules.

The reason it gives is that Laya answers narrow questions well but is weaker at the open question of what the browser should do next.

I have not run that port, so I am not vouching for it.

I have tested Laya itself, and my notes are in my Laya AI guide and in my post on running Jev locally.

Beware of lookalike repos

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

Only one is the official project.

Most of the rest are personal forks with no stars and the same name.

A few are community ports that say clearly that they are unofficial, including a Chrome version and an MCP server.

My rule is simple.

If the address does not start with github.com/browser-use, read the code before you put a key near it.

What about the cloud version?

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

When I opened that page on 11 October 2026, it was headed "SUPERFAST mode" and said it is coming soon to Browser Use Cloud.

The form asks for an email, an optional note about your use, and a company website.

I found no price and no date, so I am leaving both out.

What to do next

Clone the official repo and run the demo in Choose next mode.

Then pick one simple goal of your own and run it in a clean Chrome profile.

If you want the whole Agent OS around it, with the walkthroughs and four coaching calls a week, it lives inside the AI Profit Boardroom.

FAQ

Where is the Jev Ultrafast GitHub repo?

The official repo is github.com/browser-use/jev-ultrafast. It is owned by Browser Use, licensed under MIT and was created on 16 September 2026.

Is Jev Ultrafast a Jev model?

No. Jev Ultrafast is a browser agent that uses TypeSafe's Jev model to pick each action. The Jev model itself is hosted by TypeSafe and its weights have not been released.

Is Jev Ultrafast free?

The code is free under the MIT licence. You pay for the Jev calls, which TypeSafe lists at $0.042 per million input tokens with free output, and for the small text model that types into boxes.

How do I install Jev Ultrafast?

Clone the repo, run uv sync, copy .env.example to .env, add your TypeSafe key and text-model key, then run uv run jev and open http://127.0.0.1:8766.

Can I use the free Jev model with Jev Ultrafast?

Not without editing the code. The official version sends its requests straight to TypeSafe's own API, so it expects a TypeSafe key.

Where does Jev Ultrafast fit in an Agent OS?

Use it as the browser hands. A large model plans the job, Jev Ultrafast clicks through the page, and a separate check confirms the result before anything is marked as done.

Final word on the Jev Ultrafast GitHub repo

Use the official Browser Use repo, run it in a clean Chrome profile, and never trust a DONE answer without your own check.

That is how you turn the Jev Ultrafast GitHub project into a browser worker your Agent OS can rely on.

Related guides on agentos.guide

→ Jev AI Voice Browser: Talk To Your Browser

→ 10 Things I'm Building With Jev AI

→ Laya AI: The FREE Jev AI Alternative

→ 3 Free Ways To Use Jev AI Right Now

📺 Video notes + links to the tools 👉

🎥 Learn how I make these videos 👉

🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉

← all guides on agentos.guide