The Jev Ultrafast GitHub repo lives at browser-use/jev-ultrafast, the official Browser Use project that pairs their browser agent with TypeSafe AI's Jev decisions model. This page is the hands-on walkthrough: where the repo is, what's inside, how to install it, which two API keys you need, what the agent can actually do, its limits, and why you should only clone from the official account.
📺 Watch: NEV Jev AI Voice Browser Agent is WILD!
🔥 Get the Agent OS as a free bonus: AI Profit Boardroom members get the full Agent OS zip, prompt libraries, daily tutorials and weekly live coaching calls. → Get inside
If you want the big-picture story of why Browser Use and Jev fit together, I covered that in my Browser Use Jev GitHub explainer. This one is the practical "open the repo and get it running" version. Everything below comes from the repo's own README claims. Read the code yourself before running anything.
And if you'd rather learn browser agents with people already building them, the AI Profit Boardroom is where we pull these setups apart every week.
Where the Jev Ultrafast GitHub Repo Lives
The repo is published under the Browser Use organisation on GitHub: browser-use/jev-ultrafast. That's the one to clone.
Why does that matter? Because the Jev corner of GitHub moved fast. Within weeks of Jev's 15 September 2026 launch there were forks, side projects, and a SourceForge mirror. Some of those might be fine. Some might not. The official code comes from the browser-use account, so that's where you start.
What's Inside the Repo
Here's what the README describes, in plain English.
A numbered element table
Every time the agent looks at a page, it builds a fresh numbered table of the elements on it: buttons, comboboxes, textboxes and their current values. Jev picks from that table. Because only real elements on the page are offered, the agent can't pick something that isn't there.
One operation per request
Each step, Jev chooses a single operation. That keeps every decision small and fast, which is exactly what a decisions model is good at.
Speculative targeting
One TypeSafe request answers the operation and the candidate targets at the same time: a click target, a type target and a select target. If the operation comes back as CLICK, only the click target runs. Two decisions in one network round trip.
A small writing model, only for typing
Jev never writes text. A separate small writing model steps in only when the operation is TYPE_TEXT. Per the README, the demo config uses an OpenRouter key with a fast text model and reasoning switched off, and other models work through an OpenAI-compatible helper.
A local inspector
Once it's running, you get a local page showing the numbered elements, the operation probabilities, the target probabilities and every action taken. There's a "Choose next" mode that pauses before each step so you can watch the agent weigh its options before anything moves. Honestly, that inspector is the best way to understand how a decisions-model agent thinks.
The Operations List
The agent can only do these eight things:
| Operation | What it does |
|---|---|
| CLICK | Clicks a numbered element on the page. |
| TYPE_TEXT | Types into a field. This is the only step where the writing model is used. |
| SELECT | Picks an option in a dropdown or combobox. |
| SCROLL_UP | Scrolls the page up. |
| SCROLL_DOWN | Scrolls the page down. |
| WAIT | Waits for the page to load or change. |
| DONE | Declares the goal finished. |
| BLOCKED | Declares the agent can't continue. |
That short list is the point. A small, closed action space is why Jev can decide so fast. And having DONE and BLOCKED as explicit options means the agent can say "I'm stuck" instead of clicking around forever.
📺 Watch: Gemma 4 DESTROYS Github Copilot?
Install Steps
Setup is short. Here's the sequence from the README:
- Clone the repo from the browser-use account on GitHub.
- Install dependencies by running uv sync in the project folder.
- Copy the env example. Make your own env file from .env.example.
- Add your two API keys to that file (details below).
- Start it with uv run jev.
- Open the inspector at the local address the app gives you, which per the README is 127.0.0.1 on port 8766.
The README also notes Chrome connects through browser-harness, another Browser Use repo.
My standing advice: don't hand-edit config at midnight. Paste the repo link into your coding agent, ask it to read the code first, report what it does, and then walk you through setup. That's faster and safer than doing it by hand.
The Two API Keys
You need two keys, and they do different jobs.
| Variable | What it's for | Where to get it |
|---|---|---|
| TYPESAFE_API_KEY | Jev, the decisions model that picks every operation and target. | console.typesafe.ai (the Jev waitlist ended 21 September 2026; new accounts got $5 of free credit) |
| TEXT_MODEL_API_KEY | The small writing model used only for TYPE_TEXT. | Your text model provider; the demo config uses an OpenRouter key. |
Keep both keys in the env file, out of your source, and never commit them. If you're working from more than one machine, make separate keys so you can revoke one without breaking the other.
Jev itself is cheap: $0.042 per million input tokens with output free, per TypeSafe's published pricing. Most of your cost will usually come from the text model on typing steps, so watch both bills.
📺 Watch: NEW Perplexity Computer Update is INSANE! (Claude Code + GitHub CLI)
The Headline Demo
The README's showcase run is a Google Flights search from Zürich to London completed in 7.1 seconds from one natural-language goal. That time includes real text generation and page-loading waits. Browser Use says there are no site-specific scripts and no prepared field strings. Treat that as Browser Use's claim, not a promise for your site.
Limits to Know Before You Rely on It
- It's the maintainers' numbers. The 7.1-second run is from the README. Your sites and network will differ.
- Jev isn't perfect. TypeSafe's own disclosed figures put Jev at 67.8% aggregate against 74.1% for a comparable LLM on the same benchmarks. Fine for clicks you can undo. Not for anything irreversible.
- Rate limits move. TypeSafe has been adjusting them based on GPU capacity. Expect the odd retry.
- Eight operations only. If a task needs something outside that list, the agent can't do it.
- Real accounts need care. Don't point it at logged-in accounts that can spend money or send messages until you've watched it in Choose next mode.
Forks and the Mirror Warning
Search GitHub for "jev ultrafast" and you'll find copies. There's also a SourceForge mirror. Here's my rule: clone from browser-use, every time.
- Forks can drift. They may lag behind the official repo or change code in ways you won't spot.
- Mirrors can be stale. A mirror is only as current as its last sync.
- Your keys are at stake. This app reads your TypeSafe and text-model keys. Running an unknown copy means trusting whoever changed it.
If you want to explore the wider ecosystem of Jev projects, my Awesome Jev GitHub roundup keeps a curated list. Just treat every third-party repo as code you read before you run.
Where It Fits in Your Agent Stack
The architecture here is worth stealing even if you never run this exact repo. A fast decider chooses. Deterministic code owns the loop. Explicit DONE and BLOCKED states stop the agent spinning.
If you already run Hermes, compare this with the built-in browser options in Hermes Agent browser. The two approaches solve different problems, and plenty of people will end up using both.
For the bigger picture of wiring agents into a business, start with my Agent OS guide. Browser agents like this are exactly the kind of tool I want to put through Goldie Bench before trusting them with client work.
Want help figuring out whether a fast browser agent is worth it for your business? Book a free AI strategy session and we'll map it out.
Or if you'd rather build alongside people doing this every week, join the AI Profit Boardroom for $69/mo.
FAQ
Where is the official Jev Ultrafast repo?
It's browser-use/jev-ultrafast on GitHub, published by Browser Use. Forks and a SourceForge mirror exist, so always clone from the browser-use account.
Which API keys does jev-ultrafast need?
Two: TYPESAFE_API_KEY for Jev, from console.typesafe.ai, and TEXT_MODEL_API_KEY for the small writing model that handles TYPE_TEXT steps. The demo config uses an OpenRouter key for the text model.
How do I run jev-ultrafast?
Clone the repo, run uv sync, copy .env.example to your own env file, add both keys, then run uv run jev and open the local inspector in your browser.
Is jev-ultrafast safe to use on real accounts?
Start in Choose next mode and watch every step first. Jev is fast but not perfect, so keep it away from anything that spends money or can't be undone until you trust it on your own sites. If you want a second opinion on your setup, grab a free AI strategy session.
