BLOG
Web Based Tools: What They Are and Where They Run
Web based tools run in a browser, not on your machine. Learn how hosted Chromium and CDP change what these tools can do for AI agents.

Web based tools are software you use through a browser instead of installing on your own machine. The application logic lives on a server, and your browser is the client that renders it. That definition sounds simple, but it hides the part that matters for automation: the browser itself is now a runtime you have to manage. When an AI agent or a test harness needs to drive a web based tool, the question shifts from "which tool" to "where does the browser run, and how do I control it." This guide answers that question with concrete architecture, trade-offs, and code.
We'll cover what makes a tool "web based," why the browser layer becomes the bottleneck at scale, how hosted Chromium changes the picture, and how to connect Playwright or Puppeteer over the Chrome DevTools Protocol (CDP). If you want the broader runtime context first, see Remote Browser for AI agents.
What "web based" actually means
A web based tool has three properties:
- Server-side logic. The application runs on remote infrastructure. Your client sends requests and receives rendered output.
- Browser as the client. The interface is HTML, CSS, and JavaScript delivered to a browser engine.
- No local install of the core application. You may install nothing at all, or only a thin client.
Email clients, project trackers, dashboards, CRM systems, and internal admin panels are all web based tools. So are the sites your agents scrape, the forms they fill, and the portals they log into.
The important consequence: the browser is the integration point. Anything that needs to interact with a web based tool programmatically has to speak the browser's language. That means either the site's HTTP API (if one exists and is documented) or browser automation that drives the rendered page.
Why the browser layer becomes the bottleneck
When a human uses a web based tool, one browser on one laptop is fine. When a fleet of agents or a CI pipeline uses the same tool, the browser becomes infrastructure. Three problems show up quickly.
Resource contention
Each Chromium instance consumes memory and CPU. Running ten in parallel on a laptop is uncomfortable; running hundreds requires a scheduler, isolation, and cleanup. Local automation scripts that work in development tend to fall over when concurrency rises.
Environment drift
A locally installed browser updates on its own schedule. Font rendering, TLS behavior, and JavaScript engine versions differ across machines. A test that passes on one developer's laptop can fail in CI because the browser build differs. Pinning versions helps, but now you own a browser distribution pipeline.
State and session management
Web based tools often require login. Cookies, local storage, and session tokens need to persist across runs or be re-established each time. Managing that state locally means writing your own profile store, handling encryption, and cleaning up stale sessions.
These are not exotic problems. They are the normal cost of treating a browser as a runtime. The question is whether you pay that cost yourself or hand it to a hosted layer.
Hosted Chromium: moving the browser off your machine
A hosted browser runs real Chromium on a provider's servers. You connect to it over a network protocol, drive it with the same libraries you'd use locally, and never install a browser binary on the machine running your code.
Remote Browser provides hosted Chromium sessions with CDP access, so Playwright, Puppeteer, and Selenium clients connect the same way they would to a local Chrome instance. Sessions are isolated, support persistent profiles, and expose configurable browser settings for proxy and stealth-related needs. You can watch a session live and control usage through the dashboard. Current plan details are on the pricing page.
The practical difference is where the browser lives:
| Concern | Local browser | Hosted Chromium |
|---|---|---|
| Install and updates | You manage binaries and versions | Provider manages the build |
| Concurrency | Limited by your hardware | Scales with the provider's capacity |
| Session isolation | Manual (separate profiles, containers) | Per-session by default |
| Persistent state | You build a profile store | Built-in persistent profiles |
| Debugging | Local DevTools | Live viewer plus CDP |
| Network egress | Your IP | Configurable proxy settings |
| Cost model | Hardware and ops time | Metered usage (see /pricing) |
Neither column is universally better. If you run a single script once a day, a local browser is simpler. If you run agents continuously or need reproducible environments across many workers, hosted Chromium removes a category of operational work.
Connecting to a hosted browser over CDP
The Chrome DevTools Protocol is the wire format Chrome exposes for automation and debugging. Playwright's connectOverCDP method attaches to an existing browser rather than launching one. That is exactly what you need for a hosted session: the provider launches Chromium, hands you a WebSocket endpoint, and your code attaches.
Here is a TypeScript example using Playwright:
import { chromium, type Browser, type Page } from "playwright";
// The endpoint comes from your hosted session. It is a CDP WebSocket URL.
const cdpEndpoint = process.env.REMOTE_BROWSER_WS_ENDPOINT;
if (!cdpEndpoint) {
throw new Error("Set REMOTE_BROWSER_WS_ENDPOINT before running.");
}
async function run(): Promise<void> {
const browser: Browser = await chromium.connectOverCDP(cdpEndpoint);
// A hosted session usually starts with one default context.
const context = browser.contexts()[0] ?? (await browser.newContext());
const page: Page = context.pages()[0] ?? (await context.newPage());
await page.goto("https://example.com/dashboard", {
waitUntil: "domcontentloaded",
});
// Interact with the web based tool like any other page.
await page.getByRole("button", { name: "New report" }).click();
await page.getByLabel("Report name").fill("Q4 summary");
await page.getByRole("button", { name: "Create" }).click();
await page.waitForSelector("[data-testid='report-created']");
// Do not call browser.close() on a hosted session unless you want to
// terminate it. Disconnecting leaves the session running for reuse.
await browser.close();
}
run().catch((err) => {
console.error(err);
process.exit(1);
});A few details that matter in production:
- `connectOverCDP` vs `launch`.
launchstarts a local process.connectOverCDPattaches to a remote one. Use the latter for hosted sessions. - Contexts and pages. A hosted session may already have a context and page. Reuse them rather than creating new ones blindly, or you'll leak tabs.
- Closing semantics.
browser.close()on a CDP connection disconnects the client. Whether the underlying session terminates depends on the provider's lifecycle rules. Check your provider's docs before relying on either behavior. - Reconnection. If your worker crashes, the session may still be alive. Design for reconnection by storing the endpoint and session ID.
The Playwright `connectOverCDP` documentation covers the full option set, including headers and timeouts. The Chrome DevTools Protocol reference is the source of truth for the underlying domains and commands.
Production criteria for choosing a runtime
If you're evaluating where your web based tools should run, score candidates against these criteria rather than feature lists.
Protocol compatibility
Does the runtime expose CDP directly, or does it wrap it in a proprietary API? Direct CDP means your existing Playwright, Puppeteer, or Selenium code works with minimal changes. Wrappers can be convenient but lock you in.
Session lifecycle control
Can you create, inspect, and terminate sessions explicitly? Can you reconnect to a running session from a different worker? Persistent profiles are useful for tools that require login, but they need clear retention and isolation rules.
Isolation
Are sessions isolated from each other at the process or container level? Shared browser instances across tenants are a security and reliability risk. Ask how cookies and storage are partitioned.
Observability
Can you watch a session live? Can you capture screenshots, console logs, and network activity? Debugging a failed agent run without a viewer is slow. A live viewer plus CDP access covers most cases.
Network configuration
Can you set proxies per session? Are there region options? For web based tools with geo-restrictions or rate limits, this matters. Prefer "configurable browser settings" as the honest description; don't assume undocumented stealth features unless the provider documents them.
Usage controls
How is usage metered, and can you cap it? Look for per-session limits and a dashboard that shows consumption. See /pricing for how Remote Browser meters browser-hours.
When a hosted runtime is the wrong choice
Hosted Chromium is not a default answer. Skip it when:
- The site has a stable, documented API. If you can call an endpoint, do that. Browser automation is slower and more fragile than an HTTP request.
- You need a real user's authenticated session on their own device. Hosted sessions can hold credentials, but they don't replicate a specific person's local browser state.
- Your workload is tiny and infrequent. A cron job that runs one script nightly doesn't justify a new dependency.
- You need a browser engine other than Chromium. CDP is a Chromium protocol. Firefox and WebKit have partial or different support; check before committing.
For everything else — agents that browse continuously, test suites that need reproducibility, scrapers that must survive IP rotation — the hosted model removes real operational work. If you're comparing the online-only options, Remote Browser online walks through what "no local install" actually means in practice.
A migration path that doesn't break your code
The lowest-risk way to move from local to hosted is to keep your automation code identical and change only the connection step.
- Abstract the browser launch. Put
chromium.launch()behind a function that returns aBrowser. Add a branch that callschromium.connectOverCDP(endpoint)when an endpoint is present. - Externalize session state. Move cookie and storage handling into the provider's persistent profiles rather than a local directory.
- Run both paths in CI. Keep a local smoke test and add a hosted integration test. Compare results before cutting over.
- Add reconnection logic. Store the session ID and endpoint so a crashed worker can reattach.
- Instrument usage. Log session duration and page counts so you can forecast cost against the pricing model.
This path lets you validate the hosted runtime against your real workloads before you depend on it. It also keeps the local path available for debugging.
Where this leaves web based tools
The phrase "web based tools" describes where software runs, not how you automate it. But for anyone building agents or test harnesses, the browser is the runtime that determines reliability, cost, and speed. Treating it as infrastructure — hosted, isolated, observable, and connected over a standard protocol — is what separates a demo from a system that holds up.
Start with the protocol. If your tool speaks CDP, you can move between local and hosted runtimes without rewriting your automation. Then pick the runtime that matches your concurrency, isolation, and observability needs. The documentation covers session creation, CDP endpoints, and persistent profiles in detail, and remote web browser covers the runtime model from a different angle. If you need to drive a session interactively, remote control browser explains the viewer and control path.