← Blog

BLOG

Browser Based Tools: What They Are and Where They Run

Browser based tools run in a web page or a hosted browser. Learn how they differ from local automation and how AI agents use them in production.

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

Browser based tools are software that runs inside a browser rather than as a native desktop application. That covers two very different things: web apps you open in a tab, and automation tooling that drives a real browser session on a server. This guide separates the two, explains why the distinction matters for AI agents and automation pipelines, and shows how to connect code to a hosted Chromium session over CDP.

If you are evaluating browser based tools for agent workloads, the decision usually comes down to where the browser executes and who owns its lifecycle. A local Chrome install on a developer laptop is fine for a prototype. It stops being fine when you need concurrency, isolation, persistent logins, and a session that survives a worker restart. That is the gap hosted runtimes fill, and it is the focus of the second half of this article.

What "browser based" actually means

The phrase gets used loosely, so it helps to split it into three categories.

Browser based applications. These are tools that run in the browser tab itself — dashboards, editors, chat interfaces, project trackers. The browser is the runtime. Nothing is installed locally beyond the browser. Examples include web-based IDEs, design tools, and most SaaS products.

Browser automation libraries. Playwright, Puppeteer, and Selenium are code libraries that control a browser programmatically. They are not "browser based" in the sense of running in a tab; they run in Node, Python, or another host process and speak to a browser over a protocol. The browser they control can be local or remote.

Hosted browser runtimes. This is the category most relevant to AI agents. A provider runs real Chromium on its own infrastructure, exposes a connection endpoint, and lets your code or agent drive that session remotely. The browser is still a browser — same engine, same rendering, same DevTools protocol — but it lives on someone else's machine and is metered by session time.

When people search for browser based tools in an automation context, they usually mean the third category, or they mean the second category and are about to discover they need the third. The rest of this guide assumes that framing.

Why the hosting question matters more than the tool

A local browser is a single resource with a single lifecycle. One machine, one Chrome profile, one set of cookies, one process tree. That model breaks in predictable ways once you move past a demo:

  • Concurrency. Ten parallel agent tasks need ten isolated browser contexts. On a laptop that means ten processes competing for the same CPU and memory, and a machine that thermal-throttles under load.
  • Isolation. Two tasks that share a profile can leak cookies, local storage, and session tokens into each other. For anything touching authenticated accounts, that is a correctness bug, not a performance one.
  • Persistence. A login flow that takes thirty seconds is wasted work if the session dies when the worker restarts. Persistent profiles let you reuse authenticated state across runs.
  • Observability. When an agent fails at step fourteen, you need to see what the page looked like. A live viewer and session recordings turn a stack trace into a debuggable artifact.
  • Network posture. Some workloads need specific egress IPs or configurable browser settings. Managing that per-machine does not scale.

None of these are solved by picking a better automation library. They are solved by moving the browser off the developer machine and onto infrastructure designed to run many sessions at once. That is the core argument for a hosted runtime, and it is why the remote browser for AI agents model has become the default for production agent work.

The three ways to run a browser for automation

Here is the comparison that matters when you are choosing browser based tools for a pipeline.

ApproachWhere the browser runsIsolationScaling modelBest fit
Local Chrome + PlaywrightDeveloper machine or CI runnerPer-process, shared OSVertical; add machines manuallyPrototypes, single-user scripts, debugging
Self-hosted headless fleetYour own servers or containersPer-container if configuredHorizontal; you operate the schedulerTeams with existing infra and ops capacity
Hosted browser runtimeProvider infrastructurePer-session by defaultHorizontal via API; concurrency is a plan settingAgents, QA fleets, scraping, anything bursty

The middle option is real and worth taking seriously. If you already run Kubernetes and have someone who owns it, self-hosting Playwright in containers is a legitimate path. The cost is operational: you own image builds, browser version pinning, zombie process cleanup, outbound network configuration, and the on-call rotation when sessions start failing at 3 a.m.

The hosted option trades that operational burden for a per-session cost and a dependency on a vendor. The trade is usually worth it when browser sessions are not your core product. If you are building an AI agent, your differentiation is the agent logic, not your ability to keep Chromium containers healthy.

Connecting code to a hosted browser over CDP

The Chrome DevTools Protocol is the common interface. Playwright, Puppeteer, and Selenium all speak it in some form, and a hosted runtime exposes a WebSocket endpoint you connect to. The important detail is that you are not launching a browser — you are attaching to one that already exists.

import { chromium, Browser, Page } from 'playwright';

// The endpoint comes from your runtime's session API.
// Treat it as a secret; it grants control of a live browser.
const CDP_ENDPOINT = process.env.REMOTE_BROWSER_CDP_URL!;

