Cloudflare published the code for Kitesurf on November 13, 2026 under the Apache 2.0 license, the browser its platform uses so that AI agents can read and capture web pages. The Cloudflare announcement describes a stateless engine that runs entirely inside Workers: it parses the HTML, applies the CSS, executes each page's JavaScript and generates screenshots without a browser container behind it. There is no hidden Chrome anywhere in the invention.
The account that publishes the Browser Run documentation, the service where both engines coexist, helps put a size on the change. In a screenshot, Kitesurf uses 380 ms of CPU and 57.8 MiB of memory, compared with 1,173 ms and 271 MiB for Chromium. The same report acknowledges that it returns the image later: 1,148 ms versus 637 ms, because here there are no warm processes waiting.
Less machine and more waiting, that is the trade-off. The interest of the announcement is not in the CPU figure, but in the form: the agent's browser stops being a privileged process, with its file system and its session, and becomes a function that is invoked, isolated and shut down when finished.
A browser engine that lives inside a function
Inside the Kitesurf repository the heavy piece is not JavaScript, but a collection of Rust packages compiled to WebAssembly. Blitz handles HTML parsing, the DOM, layout and painting. Stylo takes care of the CSS cascade and computed styles. Boa executes the page's JavaScript and remains as a last resort when the engine cannot use Dynamic Workers. The Linebender libraries provide text composition and 2D graphics, and Krilla produces the PDF. Each project keeps its license and the NOTICE file collects the third-party notices.
The architecture is split into three pieces. Engine manages sessions and client connections, PageScript executes the page and its JavaScript, and PageRenderer draws the result in pixels. Because the engine speaks the Chrome DevTools Protocol, a Puppeteer, Playwright or MCP client connects over WebSocket and issues the same commands as against Chrome.
That protocol is not equivalent to a full Chrome, and the repository admits it without embellishment: some DevTools functions do not respond yet. What there is, though, is enough surface to open a page, read the DOM, click a button and save a screenshot of the result.
Respecting standards
Standards compliance is also published, and there the engine's profile shows. The DOM tests pass at 97%, the HTML tests at 96% and the text selection tests at 99%, while the URL tests stay at 83%. These are figures for an engine that prioritizes what a model needs to read, not the experience of a person browsing a website with a mouse.
The other piece that arrived on September 28, 2026 was WebMCP, the mechanism that allows a website to publish functions that the agent calls instead of simulating clicks. With that, the engine stops guessing which button to press and receives named tools, which lowers the token cost of each task. Since then Kitesurf also covers the full Browser Run API.
The stateless part deserves an explanation, because it shapes almost everything else. Each page lives in an isolated Worker that exists for as long as the task lasts, and nothing survives between visits: no cookies, no cart, no memory of the previous form. Gaining isolation this way is cheap; rebuilding a session with a login and half an order inside, on the other hand, is not so cheap.
For an agent that summarizes news or extracts product listings, the exchange pays off. For one that manages someone else's account protected with two-factor authentication, the engine falls short by design and says so.
What is gained and what is lost with a stateless engine
The documentation's comparison measures two agent tasks, screenshot and HTML extraction, with medians of five runs over a corpus of 14 URLs. Read in full, the table explains why the savings do not come free and why Chromium remains the service's default engine.
| Metric |
Kitesurf |
Chromium in Browser Run |
Difference |
| CPU on screenshot |
380 ms |
1,173 ms |
3.1 times less |
| Memory on screenshot |
57.8 MiB |
271.0 MiB |
4.7 times less |
| Memory when extracting HTML |
39.4 MiB |
273.7 MiB |
7.0 times less |
| Wall time on capture |
1.148 ms |
637 ms |
1.8 times slower |
| Wall time extracting HTML |
820 ms |
472 ms |
1.7 times slower |
The pattern has a simple technical explanation. Chromium warms up a just-in-time compiler and reuses processes across requests, so it responds faster on the first visit. Kitesurf pays the cost of starting a software renderer and offsets it by using far less machine time per page, which is the part that scales badly when there are a thousand agents in parallel.
There are websites this engine does not handle, and the list is explicit: video, WebGL, antibot challenges that require a real TLS fingerprint, and authenticated sessions that last for hours with persistent state. For all of that, the documentation itself says to use Chromium.
That is where the practical limit lies. An agent that buys, books or fills out a three-step form runs into that wall sooner or later, and when it handles money the engine becomes part of the payment path. That ground is being closed off by the micropayment protocols between agents, where MCP and A2A argue over who requests, who signs and who charges for each operation.
An engine that ships without authentication
Self-hosting Kitesurf is one command, and also the risk the repository documents with a warning in capital letters. The engine has no authentication of its own: anyone with the URL can browse the web through your account, connect their CDP client, fire outbound requests under your identity and consume the Dynamic Workers you pay for. The official recommendation is to put Cloudflare Access in front before the first deployment.
Deployment requires the Workers paid plan because each page needs its own isolated Worker, and that detail separates the product from the trade-show demo. The managed version is still in beta and free with per-account limits, so trying it costs nothing while running it does.
The threat model moves with the tenant. Previously the browser ran on someone's machine; now it executes code from an unknown website inside the infrastructure of whoever operates it, with their network, their credentials and their bill.
Incidents of that kind already exist. An AI attack that exposed Chainstack customer data came in through a test server with factory keys and was ultimately attributed to agents exploring the environment without supervision. An agent browser with no gate in front is the same category of failure, with a twist: here the agent also goes out to the internet.
Who audits the browser that pays for you?
Cloudflare published the benchmarks and the compliance dashboard openly, and that decision matters more than it seems when anyone can deploy the engine in their own account. A browser that reads private data and signs payments on someone else's behalf needs numbers a third party can reproduce on their own machine, not a demo that goes well in the presentation. The Apache 2.0 code also allows you to see how each page is isolated, which is where the real security of the invention is at stake.
The fight over agent commerce measures the ambition of the movement. While Google and OpenAI fight over the protocol an agent uses to choose, negotiate and pay, whoever controls the engine that draws the store controls what the agent gets to see. Kitesurf does not win that war this week, but it leaves the engine in the hands of anyone who wants to audit it.