Cloudflare Open-Sources Kitesurf: A Browser Engine Built for AI Agents, Not Humans
On Nov 13, 2026, Cloudflare open-sourced Kitesurf, its stateless browser engine for AI agents, under Apache 2.0. It runs on Workers with no Chromium container, speaks CDP, and deploys with one command — but it is still experimental, and its public endpoint has no auth by default.

In short: Cloudflare decided to build the browser's job itself
On November 13, 2026, Cloudflare open-sourced Kitesurf. It is a browser engine built for AI agents, running entirely on Cloudflare Workers, with no browser container and no Chromium. The code is on GitHub under the Apache 2.0 license: anyone can read it, change it, and deploy their own instance. Cloudflare promised to open-source it when Kitesurf first appeared in August, repeated the promise in September after adding WebMCP support, and has now delivered on it.
This deserves its own article not because the world needed one more open-source project, but because it points at a growing problem: AI agents open tens of thousands of web pages a day, and traditional browsers were built for humans — heavy, resource-hungry, slow to start. A browser for agents should look different. Kitesurf is Cloudflare's answer: a browser with no windows and no tabs that does just three things — load a page, run its scripts, return the result.
What Kitesurf actually is
In Cloudflare's own words, Kitesurf is a "stateless browser" that runs entirely on Workers. It parses HTML, applies CSS, executes page JavaScript, and renders screenshots, all without a browser container. It exposes the Chrome DevTools Protocol (CDP), so existing clients such as Puppeteer can connect to it directly — no new tooling to learn.
"Stateless" is the key word. A normal browser remembers a lot: logins, cookies, caches, history. Kitesurf remembers none of that. Every task starts with a fresh page and throws it away when done. For agents that is a feature, not a bug: tasks cannot contaminate each other with leftover login state, and there is no need to spin up a heavy browser instance per task.
Cloudflare states its goal plainly: give AI agents a lightweight, efficient browser that can load websites, execute JavaScript, and interact with pages while using less CPU and memory than a full browser like Chromium, and that scales on demand across Cloudflare's global Workers network. In other words, Cloudflare wants to turn "a browser" into a cloud service you can start like a function and discard when done.
What is inside: three parts and a stack of open-source wheels
The repository has three main parts. The Engine manages browser sessions and client connections — it is the dispatcher. PageScript runs the page and its JavaScript. PageRenderer draws the result. A typical task flows like this: a client sends a navigation command over CDP, the Engine spins up a fresh isolated page, PageScript parses the HTML, builds the DOM and runs scripts, and PageRenderer renders the picture, which comes back over CDP as a screenshot.
Notably, Kitesurf does not reinvent every wheel. It builds on open-source Rust packages compiled to WebAssembly: Blitz provides HTML parsing, the DOM, layout, and painting; Stylo provides CSS parsing, cascading, and computed styles; Boa runs JavaScript inside WebAssembly — though the blog is careful to note that Boa is only a last resort, used when JavaScript cannot run in Dynamic Workers; Linebender libraries provide text layout and 2D graphics; and Krilla generates PDF output. Each project keeps its own license, and the repository's NOTICE file documents third-party notices.
All packages — the engine, its Rust core, DOM shims, renderer, and the Kitesurf CLI — live in separate folders under the repository's packages directory. Anyone curious can browse the code directly, which is often faster than reading the docs.
Running it yourself: one command locally, one command to deploy
Running it locally is straightforward. Follow the repository's build requirements, clone the repo, install dependencies, and start the dev server:
git clone https://github.com/cloudflare/kitesurf.git cd kitesurf pnpm install --frozen-lockfile pnpm run dev
The first build compiles the Rust core and its dependencies, so give it some time; later builds reuse the cache. Once started, Wrangler serves a local development server at http://127.0.0.1:8787. You can open that address in Chrome DevTools to try a page, or connect to it programmatically.
The official blog includes a Puppeteer example for connecting to the local instance:
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 your AI harness at the local CDP port and let the agent take full control of Kitesurf. The blog's phrasing is blunt — "agents love CDP" — and it is fair: CDP is an existing standard, so toolchains need no special adaptation for Kitesurf.
When local changes are tested, deploying to your own Cloudflare account is also one command: pnpm run deploy. One prerequisite matters: a Workers Paid plan is required, because Kitesurf uses Dynamic Workers to create isolated Workers for pages. The free plan will not run it, and the blog states this explicitly.
It is not a drop-in Chromium replacement — do not use it as one
The most important part of the blog is arguably what it does not claim. Kitesurf is still experimental, and Cloudflare says so directly: it is under heavy development, and the current focus is making the engine more compatible, more reliable, and more efficient. The repository describes it as a CDP endpoint, not a complete Chrome implementation, and some Chrome DevTools features are still unsupported.
The limits drawn at the August launch still apply: it is not suitable for video playback, WebGL, bot-challenge handshakes that require real TLS fingerprints, or long authenticated sessions that depend on persistent state. Workflows that need browser extensions are out of scope too — extension support was traded away by design. The documentation's advice is to keep using the default Chromium browser for those jobs.
One security detail is easy to miss: the Kitesurf engine has no authentication of its own, and its workers.dev address is public by default. Deploy it without extra protection and anyone can connect to your instance and run pages on it. The first job after deploying should be adding access control, not running tests. That is not an oversight by Cloudflare; it follows from what an "engine" is. But users need to know it before they deploy.
The right mental model is this: Kitesurf fits short, sharp tasks — open a page, read its content, take a screenshot, extract data — such as web scraping, content extraction, automated screenshots, and link checking. It does not fit jobs that need login state, long interaction, or heavy web apps. Keep those two categories apart and the tool works well.
Managed or self-hosted: how to choose
One thing is easy to confuse: before open-sourcing Kitesurf, Cloudflare already offered a hosted service called Browser Run. Same idea — a browser for agents — but the managed version is a hosted API you just call, while the open-source version is engine code you deploy in your own account. Same technology, very different bills.
The managed version needs no operations work and charges per call, which suits small projects with uneven usage or only occasional browser needs. The downside is that behavior is constrained by the platform: what it can and cannot do, and whose hands your data passes through, are decided by the hosted service. Self-hosting puts control in your hands: you can change engine behavior, add your own authentication, rate limiting, and logging, and keep instances inside your own compliance boundary. The cost is the Workers Paid plan plus your own operations and security work.
For a vibe-coded project, a simple test works: ask whether you need to change how the browser itself behaves. If the job is just "open a page, screenshot it, read the content," the hosted Browser Run is enough — no reason to carry operations cost yourself. If you need customization — a separate isolated instance per user, full logs of every render, restricting access to an allow-list of domains — that is where the open-source version earns its keep. There is also a case where self-hosting is not optional: if your project has hard requirements about where data flows, for example users explicitly requiring that page content never passes through a third-party service, deploying your own instance is mandatory.
There is also a hidden bill to count: self-hosting is not "deploy once and forget." Kitesurf is evolving fast, Web Platform Tests compatibility changes month to month, and the repository updates frequently. Deploying it yourself means tracking upstream updates and handling upgrades and regression testing. Small teams should think about that maintenance cost in advance. If you are just trying it out, running it locally is enough; there is no rush to put it in production.
Doing the cost math: what gets cheaper, what gets more expensive
The biggest cost of traditional browser automation is machines: a Chromium instance takes hundreds of megabytes of memory, and concurrency means adding servers. Kitesurf turns the browser into a function on Workers, which changes the cost structure: each task uses few resources, and concurrency scales sideways on the platform instead of on servers you own. For workloads shaped like "thousands of runs a day, a few seconds each," that math is clearly better.
But some things get more expensive. Dynamic Workers are billed by usage: the longer and heavier a task runs, the more you pay. If your task is "open a heavy single-page app, wait for it to load slowly, then interact slowly," usage billing may cost more than a resident instance. The Workers Paid plan itself also has a monthly fee that, for very small personal projects, may exceed the usage charges.
So do not decide on "lighter and faster" alone — measure it with your own real tasks first. The method is simple: pick your three most representative pages — a static content page, a medium-complexity single-page app, and a page that needs login — and run each ten times with Kitesurf and with Chromium, recording time, success rate, and cost. Those three numbers will tell you whether to switch and how much. A migration decision without measured data is just a guess.
One cost is easy to forget: failed retries. An experimental engine still catching up on compatibility fails on some pages more often than Chromium does. Retry every failure once and the cost doubles. Design tasks with a fallback: try Kitesurf first, and if it fails, automatically fall back to Chromium. That keeps the cost advantage of the light engine without letting the failure rate wreck the experience. That fallback pattern is also the usage Cloudflare's own documentation implies.
An afternoon hands-on plan
If you want to verify Kitesurf yourself, there is no need to refactor a project — one afternoon is enough. Step one: run it locally with the four commands from the blog and confirm that 127.0.0.1:8787 responds. Step two: connect with the official Puppeteer example, open your own project's homepage, take a screenshot, and check whether the layout looks obviously broken. Step three: try three more pages — a pure content page, an interaction-heavy JavaScript page, and a page that needs login — and record time and outcome for each.
Step four: try WebMCP. If your project has pages, add a minimal WebMCP endpoint so agents can call structured interfaces directly, then compare "simulate clicks over CDP" against "call the structured interface over WebMCP" for time and reliability. That comparison gives you a felt sense of what "a browser for agents" means, beyond the concept.
Step five: only then decide whether to deploy to your own account. Before deploying, sort out access control: workers.dev is public by default, so add authentication or IP restrictions at minimum. After deploying, start with non-critical jobs such as scheduled screenshots and link health checks, watch the failure rate and cost for a week, and then decide whether to move more work over. After that loop, your judgment of Kitesurf will not be "I heard it is good" but "it works — or does not — for me."
A bigger signal: the browser is becoming agent infrastructure
Seen in this year's bigger picture, open-sourcing Kitesurf is a telling move. First model vendors raced on agents, then agent browsers and agent operating systems appeared, and now an infrastructure vendor like Cloudflare is open-sourcing the browser engine itself, turning it into a building block anyone can deploy.
That suggests an emerging consensus: agents are not a feature inside some app but a new layer of infrastructure. Just as cloud computing turned servers into APIs, someone is now turning "the browser" into an API. Kitesurf's bet is that agents will open so many pages that the Chromium model cannot keep up, and the world will need a browser built from the start for concurrency, statelessness, and on-demand scaling.
Whether that bet pays off depends on how fast compatibility catches up, and on whether developers are willing to adapt their toolchains for it. But for now, the code is on GitHub under Apache 2.0, and anyone can verify it. Cloudflare also keeps a Discord channel for talking with the team directly. For vibe coders, the most practical move is not to refactor a project immediately but to spend an afternoon running it locally and seeing what your own pages look like inside it — that answer is worth more than any review article. One more thing to note: now that it is open source, Kitesurf is likely to evolve faster than it did behind closed doors, because developers everywhere can file issues, submit fixes, and post reproduction pages. Until now only Cloudflare's internal team fixed compatibility problems; now anyone blocked by a page can paste a reproduction into the repository. Once that "find a problem — reproduce it — fix it" loop starts spinning, the compatibility curve should steepen noticeably. Conversely, if you try it now and find a page that renders badly, do not rush to declare it broken — search the repository for a related issue first. There is a good chance someone is already fixing it, or that your reproduction page is exactly what the team needs.

Summary
On November 13, 2026, Cloudflare open-sourced Kitesurf under Apache 2.0, with the repository on GitHub. It is a stateless browser engine running on Workers — no containers, no Chromium — exposing a CDP interface. It runs locally with one command and deploys to your own account with one more, though that requires a Workers Paid plan. It is light, fast, and scales on demand, fitting short jobs like scraping, screenshots, and content extraction. But it is still experimental: no extensions, video, WebGL, or long login sessions, and a deployed instance is publicly reachable with no authentication by default. For vibe coders, the sensible move now is to try it locally and start with non-critical tasks, expanding usage as compatibility catches up.
Comments (0)
Sources
Related articles
On 18 November 2026, Google Research and co-authors posted BuggyMLE to arXiv: bugs injected into 222 working ML repositories, and 14 models slide from 95% on the easiest tier to 9% on the hardest. A 9-billion-parameter model trained easy-to-hard beats Claude Opus 5.5 on the 10-bug tier.
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.