← Blog

BLOG

Axiom Browser: What It Is and How to Run One

Axiom browser explained: what the term covers, how it maps to hosted Chromium runtimes, and how to connect an agent over CDP with Playwright.

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

An axiom browser is not a single shipped product with a canonical spec. In practice, the term is used two ways: as a name for a browser runtime built around a fixed set of operating assumptions (an "axiom" you design against), and as a search term people use when they want a browser that an AI agent or automation script can drive reliably rather than a browser a human clicks through. This guide treats it as the second meaning — a browser runtime you can control programmatically — and shows how to stand one up on hosted Chromium, connect over the Chrome DevTools Protocol (CDP), and keep it stable in production.

If you are evaluating runtimes rather than reading for background, the short answer is: an axiom browser is only as good as its control surface. You want a real Chromium instance, a CDP endpoint you can attach to, session isolation, persistent profiles when you need them, and metered usage you can reason about. Everything else is configuration.

What people mean by "axiom browser"

The term shows up in a few overlapping contexts, and it helps to separate them before you pick a runtime.

As a design-axiom browser. Some teams use "axiom" to describe a browser whose behavior is pinned to a small set of invariants — fixed viewport, fixed user agent, fixed locale, deterministic network policy — so that agent runs are reproducible. This is a configuration philosophy, not a vendor. You can implement it on any Chromium you control.

As a generic "agent browser." Most searches for the term are really asking: how do I give an AI agent a browser it can actually operate? That is a runtime question, and it is the one this article answers.

As a misremembered product name. There is no widely documented standalone "Axiom Browser" product in the browser-automation space. If you arrived here looking for a specific download, the practical substitute is a hosted Chromium runtime you connect to over CDP — the same architecture used by every serious agent browser today.

The distinction matters because it changes what you evaluate. A branded browser is judged on features; a runtime is judged on control surface, isolation, and cost predictability.

Why agents need a dedicated browser runtime

A local Chrome window is fine for a human. It is a poor substrate for an agent for four reasons:

  • State leaks. Cookies, localStorage, and cached credentials from your personal browsing contaminate agent runs, and agent runs contaminate each other.
  • No clean control endpoint. Launching Chrome with --remote-debugging-port works on a laptop and falls apart when you need ten concurrent sessions across workers.
  • No isolation boundary. One runaway agent can pin CPU, fill disk with downloads, or navigate to something you did not intend.
  • No metering. You cannot attribute cost per task if every run shares one machine.

A hosted runtime addresses all four. Each session is a fresh Chromium process with its own profile directory, its own CDP endpoint, and its own lifecycle. You create it with an API call, drive it, and stop it. For a deeper treatment of the architecture, see Remote browsers for AI agents.

The control surface: CDP is the contract

Whatever you call the browser, the thing your code talks to is CDP. Chromium exposes a WebSocket endpoint that speaks the DevTools Protocol, and every major automation library — Playwright, Puppeteer, Selenium via a bridge — can attach to it. The Chrome DevTools Protocol documentation is the authoritative reference for the domains you will use: Page, Runtime, Network, DOM, and Target.

A hosted runtime's job is to hand you a webSocketDebuggerUrl and keep it alive for the life of the session. That is the whole contract. If a provider gives you that, you are not locked into their SDK.

Connecting Playwright over CDP

Playwright's connectOverCDP is the standard path. The example below assumes you have created a session through the Remote Browser API and received a CDP WebSocket URL. It is TypeScript, but the shape is identical in Python.

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

type Session = {
  id: string;
  cdpUrl: string; // wss://... from the session-create response
};

async function runTask(session: Session): Promise<void> {
  let browser: Browser | undefined;
  try {
    browser = await chromium.connectOverCDP(session.cdpUrl, {
      timeout: 30_000,
    });

    // A hosted session usually starts with one default context.
    const context: BrowserContext =
      browser.contexts()[0] ?? (await browser.newContext());

    const page: Page = context.pages()[0] ?? (await context.newPage());

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

    // Wait on a real signal, not a fixed sleep.
    await page.waitForSelector("h1", { state: "visible" });

    const heading = await page.locator("h1").innerText();
    console.log("heading:", heading);

    // Capture evidence for the run record.
    await page.screenshot({ path: `artifacts/${session.id}.png` });
  } finally {
    // Closing the CDP connection does not necessarily stop the remote session.
    // Terminate the session through the API so you stop paying for it.
    await browser?.close();
  }
}

