Cloudflare Kitesurf: What the Agent-First Browser Is and How to Try It

Most AI agents that use the web rely on a browser built for humans. That usually means Chromium, complete with features such as tabs, video, extensions, and precise visual rendering.

An agent rarely cares about any of those things. It wants the page content, the DOM, working JavaScript, and perhaps a screenshot. It would also prefer not to consume several hundred megabytes of memory while finding the price of a toaster.

Cloudflare built Kitesurf around that idea. Kitesurf is a lightweight browser engine designed for AI agents and web automation. It runs on Cloudflare Workers, uses V8 isolates and WebAssembly, and does not have Chromium underneath.

This guide explains what Kitesurf does, how to try it in a few minutes, and when regular Chromium is still the better choice.

Kitesurf at a glance

The simple version is this: Kitesurf gives AI agents the browser features they often need, while leaving out many features built for human browsing.

It is not a browser you install on your laptop. It is also not an AI agent by itself. It is browser infrastructure that an agent or automation system can control.

How to try Kitesurf in two minutes

You can explore Kitesurf without building an agent or writing code.

Option 1: Use the public playground

Open the Kitesurf playground, enter a URL, and load the page.

The playground lets you:

• See how Kitesurf renders a website

• Interact with the page

• Inspect its DOM

• Read console messages

• Watch network activity

• View the memory used by its WebAssembly isolates

This is the fastest way to answer the most useful early question: does Kitesurf work with the websites your agent needs?

Try a simple content page first. Documentation, blogs, Wikipedia pages, and basic web apps are more representative of Kitesurf's current strengths than a video editor or a 3D game.

Option 2: Make one API request

Kitesurf is available through Cloudflare Browser Run. If you already use its API, opting in can be as simple as adding browser=kitesurf to the endpoint.

The following request captures a screenshot:

curl -X POST \
  'https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/browser-run/screenshot?browser=kitesurf' \
  -H 'Authorization: Bearer <API_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"url":"https://example.com"}' \
  --output screenshot.png

You will need a Cloudflare account ID and an API token with Browser Run access. Cloudflare provides the full setup details in its Kitesurf documentation.

Browser Run also provides actions for fetching HTML, extracting Markdown, generating PDFs, retrieving links, inspecting accessibility trees, scraping elements, and returning structured data.

For longer workflows, Kitesurf exposes a Chrome DevTools Protocol, or CDP, endpoint. Existing Puppeteer, Playwright, Chrome DevTools, and compatible MCP clients can connect to it. Kitesurf implements a subset of CDP, so existing clients can connect, but not every command or workflow is guaranteed to work yet.

Why build a browser for agents?

Chromium is very capable because it must serve billions of human users and an enormous range of websites. It supports video, graphics, extensions, accessibility tools, smooth animation, long sessions, and accurate rendering.

That flexibility comes with a cost. A full browser instance uses meaningful CPU and memory, even when an agent only needs to load one page and read a few paragraphs.

The cost becomes more important when an application runs hundreds or thousands of browser tasks at once. Giving every task its own Chromium instance works, but it is a little like sending a moving truck to deliver a sandwich.

Agent workloads often have a different set of priorities:

• Reliable access to HTML and the DOM

• JavaScript execution

• Structured page data

• Screenshots when visual context is useful

• Isolation from untrusted websites

• Low CPU and memory use

• Fast creation of many independent sessions

• Simple disposal after a task is complete

Kitesurf is Cloudflare's attempt to optimize for that list.

How Kitesurf works without Chromium

Kitesurf is not a small Chromium build. Cloudflare assembled a new browser engine from separate components that run across Workers.

Engine

The Engine is the public entry point. It handles HTTP requests and CDP connections, and it stores the state needed for a browser session.

This compatibility layer matters. Developers can use familiar automation clients instead of learning a completely new control protocol.

PageScript

PageScript handles the page itself. It parses HTML and CSS, builds the DOM, and runs JavaScript and WebAssembly found on the page.

Each page or isolated frame receives its own Worker environment. Cloudflare uses parts of the Rust-based Blitz rendering project for HTML and CSS processing, along with Stylo, the CSS engine associated with Firefox.

Most JavaScript runs inside the Worker's V8 isolate. The JavaScript eval() function needs special handling because Workers do not currently support it natively. Kitesurf uses the Rust-based Boa JavaScript engine for those cases. Yes, that means a JavaScript engine sometimes runs inside another JavaScript runtime. Browser engineering has never been afraid of an unusual nesting doll.

PageRenderer

PageRenderer turns the computed page into pixels. It receives a representation of the page, lays out the content, and returns a PNG, JPEG, or PDF.

The renderer is disposable. If a render operation fails or stalls, the Engine can replace it and try again without rebuilding the entire browser session.

SandboxOutbound

Web pages need to fetch scripts, images, fonts, stylesheets, and data. Allowing every browser component unrestricted network access would create a large security surface.

Kitesurf routes network activity through a dedicated SandboxOutbound Worker. This component applies CORS rules, adds browser-like headers, filters responses, and keeps each page's cookies in a separate jar.

Cloudflare's design assumes every page is untrusted. Components receive only the network and application access required for their job. This does not solve every agent security problem, such as prompt injection, but it creates useful boundaries around hostile page code.

