Kitesurf, Cloudflare's stateless browser for AI agents that runs entirely on Workers, is now open source on GitHub under the Apache 2.0 license. The project was introduced in August and updated in September with WebMCP support, new APIs, and better compatibility; both announcements said the code would be opened up so developers could run their own engine on their own Cloudflare accounts. You can now read the code, run it locally, modify it, and deploy your own instance to Workers.

What Kitesurf does

The engine parses HTML, applies CSS, executes page JavaScript, and produces screenshots without a browser container. It speaks the Chrome DevTools Protocol (CDP), so clients such as Puppeteer can connect to it. The design goal is a lightweight browser for agents: loading pages, running JavaScript and interacting with them at lower CPU and memory cost than a full browser like Chromium, while scaling on demand across Cloudflare's global Workers network. Background on the architecture is in the initial announcement, and usage is covered in Browser Run's developer documentation.

Components and layout

Kitesurf is assembled from Cloudflare's Developer Platform and APIs plus a set of open-source Rust packages compiled to WebAssembly:

  • Blitz handles HTML parsing, the DOM, layout, and painting.
  • Stylo handles CSS parsing, cascading, and computed styles.
  • Boa runs JavaScript inside WebAssembly, used as the last resort only when JavaScript cannot run in Dynamic Workers.
  • Linebender libraries supply text layout and 2D graphics, and Krilla generates PDF output.

Each project keeps its own license; third-party notices are recorded in the repository's NOTICE file. The browser itself has three main parts: the Engine manages browser sessions and client connections, PageScript runs the page and its JavaScript, and PageRenderer draws the result.

The packages — the engine, its Rust core, DOM shims, renderer, and the Kitesurf CLI — each sit in their own folder under the repository's packages directory.

Building and running locally

Check the repository's build requirements, clone the repository, install dependencies, and start the engine:

git clone https://github.com/cloudflare/kitesurf.git
cd kitesurf
pnpm install --frozen-lockfile
pnpm run dev

The initial build compiles the Rust core and its dependencies, so expect it to take a while; later builds reuse the cache. Wrangler then starts a development server at http://127.0.0.1:8787, which you can open in Chrome DevTools or drive programmatically. A NodeJS script using puppeteer looks like this:

import puppeteer from "puppeteer-core";

const browser = await puppeteer.connect({
  browserWSEndpoint: "ws://127.0.0.1:8787/devtools/browser",
});

try {
  const page = await browser.newPage();
  await page.goto("https://example.com/");
  await page.screenshot({ path: "page.png" });
} finally {
  await browser.disconnect();
}

Alternatively, point an AI harness at the local CDP port and let it take control of Kitesurf.

Deploying to your own account

Once local changes and tests are done, you can deploy the engine to your own account and use it there instead of the managed Browser Run APIs. A Workers Paid plan is required, since Kitesurf uses Dynamic Workers to create isolated Workers for pages. From the repository root:

pnpm run deploy

Contributing

The project is under heavy development, with current work aimed at better compatibility (tracked via Web Platform Test evolution), reliability, and efficiency. Forks and contributions are welcome; start with the contribution guidelines. The process is to open an issue with a minimal reproduction or a proposed approach and get vouched by a maintainer before opening a pull request. Focused fixes with tests, clear evidence, and a well-defined scope are easier to review than large rewrites or unrelated cleanup. Non-code help counts too: a small page that reproduces a rendering bug, a failing automation workflow, or a documentation correction all move the project forward.