Cloudflare Kitesurf: The Agent-First Browser (2026)

Kitesurf is Cloudflare's stateless browser for AI agents, announced August 6, 2026. It runs entirely on Cloudflare Workers with no Chromium underneath, and uses 3–7× less CPU and memory than Chromium on screenshots and HTML extraction — while running 1.7–1.8× slower on wall time.

TL;DR

Cloudflare did not fork Chromium. It wrote a new browser and threw away everything only humans use.

• Kitesurf shipped on August 6, 2026, during Cloudflare's August Agents Week, as a stateless browser running entirely on Workers in V8 isolates.¹
• It is twelve weeks old. The first commit was in May 2026, and Cloudflare credits obscura, a Rust headless engine with "no Chrome, no Node.js, no dependencies," as the inspiration.¹
• The efficiency numbers are real and one-sided. Against a Chromium warm pool, Kitesurf uses 3.1× less CPU on screenshots, 3.8× less on HTML extraction, and 4.7–7.0× less memory.²
• It loses the stopwatch. Wall time is 1.8× slower on screenshots and 1.7× slower on HTML extraction, because a warm JIT beats a cold software renderer.¹²
• It is not a Chromium fork. HTML and CSS parsing come from Blitz, CSS resolution from Firefox's Stylo, and eval() from Boa JS — all Rust, all compiled to WebAssembly.¹
• It passes over 235,000 WPT subtests as of Cloudflare's August 7, 2026 docs update, with 97% DOM and 96% HTML subtest coverage.²
• Free while in beta, behind per-account limits, opt-in via a single browser=kitesurf query parameter on existing Browser Run endpoints.¹²
• Not open source yet. Cloudflare says it intends to release it "once we're ready," with no date given.¹

What You'll Learn

• What an agent-first browser is, and what Cloudflare deliberately removed
• The exact Kitesurf vs Chromium benchmark numbers and what they were measured on
• How the Rust stack underneath it works, and why eval() needed its own JavaScript engine
• What the WPT standards-compliance numbers do and do not tell you
• The four things Kitesurf still cannot do
• How Kitesurf compares to Lightpanda, obscura, and the Chromium forks
• Why the efficiency win may not reach your invoice yet
• How to point an existing Puppeteer, Playwright, or MCP client at it

What an Agent-First Browser Is

An agent-first browser is a browser engine whose feature set is chosen for a language model rather than a person. It keeps structured content extraction, DOM access, and JavaScript execution, and drops tabs, themes, extensions, profile sync, and pixel-perfect rendering.

Cloudflare's framing is blunt. "AI doesn't care about tabs, themes, browser extensions, or synchronization across devices," the launch post says. "It cares about token count, context windows, scalability, performance, and costs."¹

The economic argument follows from that. Chromium instances "consume so much memory and compute that providing every agent with its own instance is prohibitively expensive," Cloudflare writes, "restricting large parts of the Web to only the most sophisticated and costly AI models."¹

That is the actual pitch. Not a faster browser — a cheap enough one that every agent can have its own.

Kitesurf vs Chromium: The Benchmark Numbers

Cloudflare published medians of five Browser Run Quick Action runs across a 14-URL corpus, comparing Kitesurf against a Chromium warm pool.²

Two things are worth noting about the method before anyone quotes these figures.

The Chromium baseline is a warm pool, not a cold start. That is the harder comparison for Kitesurf, and Cloudflare chose it anyway.

And the corpus is 14 URLs, published openly. It is a small, disclosed sample rather than a broad benchmark suite — which is honest, but it is not a claim about the whole web.

Cloudflare's own reading of the trade: "Chromium wins the stopwatch because a JIT that has already seen this page always beats a cold software renderer." Most of the gap, it says, comes from rasterization and JPEG/PNG encoding.¹

The memory numbers are the ones that change architecture. At 39.4 MiB for HTML extraction against 273.7 MiB, a memory-bound host holds roughly seven times as many concurrent extraction sessions.

