TL;DR: Our browser agent took 30.7 seconds to find the three cheapest flights on Google Flights, against 17.6 seconds for the same agent driving a local Chrome. Six causes explain 12.8 of the 13.1 second gap. Two of them are config (the model's service tier and a default proxy), and fixing just those took the run to 20.7 seconds. The others were CDP round trips, a page-settle check that never settled, a captcha detector hogging the main thread, and our own prompt. On prod on October 9 the agent ran the task in 18.0 seconds.
Our agent needed 30.7 seconds to find the three cheapest flights from Zurich to London. The same agent on a laptop, driving a local Chrome, needed 17.6. Most of that gap came from things you can check in your own agent today, and one of them was a "page is quiet" detector that never fired, because Google Flights rewrites a CSS class on every frame.
A caveat on the numbers first. The 30.7 seconds is our staging stack on September 27, the 18.0 is prod on October 9, and about 3.4 seconds of those 18 is model time we still can't explain.
Where a browser agent's time goes
The task is simple: Google Flights, one way, a fixed date, report the 3 cheapest. The grader wants at least 3 distinct prices and the expected cheapest carrier. We kept the model fixed and changed everything around it. Agents did most of the work, testing one change at a time behind a flag while a judge checked that nothing got faster by doing less (how we judge runs).
Event timestamps split every run into startup, model, tools, wrap-up and polling. Here is the gap between our cloud setup and local Chrome, by cause. Local Chrome is the floor, with no network hop and no proxy.
The rest of this post goes through the causes roughly in the order I'd check them.
Two config flags: service tier and default proxy
We called OpenAI on the standard tier while the local run used priority. Priority costs 2x per token, and on our replica it took mean turn time from 1.20 to 1.02 seconds (p90 from 1.81 to 1.41), which is about 1.9 seconds off a 12-turn run.
Every run also went through a residential proxy. Now the agent starts direct and moves to a proxy browser only when a site blocks it. Even on October 9, the same harness with a US proxy was 5.3 seconds slower (25.3 against 20.0, n=8).
Those two flags alone took Flights from 30.7 to 20.7 seconds and example.com from 10.3 to 6.5. That saved 10.0 seconds, more than the 5.7 their bars add up to, so read the chart as a rough split rather than an exact one.
One more config surprise: with no explicit model parameters, our harness ran GPT-6 Luna at xhigh reasoning effort. One Flights run took 141 seconds and 39 model calls. Set your parameters explicitly.
CDP round trips: run next to the browser
Our first reproduction ran on a laptop and took about 40 seconds, slower than staging. The laptop sat across the country from the cloud browsers, so every CDP call cost about 85 ms. Two steps took 8.2 and 8.7 seconds, which works out to roughly 100 sequential calls each (an estimate, not a count).
So run your benchmark where prod runs. Even in the same region, about 260 calls per run at 3 to 6 ms each still adds up to a second, so it also pays to send fewer of them. The cloud browser also read the accessibility tree in 46 ms where local Chrome took 12.
Page-settle detection that never settles
Every action waits for the page to settle: the document is parsed, no fresh requests are in flight (anything older than 1.5 seconds counts as long-polling or analytics), and the DOM hasn't changed for 80 ms. It gives up after 800 ms, or 3,000 ms while the page is still loading.
On Flights, every single settle ran to the 800 ms cap. Google Flights writes the same value into a class attribute on every frame, a MutationObserver reports that as a change, and so the detector never saw quiet. The fix is to ignore writes that don't change anything:
// Writing an attribute's current value changes nothing
// (Google Flights rewrites a class every frame).
if (
r.attributeName &&
r.oldValue === (r.target as Element).getAttributeNS(r.attributeNamespace, r.attributeName)
)
continue;A second rule says a style change only counts if it's the first on its element in 200 ms, so a menu opening still counts and an animation loop doesn't. The same change set stopped re-probing every 40 ms, which cut CDP calls on a Flights run by about 30% with scores, model calls and cost unchanged (PR #19). The no-op fix shipped inside it, so we only have the combined number, 0.5 to 1.4 seconds per task on the replica.
A captcha detector blocking the main thread
On September 27 a probe showed the cloud browser's main thread blocked for 674 to 698 ms in every 2-second window. Locally it was zero.
We suspected the always-on captcha detector, and an agent tested it overnight. With the detector on, an idle Flights page burned 32 to 35% main-thread CPU, and with it off, none. Runtime.evaluate on the results page dropped from about 110 ms to 76.
Ultrafast browsers now start with the solver off. When the agent hits a captcha, it calls a solve_captcha tool that turns the solver on until the captcha is solved. By October 9 the stall was gone with the solver on or off, so some other browser change in those two weeks fixed it too. We never found which one.
A shorter prompt and a stable tool list
Our full Cloud prompt and tool set made the ultrafast agent take 1.16x the time and cost 1.70x the money at the same score (paired evals, September 28). So Cloud now runs plain Pi with a short prompt. The first model call shrank from 5,578 to 2,740 tokens for API runs, none of 99 tasks flipped between pass and fail, and runs came out 20% cheaper.
One prompt-cache bug was worth fixing on its own. On the last allowed step, the harness swapped the tool list down to the two finish tools. Tools are part of the cached prefix, so that turn re-sent the whole context uncached. Keeping the list fixed and restricting the turn with OpenAI's allowed_tools cut agent cost by 10 to 17% on two of three benchmarks, with scores unchanged (PR #20).
Browser agent speed after the fixes
With all the winning changes on a replica of Cloud that sits in the browsers' region, every task got faster, from 23 to 36%, and all 49 runs stayed correct.
Then came the real test on prod, on October 9, with 8 Flights runs per setup:
| Setup | Total | Model | Browser | Correct |
|---|---|---|---|---|
| Laptop + local Chrome | 18.8 s | 13.5 s | 5.1 s | 5/8 |
| Prod Cloud, bu-ultrafast | 18.0 s | 9.6 s | 6.4 s | 7/8 |
| Harness in region + cloud browser | 20.0 s | 13.0 s | 6.5 s | 8/8 |
| Same, with US proxy | 25.3 s | 13.9 s | 11.6 s | 8/8 |
These are medians over all 8 runs, misses included. The laptop ran the same harness commit Cloud runs, and Cloud's total includes about 1.6 seconds of startup.
The part we can't explain is model time. Cloud's was 3.4 seconds lower than the same harness calling OpenAI directly from the same region (9.6 against 13.0), with the same turns and the priority tier verified on both. Without that gap, Cloud would be about 2.6 seconds slower than the laptop. It also still spends 1.3 seconds more on browser time than local Chrome does.
Speed only counts at matched correctness, and the agents doing this work needed watching. They edited files mid-benchmark, which threw away five runs, and they read judge noise as signal, so we now require at least 6 runs per task for any quality claim. The 30 experiment branches from September 26 to 30 are public in Browser Use Pi, losers included.
To try the result, set model to bu-ultrafast in Browser Use Cloud. It's built for short tasks; for long ones, use bu-fast.
Published November 20, 2026
Keep reading
All articles
Engineering
/Nov 20, 2026Browser Agent Blocked? How to Tell Which Wall You Hit and Get Past It
We paid $100 for every site that blocked our browser agent. Of 82 we could test, 7 blocked it every time and 6 more only blocked US traffic. Here is what fixes each kind of block.
Magnus Müller

Engineering
/Nov 20, 2026browser-use 1.0: Why We Replaced 24 Agent Tools With One
browser-use 1.0 gives the model one main tool, python, instead of 24 browser actions. The same models scored 14 to 33 points higher, and the agent started doing things we never built.
Magnus Müller

Engineering
/Nov 20, 2026LLM-as-a-Judge Bug: Our Judge Read a Fifth of Each Answer
A fix scored +5.1 points on our agent eval. Up to half of that came from a bug: our LLM judge only saw the end of each answer. How rejudging saved runs caught it.
Magnus Müller
AI 热点