Executive Summary

Cloudflare released Kitesurf on August 6. It is a cloud browser built for AI agents rather than for people. Tabs, themes, extensions, and pixel-perfect 60-frame rendering are all gone. There is no Chromium inside it. The rendering parts are written in Rust, compiled to WebAssembly, and run on Workers, the company's serverless platform.

Across the 14-URL corpus the company published, memory use on HTML extraction fell to a seventh of Chromium's. In exchange, the same runs took 1.7 to 1.8 times longer to finish, because software rendering gets none of the speed that JIT compilation buys. The trade works because what waits at the other end is not a human eye but the next token.

That is where the performance story ends. When infrastructure absorbs the cost of reading the web, the people who make the content are handed a different problem. Of the HTML people see and the structured data agents read, which one is your site's canonical copy? Leave that undecided and the drift between the two becomes the next data quality problem.

Key Numbers

The savings and the payment have to sit side by side for the design to read clearly. The first two numbers are resources Kitesurf spends less of than Chromium. The third is the time it spends more of in return. The last is the company's evidence that a browser without Chromium still handles ordinary pages.

Source: Cloudflare engineering blog, measured across a 14-URL corpus

3.8x

Less CPU on HTML extraction

Against Chromium. Screenshot work comes in at 3.1x

7.0x

Less memory on HTML extraction

Screenshot work comes in at 4.7x

1.8x

Longer to finish the same job

The price of being light. Software rendering gets no JIT benefit

215,000

Web Platform Tests passed

Hundreds more pass every week

How quickly that last number piled up is laid out in a chart the company published alongside the announcement.

Cloudflare's published chart showing Web Platform Tests passing climb from zero to 215,000 over Kitesurf's 12-week build
▲ Passing tests climbed to 215,000 over the 12-week build | Source: Cloudflare engineering blog
1

What Did They Strip Out, and What Did It Cost?

Cloudflare's stated reasoning is simple. Agents do not use tabs, themes, extensions, or syncing across devices. What they weigh instead is token counts, context windows, scale, performance, and cost. Browsers made for people are built in exactly the opposite order of priority. They spend enough memory and compute that giving every agent its own browser stops adding up, and so, the company adds, much of the web is open only to whoever can afford to run expensive models against it.

Kitesurf contains no Chromium. Three Rust components were compiled to WebAssembly and put on top of Workers. Blitz parses the HTML and paints the text, Stylo, borrowed from Firefox, handles CSS, and Boa executes JavaScript. Every page gets its own V8 isolate, and outbound requests pass through a dedicated worker that enforces cookie and CORS boundaries. The structure treats threats specific to agents, prompt injection among them, as a matter of isolation.

Building it took 12 weeks. That schedule was possible because nobody wrote a browser engine from scratch; existing open-source parts were reassembled instead, starting from a prototype that ported the open-source headless engine Obscura onto Workers. It now passes more than 215,000 Web Platform Tests and renders Wikipedia, Hacker News, TodoMVC, and parts of Cloudflare's own dashboard correctly.

Performance was measured against Chromium on a corpus of 14 URLs. Taking a screenshot used 3.1 times less CPU and 4.7 times less memory, and extracting HTML widened the gap to 3.8 and 7.0 times. Wall-clock time in the same runs went the other way, rising by 1.7 to 1.8 times. Normalize Chromium to 1.0 and what was saved and what was given up are not the same size.

Cost of one HTML extraction (Chromium = 1.0) Chromium Kitesurf CPU used 1.0 0.26 Memory used 1.0 0.14 Time taken 1.0 1.8 Fewer resources, more time. The trade holds because no person is waiting on the screen.
▲ Pebblous original diagram, built from Cloudflare's published 14-URL corpus measurements and normalized to Chromium.

Give up speed, save resources. The design comes down to that. A browser 1.8 times slower is unusable if a person is sitting in front of the screen, but an agent opens a page and never shows it to anyone. Where being able to run ten jobs at once matters more than finishing one half a second sooner, the arithmetic flips.

It is free during the beta, within per-account limits. Adding one parameter to the endpoint of Browser Run, Cloudflare's product for driving a browser from code, starts a Kitesurf session instead of a Chromium one. The company says it will open the source once things are ready, so customers can deploy it in their own accounts.

2

A Browser Nobody Installs

Several outlets lined this browser up next to Perplexity's Comet and OpenAI's Atlas within hours of the announcement. Apart from the word browser in the name, the two groups differ in who uses them and how they are sold. One is software a person installs on their own machine so an AI can click through it for them. The other is infrastructure that developers building agents call from a server.

Group Who uses it Products
Consumer agentic browsers End users download and install them Perplexity Comet, OpenAI Atlas, Dia
Developer cloud browsers Agent builders call them from code Browserbase, Browser Use, and now Kitesurf

The top row is being reshuffled right now. OpenAI said on July 9 that it was retiring Atlas, and the service shuts down on August 9, less than ten months after its Mac release in October 2025. The agentic browsing itself does not disappear. It moves into the ChatGPT desktop app and a Chrome extension, on the judgment that it is better to live inside the browser people already use.