For a fleet of agents that each need a browser for a few seconds, that density is the whole game.

Inside the Stack: Blitz, Stylo, and a JavaScript Engine for eval()

Kitesurf splits into three components plus a network gatekeeper, all running as separate Workers isolates.¹

The Engine is the only public-facing piece. It handles the Chrome DevTools Protocol WebSocket and HTTP REST APIs and holds session state. Everything else is stateless.

PageScript gets a fresh isolate per page or out-of-process iframe, spun up through Dynamic Workers, containing a clean globalThis and a DOM document. HTML and CSS parsing use parts of Blitz, a modular Rust rendering engine, and Stylo, Firefox's CSS parser.

PageRenderer paints. It uses blitz-paint, which in turn uses Parley to shape characters into glyphs, choose fonts, and break text into lines. The Engine calls renderFrame() over Workers RPC and gets a PNG back. Because the renderer holds no page state, a stuck render can simply be killed and retried.

SandboxOutbound is the only component allowed to touch the network, enforced by Dynamic Workers.

The most revealing detail is eval(). Workers does not support eval natively for security reasons, and Cloudflare could not spin up a second isolate to handle it, because that isolate would not share globalThis. So Kitesurf embeds Boa JS, an ECMAScript engine written in Rust, and runs it on top of the Workers runtime.

Cloudflare is candid about it: "We are basically executing a runtime on top of a runtime, which doesn't seem optimal, and it isn't, but it works well enough to handle the occasional evals we find in the code."¹ The plan is to drop Boa once native eval support lands in Workers.

That is the kind of admission that makes the rest of the post credible.

What 235,000 WPT Subtests Actually Tell You

Cloudflare's launch post cited "215,000+" Web Platform Tests. The documentation, updated a day later on August 7, 2026, raises that to over 235,000 subtests and breaks out coverage by area.¹²

The high-coverage areas are exactly the ones agents touch: DOM traversal, HTML parsing, text selection, and encoding. URL handling at 83% is the visible soft spot.

Cloudflare attaches its own caveat, and it is the right one: "WPT measures conformance to web standards, not a browser's ability to render and interact with every real-world website."² Standards conformance and site compatibility are different problems, and the second one is harder.

In practice, Cloudflare says Kitesurf correctly renders TodoMVC in vanilla, React, Vue, Angular, and Preact, plus Wikipedia, Hacker News, the Cloudflare Blog, and much of the Cloudflare dashboard.¹²

The Four Things Kitesurf Cannot Do Yet

Cloudflare lists these explicitly, in both the blog post and the docs.¹² Kitesurf is not the right choice if you need to:

• Play video
• Render WebGL
• Negotiate a bot-challenge handshake with real TLS fingerprints
• Start a long-running, authenticated session that requires persistent state

The third one deserves attention. Kitesurf will not look like Chrome to an anti-bot system, because it is not Chrome. For agents operating on sites that fingerprint browsers, that is disqualifying — and it sits awkwardly beside Cloudflare's own bot-detection business.

The fourth follows from the design. Kitesurf is stateless by construction, so a ten-minute authenticated session is not a configuration problem, it is a category mismatch. Cloudflare's answer in both cases is the same: use Browser Run's default, which is Chromium.

For agents that need to prove who they are rather than hide it, the emerging alternative is signed identity rather than fingerprint mimicry — the direction the Web Bot Auth work at the IETF is pushing.

Kitesurf vs Lightpanda vs the Chromium Forks

Kitesurf is not the first browser engine rebuilt for agents, and Cloudflare does not claim it is — the launch post credits obscura as the inspiration.¹ The field now splits into three camps.

The split that matters is not Rust versus Zig. It is whether the engine paints.

Lightpanda's speed comes precisely from never rendering — no image decoding, no compositing, no font rasterization. That makes it superb for extraction and useless for screenshots, which is why toolchains commonly fall back to Chrome for the steps that need pixels.⁴