async function runTask(): Promise<void> {
  let browser: Browser | undefined;

  try {
    // connectOverCDP attaches to an existing Chromium instance
    // instead of spawning a new one. No local Chrome required.
    browser = await chromium.connectOverCDP(CDP_ENDPOINT);

    // A hosted session usually starts with one default context.
    // Reuse it so cookies and storage persist for the session.
    const context = browser.contexts()[0] ?? (await browser.newContext());
    const page: Page = context.pages()[0] ?? (await context.newPage());

    await page.goto('https://example.com/login', {
      waitUntil: 'domcontentloaded',
      timeout: 30_000,
    });

    await page.fill('#email', process.env.APP_EMAIL!);
    await page.fill('#password', process.env.APP_PASSWORD!);
    await page.click('button[type="submit"]');

    // Wait on a concrete signal, not a fixed sleep.
    await page.waitForURL('**/dashboard', { timeout: 30_000 });

    const title = await page.title();
    console.log('Landed on:', title);
  } finally {
    // Closing the connection does not necessarily terminate the
    // remote session. Use the runtime's session API to stop it
    // explicitly so you are not billed for idle browser time.
    await browser?.close();
  }
}

runTask().catch((err) => {
  console.error('Task failed:', err);
  process.exit(1);
});

A few implementation notes that save time in practice:

  • Do not call `chromium.launch()`. That starts a local browser. Use connectOverCDP against the endpoint your runtime returns.
  • Reuse the default context. Creating a fresh context per task is correct for isolation but wrong if you want the session's persisted profile. Decide deliberately.
  • Close the session, not just the connection. Disconnecting a client leaves the remote browser running. Idle sessions still consume metered time.
  • Wait on signals. waitForURL, waitForSelector, and network-idle conditions are more reliable than fixed timeouts, especially over a network hop.

The Playwright documentation on connecting over CDP is the authoritative reference for the client side. The Chrome DevTools Protocol spec covers the underlying domains if you need to drop below the Playwright abstraction.

What to check before you commit to a runtime

Not all hosted browser products are equivalent, and the differences show up in production rather than in a demo. Evaluate on these axes.

Protocol access. Does the runtime expose raw CDP, or only a proprietary SDK? Raw CDP means you can use Playwright, Puppeteer, Selenium, or a custom client without rewriting. It also means your existing test suites and agent frameworks work unchanged. If the vendor only offers a closed API, you are locked into their client library.

Session isolation. Are sessions isolated by default, or do you have to opt in? For multi-tenant agent workloads, isolation should be the default, not a configuration flag you remember to set.

Persistent profiles. Can you save and reuse authenticated state across sessions? This is the difference between an agent that logs in every run and one that does not. It also affects cost, since login flows burn browser time.

Live viewer and recordings. Can you watch a session in real time and replay it afterward? When an agent fails, a recording is often the fastest path to the root cause. This is closely related to remote control workflows, where a human takes over a stuck session.

Network configuration. Does the runtime support configurable browser settings for egress, including proxy options? Be specific about what you need — region, IP type, and whether the setting is per-session or per-account.

Usage controls. How is time metered, and can you cap it? A runaway agent loop can burn through a budget quickly. Look for per-session limits and clear reporting. Current rates and plan details are on the pricing page.

Compatibility surface. Confirm which browser engines and versions are available. If your workload depends on a specific Chromium version, verify you can pin it.

Where browser based tools fit in an agent stack

A useful mental model: the agent framework decides *what* to do, and the browser runtime decides *where* it happens. Keeping those concerns separate pays off when either side changes.

  • Swap the agent framework without re-provisioning browser infrastructure.
  • Scale browser concurrency independently of model throughput.
  • Run the same agent against a local browser in development and a hosted session in production by changing one environment variable.
  • Give QA and agent teams the same runtime, so a bug reproduced in one is reproducible in the other.

This separation is also why "browser based tools" is a broader category than any single product. The tool you pick for the agent layer and the runtime you pick for the browser layer are independent decisions, and conflating them is a common source of rework.

If you are starting from scratch, the practical sequence is: get a working script against a local browser, confirm the selectors and wait conditions are stable, then move the connection to a hosted endpoint and re-run. Most failures at that step are lifecycle bugs — sessions left running, contexts reused when they should not be, or timeouts tuned for localhost latency. The remote browser online walkthrough covers that migration in more detail.

Common mistakes

Treating the remote browser as a local one. Network latency to the endpoint is real. Timeouts that work locally at 5 seconds may need to be 30 over a WAN hop. Set them explicitly.

Ignoring session cleanup. Every session you start and forget is metered time. Wrap task execution in try/finally and stop the session in the finally block.

Sharing profiles across tenants. Persistent profiles are convenient and dangerous. Scope them per user or per task class, never globally.

Assuming headless means invisible. Headless Chromium is detectable, and some sites behave differently. If your workload depends on rendering fidelity, test in the mode you will actually run.

Skipping the viewer until something breaks. Turn on recordings from day one. The first incident is not the time to discover you have no replay.

Summary

Browser based tools span web apps, automation libraries, and hosted runtimes. For AI agents and automation pipelines, the hosting decision dominates: local browsers do not give you isolation, concurrency, or persistence at scale, and self-hosting a browser fleet is real operational work. A hosted Chromium runtime with raw CDP access lets you keep your existing Playwright or Puppeteer code, attach over a WebSocket endpoint, and let the provider handle lifecycle and isolation. Evaluate on protocol access, isolation defaults, persistent profiles, observability, network configuration, and usage controls — then check current rates on the pricing page and the connection details in the documentation before you ship.