Skip to main content
← All news
ai-agents

Cloudflare Built a Browser for Agents, Not Humans, and Put It on Workers

By AgentRiot Editorial

Kitesurf is a Chromium alternative for agent workloads: Rust/Wasm pieces, V8 isolates, CDP compatibility, 3–7× less CPU/memory on Cloudflare’s corpus, and an honest list of things it still cannot do.

Cloudflare Kitesurf agent browser on Workers Aug 2026
cloudflarekitesurfbrowser-runagentsworkerscdppuppeteerplaywright

On August 6, 2026, Cloudflare Developers posted a short launch note: Chromium is too heavy to hand every agent one, so the company built Kitesurf - a browser for agents that runs entirely on Cloudflare Workers, spins up per request, and is free in beta through Browser Run.

That X post is the signal. The source of record is the engineering blog and Browser Run docs. Together they describe something more specific than “another headless Chrome on the edge.” Kitesurf is not a lighter Chromium pack. It is a different browser stack aimed at agent economics: token-relevant structure, isolation, and disposable sessions instead of tabs, themes, extensions, and pixel-perfect human chrome.

The problem Kitesurf is actually solving

Browser Run already gives agents headless automation. The growth problem Cloudflare names is cost and density. Full browser engines were built for people. Memory and CPU that are acceptable for one interactive tab become painful when every agent task wants its own instance.

Cloudflare’s framing is blunt: agents care about context windows, scalability, and bill shape. They do not need smooth 60-fps scrolling or a theme engine. They do need structured content, screenshots or HTML they can reason over, and a threat model that includes prompt injection and untrusted tool output.

Kitesurf is Cloudflare’s answer after twelve weeks of work (first commit in May 2026): keep the automation surface agents already speak, throw away the human browser product surface, and run the result inside Workers isolates.

What shipped

Product shape

  • A stateless, agent-first browser that runs on Workers / V8 isolates.
  • Delivered through existing Browser Run surfaces.
  • Opt-in with browser=kitesurf on CDP and Quick Action endpoints.
  • Free while in beta, still subject to Browser Run per-account limits.
  • Public playground at kitesurf.cloudflare.app, with injected Chrome DevTools and Wasm memory visibility.

Compatibility surface

Because the Engine speaks a useful subset of the Chrome DevTools Protocol, existing clients keep working: Puppeteer, Playwright, chrome-remote-interface, and agents that drive browsers over MCP/CDP. Cloudflare’s docs show the same pattern for Opencode-style MCP config and for one-shot screenshot Quick Actions - add the query parameter, keep the client.

That is the operator-friendly part. You do not learn a proprietary “agent browser API” to try the beta. You point a CDP client at Browser Run and select Kitesurf.

Architecture in one pass

Cloudflare’s blog is unusually concrete about internals. The useful mental model:

  1. Engine - public face; CDP WebSocket / REST; holds session state. Everything else is meant to be disposable.
  2. PageScript - Dynamic Worker isolate per page / OOPIF; clean globalThis + DOM; HTML/CSS parsing via Rust pieces (Blitz modules, Servo’s Stylo) compiled toward Wasm.
  3. PageRenderer - stateless raster path; Engine asks for a frame over Workers RPC and gets JPEG/PNG/PDF-ready buffers back.
  4. SandboxOutbound - single network choke point for origin fetches, CORS, browser-shaped headers, cookie jars, and policy denials.

Design rules Cloudflare calls out: degrade faults to blank frames rather than dead sessions; isolate untrusted pages hard; keep components stateless wherever recovery should mean “start over.”

Evals are the awkward corner case. Workers still do not support native eval, so Kitesurf runs Boa, a Rust ECMAScript engine, as a runtime-on-runtime for occasional eval paths, with a planned migration when native eval lands.

None of that is “rewrite Chromium in Rust.” It is a Workers-native browser assembled from Rust/Wasm engines, isolate boundaries, and CDP glue.

The numbers Cloudflare published

On a fixed 14-URL corpus, medians of five Browser Run Quick Action runs (Chromium from a warm pool):

MetricKitesurfChromium (warm)Relative
CPU screenshot380 ms1,173 ms3.1× less CPU
CPU HTML extraction229 ms877 ms3.8× less
Memory screenshot57.8 MiB271.0 MiB4.7× less
Memory HTML extraction39.4 MiB273.7 MiB7.0× less
Wall time screenshot1,148 ms637 ms1.8× slower
Wall time HTML extraction820 ms472 ms1.7× slower

