Best Browser Infrastructure for AI Agents 2026
In August 2026 Cloudflare shipped a browser with no Chromium in it. That is the clearest signal yet that the browser your agent drives should not be the browser a human drives. We compare Kitesurf, Browserbase, Browser Use, Steel, Stagehand and Firecrawl on cost per browser hour, session persistence, bot-detection survivability, and which layer you actually need.
First: why an agent needs browser infrastructure at all
An LLM cannot click. It can reason about a page beautifully and then do precisely nothing with it, because the model's only output is text. Browser infrastructure is the layer that turns that text into navigation, typing, clicking and waiting — and then turns the resulting page back into something the model can read.
The reason this is a market rather than a one-line library import is that most of the web was never built to be read by software. Nearly everything valuable sits behind JavaScript rendering, a login, a cookie banner, or a bot check. An API would be nicer. An API usually does not exist.
Reach systems that have no API
Supplier portals, government forms, legacy admin panels, booking systems, competitor pricing. If a person can do it in a browser, an agent can be made to do it — no integration required from the other side.
Read what the page actually renders
A plain HTTP fetch of a modern app returns an empty shell and a script tag. A browser returns the DOM after the JavaScript has run, which is the only version of the page that contains the content.
Hold a session across steps
Log in once, then do twelve things. Persistent context, cookies and storage are what separate a demo that scrapes one public page from a workflow that does real work on your behalf.
See what went wrong
Session replay, live view and logs. A browser agent that failed silently at 3am against a page that has since changed is otherwise close to unfixable — this is the capability teams underrate most.
When you need none of this: if the agent only has to read, an extraction API returns clean Markdown for a fraction of the cost and none of the operational weight. Reach for a browser when the agent has to act — click, type, submit, stay logged in. A large share of "we need a browser agent" projects turn out to be a crawl, a chunk and an embedding.
Quick Verdict
Persistent contexts, Live View, session replay, logs and a real debugger sit beside the managed browser — the strongest story here for seeing what the agent actually did when it fails.
The cheapest way to do a lot of shallow page work. No Chromium, runs in V8 isolates, 3–4× less CPU and 5–7× less memory. Free in beta, and roughly $0.09 per browser hour on Browser Run.
Give it a goal and it picks the steps, scoring 89.1% on WebVoyager — the highest of the open-source frameworks. Cloud starts near $0.02 per browser hour; self-hosting is free.
Deliberately less autonomous. Typed act, extract and observe primitives you compose yourself, with an escape hatch straight into raw Playwright. Cloud is ~$0.05 per step, everything included.
Open source with the most generous free tier in the category — 100 browser hours a month. Fair pricing below roughly 500 hours; above that, do the arithmetic against Browserbase.
TL;DR
These are three layers, not five rivals — most stacks use two. Stays logged in and must be debuggable → Browserbase. Thousands of stateless pages cheaply → Kitesurf. Open-ended tasks from a prompt → Browser Use. A workflow that must run identically every time → Stagehand. Free tier that covers the whole job → Steel. Only need the text → Firecrawl, and skip browsers entirely.
These products are not competitors — they are three layers
Most confusion in this category comes from comparing a framework to a hosting provider. Sort the market into layers first and the choice mostly makes itself.
Layer 1 — the agent framework
Decides what to click. Browser Use, Stagehand, Skyvern. This is library code in your repo, and it needs a browser to drive from somewhere.
Layer 2 — the browser runtime
Actually renders the page. Browserbase, Steel, Hyperbrowser, Kitesurf, or your own Playwright container. This is what you pay per hour for, and where session persistence, proxies and captcha handling live.
Layer 3 — the extraction API
Skips the browser as a concept entirely and hands you Markdown. Firecrawl, Exa, Jina. If your agent only needs to read, start here — it is dramatically cheaper and simpler than anything below it.
Practical consequence: Stagehand and Browserbase are made by the same team and are designed to be used together. Browser Use runs on its own cloud or on top of anyone else's. And a large fraction of teams shopping for "a browser for my agent" discover they needed Firecrawl and a cron job.
The news: Cloudflare deleted Chromium
Kitesurf launched on 6 August 2026, and the interesting part is not the benchmark — it is the premise. Every headless browser before it was a human browser with the human parts switched off. You still paid for a compositor, a full JS engine tuned for interactive animation, tab management, an extension system, and pixel-accurate rendering, so that an agent could read some HTML.
Kitesurf throws all of that away. It runs entirely in V8 isolates on Cloudflare Workers, assembled from Blitz (a modular rendering engine), Stylo (Firefox's CSS parser), and Boa (a Rust ECMAScript engine). Cloudflare measured 3.1–3.8× less CPU and 4.7–7.0× less memory than Chromium on common agent tasks.
What it is genuinely good at
- Navigating a page and extracting rendered content
- Screenshots and PDF generation at volume
- Bursty, spiky workloads — isolates start fast and cost nothing idle
- Anything stateless that you would otherwise run a Chromium pool for
- Staying inside a Workers deployment you already run
What it explicitly is not for
- Long authenticated sessions — it is ephemeral and stateless by design
- Evading anti-bot checks: it is not Chromium, so the fingerprint is distinctive
- Rich media — video, canvas, WebGL
- Anything needing pixel-faithful rendering of a complex app
- Production commitments: it is beta, with no published post-beta price
Pricing caveat: Kitesurf is free in beta behind per-account limits, and Cloudflare has published nothing about what it costs afterwards. Browser Run — the product it ships inside — includes 10 browser hours a month on Workers Paid and charges about $0.09 per additional browser hour as of 23 August 2026. Plan on that shape, not on free.
The platforms, in detail
Published plans as of September 2026. Browser-hour pricing in this category moves quickly — verify before you build a cost model on it.
Browserbase
Managed Chromium, fully observable
$20/mo
Developer · Startup $99 · overage $0.10–0.12/browser-hr
- Persistent contexts — the agent stays logged in across runs
- Live View: watch the session in real time in a browser tab
- Session replay, logs and a real debugger for post-mortems
- Residential proxies and captcha handling built in
- Real Chromium, so anti-bot survivability is the best here
- Ships Stagehand as its first-party agent SDK
- The most expensive per browser hour of the managed options. Idle sessions bill, so close them.
Best for: Agents that log in, hold state, and will eventually need a human to work out what went wrong.
Cloudflare Kitesurf
An agent-first engine with no Chromium
Free (beta)
Browser Run: 10 hrs/mo incl., ~$0.09/hr after
- Runs entirely in V8 isolates on Cloudflare Workers
- 3.1–3.8× less CPU, 4.7–7.0× less memory than Chromium
- Built from Blitz, Stylo and Boa — no Chromium anywhere
- Navigate, extract rendered content, screenshot, generate PDFs
- Scales well for bursty, spiky agent workloads
- Sits inside Workers, next to your Durable Objects and queues
- Beta, stateless by design, distinctive fingerprint, and no video/canvas/WebGL. No post-beta price published.
Best for: High-volume stateless page work — read, screenshot, extract, discard — especially if you already deploy on Workers.
Browser Use
Autonomous agent framework
~$0.02/browser-hr
Cloud entry price · self-hosting free
- State-of-the-art 89.1% on the WebVoyager benchmark
- Natural-language goals — the agent chooses the steps
- Model-agnostic: run it against whichever LLM you prefer
- Large community and the most examples to copy from
- Runs on its own cloud or on top of any browser runtime
- Autonomy cuts both ways — runs are not deterministic, and token cost per task is the real bill, not the browser hour.
Best for: Open-ended tasks where the page layout changes and you cannot enumerate the steps in advance.
Stagehand
Composable primitives over Playwright
~$0.05/step
managed cloud, all-in · self-host free
- act / extract / observe primitives you compose yourself
- Drop into raw Playwright any time you need determinism
- One all-in price: no separate token, session or proxy line items
- Typed extraction with schemas rather than prompt-and-hope
- First-party with Browserbase, so the runtime story is solved
- Per-step billing means a chatty workflow gets expensive fast. Count steps, not tasks, when modelling.
Best for: Repeatable production workflows — the same login, the same form, a thousand times, identically.
Steel
Open-source browser API
Free to 100 hrs/mo
then usage-based
- 100 free browser hours a month — the most generous here
- Open source, so self-hosting is a real exit path
- Session management, proxies and captcha support
- Playwright and Puppeteer compatible
- Fair pricing up to roughly 500 hours a month
- Smaller team and a thinner debugging story than Browserbase. Above ~500 hours, re-run the numbers.
Best for: Prototypes, side projects and anything where 100 free hours a month is simply the whole workload.
If the agent only needs to read, Firecrawl crawls and returns clean Markdown with no browser API in your code at all. In August 2026 it also shipped AnyDoc, a Rust library that converts office documents to Markdown at a 4.4 millisecond median.
Try this layer before the ones above it. A surprising share of "we need a browser agent" projects are actually a crawl, a chunk, and an embedding.
Feature comparison
"Via BB" means the capability comes from Browserbase when Stagehand runs on its first-party runtime. "Bring one" means the framework drives whatever browser you point it at.
Browser hours are not your biggest bill
Teams shop this category on browser-hour price and then get surprised by the invoice, because for an LLM-driven agent the browser is usually the cheap part. A single autonomous run that takes 30 steps against a frontier model can spend more on tokens in four minutes than the browser costs in four hours.
~$0.02–0.12
per browser hour
The number everyone compares. It matters at scale and is close to noise below a few hundred hours.
Tokens
the line item that actually grows
Every step re-sends page state to the model. Screenshot-based agents are worse than DOM-based ones. Trim the observation, not the browser.
Proxies
billed by bandwidth
Residential proxy bandwidth can quietly exceed both. Stagehand's all-in per-step price exists precisely to make this predictable.
The optimisation that actually pays: cache the page. If two agent runs a minute apart need the same product page, fetch it once. The cheapest browser hour is the one you never started — which is also the argument for putting Firecrawl, or a plain HTTP fetch, in front of anything that renders.
Which one should you pick?
Your agent has to log in and stay logged in
Browserbase. Persistent contexts plus real Chromium is the combination that makes authenticated multi-step work survivable, and Live View is the difference between debugging a failure and guessing at it.
You are rendering thousands of pages a day, statelessly
Kitesurf, especially if you already deploy on Workers. Stateless, ephemeral, 3–4× cheaper in CPU, and it scales through a traffic spike without a warm pool. Keep a Chromium fallback for the pages it cannot render.
The task is open-ended and the pages keep changing
Browser Use. It is the best-scoring open-source agent on WebVoyager and the one with the most prior art to copy. Accept that runs will not be identical and build retries and verification around it.
The same workflow, a thousand times, identically
Stagehand. Compose the steps yourself, use the model only where the page is genuinely unpredictable, and drop into Playwright for the rest. Determinism is a feature, and the all-in per-step price makes the bill legible.
You only need the text on the page
Then you do not need any of this. Firecrawl returns clean Markdown and you skip browsers, proxies, sessions and step billing entirely. Reach for a browser runtime when the agent has to click something, not when it has to read something.
Frequently Asked Questions
What is Cloudflare Kitesurf?
Kitesurf is a browser engine Cloudflare shipped on 6 August 2026 that is built to be driven by an AI agent rather than a person. It contains no Chromium at all — it runs entirely inside V8 isolates on Cloudflare Workers, assembled from the Blitz rendering engine, Firefox’s Stylo CSS parser, and Boa, a Rust ECMAScript engine. Cloudflare measured it at 3.1 to 3.8 times less CPU and 4.7 to 7.0 times less memory than Chromium on common agent tasks like screenshots and HTML extraction.
Kitesurf vs Browserbase: which should I use?
They are not really competitors, and the choice follows the workload rather than a ranking. Kitesurf suits high-volume, stateless, read-shaped work: fetch a page, extract the rendered HTML, take a screenshot, generate a PDF, then throw the browser away. Browserbase suits agents that stay logged in across steps, need a real Chromium fingerprint to survive anti-bot checks, or have to be debugged by a human watching them. Kitesurf is cheaper per task; Browserbase does more per session. Plenty of stacks run both.
How much does browser infrastructure for AI agents cost?
As of late August 2026, Cloudflare Browser Run includes 10 browser hours per month on a Workers Paid plan and charges about $0.09 per additional browser hour, with Kitesurf itself free in beta behind per-account limits. Browserbase lists Developer at $20/month and Startup at $99/month, with browser-hour overage at $0.12 and $0.10 respectively. Browser Use Cloud starts around $0.02 per browser hour. Steel offers 100 free browser hours a month. Stagehand’s managed cloud bills roughly $0.05 per step with model tokens, browser, and proxy bandwidth included.
Do I need a managed browser service, or can I self-host Playwright?
Self-hosting Playwright or Puppeteer is genuinely fine until concurrency bites. The cost of DIY is not the browser, it is everything around it: warm pools so a session does not cold-start, per-session isolation so one page crash does not take down the box, proxy rotation, captcha handling, session persistence, and a way to watch what the agent did when it fails at 3am. Most teams cross over to managed infrastructure at somewhere between 10 and 50 concurrent sessions.
What is the difference between Browser Use and Stagehand?
Browser Use is an autonomous agent framework: you give it a goal in natural language and it decides the steps, scoring a state-of-the-art 89.1% on the WebVoyager benchmark. Stagehand, from the Browserbase team, is deliberately less autonomous — it gives you typed act, extract and observe primitives you compose yourself, so the run is repeatable and you can drop into raw Playwright whenever you want determinism. Pick Browser Use for open-ended tasks, Stagehand for workflows you want to run the same way every time.
Can AI agent browsers get past bot detection?
Managed services with real Chromium and residential proxies — Browserbase, Steel, Hyperbrowser — do substantially better than a bare headless browser, but nobody will promise you a pass rate. Kitesurf explicitly cannot help here: it is not Chromium, so its fingerprint is distinctive, and Cloudflare positions it for cooperative pages rather than adversarial ones. If your workload depends on evading detection, that constraint should pick your vendor before price does.
Is Firecrawl a browser for agents?
Not exactly — it sits one layer higher. Firecrawl crawls and converts pages into clean Markdown ready to hand an LLM, and in August 2026 it shipped AnyDoc, a Rust library that converts office documents to Markdown at a 4.4 millisecond median. If your agent needs to read the web, Firecrawl is often the right answer and you never touch a browser API. If it needs to click, log in, and submit, you need one of the browser platforms instead.
Related Articles
Where the agent runs its code
LangGraph vs CrewAI vs AutoGenThe framework driving the browser
MCP in 2026: Complete GuideHow agents reach tools like these
AI Agent Payments: x402 vs AP2 vs ACPWhat happens when the agent checks out
LLM Observability & Evals 2026Tracing a browser agent that failed
Best Vector Database for RAG 2026Where the crawled pages end up