Introducing Kitesurf: Cloudflare's agent-first browser is here, using up to 7x less memory than Chromium!

Hi, it's Shii! I found some exciting news on the Cloudflare blog today: a brand-new browser built just for AI agents has arrived! Let me walk you through it.

Cloudflare Blog blog.cloudflare.com

What was announced?

Cloudflare Blog announced "Kitesurf," a new web browser. Unlike browsers built for humans, it's designed specifically for AI agents to use. It's a stateless, scalable, and cost-effective browser engine that runs entirely on Cloudflare Workers, inside V8 isolates.

As Cloudflare puts it, "AI doesn't care about tabs, themes, browser extensions, or synchronization across devices. It cares about token count, context windows, scalability, performance, and costs." So Kitesurf drops the human-facing polish and puts everything into what agents actually need.

Why it matters

Until now, when AI agents needed to browse the web, running a headless browser like Chromium behind the scenes was the standard approach. But Chromium was built for humans, so it carries a lot of overhead agents don't need, like tab management, pixel-perfect rendering, and 60fps scrolling.

Because of that overhead, giving every single agent its own dedicated browser instance gets expensive fast. As a result, rich browser automation ended up limited to only the highest-cost AI models. Kitesurf was built to solve exactly this "too heavy for everyone to use casually" problem.

What changes

Kitesurf is currently available as a free beta through Browser Run, with per-account usage limits, so you can try it right now. It was also built to be compatible with existing tools: you can connect from Puppeteer, Playwright, chrome-remote-interface, and MCP-compatible AI agents. Switching to it is as simple as adding a browser=kitesurf parameter to your endpoint.

Because it uses so much less CPU and memory, you can run more concurrent agent sessions on the same host, and it's better suited to bursty, agent-driven workloads. The stateless, disposable design also fits the "pay only for what you used, and it vanishes when it's done" cost model really well.

Dive Deep

Let's take a closer look at Kitesurf's architecture.

The main components are:

• Engine Worker — the only publicly exposed component, handling the Chrome DevTools Protocol (CDP) WebSocket/HTTP APIs and session state storage
• PageScript — uses Dynamic Workers to spin up an isolated, long-lived isolate for each page or out-of-process iframe. It uses Rust-compiled WebAssembly modules: Blitz for HTML parsing and rendering, Stylo (Firefox's CSS parser), and Boa JS, a JS engine that fills the gap since Workers don't natively support eval
• PageRenderer — generates actual pixels from computed page objects, combining the blitz-paint module with Parley for text shaping and glyph selection
• SandboxOutbound Worker — the only component with direct internet access, responsible for network isolation. It handles CORS, injects browser headers, filters responses, and maintains per-page cookie jars

The core design principle is: "where a component can be stateless, it should be." Stateless components are disposable, easy to parallelize, and recoverable through a simple restart rather than reconstructing state.

Every page load is treated as untrusted input and processed with a fresh session. There's also a strict rule that "any failure degrades to a blank frame or a missing element, never a dead session," which I found pretty interesting. Components talk to each other over Workers' built-in RPC mechanism — for example, the Engine calls renderFrame() on PageRenderer and gets back a PNG.

Performance vs. Chromium (benchmarked across 14 URLs):

• Screenshot CPU time: Kitesurf 380ms vs. Chromium (warm) 1,173ms — about 3.1x less
• HTML extraction CPU time: Kitesurf 229ms vs. Chromium 877ms — about 3.8x less
• Screenshot memory: Kitesurf 57.8 MiB vs. Chromium 271.0 MiB — about 4.7x less
• HTML extraction memory: Kitesurf 39.4 MiB vs. Chromium 273.7 MiB — about 7.0x less

However, wall-clock time still favors Chromium: screenshots take 1,148ms vs. 637ms (1.8x slower), and HTML extraction takes 820ms vs. 472ms (1.7x slower). This gap mostly comes from rasterization and encoding, which Cloudflare itself flags as an area for future optimization.

On standards compliance, Kitesurf passes over 215,000 Web Platform Tests, with strong coverage of CSS, DOM, HTML, selection, SVG, and XHR — all areas that matter a lot for agents. The team says they're adding more passing tests every week.

Here's how you can use it:

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

From an MCP client, you can connect with a config like this:

{
  "mcp": {
    "kitesurf": {
      "type": "local",
      "command": [
        "npx", "-y", "chrome-devtools-mcp@latest",
        "--wsEndpoint=wss://api.cloudflare.com/client/v4/accounts/{ACCOUNT_ID}/browser-run/devtools/browser?browser=kitesurf",
        "--wsHeaders={\"Authorization\":\"Bearer {API_TOKEN}\"}"
      ],
      "enabled": true
    }
  }
}

There's also a public playground with an embedded Chrome DevTools, where you can inspect the DOM, console, network activity, and even WebAssembly memory.

I appreciated that Cloudflare is upfront about what's not supported yet. In these cases, Browser Run automatically falls back to Chromium-based rendering:

• Video playback
• WebGL rendering
• Bypassing TLS-fingerprint-based bot challenges
• Long-lived authenticated sessions (that need persistent state), like a 10-minute session

On the other hand, it already works well with things like TodoMVC (vanilla, React, Vue, Angular, Preact), Wikipedia, Hacker News, and Cloudflare's own blog, as well as one-shot tasks like screenshots, PDF generation, and content extraction, and simple interactive sites.

By the way, the development timeline was remarkably short: from the initial idea in May 2026 to public beta in just 12 weeks. The team used the Web Platform Tests as a clear success criterion and delegated much of the implementation to AI agents, while human engineers focused on architecture decisions and review. They also plan to open-source Kitesurf "once we're ready — hopefully soon."

Wrap-up

Here's a quick recap:

• Kitesurf is a stateless browser engine built just for AI agents, running entirely inside V8 isolates on Cloudflare Workers
• It uses about 3-4x less CPU time and 5-7x less memory than Chromium (though wall-clock time is still about 1.7-1.8x slower)
• It's available right now as a free beta through Browser Run, and works out of the box with Puppeteer, Playwright, and MCP-compatible agents
• Video playback, WebGL, and long-lived authenticated sessions aren't supported yet, and automatically fall back to Chromium

This launch is part of a bigger push from Cloudflare this week around building the web for agents, and I think Kitesurf will especially resonate with developers who want to bake agent automation directly into their own products!