BLOG
Browser With AI Built In: What It Actually Means
A browser with AI built in is more than a chat sidebar. Learn how agent-driven browsing works, where it breaks, and how to run it in production.

A browser with AI built in is a browser where a model can observe the page, decide what to do next, and act on it — clicking, typing, navigating, and reading results — without a human driving each step. That definition matters because most products marketed this way only add a chat panel next to a normal tab. The model can talk about the page, but it cannot reliably operate it. Real built-in AI means the browser exposes a control surface an agent can drive: DOM access, input events, navigation, and a way to verify what happened. This article explains how that control surface works, where local and hosted approaches diverge, and what to check before you depend on either.
What "AI built in" actually requires
Strip away the marketing and an AI-driven browser needs four things working together.
A real rendering engine. The agent must see what a user sees. That means a full Chromium instance that executes JavaScript, loads stylesheets, and runs the same client-side logic as a human session. A headless HTTP fetcher is not a browser with AI built in; it is a scraper with a language model attached.
A programmatic control layer. The model's decisions have to become browser actions. In practice this is the Chrome DevTools Protocol (CDP): a WebSocket interface that exposes page navigation, DOM queries, input dispatch, network events, and screenshots. Playwright, Puppeteer, and Selenium all sit on top of this layer. If a product cannot expose CDP or an equivalent, an agent cannot drive it deterministically.
A perception loop. The agent needs to turn page state into something a model can reason about — accessibility trees, DOM snapshots, screenshots, or extracted text — then act, then re-observe. This loop is where most reliability is won or lost.
Session state. Logins, cookies, and local storage have to persist across steps, or the agent re-authenticates on every action. Persistent profiles are not a nice-to-have; they are the difference between a demo and a workflow.
A browser that has all four is an agent runtime. A browser that has only the first is a browser with a chatbot bolted on.
Two architectures: local extension vs. hosted runtime
Once you accept that the model needs CDP-level control, the next question is where the browser runs.
| Dimension | Local browser + extension | Hosted Chromium runtime |
|---|---|---|
| Where Chromium runs | User's machine | Provider's servers |
| Control surface | Extension APIs, limited CDP | Full CDP over WebSocket |
| Session persistence | Tied to the local profile | Configurable persistent profiles |
| Scaling | One machine, manual | Many isolated sessions via API |
| Network identity | User's IP | Configurable proxy settings |
| Debugging | Local DevTools | Live viewer + CDP |
| Failure isolation | Shares the user's environment | Isolated per session |
| Best fit | Personal assistance, single user | Agents, automation, multi-tenant workloads |
The extension model is genuinely useful for a person who wants an assistant in their own browser. It is a poor fit for anything that needs to run unattended, at volume, or across many users, because the browser is bound to one desktop and one profile. The hosted model moves Chromium off the device and exposes it as an API, which is what most production agent workloads actually need. If you want the longer version of that argument, see Remote browsers for AI agents.
How an agent actually drives the browser
The mechanics are less mysterious than the marketing suggests. A hosted runtime hands you a CDP endpoint. Your agent framework — or your own code — connects over WebSocket and issues commands.
import { chromium } from "playwright";
// The runtime returns a CDP WebSocket endpoint when a session starts.
const cdpEndpoint = process.env.REMOTE_BROWSER_CDP_URL!;
const browser = await chromium.connectOverCDP(cdpEndpoint);
const context = browser.contexts()[0] ?? (await browser.newContext());
const page = context.pages()[0] ?? (await context.newPage());
await page.goto("https://example.com/login", { waitUntil: "domcontentloaded" });
// The agent's decision layer fills these in; the browser layer just executes.
await page.getByLabel("Email").fill("agent@example.com");
await page.getByLabel("Password").fill(process.env.APP_PASSWORD!);
await page.getByRole("button", { name: "Sign in" }).click();
await page.waitForURL("**/dashboard");
// Re-observe: hand structured state back to the model.
const snapshot = await page.accessibility.snapshot();
console.log(JSON.stringify(snapshot, null, 2));
await browser.close();Three details in that snippet matter more than they look.
connectOverCDP attaches to an already-running browser rather than launching one. That is the whole point of a hosted runtime: the browser exists before your code does, and it can outlive a single script. The Playwright CDP documentation covers the connection semantics, and the Chrome DevTools Protocol reference documents the underlying domains.
The accessibility snapshot is a perception choice, not a requirement. Some agents work from screenshots and vision models; others parse the DOM. Accessibility trees tend to be more stable across cosmetic page changes, which is why many production agents prefer them.
browser.close() on a connected browser detaches rather than kills the remote session in most setups. Session lifecycle is managed by the runtime's API, not by the client. That distinction matters for billing and for cleanup.
Where "AI built in" breaks in practice
The gap between a working demo and a dependable agent is almost always one of these four problems.
Perception drift. Pages change. A selector that worked last week now matches a cookie banner. Agents that rely on brittle CSS selectors fail silently; agents that re-observe and re-plan recover. The runtime cannot fix this for you, but it can make recovery cheap by keeping the session alive while the agent retries.
Authentication and state. Multi-step logins, MFA, and session expiry are the most common cause of agent failure in the wild. Persistent profiles help, but they introduce their own problem: a profile tied to one session cannot be used by two concurrent agents without conflicts. Plan profile allocation deliberately.
Network identity. Some sites behave differently for datacenter IPs. Hosted runtimes typically offer configurable proxy settings so you can route traffic through residential or regional egress. This is a configuration concern, not a guarantee — treat it as one more variable to test, not a switch that makes every site cooperate.
Observability. When an agent fails at step 14 of 20, you need to see what the page looked like. A live viewer and session recordings turn a black-box failure into a debuggable one. Without them, you are reading logs and guessing.
None of these are solved by adding a model to a browser. They are solved by treating the browser as infrastructure with the same rigor you apply to a database.
What to evaluate before you commit
If you are choosing a runtime for a browser with AI built in, test against these criteria rather than feature lists.
- CDP fidelity. Can you connect with Playwright, Puppeteer, and Selenium without a translation layer? Partial CDP support shows up as missing domains and flaky input dispatch.
- Session isolation. Does each session get its own browser context, cookies, and storage? Shared state across tenants is a security problem, not a convenience.
- Profile management. Can you create, reuse, and retire persistent profiles through an API? Manual profile handling does not scale past a handful of workflows.
- Live debugging. Is there a viewer you can open mid-session, and can you attach DevTools directly?
- Usage controls. Are concurrency and session duration governed by explicit limits you can query? See pricing for how Remote Browser meters sessions.
- Egress configuration. Can you set proxies per session or per profile, and does the runtime report which egress was used?
- Failure semantics. What happens to a session when your client disconnects? Does it persist, time out, or terminate immediately?
Run your own workload against two or three candidates. A login flow, a multi-page form, and a data extraction task will surface more than any comparison table. The documentation covers how to start a session and connect over CDP if you want a concrete baseline to test against.
Local, hosted, or hybrid
There is a legitimate case for each.
Local makes sense when the agent acts on behalf of one person in their own authenticated browser, and the workload is interactive rather than batch. The extension model fits here, and the privacy story is simple because nothing leaves the machine.
Hosted makes sense when the workload is unattended, needs to scale horizontally, or must run in an environment you control rather than a user's desktop. This is the common case for agent products and internal automation.
Hybrid — a hosted runtime for bulk work, a local browser for interactive assistance — is increasingly common. The two share the same CDP contract, so agent code written against one usually ports to the other with a connection-string change.
The mistake is choosing based on the demo. Choose based on where the workload will run in six months, and whether you can debug it when it fails at 3 a.m. If you want to see what a hosted session looks like end to end, run a remote browser online is a practical starting point.
The bottom line
A browser with AI built in is defined by its control surface, not its chat UI. If a model can observe page state, dispatch real input events, persist session state, and be debugged when it goes wrong, you have an agent runtime. If it cannot, you have a browser with a sidebar.
Remote Browser provides hosted Chromium sessions with CDP access, Playwright/Puppeteer/Selenium compatibility, a live viewer, persistent profiles, configurable proxy settings, and per-session isolation. It is infrastructure for agents, not a consumer browser — which is exactly the layer most "AI browser" products are missing. Start with the documentation, check pricing for current session limits, and test it against a workflow you already know is hard.