Kitesurf takes the harder road. It keeps a real paint path, which is why it can serve screenshots and PDFs, and also why its wall time trails Chromium by 1.7–1.8×. Cloudflare traded latency to keep rendering rather than dropping rendering to win latency.

Meanwhile the Chromium forks — Steel's Stealth Browser, announced June 22, 2026, and Browserbase's custom builds — are optimizing for a different constraint entirely: not getting blocked.⁶⁷ Three camps, three different definitions of what an agent's browser is for.

Why the Efficiency Win May Not Reach Your Invoice

Here is the part that is not in the launch post.

Cloudflare says Kitesurf "wins on memory and CPU, the things that actually drive your bill."¹ But Browser Run's published pricing does not meter CPU or memory at all.

As of the pricing page's April 21, 2026 update, Workers Paid customers get 10 browser hours per month included, then pay $0.09 per additional browser hour. Concurrency is billed separately: 10 concurrent browsers included, then $2.00 per additional concurrent browser.

Workers Free is capped at 10 minutes of browser time per day and 3 concurrent browsers.⁸

Browser hours are wall time. On that meter, a task that takes 1.7× longer consumes 1.7× more billable time — Cloudflare totals usage daily in seconds and rounds the monthly sum to the nearest hour.⁸

So the CPU and memory savings currently accrue to Cloudflare's infrastructure, not to the line item on your bill — which is a reasonable read of why Kitesurf is free during beta, and why Cloudflare has not published separate Kitesurf pricing. If those savings are eventually passed through, it will have to be through a pricing change, not through the existing browser-hour meter.

That is worth watching, because it determines whether Kitesurf is a cost story or an infrastructure-density story. Right now the public evidence only supports the second. Agent teams already tracking token and infrastructure cost per task should model both dimensions before assuming a switch saves money.

How to Try It

Kitesurf is opt-in on infrastructure you may already be using. Add browser=kitesurf to a Browser Run endpoint and existing Puppeteer, Playwright, and chrome-remote-interface clients keep working, because Kitesurf speaks CDP.²

For the CDP WebSocket endpoint:

wss://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/browser-run/devtools/browser?browser=kitesurf

For a Quick Action screenshot:

curl -X POST 'https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/browser-run/screenshot?browser=kitesurf' \
  -H 'Authorization: Bearer <API_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"url": "https://example.com"}' \
  --output "screenshot.png"

Any agent that speaks MCP and CDP can drive it through chrome-devtools-mcp pointed at the same WebSocket endpoint.²

If you would rather not write code first, the public playground accepts any URL and injects Chrome DevTools into the UI. The Memory panel reports the WebAssembly footprint of each isolate, including frames — which is the fastest way to see whether a specific site is worth moving.¹²

For teams choosing between hosted agent browsers more broadly, our rundown of AI browser agents from Claude, ChatGPT, and Gemini covers the model-side of the same problem, and the Cloudflare agent runtime post covers the isolate-versus-container bet Kitesurf is built on.

Bottom Line

Cloudflare built a browser by asking which features exist only because a human is looking at the screen — and then not building them.

The engineering is genuinely interesting — a Rust rendering stack compiled to WebAssembly, running inside V8 isolates, with a second JavaScript engine bolted on to cover eval() because the host runtime forbids it. Cloudflare says that last part is not optimal, and it is right.

But read the benchmark table in both directions. The efficiency wins are large and the latency loss is real, and on a meter that bills wall time, the loss is the part your invoice sees today. Twelve weeks old, not open source, no published pricing, and explicitly unsuited to authenticated sessions or fingerprinted sites.

Kitesurf is a major cloud platform betting that agents deserve their own browser engine rather than a borrowed one — while AWS ships a managed Chromium instance for the same job.⁹ It is not yet the browser most production agents should be running on. Try it on the extraction jobs, keep Chromium for everything with a login box, and watch what Cloudflare charges when the beta ends.

Sources