Two details in that snippet matter more than they look. First, connectOverCDP attaches to an existing browser; it does not launch one, so browser.close() disconnects your client but the remote session may keep running until you explicitly stop it. Second, waitForSelector on a real DOM signal is more reliable than waitForTimeout, which is the single most common cause of flaky agent runs.

If you prefer to keep the browser open across worker restarts, persistent profiles let a session resume with cookies and storage intact. That is covered in the documentation.

Choosing a runtime: what to compare

Most "axiom browser" comparisons collapse into a handful of concrete criteria. The table below is the checklist worth running against any candidate, including Remote Browser.

CriterionWhat to checkWhy it matters
Control protocolRaw CDP WebSocket endpoint exposedAvoids SDK lock-in; works with Playwright, Puppeteer, Selenium
Session isolationOne Chromium process and profile per sessionPrevents credential and cookie bleed between tasks
Profile persistenceOpt-in saved profiles with explicit lifecycleNeeded for logged-in workflows; dangerous if always-on
Live inspectionViewer or screenshot stream during a runDebugging agents without replaying from scratch
Network controlsConfigurable proxy and browser settingsRegional access and consistent egress
Usage meteringPer-session time accountingCost attribution per task or tenant
Concurrency modelDocumented limits per planPrevents surprise throttling at scale

Pricing and concurrency limits change; check /pricing for current numbers rather than relying on a blog post. The comparison that matters is not "which is cheapest per hour" but "which gives me a CDP endpoint, isolation, and a stop button I trust."

Local Chrome vs. hosted runtime

A quick decision frame:

  • Local Chrome with `--remote-debugging-port` — fine for development and single-run debugging. Not viable for concurrent agents or multi-tenant workloads.
  • Self-hosted Chromium in containers — full control, but you own process supervision, profile cleanup, outbound proxy configuration, and the debugging UI. This is real infrastructure work.
  • Hosted runtime — you trade some control for a managed lifecycle, a viewer, and metering. The right choice when the browser is not your product.

For a walkthrough of the hosted path without local setup, see Remote browser online.

Production criteria that separate good runtimes from demos

Once you have a CDP endpoint working, the failure modes shift from "can I connect" to "can I keep this running for a month." Four things to get right:

Session lifecycle discipline. Every session you create must be stopped. Wrap session creation in a try/finally or a job-level cleanup hook. Orphaned sessions are the most common source of runaway spend in agent deployments.

Deterministic waits. Agents that sleep are agents that fail under load. Prefer waitForSelector, waitForResponse, or waitForFunction tied to the actual state transition you care about.

Evidence capture. Screenshot on failure, log the final URL, and record the CDP session ID. When an agent does something unexpected, you want the artifact trail, not a guess.

Network policy. If your workload depends on a specific region or egress IP, configure it at session creation, not mid-run. Configurable browser settings at the session level are more reliable than per-request overrides.

Debugging a live session

The live viewer is the difference between "the agent failed" and "the agent failed because a cookie banner covered the submit button." When a run stalls, attach to the viewer, inspect the DOM state, and decide whether the fix is a selector change, a wait change, or a prompt change. For more on driving sessions interactively, see Remote control browser.

Common mistakes with agent browsers

  • Treating the browser as stateless when it is not. Cookies persist within a session. If you reuse a session across tenants, you have a data leak.
  • Assuming `browser.close()` stops billing. It usually does not. Stop the session through the API.
  • Hardcoding selectors against a page you have not inspected. Use the viewer to confirm the DOM before you write the locator.
  • Ignoring concurrency limits until launch day. Read the plan limits before you build a fan-out job.
  • Skipping the CDP version check. Playwright and Puppeteer expect a compatible Chromium. A hosted runtime pins the version for you; a self-hosted one does not.

Where Remote Browser fits

Remote Browser is a hosted Chromium runtime built around the CDP contract described above. You create a session, get a WebSocket endpoint, connect with Playwright, Puppeteer, or Selenium, and drive a real browser. Sessions are isolated, profiles are opt-in, the live viewer is available during the run, and usage is metered per session so you can attribute cost. It is not a framework and it does not try to be your agent — it is the browser layer underneath whatever agent you already run.

If you are migrating from a local setup, the documentation covers session creation, CDP connection, and profile handling. If you are comparing runtimes, start with Remote web browser for the architecture overview, then check /pricing for current limits.

Summary

An axiom browser, read as a runtime question, is a browser your code can control deterministically. The answer is not a specific download — it is a hosted Chromium session with a CDP endpoint, isolation, a viewer, and metered lifecycle. Connect with connectOverCDP, wait on real DOM signals, stop your sessions, and capture evidence. Everything else is tuning.