Kitesurf versus Chromium

Cloudflare published an early comparison using five Browser Run Quick Action runs across a set of 14 URLs. The test compared Kitesurf with Chromium instances from a warm pool.

The result needs careful wording. Kitesurf was more efficient, but it was not faster.

It used much less CPU and memory for these tasks. That could allow Cloudflare and its customers to run more browser sessions on the same infrastructure. However, each tested request took longer to finish. Cloudflare attributes much of the gap to software rendering and image encoding.

These are Cloudflare's own beta benchmarks over a small URL set. They are useful evidence of the design goal, not proof that Kitesurf will reduce costs or resource use in every application. Developers should test their own pages, commands, and concurrency patterns.

You can review Cloudflare's current figures and test notes in the official comparison.

What can you build with Kitesurf?

Kitesurf is best suited to short browser tasks that can run independently.

Possible uses include:

• Research agents that load and read web pages

• Page-to-Markdown pipelines

• Content and metadata extraction

• Lightweight crawling

• Link collection

• Screenshot and PDF generation

• Accessibility-tree analysis

• Monitoring public pages

• Large batches of simple browser tasks

• MCP-connected agents that need web access

A good Kitesurf workload has many brief tasks, moderate rendering needs, and enough volume for resource efficiency to matter.

For example, imagine an agent that checks 5,000 public product pages and extracts the product name, price, availability, and source URL. Each visit is short. The sessions do not need to share state. A failure on one page should not affect the rest. That workload matches Kitesurf's stateless model.

An agent that logs into an application, completes a multi-step workflow over 20 minutes, plays an instructional video, and opens a WebGL product preview is a different story. Chromium can keep that assignment.

What Kitesurf cannot do yet

Kitesurf is a young beta, not a complete replacement for Chromium.

Cloudflare currently recommends using Chromium when a task needs:

• Video playback

• WebGL rendering

• Pixel-perfect visual output

• A long-running authenticated session

• Persistent browser state

• A bot challenge that checks genuine browser TLS fingerprints

• Browser APIs or CDP commands that Kitesurf has not implemented

Kitesurf passes more than 235,000 Web Platform Test subtests, according to the latest documentation. Cloudflare reports strong coverage for areas such as DOM, HTML, Selection, SVG, encoding, CORS, and XHR.

That number is encouraging, but it does not mean every real website works. Standards tests measure individual browser behaviors. Production websites combine those behaviors with frameworks, third-party scripts, unusual loading patterns, security checks, and years of creative decisions.

The safest adoption pattern is simple:

1. Test the target websites in the playground.

2. Run a small set of real tasks through the API.

3. Compare the output with Chromium.

4. Keep Chromium as a fallback for incompatible workflows.

This hybrid approach lets developers use Kitesurf where it fits without asking a beta browser to solve the entire web on its first week outside the office.

Where Kitesurf fits in Cloudflare's larger plan

Kitesurf is one part of Cloudflare's broader work on what it calls the Agentic Internet.

The company is working on several layers of agent access:

• Markdown for Agents gives agents a lighter representation of page content.

• WebMCP lets websites expose structured actions that agents can call.

• Agent identity tools help websites identify and manage automated visitors.

• Payment and monetization tools aim to support paid access to content and services.

• Kitesurf gives agents a lightweight browser when a website still needs to be rendered or inspected.

Together, these projects suggest a larger goal. Cloudflare wants to provide infrastructure between agents and websites, much as it already provides infrastructure between human browsers and websites.

This context also explains why Kitesurf is more interesting than a reduced browser bill. If websites begin offering content and actions directly to agents, browsers may no longer need to imitate every detail of human interaction. A smaller browser designed around structured access could become enough for a large share of tasks.

Cloudflare explains this wider direction in its Agentic Internet overview.

Should you use Kitesurf today?

Kitesurf is worth testing if you build agents or automations that perform many short web tasks. The public playground makes the first compatibility check easy, and existing Browser Run users can opt in with one query parameter.

The following guide is a useful starting point:

Kitesurf is free while in beta, behind per-account limits. Cloudflare says it plans to improve CDP support, rendering quality, standards coverage, and efficiency. The company also intends to open-source Kitesurf when it is ready. At the time of writing, that is a plan, not a current feature.

A browser that does less, on purpose

Kitesurf asks a useful question: how much browser does an AI agent actually need?

For many tasks, the answer may be less than Chromium provides. An agent needs enough browser behavior to load the page, run its scripts, inspect its structure, and return a useful result. It does not need a tab bar. It is unlikely to complain about the theme.

Cloudflare's first version shows the trade-off clearly. Kitesurf uses less CPU and memory in the company's tests, but it takes longer to complete requests and supports fewer web features. That makes it a specialized option, not a universal replacement.

The practical next step is to choose one real page your agent uses and open it in the Kitesurf playground. If it works, compare the same task through Kitesurf and Chromium. The result will tell you more than any launch benchmark can.

Sources

• Introducing Kitesurf, Cloudflare Blog

• Kitesurf documentation, Cloudflare Developers

• Browser Run Quick Actions, Cloudflare Developers

• Building an open Agentic Internet, Cloudflare Blog