In the bottom row, putting Chromium in the cloud has been the standard approach until now. That is the row Kitesurf competes in, and its pitch is that it does not use Chromium at all. Swapping the browser engine is not a story you can sell to a consumer, but it lands as a number for anyone counting the cost of a single session.

Pricing splits along the same line. Installed products are priced per person per month, while infrastructure is priced by how many sessions were opened and how long they were held. In the second model, the memory and compute spent opening one page go straight onto the cost sheet. So dropping Chromium reads here as a statement about unit cost rather than a feature description.

One thing is worth stating plainly. How well agents handle the web remains an open problem with a wide gap to human performance, and Kitesurf is not an attempt to solve it. Smart agent or not, opening a page costs something, and this announcement is aimed at that cost.

Another problem stays open too. Prompt injection, where an agent mistakes a sentence on the page it opened for an instruction from its user, has come up repeatedly with consumer AI browsers, and Anthropic has said publicly that handing a browser to an agent is still risky. That is the backdrop for Kitesurf putting isolation forward as prominently as performance. Isolation, though, separates execution environments; it does not sort out which sentences on a page an agent should refuse to follow.

Diagram of Kitesurf's isolation boundary: an untrusted page's outbound traffic must pass through a Workers isolate boundary and network proxy before reaching the internet
▲ Outbound traffic from an untrusted page crosses the isolate boundary and a network proxy | Source: Cloudflare engineering blog
3

Blocking and Selling From the Same Company

Cloudflare spent the past year making its name on the side that blocks AI traffic. On July 1 it opened a setting that splits AI bots into search, agent, and training categories so each can be handled differently, and from September 15 newly onboarded domains will block the training and agent categories by default on ad-supported pages. Paying publishers per crawl is turning into paying them when the content is actually used in an answer.

A month later, the same company shipped a browser that lets agents read the web more cheaply. It looks like a contradiction, but the two products point at different customers. Crawlers that arrive without permission get blocked, which puts the company on the publisher's side, and agents that arrive with permission get sold infrastructure. One company ends up holding both the gate that controls access and the runtime on the other side of it.

The scale explains the arrangement. By the company's own network measurements, bot traffic passed human traffic in early June, and agent requests grew more than seventeenfold in a year. In the stretch where the web's readers shift from people to machines, whoever owns the gate can sell to both sides.

The publisher's arithmetic has already come out wrong once. Large publishers that blocked crawlers lost visitors while their citations inside AI answers mostly stayed put, something we examined with first-party data, and as training crawls diverged from real-time agent requests, we also covered why one line in robots.txt no longer stops the latter. While the blocking switch loses its usefulness, the cost of reading keeps falling on the other side.

4

Where the Canonical Copy Lives

There is one thing Kitesurf leaves untouched, and it is the content itself. A web page is still a DOM built for a human screen, and an agent still opens it, pulls out the text, and turns it into tokens to read. What Cloudflare did was make that process cheap, not remove it.

One sentence in the same announcement is worth marking for anyone who makes content. What matters to agents, it says, is content structured so machines can read it, and agents are fine if CSS is interpreted a little imperfectly or rendering is not pixel-accurate. The company cutting the cost of reading is saying that what it actually wants is not cheap rendering but a well-structured source.

That leaves publishers with a choice. Keep the HTML people see as the single canonical copy and let agents work it out, or build a separate representation for agents and publish both. The Pebblous blog runs closer to the second. The same article goes out as HTML, as JSON-LD schema, in llms.txt, and over RSS, which means one piece of writing exists in several representations.

The cost that appears the moment you add representations is maintenance. A headline gets fixed but the old one stays in the structured data, a paragraph gets cut but the summary still has it, a date changes on one side only. The human-facing screen looks fine while only the machine-facing copy is wrong, and the publisher does not find out for a while. Data quality problems usually start in exactly this shape.

Keep one canonical copy and maintenance stays cheap while you lose control over what agents read. Keep two and you control the quality but carry the risk of the pair drifting apart. Either way the thing to settle is the same. What is canonical, and are the other representations generated from it automatically?

If you run a site, there are two things worth checking today. Both are questions that need an answer before agent traffic grows further.

  • Is the agent-facing representation generated from the canonical copy automatically? If a person edits both places by hand, drift is a matter of time. Automatic generation surfaces drift as a deployment failure; manual work lets it pile up quietly.
  • Is there a way to notice when the two disagree? Checks that only look at the human-facing screen will not catch an error in structured data. Something has to compare the human side and the machine side against the same standard.

When the readers of the web change, the shape of the web changes with them. This announcement is a case of infrastructure absorbing that change first, and the content side of it is still everyone's own to work out.

Editor's Note

When Pebblous talks about AI-Ready Data, consistency across representations sits next to quality. If the same fact is written one way on a human screen and another way in machine-facing data, the judgments made from that data go wrong along with it.

R

References

Primary sources (Cloudflare)

News coverage