Cloudflare has shipped a web browser with no Chromium anywhere in it. Kitesurf, posted to the company's engineering blog yesterday and picked up across the tech press this morning, is a rendering engine written in Rust that runs inside a V8 isolate on Cloudflare Workers, and it exists for one reason: the thing opening most new browser sessions in 2026 is not a person. On the agent tasks Cloudflare benchmarked, screenshots and HTML extraction, it burns 3.1x to 3.8x less CPU and 4.7x to 7.0x less memory than headless Chromium. It also renders each page roughly 1.75x slower, which is the part most of the coverage is skipping.

That combination is the whole story. Kitesurf is not a faster browser. It is a cheaper one per session, at the cost of being slower per page, and Cloudflare made that trade on purpose because an agent fleet is a very different workload from a human with a laptop.

RelatedMeta's Muse Code Costs 12x Less If You Hand Over Data

Headless Chromium stack compared with the Kitesurf stack Headless Chromium needs a container or virtual machine running a full Chromium process with Blink and V8. Kitesurf runs a Rust engine compiled to WebAssembly inside a V8 isolate on Cloudflare Workers, spun up per request. TWO WAYS TO GIVE AN AGENT A BROWSER Headless Chromium Container or VM Chromium process Blink layout + V8 One page, long lived Kitesurf Cloudflare Workers V8 isolate, per request Rust engine, WASM One page, stateless heavy, warm, human grade light, cold, agent grade genztech.blog
Fig 1 Kitesurf drops the container and the Chromium process. The engine itself is Rust compiled to WebAssembly, running in the same isolate model that already runs Workers code.

What is actually inside Kitesurf?

Cloudflare did not fork Chromium and strip it down, which is what almost every "browser for agents" product before this one did. Kitesurf is assembled from three Rust projects that already existed in the open: Blitz, a modular rendering engine, provides the layout core; Stylo, the CSS engine Firefox ships, does style resolution; and Boa, a Rust implementation of ECMAScript, runs the JavaScript on the page. Cloudflare's engineers credit the open source Rust headless engine Obscura as the direct inspiration. The whole thing compiles to WebAssembly and splits into three pieces internally: an Engine, a PageScript layer, and a PageRenderer.

The compatibility trick is the Chrome DevTools Protocol. Kitesurf speaks CDP, so Puppeteer scripts, Playwright scripts, chrome-remote-interface tooling and MCP browser clients all keep working. Switching costs one query parameter on a Browser Run endpoint:

curl -X POST 'https://api.cloudflare.com/client/v4/accounts/<accountId>/browser-run/screenshot?browser=kitesurf'

Cloudflare says the decision to build this was made twelve weeks before launch. For a from scratch browser engine that already clears 215,000 Web Platform Tests, with hundreds more passing each week, that is an aggressive timeline, and it is only plausible because so much of the hard work was borrowed from Blitz, Stylo and Boa rather than written fresh.

Is it faster than Chromium, or just cheaper?

Cheaper. The distinction matters if you are sizing a workload.

Kitesurf resource use and wall time relative to headless Chromium With headless Chromium set to 1.0, Kitesurf uses roughly 0.29 of the CPU and 0.17 of the memory, but takes about 1.75 times the wall time per page. RELATIVE TO HEADLESS CHROMIUM, SCREENSHOT + HTML EXTRACTION Chromium Kitesurf 1.0 0.29 CPU 0.17 Memory 1.75 Wall time genztech.blog
Fig 2 · benchmark Lower is better on the first two bars and worse on the third. Kitesurf wins decisively on resources and loses on latency, because it renders cold on every request instead of reusing a warm process. Figures from Cloudflare's own published comparison.

Cloudflare is upfront about the latency cost and explains where it comes from: nothing is warm. A headless Chromium session amortises its startup across many page loads, so the second page is cheap. Kitesurf spins up per request, so every page pays the cold cost. If your agent loads one page and stops, Chromium finishes first. If you are running thousands of short, bursty sessions in parallel, which is what agent traffic actually looks like, the memory ceiling is what caps you, and that is where a 4.7x to 7.0x reduction changes how many sessions fit on the same hardware.

 Headless ChromiumKitesurf
