> ## Content Index
> Fetch the complete content index at: https://wordsandweights.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Inside Cloudflare's Kitesurf for AI Agents
- URL: https://wordsandweights.com/a-browser-without-tabs-runs-doom/
- Published: 2026-08-11T09:14:03.000Z
- Updated: 2026-08-17T22:32:15.000Z
- Author: Vivek Mahato

It is May 2026 and somewhere at Cloudflare, someone finds a GitHub repo called [obscura](https://github.com/h4ckf0r0day/obscura?ref=wordsandweights.com) — a headless browser engine written in Rust with "no Chrome, no Node.js, no dependencies." The person shares it with their team, feeds it to an AI coding agent with a detailed plan, and asks it to port obscura to Cloudflare Workers.

It barely works. But it works enough to make the team sit up straight.

Twelve weeks later, on August 6, the same team announces **Kitesurf** — a web browser built entirely for AI agents, running on Cloudflare's serverless Workers platform, using less memory than Chromium for some tasks and passing more than 215,000 web platform tests.

Here's what it actually is, why it matters, and what it isn't.

## The Problem With Browsers for AI Agents

Most AI agents that interact with the web today use Chromium under the hood. Headless Chrome. Puppeteer. Playwright. These tools work — but they were built for humans first, machines second.

A human browser needs tabs, themes, extensions, smooth 60fps scrolling, pixel-perfect rendering, device sync, and a thousand other things that have nothing to do with what an AI model actually cares about: token count, context windows, cost, and the ability to extract structured content from a page.

Chromium eats 271 megabytes of RAM to take a screenshot. Kitesurf takes 57.8 MB. Chromium needs 273.7 MB to extract HTML. Kitesurf needs 39.4 MB. Those aren't small differences. They're the difference between running hundreds of concurrent agent sessions on a single worker and running twenty.

> AI doesn't care about tabs, themes, browser extensions, or synchronization across devices. It cares about token count, context windows, scalability, performance, and costs.
> 
> — Celso Martinho, Ruskin Constant, and Rui Figueira, Cloudflare

## How Kitesurf Is Built

Kitesurf is not a fork of Chromium. It's built from three independent components, each a separate Cloudflare Worker:

**The Engine** — The public-facing component. It handles the Chrome DevTools Protocol (CDP) over WebSocket and HTTP REST APIs, serves a landing page for internal testing, and stores each session's state. Everything else is stateless.

**PageScript** — Handles every page load or out-of-process iframe. Uses Cloudflare's new Dynamic Workers feature to spin up a long-lived isolate with a clean `globalThis` and a DOM document object. HTML parsing uses a module from [Blitz](https://github.com/DioxusLabs/blitz?ref=wordsandweights.com), a modular rendering engine. CSS parsing uses [Stylo](https://github.com/servo/stylo?ref=wordsandweights.com), Firefox's high-performance CSS parser. JavaScript execution uses [Boa JS](https://boajs.dev/?ref=wordsandweights.com), a Rust ECMAScript engine. Everything is compiled to WebAssembly and runs natively on Workers.

**PageRenderer** — Generates actual pixels from the computed page objects. Fetches fonts and images from Static Assets, rasterizes everything into an image buffer, and returns it as JPEG/PNG or PDF. It holds no page state — only a disposable cache — so the engine can kill and relaunch it on any failed or stuck call.

The browser is written in Rust and compiled to WebAssembly using `wasm-bindgen`, avoiding the bulky emulation layers that Emscripten introduces. Each component is isolated and gets only the resources it needs. Every page load is untrusted input. Every session starts fresh.

For JavaScript evals — which Workers don't natively support — Kitesurf runs Boa as a runtime on top of a runtime. "It doesn't seem optimal, and it isn't," the team writes. "But it works well enough to handle the occasional evals we find in the code."

## The Benchmarks

Cloudflare ran a 14-URL test corpus across five quick-action runs each and compared Kitesurf against a warm-pool Chromium instance. Here are the medians:

| Metric                      | Kitesurf | Chromium | Difference       |
| --------------------------- | -------- | -------- | ---------------- |
| CPU (screenshot)            | 380 ms   | 1,173 ms | 3.1× less CPU    |
| CPU (HTML extraction)       | 229 ms   | 877 ms   | 3.8× less CPU    |
| Memory (screenshot)         | 57.8 MB  | 271.0 MB | 4.7× less memory |
| Memory (HTML extraction)    | 39.4 MB  | 273.7 MB | 7.0× less memory |
| Wall time (screenshot)      | 1,148 ms | 637 ms   | 1.8× slower      |
| Wall time (HTML extraction) | 820 ms   | 472 ms   | 1.7× slower      |

Chromium wins on wall-clock time because its JIT compiler, after seeing a page once, always beats a cold software renderer — by about 1.7×. Most of that gap comes from rasterization and JPEG/PNG encoding, which the team is still optimizing.

But memory and CPU are what drive infrastructure bills. On those metrics, Kitesurf wins by 3-7×, and that's the real story. Lower resource usage means more concurrent agent sessions at lower cost.

## What Kitesurf Actually Is

Kitesurf is an ephemeral, fully-isolated, stateless rendering engine designed to exist only for the duration of a task. It scales for bursty, AI-driven workloads where you can kill a stalled session and spin up a new one without losing anything.

It passes 215,000+ Web Platform Tests and adds hundreds more each week. The parts of a browser that matter most to agents — CSS, DOM, HTML, selection, SVG, and XHR — have good coverage already.

It works with Puppeteer, Playwright, `chrome-remote-interface`, and any MCP client that speaks CDP. You add a single parameter (`browser=kitesurf`) to the Browser Run CDP endpoint and everything already works.

The team has tested it against TodoMVC (vanilla, React, Vue, Angular, Preact), Wikipedia, Hacker News, the Cloudflare Blog, and much of the Cloudflare dashboard. All render correctly.

## What Kitesurf Is Not

Kitesurf is not a Chromium replacement. It will not play video, render WebGL, negotiate a bot-challenge handshake with real TLS fingerprints, or maintain a ten-minute authenticated session with persistent state. For those use cases, the default Chromium-based Browser Run is still the right tool.

The team is honest about this: *"If you need to play video, render WebGL, or start a ten-minute authenticated session that requires persistent state — Kitesurf isn't yet the right option. Just use Browser Run's default."*

## Why This Matters

Bots now generate most web traffic, with AI agent activity growing nearly 8,000% in the past year. The idea of running a full Chromium instance for every AI agent that needs to read or interact with a webpage is becoming expensive fast.

Kitesurf is a bet that a purpose-built browser — stripped of everything humans need but keeping everything agents do — can serve that workload at a fraction of the cost. It's not the first headless browser for AI (obscura came first, and Cloudflare credits it as the initial inspiration), but it's the first to run entirely on serverless isolates with zero cold starts and true statelessness.

Cloudflare is simultaneously building the infrastructure for agents that work (Kitesurf) and blocking the bots that take (their AI crawler paywall system). *"Charge the bots that take, and give the bots that work a cheaper, purpose-built tool to work with,"* The Next Web puts it.

The team plans to open-source Kitesurf "hopefully soon" and eventually let customers deploy their own instances on their own accounts.

## The Most Important Test of All

No matter how many tests you have, a project isn't truly complete until Doom runs on it. Kitesurf runs Doom.

It also runs [this](https://kitesurf.cloudflare.app/?ref=wordsandweights.com), a public playground where you can type in any URL and watch the page render, inspect the DOM, read console messages, and see memory metrics for each WebAssembly isolate in real time.

Give it a URL. Watch it render. You'll see a browser without tabs, without themes, without extensions — and somehow, still a browser.

---

*Sources: [Cloudflare blog](https://blog.cloudflare.com/kitesurf/?ref=wordsandweights.com) (Aug 6, 2026), [TechCrunch](https://techcrunch.com/2026/08/07/cloudflare-launches-kitesurf-a-browser-built-for-ai-agents/?ref=wordsandweights.com) (Aug 7, 2026), [The Next Web](https://thenextweb.com/news/cloudflare-kitesurf-browser-ai-agents-workers?ref=wordsandweights.com) (Aug 7, 2026), [Browser Run docs](https://developers.cloudflare.com/browser-run/?ref=wordsandweights.com)*