Browser automation has always been expensive in two currencies: engineering time and model tokens. The cheapest AI web agent we have seen so far, Jev Ultrafast (browser-use/jev-ultrafast on GitHub, with more than 23,000 stars and an MIT licence), tries to collapse both. Give it one natural-language goal — “find one-way flights from Zürich to London” — and it completes a live Google Flights search in about 7 seconds, at a reported cost of roughly $0.0039 per run. In this deep-dive we explain what it is, how its indexed action space works, what it genuinely costs, and when this kind of agent makes sense for your business.
What Jev Ultrafast is
Jev Ultrafast is a minimal, open-source browser agent built as a collaboration between the Browser Use team and TypeSafe, the company behind the Jev decision model. It was released in mid-September 2026 and collected its 23,000+ stars in about a month — one of the fastest climbs of any AI repository this year. The entire project is deliberately small: the core loop lives in six files (agent.py, snapshot.js, browser.py, model.py, questions.py and demo.py), and the maintainers describe the codebase as “small enough to read.”
Its positioning is right there in the repository description: “Fastest and cheapest web agent.” It is written in Python, ships under the permissive MIT licence (so you can use it commercially without legal friction), and remains under active development — commits were landing as recently as this week. Unlike general-purpose frameworks that bolt browsing onto a large language model, Jev Ultrafast is a special-purpose machine: one goal goes in, and a sequence of lightning-fast browser actions comes out.
What it can do
From the README and the published demos, the agent handles the bread-and-butter of web automation: clicking buttons and links, typing into forms, selecting from dropdowns, scrolling, waiting for page state, and declaring a task done or blocked. The project documents three concrete runs:
- A Google Flights search from Zürich to London, completed in 7.073 seconds end to end — including model calls, generated text, browser work and loading waits — with an independent check verifying the route, date and visible results.
- A Wikipedia navigation task (“find and open the article about Gödel’s incompleteness theorems”) finished in 2.798 seconds.
- A hotel search-and-filter task passed in 1.896 seconds.
It connects to your existing Chrome through the Browser Harness (installed automatically) and ships with a local inspector UI: open a page, click “Start demo,” and you can watch the numbered elements, operation probabilities and executed actions stream in real time. There is also a library mode, so you can drop the agent into your own Python scripts:
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"])
Why it is the cheapest AI web agent: the indexed action space
The trick — and the reason it can claim the cheapest AI web agent crown — is architectural, not magical. Traditional browser agents take a screenshot, send it to a large vision model, and ask “what should I click?” on every step. Screenshots are token-hungry, and a frontier model call per click is what makes typical agents cost cents per action and feel sluggish.
Jev Ultrafast replaces screenshots with a dynamic, indexed action space. At every step, a single atomic DOM snapshot captures the visible controls, their names, values and text in one browser call. The agent turns that snapshot into a numbered table:
[1] button Change ticket type · Round trip
[2] combobox Where from? · San Francisco
[3] combobox Where to? · empty
[4] textbox Departure · empty
TypeSafe’s Jev model then picks an operation (CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE or BLOCKED) and an element from that table — two decisions, one network round trip. A small, cheap text model is invoked only when the chosen operation is TYPE_TEXT, for example to generate “London” into the destination field. The expensive general-purpose LLM never touches the control loop at all.
Several engineering details compound the savings: no screenshots in the default loop (the agent consumes structured state instead), one browser call per snapshot, waits capped at 200 ms for suggestions and 50 ms for animations, and only visible text sent to the model so offscreen footers never fill the context. Model output is also deliberately constrained — it can never become selectors, coordinates, shell commands or executable JavaScript — which is both a safety property and a latency win, since outputs parse as small typed objects instead of freeform prose.
The real numbers: speed and cost
Let us be precise about what the project itself reports, because this is where many demos get slippery. The headline 7.073-second Flights run is the repository’s own documented demo, measured from the first page observation and including model calls, text generation, browser work and loading waits. In six alternating runs of the same task with identical settings, the team reports both versions passed 3/3, with median task time falling from 9.450 s to 7.092 s (about a 25% reduction) and median browser protocol calls dropping from 1,092 to 101. That is three repeats of one task on one browser profile — a real measurement, but not a general reliability benchmark, and the project says so itself.
On cost, independent coverage gives us two useful datapoints. AlphaSignal reports the demo flight search costing roughly $0.0039 per run, and Requesty’s Jev explainer cites TypeSafe pricing of $0.042 per million input tokens with output free — which is why per-step decisions cost close to nothing. Both are the publishers’ figures, not ours; verify them against your own runs before budgeting.
Getting started: setup and first run
The whole point of a “small enough to read” codebase is that you can be running in minutes. The README’s path is:
- Clone the repository:
git clone https://github.com/browser-use/jev-ultrafast.gitand enter the directory. - Install dependencies with
uv sync(this also installs the Browser Harness). - Configure keys: copy
.env.exampleto.envand add two keys —TYPESAFE_API_KEYandTEXT_MODEL_API_KEY(the example uses an OpenRouter key). This is the step people trip on: the demo will not run on the Jev key alone. The default text model is inception/mercury-2.5 with reasoning disabled; Gemini, GLM and DeepSeek also work through the OpenAI-compatible text helper. - Connect Chrome: run
uv run browser-harness --doctorif the browser needs connecting, and allow remote debugging when Chrome prompts. - Launch the demo:
uv run jev, open http://127.0.0.1:8766, click “Start demo,” then “Run automatically.” The inspector shows numbered elements, operation and target probabilities, and every executed action.
For developers, ruff check and pytest run the offline test suite, and scripts/check_guards.py exercises the real-control guards in a local browser without making model calls. Note that the live examples make paid API calls — small ones, but paid. A Browser Use Cloud with hosted ultrafast agents is on the waitlist for teams that would rather not run their own Chrome.
From our experience: where this fits — and where it does not
As an agency that builds workflow automations and AI integrations for clients, here is our honest read. The unit economics change which automations are worth building. At fractions of a cent per task, browser agents stop being a premium feature and become infrastructure: nightly competitor-price checks, lead-list enrichment, invoice downloads, review monitoring. Tasks that were “not worth the tokens” at frontier-model pricing become trivially worth it at Jev-class pricing.
But do not mistake a fast demo for a finished product. The honest limitations are documented in the repository itself: the DOM reader handles common HTML and ARIA controls but not the full accessible-name specification; shadow roots, frames, canvas, uploads, pop-up tabs, nested scrolling and arbitrary keyboard widgets are outside the current scope; and a DONE verdict still requires independent outcome verification. In our experience, that last point is the one that matters for production: always verify the outcome (the flight results are visible, the form actually submitted) rather than trusting the agent’s self-reported success. The project’s own Flights example does exactly this with an independent check, and you should copy that pattern.
Also note what this is not: it is not a drop-in replacement for a scripted RPA bot on a stable internal portal, and it is not a general reasoning agent. Its superpower is navigating changing public web interfaces without selector maintenance, at near-zero marginal cost. If your workflow is a fixed internal form that never changes, a boring script is still cheaper. If the web keeps moving under your feet — supplier portals, booking sites, directories — this architecture is worth a serious look. Browse more tools like it in our AI tools directory.
Responsible-use note
A tool this fast and cheap lowers the bar for misuse as well as legitimate use: aggressive scraping against a site’s terms of service, hammering login forms, or automating actions a human would never take at that speed can get accounts banned and, in some jurisdictions, create legal exposure. The executor’s design — it rechecks page freshness, rejects covered controls, and can never emit shell commands or arbitrary JavaScript — constrains how it acts, but not what you point it at. Use it on your own properties and data, respect robots.txt and terms of service, keep a human in the loop for anything that spends money or sends messages, and throttle request rates to what a courteous user would generate.
Frequently asked questions
Is Jev Ultrafast really the cheapest AI web agent?
On the published figures, yes — it is the cheapest AI web agent with public benchmarks we have seen. The demo flight search is reported at about $0.0039 per run, and TypeSafe’s per-decision pricing ($0.042 per million input tokens, output free) keeps per-step costs near zero. The saving comes from architecture: a purpose-built decision model plus a small text model replace the frontier-LLM-per-click pattern that makes other agents expensive.
What do I need to run Jev Ultrafast?
Python, the uv package manager, Chrome, and two API keys: a TypeSafe key (TYPESAFE_API_KEY) and a text-model key (TEXT_MODEL_API_KEY, e.g. from OpenRouter). The README is explicit that the demo needs both keys — a Jev key alone is not enough. Live examples make small paid API calls.
Can I use it commercially?
Yes. The repository is MIT-licensed, which permits commercial use, modification and distribution. You still pay for the TypeSafe and text-model API usage, and you should confirm the current terms on the providers’ sites before building a product on top.
How fast is it compared to other browser agents?
The project’s headline demo — a Zürich to London Google Flights search — completed in 7.073 seconds end to end, with Wikipedia navigation at 2.798 seconds and a hotel search at 1.896 seconds. In the team’s own six-run comparison, median task time fell 25% (9.450 s to 7.092 s) and browser protocol calls fell from 1,092 to 101. Treat these as the project’s documented measurements, not an independent benchmark.
What are its limitations?
It handles common HTML and ARIA controls but not the full accessible-name specification; shadow roots, iframes, canvas, file uploads, pop-up tabs, nested scrolling and custom keyboard widgets are out of scope. A DONE result needs independent verification, and owned tabs share your existing Chrome profile. For production use, wrap it with your own outcome checks and a human-in-the-loop for money-moving actions.
The cheapest AI web agent is not interesting because it wins a benchmark — it is interesting because it changes which automations are worth building. If you have a repetitive web workflow eating staff hours, the economics of this approach may finally make automating it a no-brainer. Talk to our team and we will tell you honestly whether your process fits — and if it does, we will build it properly.