EngineBlink, C++Blitz + Stylo + Boa, Rust
Runs inContainer or VMV8 isolate on Workers
Session modelWarm, long livedStateless, per request
Client protocolCDPCDP, unchanged
Video and WebGLYesNo
TLS fingerprintChrome-likeNot emulated
Web Platform TestsEffectively all215,000 and climbing
Price todayMeteredFree beta, capped

What did Cloudflare throw away to get here?

Quite a lot, and the list is more revealing than the benchmark. Kitesurf has no video playback and no WebGL. It has no tabs, no extensions, no themes, no device sync, and limited persistent state. None of that is surprising for a headless product. The interesting omission is TLS fingerprinting.

Anti-bot systems, including Cloudflare's own, lean heavily on the TLS handshake to tell a real Chrome from something pretending to be one. Every serious scraping stack spends real effort making that handshake look right. Kitesurf does not emulate it, which means Kitesurf traffic is trivially identifiable as Kitesurf traffic. Cloudflare lists this under limitations, but read it the other way and it is a design position: this browser is not built to sneak past defenses. It is built for a web where the agent says what it is and the site decides what to do about that.

Why is the company that blocks bots now shipping one?

Because it wants to sell to both sides, and it has been assembling that position for a year. In July we covered Cloudflare's measurement that AI crawlers now touch 52 percent of the web, and its PACT token scheme for separating declared bots from humans. Yesterday it open sourced Cloudflare OS, an agent workspace with a capability based security layer. Kitesurf is the missing piece: the vehicle.

RelatedOpenAI retracts SWE-Bench Pro after finding 30% broken

Owning the browser is strategically better than owning the tollbooth alone. If agents run on Cloudflare's engine, Cloudflare knows the request is an agent without guessing, the publisher gets a clean signal it can price against, and the compute for both the crawl and the block happens on the same network. A browser that refuses to disguise itself is not a limitation in that world. It is the product.

What it means for the market

The obvious exposure is the managed headless browser market that grew up around agent workloads: Browserbase, Browserless, Steel, and the browser tiers of scraping vendors like Bright Data and Zyte. Their pitch is fleets of warm Chromium instances rented by the hour. Cloudflare has just made a functionally compatible alternative free during beta, on infrastructure it already owns, reachable by changing one parameter in code those customers have already written. The switching cost is close to zero, which is the part that should worry them.

For Cloudflare, NET, this fits the pattern the market already prices: land a developer primitive cheap or free, meter it later, and use it to pull adjacent spend onto the network. The signal for investors is not Kitesurf revenue, which will be nothing for a while. It is whether Browser Run session counts show up as a named growth driver on the next couple of earnings calls the way Workers and R2 did. Watch for that phrasing rather than the launch itself.

What to watch · next 6 to 12 months
  • Whether the WPT number keeps climbing. 215,000 tests is a real milestone and still a long way from full coverage. If it stalls, Kitesurf stays a screenshot and extraction tool rather than a general browser.
  • What the beta caps become. Free with per account limits is a pricing question deferred, not answered. The metered price against Browser Run's Chromium tier will tell you what Cloudflare thinks this is worth.
  • Whether anyone else drops Chromium. Kitesurf proves an agent browser can be built on Blitz, Stylo and Boa in twelve weeks. That is a template, and the Rust rendering stack is public.
  • How sites treat a browser that will not hide. If publishers start allowing Kitesurf traffic explicitly while blocking disguised scrapers, the declared agent web stops being a proposal.

Our take

The technically impressive part is the twelve week build. The important part is the TLS decision. Every previous attempt at an agent browser tried to be indistinguishable from a human's Chrome, because the web punished anything that admitted to being automated. Cloudflare is betting that era is ending, and it is in an unusually good position to make that bet true, since it operates the defenses that would do the punishing.

The honest caveat: the wall time number means Kitesurf is not a drop in upgrade. Anyone running a latency sensitive agent loop will feel 1.75x per page, and Cloudflare's own framing quietly assumes your bottleneck is fleet cost rather than response time. That is true for crawling and batch extraction. It is not true for an agent a user is waiting on. Test both before you flip the parameter.

Primary sources

Original analysis by GenZTech. Reporting informed by TechCrunch.