← Blog

BLOG

AI Browser for Windows: Local Chrome vs Hosted Runtime

An AI browser for Windows usually means local Chrome plus automation. Here is where that breaks and when a hosted Chromium runtime is the better fit.

9 min readRemote Browser
Ivory computer towers connected across terracotta platforms in a quiet desert landscape
The infrastructure behind your browserREMOTE BROWSER / ILLUSTRATION

If you are searching for an AI browser for Windows, you probably want one of two things: a desktop browser with AI features built in, or a way to run an AI agent that drives a real browser on a Windows machine. This article is about the second case, because that is where the engineering decisions actually live. The short answer: on Windows, the practical setup is Chromium or Chrome driven over the Chrome DevTools Protocol (CDP) by Playwright, Puppeteer, or an agent framework — and the real question is whether that browser should run on the Windows box in front of you or on a hosted runtime you connect to remotely.

Most teams start local. It works for a demo, then stops working the moment you need concurrency, persistence, or a machine that does not sleep. Below is a concrete comparison of the two paths, the Windows-specific failure modes, and a working TypeScript connection example.

What "AI browser for Windows" actually means

There is no separate browser binary called an "AI browser." An AI browser is a normal Chromium instance plus a control surface. The model reads the page (via accessibility tree, DOM, or screenshots), decides on an action, and issues a command — click, type, navigate — through CDP. Everything else is plumbing.

On Windows, that plumbing has a few well-known shapes:

  • Local Chrome + Playwright/Puppeteer. You launch chrome.exe with --remote-debugging-port=9222 and connect over CDP. Fast to set up, zero cost, and fine for a single agent.
  • Local Chrome + an MCP server. Tools like Playwright MCP expose browser actions to a model as tool calls. The browser still runs locally.
  • Hosted Chromium + CDP endpoint. The browser runs on a provider's infrastructure. Your agent connects to a wss:// CDP URL from anywhere, including a Windows dev machine or a Linux CI runner.

The first two are "an AI browser on Windows." The third is "an AI browser your Windows machine controls." For production agents, the distinction matters more than the label.

Why local Chrome on Windows breaks down

Local Chrome is not a bad starting point. It is a bad *production* runtime, for reasons that are specific and predictable.

Session state is tied to a user profile. Chrome on Windows stores cookies, logins, and extensions in a profile directory under %LOCALAPPDATA%. If your agent logs into a site, that session lives on one machine. Move the agent to a second worker and it starts logged out. Copy the profile directory and you inherit lock files and corruption risk.

Concurrency is limited by the desktop. Each Chrome instance needs memory and a window (or headless process). Running ten agents in parallel on a Windows workstation is possible but fragile — one crashed renderer or a Windows update reboot takes the whole batch down.

The machine has to stay awake. Agents that run on schedules, or that wait on slow third-party flows, need a host that does not sleep, lock, or get unplugged. A laptop is not that host.

Debugging is awkward. When an agent fails at step 14, you want to see the page as it was. With local Chrome you are reading logs and hoping the screenshot saved. There is no shared live view for a teammate to watch.

Environment drift. Chrome auto-updates on Windows. A version bump can change rendering, break a selector strategy, or alter headless behavior mid-week. Pinning versions locally is possible but adds maintenance.

None of these are fatal for a prototype. All of them are the reason teams move to a hosted runtime before they ship.

Local Chrome vs hosted Chromium: a decision table

CriterionLocal Chrome on WindowsHosted Chromium runtime
Setup timeMinutesMinutes (API key + CDP URL)
Cost modelFree software, your hardwareMetered per browser-hour — see /pricing
ConcurrencyBounded by RAM and desktop sessionScales with provider capacity and your plan
Session persistenceProfile directory on one machinePersistent profiles managed server-side
UptimeTied to the workstationIndependent of your machine
Live debuggingScreenshots and logsLive viewer for real-time inspection
Version controlChrome auto-update on WindowsProvider-managed Chromium builds
Network identityYour office or home IPConfigurable proxy settings
Best fitPrototypes, single-agent dev loopsProduction agents, parallel workloads, CI

The table is not an argument that hosted always wins. It is an argument that the choice should be made against your workload, not against a demo.

Connecting an agent to a hosted browser from Windows

The connection path is the same CDP contract you would use locally. Playwright's `connectOverCDP` accepts a WebSocket endpoint, so the only change from local development is the URL.

import { chromium, type Browser, type Page } from "playwright";

type Session = {
  cdpUrl: string; // wss://... from your runtime provider
  sessionId: string;
};

async function openAgentBrowser(session: Session): Promise<{ browser: Browser; page: Page }> {
  const browser = await chromium.connectOverCDP(session.cdpUrl, {
    timeout: 30_000,
  });

  // Reuse the existing context so cookies and storage from a persistent
  // profile are available to the agent.
  const context = browser.contexts()[0] ?? (await browser.newContext());
  const page = context.pages()[0] ?? (await context.newPage());

  page.setDefaultTimeout(20_000);
  await page.goto("https://example.com", { waitUntil: "domcontentloaded" });

  return { browser, page };
}

