WebMCP arrives in Kitesurf
The web was designed for humans clicking pixels, and agent-driven browsing through simulated clicks is slow and brittle. WebMCP lets sites expose functionality directly as callable functions — for example searchFlights() — rather than forcing agents to guess at DOM elements. Kitesurf now supports it.
Cloudflare has backed WebMCP since its early days: site owners can enable it with a single switch and keep their code untouched, and Browser Run has supported it when driving Chrome beta.
To see it in action, open the public Kitesurf playground, load Cloudflare Radar and check the WebMCP section of the Application tab in DevTools. Radar exposes tools such as navigate-to and set-location that let clients explore the page programmatically. Pointing an agent at Kitesurf shows the model invoking those tools to finish tasks more reliably.
If you target Kitesurf with your AI Agent:
{
"mcp": {
"kitesurf": {
"type": "local",
"command": [
"npx",
"-y",
"chrome-devtools-mcp@latest",
"--wsEndpoint=wss://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/browser-run/devtools/browser?browser=kitesurf",
"--wsHeaders={\"Authorization\":\"Bearer <BEARER_TOKEN>\"}",
"--category-experimental-webmcp"
],
"enabled": true
}
}
}You can see that the AI model can interact with the exposed WebMCP tools which you can use to complete tasks more reliably.
Documentation for WebMCP with Kitesurf and Browser Run is here.
Surface area: standards and isolation
Standard coverage keeps expanding so agents can render more complex pages. The supported list now includes:
JavaScript loading on chunked sites improved through URL-based module resolution, JSON modules and import map handling; imports from URLs ride on the new Cloudflare Workers module registry. Iframes now load at the right moment, stay better isolated, and render text correctly across more languages and encodings.
Because test coverage is how quality stays under control, Web Platform Tests (WPT) remain central. Kitesurf passes 730,000+ subtests — 500,000 more than at launch — and the number keeps climbing.
Optimizing the agentic loop, not page loads
What matters to an agent is the latency of its reasoning loop, not raw page-load speed. Kitesurf's engine internals have been reworked so that DOM traversal, timers and font fetches stay as cheap as possible.
- JS execution: less work crosses between Boa and the DOM, and the boundary behaves more like real web frameworks. Frequent reads such as getAttribute, id and parentNode are answered inside the Wasm DOM rather than traversing Boa → JavaScript shim → Wasm repeatedly.
- Runtime behavior: fewer repeated operations when running timers and loading scripts, memory released from objects no longer needed, and more consistent handling of objects and classes as code crosses between the two JavaScript engines — busy pages run more efficiently.
- Fonts: fetched on demand, fewer language-specific files downloaded for pages that won't use them, characters present on the page checked first, and synthetic italics rendered more faithfully.
Despite the broader standards coverage — closing in on full-featured browsers such as Chrome — wall-clock time and CPU usage stay roughly in line with the launch benchmarks, and have improved in some cases.
Full API coverage in Browser Run
Browser Run is the developer platform product for programmatically controlling headless browser instances, with Kitesurf offered as one of the selectable browser flavors. All flavors have to work across the whole API surface, and as of now Kitesurf has full Browser Run API coverage: CDP, Playwright, Puppeteer and MCP.
Quick Actions — simple interfaces for screenshots, HTML extraction, PDF generation and similar tasks — were previously reachable only through the REST API. They can now be invoked from inside a Worker script via the env.BROWSER.quickAction() binding:
interface Env {
BROWSER: BrowserRun;
}
export default {
async fetch(request, env): Promise<Response> {
return await env.BROWSER.quickAction("screenshot", {
url: "https://example.com",
browser: "kitesurf"
});
},
} satisfies ExportedHandler<Env>;Separating rendering from the page session
Kitesurf splits PageScript, the isolate owning the page session and running page code, from PageRenderer, which turns computed page objects into actual pixels.
Besides isolation and flexibility, this split allows rendering to be relocated — to a client or another Worker — while security-critical work stays server-side inside Cloudflare's network. The same pattern underpins Cloudflare Browser Isolation, which executes untrusted web code at the edge and streams rendering data to clients.
To demonstrate it, PageRenderer was moved to the Playground Worker and patched to emit Kitty, a terminal graphics protocol supported by Kitty itself, Ghostty, WezTerm and others, with a pure ANSI text mode added as a fallback where Kitty is unavailable. Pages can therefore be opened and rendered without leaving the terminal — handy both for glancing at the modern web without context-switching and for inspecting what an agent using Kitesurf "sees".
To install the terminal version of Kitesurf, do this:
$ brew install cloudflare/cloudflare/kitesurfFrom now on just type this in terminal:
$ kitesurf https://blog.cloudflare.com
$ kitesurf --helpHere's a demo of it working.
Scrolling and click events flow back as well, so keyboard, arrow keys and mouse behave as they would in a dedicated browser window. The Silent Space Marine Doom demo also runs in Kitesurf inside the terminal:
What's next
Expect benchmark performance to keep improving and the list of supported standards and WPT coverage to rise quickly; Kitesurf now publishes those results here and here in the open for real-time tracking. Work will continue on scenarios where decoupling Kitesurf from PageRenderer pays off for agents, or where higher frame rates matter.
Open-sourcing remains a commitment, though rapid development is currently the priority — it is coming soon, and the team wants to do it properly so Kitesurf can be supported long term.
The original design goal stands: Kitesurf runs entirely on top of Workers as any customer application would, using only publicly available features and APIs and holding no special privileges. That dogfoods the platform, and is also how Kitesurf stays cheap and scales automatically across the Cloudflare network.
Try it in the refreshed kitesurf.dev playground, or use it in projects through Browser Run. It is available for free while in beta, subject to per-account limits.
