Skip to content
browserlane

Agentic browser testing and debugging for real web apps

A real browser, made legible for agents.

browserlane gives AI agents and developers a single binary for driving Chrome, inspecting web apps, debugging failures, and capturing evidence across every run.

v0.1.3 · one static binary · macOS / Linux / Windows · Apache-2.0

zsh — bl
$ bl go https://app.example.com
200 · Acme — Dashboard
$ bl map
@e1 link "Projects" @e2 button "New project"
$ bl click @e2
clicked · url /projects/new
mcp · tools/callagent
{
  "name": "browser_click",
  "arguments": { "selector": "@e2" }
}
→ clicked · 96 ms

One static binary

A single Rust binary for macOS, Linux, and Windows. No Node, no driver daemon, no runtime.

CLI + MCP

66 CLI commands for humans and scripts. 86 MCP tools for AI agents. Same engine underneath.

Chrome over WebDriver BiDi

The W3C-standard bidirectional protocol — not a vendor side-channel.

Built for real web apps

Real renders, real input events, real state — and evidence captured on every run.

The browser stack

A browser isn’t one surface. It’s a stack.

Shell, tabs, DOM, input, state, signals, environment, evidence. browserlane gives agents and developers a handle at every layer — not just a screenshot of the top one.

01 · Browser shell

Start with a real browser.

One command launches Chrome over WebDriver BiDi — visible while you build, headless in CI. Navigate, wait, reload, capture. Every run is a real render of your real app, not a DOM emulation.

$ bl go https://app.example.com
$ bl screenshot -o home.png

02 · Tabs & contexts

Every tab is a handle.

Pages are enumerable and addressable — open, list, and switch by index or URL. A warm daemon keeps the session alive between commands, so multi-tab flows stay scriptable.

$ bl page new https://app.example.com/admin
$ bl pages
$ bl page switch admin

03 · Page & DOM

The page, made legible.

Query by CSS, role, label, text, or XPath. Map every interactive element to a stable @ref an agent can act on, and read the accessibility tree the way assistive tech does.

$ bl map
$ bl find role button
$ bl a11y-tree

04 · Human inputs

Input that behaves like a person.

Real pointer and keyboard events with actionability checks built in: click, type, fill, drag, press. If a human can do it in the page, an agent can script it — and the app can’t tell the difference.

$ bl fill "#email" "sam@acme.dev"
$ bl click "button[type=submit]"
$ bl drag "#task-3" "#done"

05 · State & auth

Sessions you can carry.

Export cookies, localStorage, and sessionStorage as JSON; restore them in the next run. Log in once, then test authenticated flows on every run after — no scripted logins.

$ bl storage -o state.json
$ bl storage restore state.json

06 · Console & network

See what the app was doing.

Recordings capture console output and network activity alongside snapshots — the failed POST and the stack trace behind it travel with the run, not just the final pixels.

$ bl record start --snapshots
$ bl record stop -o run.zip

07 · Emulation

Test the environment too.

Resize to any device, override geolocation, and force CSS media features like dark mode or reduced motion — per session, without touching app code.

$ bl viewport 390 844 --dpr 3
$ bl geolocation 12.9716 77.5946
$ bl media --color-scheme dark

08 · Recording & observability

Every run leaves evidence.

Assertions with real exit codes, structured diffs between steps, annotated screenshots, replayable recordings. When a run fails, you open the evidence — you don’t reproduce the failure.

$ bl expect url contains "/done"
$ bl diff map
$ bl record stop -o evidence.zip

Two surfaces

One binary. Two ways in.

The same engine answers to a human at a shell and to an agent over MCP. Whatever your agent learns to do, you can reproduce by hand — and vice versa.

CLI · for humans & scripts

Drive the browser from your shell.

66 commands with composable output and real exit codes — pipe them, script them, put them in CI.

zsh — bl
$ bl go https://app.example.com
200 · Acme — Dashboard
$ bl map
@e1 link "Projects" @e2 button "New project"
$ bl click @e2
clicked
$ bl expect url contains "/projects/new"
pass · exit 0
CLI reference →

MCP · for AI agents

Give your agent structured hands.

86 tools over stdio JSON-RPC. One command registers the server with Claude Code, Claude Desktop, Cursor, VS Code, or Codex.

mcp · stdio json-rpc
→ browser_navigate {"url":"https://app.example.com"}
→ browser_map {}
← @e2 button "New project"
→ browser_click {"selector":"@e2"}
← clicked · 96 ms
→ browser_expect {"kind":"url","contains":"/projects/new"}
← pass
$ bl add-mcp claudeMCP reference →

There’s a third, token-light surface too: a Claude Code skill that teaches agents the CLI directly — bl add-skill. Skill reference →

Debugging

Agents shouldn’t click blind.

Most browser tools tell an agent what the page looks like. browserlane also tells it what happened — assertions with exit codes, structured diffs, and recordings that carry console and network context. Failures become evidence to read, not behavior to guess at.

Assertions · real exit codes

$ bl expect text "#total" "$42.00"
✗ fail · expected "$42.00", got "NaN"
exit 1 — CI stops here, with a reason

State diffs · between steps

$ bl diff map
+ @e9 button "Retry payment"
− @e5 spinner "Processing…"
2 changes since last map

Recordings · replayable runs

$ bl record stop -o run.zip
✓ saved · 9 steps · screenshots + snapshots
with console output & network activity

Screenshots · annotated evidence

$ bl screenshot --full-page --annotate
✓ screenshot.png · interactive elements numbered
what the agent saw, exactly when it saw it

Quickstart

Running in under a minute.

One line to install, one command to fetch Chrome for Testing, and you’re driving a real browser — from your shell or your agent.

1 · Install — macOS / Linux

$ curl -fsSL https://browserlane.com/install.sh | sh

Windows (PowerShell)

$ irm https://browserlane.com/install.ps1 | iex

2 · Fetch Chrome for Testing

$ bl install

3 · First commands

$ bl go https://example.com
$ bl screenshot -o page.png

For agents · register the MCP server

$ bl add-mcp claude
Read the docsStar on GitHub

checksummed installer · signed & notarized binaries