Cloudflare Open-Sources Kitesurf Under Apache 2.0: A Self-Hostable Browser Engine Your Agents Can Drive Over CDP
Cloudflare's Workers-native agent browser is now Apache 2.0. What coding- and web-agent operators can do with a self-hostable browser engine, and the unauthenticated-deploy trap in its own README.
Cloudflare has made good on the promise it repeated at Kitesurf’s August launch and its September WebMCP update: the stateless browser for AI agents is now open source on GitHub under Apache 2.0, announced November 13, 2026 by Celso Martinho, Rui Figueira, Bernardo Pereira and Luís Duarte. You can read the code, run it locally, change it, and deploy your own instance to Cloudflare Workers.
For teams running web-driving coding agents, this is more than a license file. It turns Kitesurf from a managed Cloudflare product into an inspectable, self-hostable agent browser engine — a concrete alternative to both closed commercial sandboxes and per-agent Chromium containers, in a year when agentic browsers have become a mainstream, and injectable, part of the stack.

Why a stateless browser matters for agent operators
Kitesurf runs entirely on Cloudflare Workers. It parses HTML, applies CSS, executes page JavaScript, and renders screenshots without a browser container — no Chromium, no headless Chrome pod, no browser Docker image in your fleet. It speaks the Chrome DevTools Protocol, so existing CDP clients such as Puppeteer connect without changes — a different layer from the WebMCP support Cloudflare added in September, when it turned on agent-callable tools for nearly 100,000 commerce storefronts — and, as the announcement puts it, you can point your AI harness at the local CDP port and watch it take full control.
The practical consequence: an agent browser that scales on demand across Cloudflare’s Workers network with less CPU and memory than a full Chromium instance. If your agents spend most of their browsing time on reading, form-filling and screenshot capture rather than exotic Chrome features, that is a materially cheaper and simpler runtime to operate. Cloudflare is candid in the README that Kitesurf “provides a CDP endpoint, not a full Chrome implementation” and that some DevTools features do not work yet — so treat it as a complement to full-browser lanes, not a drop-in replacement everywhere.
What is actually inside the repository
The engine is assembled from a stack of open-source Rust projects compiled to WebAssembly: Blitz for HTML parsing, DOM, layout and painting; Stylo for CSS parsing and computed styles; Boa for JavaScript inside WebAssembly (used only as a fallback when JavaScript cannot run in Dynamic Workers); Linebender libraries for text layout and 2D graphics; and Krilla for PDF output.
The repo splits into three main parts — the Engine (browser sessions and client connections), PageScript (the page and its JavaScript), and PageRenderer (drawing the result) — with packages for the Rust core, DOM shims, renderer and the Kitesurf CLI laid out separately under packages/. That layout is the audit surface: if you are evaluating Kitesurf as the browser your agents drive, you can now read exactly how a page is parsed, scripted and rendered instead of trusting a managed API.
Running it yourself
Local development follows the usual clone-and-build path: git clone https://github.com/cloudflare/kitesurf.git, pnpm install --frozen-lockfile, then pnpm run dev. The first build compiles the Rust core and its dependencies with Bazel, so expect a long first build; later builds reuse the cache. Wrangler then serves the engine at http://127.0.0.1:8787, where a /health endpoint confirms it is running and the landing page offers a URL form for Chrome DevTools inspection.
The Puppeteer connection is the whole point for agent work:
import puppeteer from "puppeteer-core";
const browser = await puppeteer.connect({
browserWSEndpoint: "ws://127.0.0.1:8787/devtools/browser",
});
const page = await browser.newPage();
await page.goto("https://example.com/");
await page.screenshot({ path: "page.png" });
await browser.disconnect();
Requirements are nontrivial but documented: Bazelisk as bazel, Node.js 22 or newer, pnpm 9.15.4, and GNU tar on macOS.
Deploy to your account — and read the warning first
pnpm run deploy pushes the engine to your own Cloudflare account, where you can use it instead of Cloudflare’s managed Browser Run APIs. Note the plan requirement: Kitesurf uses Dynamic Workers to create an isolated Worker per page, which requires a Workers Paid plan.
The README’s deployment warning deserves to be quoted in every internal runbook that adopts this. The engine has no authentication of its own. A person who has the URL can open DevTools and browse the web through your engine, connect Puppeteer and other CDP clients, send outbound requests from your Cloudflare account, and burn the CPU time and Dynamic Workers your account pays for. The workers.dev URL is public by default and follows a predictable pattern. The prescribed fix is to put Cloudflare Access (or another authentication layer) in front of the Worker immediately — ideally enabling Access for all Workers in the account before deploying, to close the gap between deploy and protection — and to protect Version URLs too. For programmatic CDP access through Access, the repo documents minting a service token and sending CF-Access-Client-Id and CF-Access-Client-Secret headers on the WebSocket connection.
This is the same lesson agent operators keep relearning with managed browser services: a per-agent isolated browser is still your identity and your bill, and an unauthenticated browser endpoint is an open proxy with your Cloudflare account’s name on it.
What to do this week
- Clone and audit the parts you care about — the Engine’s session handling and the PageScript DOM shims determine what your agents can and cannot do in a page.
- Prototype one agent lane against local CDP using Puppeteer or your existing harness, and compare it against your current Chromium-container lane on cost, latency and page compatibility.
- If you deploy, deploy behind Access from minute zero, with service tokens for CDP clients, and treat the
workers.devsubdomain as public until proven otherwise. - Track compatibility before committing: Cloudflare points adopters at its Web Platform Tests evolution page and benchmarks for the current standards-compatibility picture.
Kitesurf was already moving quickly as a managed product; open sourcing it means your agent fleet can now own its browser engine the same way it owns its model routing and its MCP gateways. Fork it, read it, and put an auth wall in front of it.
Sources: Cloudflare blog announcement, cloudflare/kitesurf on GitHub, and the Cloudflare blog index for the November 13, 2026 publication date.