Read the table the way Cloudflare does: Kitesurf wins the resources that drive concurrency and bill shape; Chromium still wins the stopwatch because a warm JIT plus mature raster path beats a cold software renderer. Vendor corpus, vendor harness. Useful directional evidence, not an independent bake-off across the whole web.

Conformance is tracked with Web Platform Tests. The launch blog cites roughly 215,000+ passing tests and rising weekly; Browser Run’s Kitesurf docs, as fetched the same day, say over 235,000 subtests with strong agent-relevant areas (DOM/HTML/selection/SVG/CORS/XHR coverage in the mid-to-high 90s on the published table). Treat the exact count as moving; the direction is “agent-useful web platform surface expanding fast,” not “full Chrome parity.”

When to use it - and when not to

Cloudflare is unusually clear about non-goals. That honesty is the difference between a launch post and a usable routing rule.

Use Kitesurf when:

  • The job is ephemeral: screenshot, HTML/markdown extract, PDF, scrape, short agent browse.
  • You can accept non-pixel-perfect rendering.
  • Burst density and memory/CPU matter more than lowest single-request wall time.
  • The site is in the “works today” class Cloudflare names (TodoMVC stacks, Wikipedia, Hacker News, Cloudflare blog/dashboard chunks) or passes a playground check.

Keep default Chromium Browser Run when you need:

  • Video playback or WebGL.
  • Bot-challenge handshakes that depend on real TLS fingerprints.
  • Long authenticated sessions with persistent state.

That third bullet matters for agent builders. Kitesurf is optimized as a task-scoped engine, not a ten-minute logged-in coworker browser. If your workflow is “log in, keep cookies warm, click through a multi-step console,” Chromium remains the documented path.

Also do not confuse free in beta with a permanent free browser tier. Browser Run still has plan limits. Free-plan accounts remain tightly capped on browser time and concurrency; paid plans lift those ceilings under Browser Run pricing. Kitesurf is an engine choice inside that product, not a bypass of account limits.

Why this is an AgentRiot story

Agent infrastructure is splitting into two browser problems:

  1. Faithful human web - fingerprint realism, long sessions, hard sites, pixel truth.
  2. Cheap disposable web - many short agent actions, isolation by default, cost that does not explode with parallelism.

Most “browser for agents” products still solve (1) with managed Chromium. Kitesurf is an explicit bet on (2), built by the company that already sits in front of a huge fraction of origin traffic and already sells Browser Run.

The strategic tension writes itself. Cloudflare protects sites from automated abuse and now sells agents a lighter browser to automate sites. Replies under the launch post immediately asked whether Kitesurf “passes Cloudflare bot protection.” Cloudflare’s own docs answer the practical version: if you need bot-challenge negotiation with real TLS fingerprints, use Chromium. Kitesurf is not marketed as a stealth browser.

The durable product claim is narrower and stronger: for agent tasks that only needed a throwaway renderer and a CDP socket, you may no longer need a full Chrome process on every call.

What to try first

  1. Open the playground and hit your target URLs. Watch console + memory panels.
  2. Point an existing Puppeteer/Playwright/MCP CDP client at Browser Run with browser=kitesurf.
  3. Benchmark your corpus on screenshot/HTML extract cost and failure modes, not just Cloudflare’s 14 URLs.
  4. Keep a Chromium fallback path for auth-heavy or challenge-heavy flows.
  5. Watch the Browser Run changelog. Cloudflare says open source is planned once ready, and CDP/WPT/rendering work is ongoing.

Bottom line

Kitesurf is a twelve-week, Workers-native, agent-scoped browser with CDP on the front door and Rust/Wasm machinery underneath. Cloudflare’s own numbers say it trades wall-clock speed for large CPU/memory wins on common agent actions. The docs are equally clear about the jobs it should lose.

If you build agents that browse, the useful decision is not “is this Chrome?” It is “is this task disposable enough that a lighter isolate browser is the right default?” For that class of work, Kitesurf is now a first-party option on Cloudflare’s network - free in beta, opt-in, and worth a corpus test before you keep paying Chromium prices for HTML extraction.

Sources