The Jev Ultrafast GitHub repo is real, it lives at github.com/browser-use/jev-ultrafast, and it is an 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.
That one line clears up most of the confusion I see in my comments.
People search for it expecting a faster version of Jev that they can pull from GitHub and run offline.
What they actually find is a small Python project that drives your Chrome browser at high speed, with Jev making the decisions over the internet.
In this walkthrough I'll show you where the real repo is, what is inside it, how to set it up step by step, what it costs, and where it breaks.
Where The Jev Ultrafast GitHub Repo Actually Lives
The official repository is github.com/browser-use/jev-ultrafast.
The owner is Browser Use, which is the same team behind the popular open-source browser-use project and Browser Harness.
GitHub describes the repo in five words: "Fastest and cheapest web agent".
Here is the snapshot I pulled from GitHub's own data on 11 October 2026.
| Detail | What GitHub shows |
|---|---|
| Repository | browser-use/jev-ultrafast |
| Owner | Browser Use |
| Licence | MIT, copyright 2026 Browser Use |
| Created | 16 September 2026, one day after Jev launched |
| Stars and forks | About 22,500 stars and about 1,650 forks |
| Language | Python, with a small JavaScript page reader |
| Package version | 0.1.0, and it needs Python 3.12 or newer |
| Last push when I checked | 30 September 2026 |
Star counts move every day, so treat that number as a snapshot and not a promise.
The date is the detail I find most interesting.
Jev launched on 15 September 2026, and this repo was created the very next day.
What Jev Ultrafast Is (And What It Is Not)
Jev Ultrafast is a browser agent, which means it is a program that clicks, types and scrolls on websites for you.
You give it one goal in plain English, such as "find one-way flights from Zurich to London on this date".
It then works through the page on its own until the goal is done.
The clever part is how it splits the work between two models.
Jev, the decision model from TypeSafe AI, picks what to do next and which thing on the page to do it to.
A small, cheap writing model only gets called when a box needs text typed into it.
That split is why it is fast, because Jev doesn't write sentences and answers in a fraction of a second.
Now here is what Jev Ultrafast is not.
- It is not a new or faster version of the Jev model.
- It is not made by TypeSafe, although it calls TypeSafe's API.
- It does not contain Jev's weights, because TypeSafe has not released them.
- It does not run offline, because every decision is a call to TypeSafe's servers.
If you wanted the model itself on your own machine, my walkthrough on how to run Jev locally covers the honest options.
How Jev Ultrafast Works In Plain English
Every time the page changes, the agent reads it and builds a short numbered list of the things you can interact with.
The README shows the idea with a flight search page.
[1] button Change ticket type · Round trip
[2] combobox Where from? · San Francisco
[3] combobox Where to? · empty
[4] textbox Departure · empty
Jev then answers two questions in a single request.
The first question is which operation to run, and the second is which numbered element to run it on.
There are eight operations in total.
| Operation | What it does |
|---|---|
| CLICK | It clicks one numbered element. |
| TYPE_TEXT | It asks the small writing model for text and types it into a box. |
| SELECT | It picks an option from a normal dropdown. |
| SCROLL_UP | It scrolls the page up. |
| SCROLL_DOWN | It scrolls the page down. |
| WAIT | It pauses so the page can finish loading. |
| DONE | It says the goal is finished. |
| BLOCKED | It says it cannot continue. |
The agent does not send screenshots to the model in its normal loop.
It sends a tidy text description of the visible controls instead, which keeps each request small.
The README is also clear about safety.
The model's answer never turns into code, coordinates or commands, because it can only pick from elements the agent has just seen on the page.
🔥 Want my exact Jev Ultrafast GitHub setup, step by step? Inside the AI Profit Boardroom you get step-by-step video trainings, my installable Agent OS and four coaching calls a week with 3,400+ members building real automations. → Join the AI Profit Boardroom
What You Need Before You Set It Up
You need five things, and none of them are hard to get.
- You need a computer with Google Chrome installed.
- You need Python 3.12 or newer, because that is what the project file asks for.
- You need uv, which is the Python tool the README uses for every command.
- You need a TypeSafe API key for Jev, which you create in the TypeSafe console.
- You need a key for a small text model, and the example setup uses an OpenRouter key.
I'll be straight about the TypeSafe key, because this catches people out.
I read the code, and it calls TypeSafe's own address directly.
That means the free OpenCode Zen model I covered in my free Jev API key walkthrough will not work here unless you edit the code yourself.
If you are still waiting for TypeSafe access, my post on the Jev waitlist explains where things stand.
How To Set Up Jev Ultrafast From GitHub: Step By Step
These are the commands from the official README, in the order I'd run them.
Step 1: Clone The Repo
Open your terminal and copy the project down from GitHub.
git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast
Check the address carefully, because it must start with github.com/browser-use.
Step 2: Install Everything With uv
One command installs the project and its two dependencies.
uv sync
That also installs Browser Harness, which is the piece that connects the agent to your Chrome.
Step 3: Add Your Two Keys
Copy the example settings file, then open the new file and paste in your keys.
cp .env.example .env
The file has two keys to fill in, which are TYPESAFE_API_KEY and TEXT_MODEL_API_KEY.
The Jev model is already set to jev-latest, and the text model is already set to inception/mercury-2.5 on OpenRouter with reasoning turned off.
Never share that file or paste it into a chat, because it holds your keys.
Step 4: Start The Demo
Run the one-word command the project adds.
uv run jev
Then open http://127.0.0.1:8766 in your browser.
Step 5: Run It And Watch The Inspector
Click Start demo, then click Run automatically.
The inspector page shows you the numbered elements, how likely Jev thought each operation was, and every action it took.
There is also a Choose next button that pauses before each action, which is the mode I'd use on day one.
Step 6: Fix The Chrome Connection If It Fails
Chrome has to allow remote debugging, and it will prompt you the first time.
If the connection still fails, the README gives you a doctor command.
uv run browser-harness --doctor
That checks the link between the agent and Chrome and tells you what is wrong.
🔥 Want help wiring a fast browser agent into your own setup? Inside the AI Profit Boardroom, I share my Jev and agent walkthroughs as I build them, plus four coaching calls a week where you can bring your own terminal errors. Over 3,400 members are building real automations in there. → Get access here
How To Use Jev Ultrafast In Your Own Scripts
The demo is only the start, because the repo also works as a small Python library.
This is the example from the README.
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"])
You give the Agent a starting page and a goal, and it reports its progress after every step.
You run your own script with uv run --env-file .env python your_script.py.
There is also a ready-made runner that takes any page and any goal.
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.'
The flights example in the repo searches and checks the route, the date and the results.
The README states that it does not select or book a flight, and I think that is the right default for any agent.
🚀 Ready to put Jev Ultrafast GitHub to work in your business? Inside the AI Profit Boardroom you get step-by-step video trainings, my installable Agent OS and four coaching calls a week with 3,400+ members building real automations. → Join the AI Profit Boardroom
How Fast Is It? The Numbers Browser Use Published
I want to be clear about whose numbers these are.
I have read the code and the performance report, but I have not re-run the flight benchmark myself.
Every figure in this table comes from Browser Use's own measurements in the repo.
| Task | Time | Notes from the report |
|---|---|---|
| Google Flights, Zurich to London | 7.073 seconds | The timer starts after the first page read and includes loading waits. |
| Wikipedia, open a named article | 2.798 seconds | The check confirmed the exact article address. |
| Local hotel search with three filters | 1.896 seconds | This one ran against a local test page. |
The flights run used 17 Jev requests, 10 interactions, one wait and two calls to the writing model.
The report gives a middle Jev response time of 178 milliseconds.
Browser Use also compared the old version of its loop against the new one.
The middle run time fell from 9.450 seconds to 7.092 seconds, which is 25% lower.
The team is honest that this was three pairs of runs on one task and one Chrome profile.
They say in plain words that it is not a general reliability benchmark, and I respect that.
What Jev Ultrafast Costs To Run
The code is free, because the MIT licence lets you use it, change it and sell things built on it.
The running costs come 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 today.
The recorded flights run sent 90,558 input tokens to TypeSafe.
At the listed price that works out to well under one cent by my own maths, although the report itself gives no billed figure for the Jev side.
The report does give the writing-model cost, and it was $0.00006272 for the two text calls.
So one run is cheap, but the README warns that live examples and recording scripts make paid API calls.
Limits You Should Know Before You Trust It
This is a small first version, and the README calls it an MVP.
Here are the limits I'd write on a sticky note.
- A DONE answer is not proof, so you still need your own check that the job really finished.
- It reads common HTML and ARIA controls, and it does not handle every unusual widget.
- Shadow roots, frames, canvas, file uploads and pop-up tabs are outside this version.
- Nested scrolling and custom keyboard widgets are outside this version too.
- The tabs it opens share your existing Chrome profile, so it can see whatever you are logged into.
- A valid click can still be the wrong click.
That Chrome profile point is the one I'd take most seriously.
I would run it in a separate Chrome profile with nothing important logged in until I trusted it.
Beware Of Copycat Repos
When I searched GitHub for the name, more than 50 repositories came back.
Only one of them is the official project.
Most of the others are personal forks with zero stars and the exact same name.
A few are honest community ports that say clearly what they are.
| Repo | What it says it is | Official? |
|---|---|---|
| browser-use/jev-ultrafast | The original browser agent from Browser Use | Yes |
| ipenywis/laya-ultrafast | A port that makes decisions locally with Laya on Apple Silicon | No, community |
| chy4pro/jev-for-chrome | A community port that drives the tab you are looking at | No, community |
| jiawei686/jev-ultrafast-mcp | A community MCP server built on the same idea | No, community |
I have not run any of the community ports, so I'm not vouching for them.
My rule is simple.
If the address does not start with github.com/browser-use, read the code before you put a key anywhere near it.
How I'd Wire It Into An Agent Setup
Here is the pattern I'd use as an operator.
- Your main agent, such as Claude Code or Hermes, stays in charge of planning and writing.
- Any job that is mostly clicking through a known website gets handed to a fast browser agent like this one.
- A separate check confirms the outcome before anything is marked as done.
- Anything involving payments, bookings or sending messages stops and asks you first.
If you don't have a main agent running yet, my one-click Hermes setup walkthrough gets that side ready.
I also built my own voice-steered browser on Jev, so I have watched Jev steer a real browser on my own machine.
Related Reading
📺 Video notes + links to the tools 👉
🎥 Learn how I make these videos 👉
🆓 Get a FREE AI Course + Community + 1,000 AI Agents 👉
🔥 Ready to run agents that actually finish the job? The AI Profit Boardroom has the Agent OS walkthroughs, the Jev tutorials as they ship, and four coaching calls a week where you can bring your own setup. Over 3,400 members are building with it right now. → Join the AI Profit Boardroom
Also On Our Network
- 🌐 How a business would actually use Jev Ultrafast
- 🌐 Jev Ultrafast feature by feature, with my verdict
- 🌐 The Jev Ultrafast quick start for an Agent OS
- 🌐 Jev Ultrafast and the models that sit behind it
- 🌐 The voice browser I built on Jev
FAQ: Jev Ultrafast On GitHub
Where is the Jev Ultrafast GitHub repo?
The official repo is github.com/browser-use/jev-ultrafast, and it is owned by Browser Use.
It is MIT licensed and was created on 16 September 2026.
Is Jev Ultrafast a new Jev model?
No, it is a browser agent that uses the existing Jev model to choose actions.
The Jev model itself still runs on TypeSafe's servers.
Is Jev Ultrafast free?
The code is free under the MIT licence.
You still pay for the Jev calls and the small text-model calls it makes while it runs.
Do I need a TypeSafe API key?
Yes, the project needs a TypeSafe key for Jev and a second key for the small text model.
The example settings use OpenRouter for the text model.
Can Jev Ultrafast run offline?
No, the official project calls Jev over the internet for every decision.
A community port called laya-ultrafast swaps in a local model on Apple Silicon, but I have not tested it.
Does it book or buy things for me?
The flights example only searches and checks the results, and the README says it does not select or book a flight.
I would keep it that way and add a human check before any payment step.
About Julian
I'm Julian Goldie, an AI entrepreneur, SEO expert, and founder of the AI Profit Boardroom, which has 3,400+ members.
I help business owners scale with AI agents, automation, and SEO.
- I have 400,000+ YouTube subscribers who watch my AI tool tests every week.
- I built a 7-figure agency from the ground up.
- I run daily AI training inside the Boardroom.
- I wrote two Amazon best-sellers on SEO and agency growth.
→ Get my best AI training inside the AI Profit Boardroom
So that is the whole picture in one place.
The real repo is browser-use/jev-ultrafast, the setup is six steps, and the limits are written down, so you now know exactly what you are getting from the Jev Ultrafast GitHub project.