async function runTask(session: Session) {
  const { browser, page } = await openAgentBrowser(session);
  try {
    const title = await page.title();
    console.log("Loaded:", title, "session:", session.sessionId);
    // Agent loop: read page state, decide action, act, repeat.
  } finally {
    // Disconnect without killing the remote browser if you want to resume later.
    await browser.close();
  }
}

Two details matter in production. First, browser.close() on a CDP connection disconnects your client; whether the remote session terminates depends on the runtime's session lifecycle, so read the docs for your provider. Second, always reuse contexts()[0] when you expect a persistent profile — creating a fresh context silently discards the logged-in state you paid to preserve.

For the full connection model, including session lifecycle and profile handling, see Remote browsers for AI agents.

What to evaluate in a hosted runtime

Not all hosted Chromium is equivalent. When you compare providers — or decide to build your own — check these properties against your workload.

CDP fidelity. You want a real Chromium instance with a standard CDP endpoint, not a shim that emulates a subset of commands. If Playwright, Puppeteer, and Selenium can all connect without special adapters, that is a good sign.

Session isolation. Each agent session should get its own browser context or process. Shared state between concurrent agents causes the worst kind of bug: intermittent, unreproducible, and data-leaking.

Persistent profiles. If your agent logs into a portal once and returns daily, you need profiles that survive session teardown. Ask how profiles are scoped, how many you can hold, and how they are cleaned up.

Live viewer. A real-time view of the running browser is the single biggest debugging accelerator for agent work. It turns "the agent failed" into "the agent clicked the wrong button at 00:42."

Configurable browser settings. Proxy configuration, user-agent, locale, timezone, and viewport should be settable per session. Be precise about what you need: "configurable browser settings" is a real capability; broader claims about disguising browser identity deserve scrutiny and evidence.

Usage controls. Concurrency limits, session timeouts, and per-session metering. If you cannot see what a runaway agent is costing you, you will find out from the invoice.

Data handling. Where do session recordings and profile data live, and how long are they retained? This matters if agents touch customer accounts.

Windows-specific practical notes

A few things trip people up specifically on Windows clients.

  • Path and shell differences. Scripts that assume /tmp or POSIX shells fail on Windows. Keep agent code path-agnostic and use path.join or environment variables.
  • Firewall and proxy. Corporate Windows machines often route traffic through a proxy. A wss:// CDP connection may need explicit allowlisting. Test the connection from the same network the agent will run on.
  • WSL is a valid client. Many teams run the agent inside WSL2 on Windows and connect out to a hosted browser. That combination avoids most local Chrome quirks entirely.
  • Do not tunnel the CDP port through a consumer VPN. Latency on the CDP WebSocket directly degrades agent step time. Connect from a stable network.

If you want to try the hosted path without installing anything locally, run a remote browser online is the fastest way to see the connection model in practice.

When local Chrome on Windows is still the right call

Be honest about the trade-off. Local Chrome wins when:

  • You are developing a single agent and iterating on prompts and selectors.
  • The task requires a browser profile that already exists on that machine and cannot be recreated.
  • You are working with sites that require a specific local network position.
  • Cost sensitivity is extreme and volume is near zero.

In those cases, launch Chrome with --remote-debugging-port and connect Playwright to http://localhost:9222. It is a legitimate setup. Just plan the migration path before you have ten agents depending on it.

A migration path that does not require a rewrite

The good news: if you built against CDP, moving from local Chrome to a hosted runtime is mostly a configuration change. The pattern:

  1. Abstract the endpoint. Put the CDP URL behind an environment variable. Local dev points at http://localhost:9222; staging and production point at your runtime's wss:// URL.
  2. Stop assuming a fresh browser. Write agent code that reuses the first context and page, so persistent profiles work identically in both environments.
  3. Move secrets out of the profile. Credentials stored in a local Chrome profile do not travel. Use your runtime's profile management or a secrets store the agent reads at session start.
  4. Add session observability. Log session IDs alongside agent step logs so a failed run can be traced to a specific browser session and replayed in the live viewer.
  5. Set usage guardrails. Cap session duration and concurrency before you turn on parallel workloads.

This sequence lets you keep local development fast while running production agents on infrastructure that does not depend on a Windows desktop staying awake.

Bottom line

An AI browser for Windows is Chromium plus a control protocol. The browser binary is not the interesting decision — the runtime is. Local Chrome is the right tool for building and debugging a single agent. A hosted Chromium runtime is the right tool for running agents in parallel, preserving sessions, and debugging failures you cannot reproduce. Start local if you are prototyping; move the runtime before you scale, and keep the CDP contract as the seam between the two.

For connection details, session lifecycle, and profile behavior, start with the documentation. For current metering and plan details, see /pricing.