Advanced handbook: Jev Ultrafast browser agent and pitfall guide
💡 Goal: finish two things in about 92 minutes—get the Jev Ultrafast browser agent running on your own computer (official recording: a real Google Flights search in 7.073 seconds), and take away the 9 failure modes and alternative approaches from the official pitfall docs of Jev 1.13.
🎯 Stage goals
- Explain how Jev Ultrafast works: a dynamically indexed action space, one round trip that decides both the operation and the target, and a default loop that takes no screenshots
- Run it end to end from scratch:
uv sync+ two API keys, view numbered elements and probabilities in the inspector at127.0.0.1:8766, then write your own browser task with the Agent library - Be able to read the official performance data and know its boundaries: how the 7.073 seconds are measured, what 1,092→101 protocol calls mean, which controls are unsupported, and why DONE needs independent verification
- Recognize the 9 failure modes of Jev 1.13, and for each one be able to state the official alternative—do arithmetic in code, extract dates into widgets, filter large state first
⏳ Estimated time
- The 7 lessons total about 92 minutes; with buffer time, budget about 64–120 minutes
- 5.1–5.4 form one main thread (principles → installation → real run → reading data), so going in order is recommended; 5.5 / 5.6 only depend on the environment from lesson 2 and can be read standalone as needed
- The 5.7 pitfall handbook is fully independent and readable without touching a browser—pure API users lose nothing by jumping straight to it
🚀 Before you start
- completed daily use: mastered the five ways of asking questions with Jev: every decision step in Ultrafast is a TypeSafe request, so state, typed questions, and probability distributions need to be clear first
- have a TypeSafe API key in hand (signup and API key); Ultrafast additionally requires a
TEXT_MODEL_API_KEYfor a text model (lesson 2 shows you how to configure it) - have Chrome and uv on your computer—Ultrafast installs with
uv sync, and Chrome connects via the Browser Harness - a cup of water ☕—at this stage, Jev will finally click around the browser for you
📚 Lessons in this stage
The star of the first 6 lessons is Jev Ultrafast—a browser agent from Browser Use × TypeSafe, positioned by the official one-liner as: "a browser agent with a dynamic, indexed action space." The usage is still the Jev-style judgment you know: give it a goal, Jev picks the operation and element, and the small LLM only writes a string when typing is needed (TYPE_TEXT).
On the cloud there is also the officially hosted BU Ultrafast (Browser Use Cloud, available on all plans, model: "bu-ultrafast", entry point cloud.browser-use.com); this stage walks you through the open-source version on GitHub, with all operations done on your own computer.
First, see how it differs from your current approach:
| Your current approach | Jev Ultrafast's approach |
|---|---|
| ❌ Automation scripts hardcode selectors and break in batches whenever the page changes | ✅ Each observation dynamically generates a table of numbered elements ([1] button Change ticket type · Round trip …), and Jev only picks from things that actually exist on the current page |
| ❌ Visual agents guess coordinates from screenshots, one screenshot per step—slow and expensive | ✅ The default loop takes no screenshots: Jev consumes structured state, and one round trip decides both the operation and the target |
| ❌ Have a big LLM spit out an "operation plan" JSON, then pray it parses and executes | ✅ Both the operation and the target are typed answers; the model's output never becomes a selector, coordinates, or executable JS |
There are 8 operations in total: CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, BLOCKED—there is no dangerous "execute arbitrary script" action. Lesson 1 breaks this action space down.
Lesson schedule:
| Lesson | Content | Duration |
|---|---|---|
| 5.1 Jev Ultrafast principles | The dynamically indexed action space and its 8 operations; one TypeSafe request asks for both the operation and the target at once (two decisions, one round trip); why the default loop takes no screenshots | 12 minutes |
| 5.2 Ultrafast installation and running | git clone + uv sync + two API keys; open the inspector at 127.0.0.1:8766 to view numbered elements, operation probabilities, and target probabilities | 15 minutes |
| 5.3 Running a real Google Flights | search, Zürich → London, officially recorded 7.073 seconds; examples/flights.py includes independent verification, search only, no booking | 15 minutes |
| 5.4 Performance interpretation | How the 7.073 seconds was measured: 17 Jev requests, median latency 178 ms; compared against measured 9.450→7.092 s and protocol calls 1,092→101—the official source explicitly says it is a small sample, not a general benchmark | 10 minutes |
| 5.5 Writing your own browser task | Agent library in practice: Agent(url, goals) + run() to get the state step by step; changing the URL and goals makes it a new task | 15 minutes |
| 5.6 Ultrafast troubleshooting | What to do when Chrome won't connect (browser-harness --doctor), TEXT_MODEL throws errors, or clicks go astray; the list of unsupported items: shadow DOM, canvas, uploads, new tabs popping open | 10 minutes |
| 5.7 Jev 1.13 Pitfall handbook | The 9 failure modes from the official jaggedness doc and their alternatives: literal interpretation, arithmetic counting, date comparison, indirect references, large state, adversarial content, contradictory instructions, option ordering, requiring generation | 15 minutes |
💡 You can use a domestic text model
Ultrafast's text helper uses an OpenAI-compatible interface; the official README explicitly states that Gemini, GLM, and DeepSeek can all be configured. When no environment variable is set in the code, the default endpoint is DeepSeek (https://api.deepseek.com/v1 + deepseek-chat). It only appears when TYPE_TEXT is set—not configuring TEXT_MODEL_API_KEY raises an error outright, in the official words: no text is hardcoded or guessed.
⚠️ DONE does not mean success
The official docs say it plainly in Evidence and limits: even after DONE is chosen, the result still needs independent verification (the verify() in the Flights example does exactly this); the DOM reader only recognizes common HTML/ARIA controls—shadow roots, frames, canvas, uploads, new tabs popping open, nested scrolling, and arbitrary keyboard components are not in this MVP. Valid actions can still be wrong—lesson 4 and lesson 6 will stress this point repeatedly.
The final lesson is relatively standalone: the officials compiled the known issues of Jev 1.13 into the jaggedness doc—9 failure modes, each with an alternative approach. The doc is marked as applying to jev-1.13 (last reviewed 2026-10-02), and the officials also say many of these will be fixed in later versions; but question-writing habits like "put arithmetic in code, extract dates into components, filter large state first" are worth developing regardless of the version you use.
🎒 What you will gain
- A working browser Agent: from cloning to the inspector to writing custom tasks with the Agent library, all done locally
- The right way to read official performance data: the timing boundary of 7.073 seconds, and how to cite small-sample comparisons—neither hyping nor trashing
- Awareness of safety boundaries: model output never becomes executable code, DONE must be independently verified, and you know the list of unsupported controls by heart
- 9 failure modes as a "symptom → alternative approach" checklist, so you proactively avoid Jev 1.13 pitfalls when writing questions
Beyond the browser, if you want to see Jev in 15 complete pure-API case studies (danmaku filtering, RAG gating, cascaded extraction), revisit Scenario practice: choose your route; for request formats and status codes, go to API quick reference, and for model versions and pricing see Models and pricing.