Dev & Engineering browser-automationchrome-devtools-protocolrust-clishell-automationremote-browserweb-testingbrowser-observability

browser-control

A compact shell interface for coding agents to observe and operate real CDP browsers.

FollowAgents review · FARS-2.1
Use with care
72/ 100 5-point scale 3.6 / 5
1 2 3 4 5 6
1Trust13 / 29 · 2.2/5

The tool is driven by explicit CLI subcommands, refuses implicit stdin execution, and documents its local socket, trace files, CDP endpoints, cloud services, and environment variables, giving useful visibility into data flows and effects. Deductions apply because eval, raw CDP, uploads, script execution, profile synchronization, and cloud sessions are broad capabilities without privilege narrowing, hazardous-action confirmation, or general recovery. API keys are read from environment variables, but no redaction, log-isolation, or credential-lifecycle controls are shown. Dependencies are exactly pinned and a committed Cargo.lock is claimed, while release assets receive SHA-256 checksums; however, the supplied evidence omits the lockfile, vulnerability scanning, and an SBOM, and workflow actions use major-version tags rather than immutable commits. Two inspirations are credited and the license names Om Labs, but the relationship between repository publisher and maintenance owner is not established.

2Reliability11 / 14 · 3.9/5

The README, Cargo metadata, release workflow, and end-to-end test script agree on the binary name, Rust/CDP architecture, and principal usage, supporting full self-consistency. Dependencies and runtime prerequisites are documented and doctor assists Chrome discovery, but operation still relies on a recent browser, Rust 1.92, external cloud services, and available platform artifacts, with no outage or offline strategy shown. Failures produce command errors, bounded timeouts, and compact traces, while the test wrapper retains stdout and stderr; deductions remain because no comprehensive error taxonomy, stable error-code contract, or organized remediation guide is provided.

3Adaptability16 / 18 · 4.4/5

The audience is explicitly coding agents that already supply planning and retry loops, with scenarios spanning local browsers, remote CDP, cloud providers, three selector styles, and shell scripts. The README clearly bounds the product as a browser-control pipe rather than an autonomous planner, while identifying raw CDP as its deliberate escape hatch. Trigger semantics are precise: subcommands initiate operations, stdin execution requires --from-stdin, and an empty invocation fails. Environment-fit deductions reflect release targets shown only for macOS and Linux, requirements for recent Chrome/Chromium and Rust 1.92, and a test default Chrome path tailored to macOS; Windows support is not addressed.

4Convention15 / 18 · 4.2/5

The documentation is well organized and supplies installation paths, requirements, quick starts, command examples, cloud setup, observability, architecture, and verification instructions. It explicitly explains the crate/binary naming difference, and the MIT text agrees with Cargo metadata. Full credit is withheld for limitations because there is no consolidated account of security constraints, site compatibility, or unsupported behavior. A package version and v-tag release route exist, but no changelog, compatibility policy, or upgrade guidance is supplied. Repository and copyright ownership are visible, yet named maintainers, support channels, response expectations, and release responsibilities are absent; unknown publisher identity is not treated as suspicious.

5Effectiveness12 / 13 · 4.6/5

Compact text or JSON output, stable element references, event/network/console rings, and failure traces are directly usable by coding agents. Shell composability, reference-based targeting, and a raw-CDP fallback provide clear marginal value over hand-built selectors or SDK-bound integrations. A single Rust binary and local mode reduce setup overhead, but a real Chrome installation remains necessary, cloud operation may cost money, and the agent smoke test depends on Claude Code; performance, resource consumption, and provider costs are not quantified, so cost-benefit is not fully established.

6Verifiability5 / 8 · 3.1/5

Most functional claims map to documented commands, Cargo configuration, the release workflow, or the end-to-end test source, but claims such as “tiny,” “fast,” and “reproducible” lack supplied size measurements, benchmarks, or build evidence. The available files corroborate naming, versioning, build flow, and intended browser interaction, and the test is designed to verify browser state independently. Nevertheless, no execution results are supplied, and Cargo.lock, rust-toolchain.toml, verify.sh, and the core src implementation are absent, preventing strong cross-checking. Design rationale is generally distinguished from operational facts, although several marketing and reproducibility conclusions go beyond the included evidence.

Evidence confidence: Low Reviewed Aug 16, 2026 Reviewed revision 8df03afb21c3
The upstream repository has new commits since this review. The score still applies to the reviewed revision shown and may not cover the latest changes.
Safety controls not found in source: confirmation before acting
Before you use it
  • eval and raw CDP can perform arbitrary operations in the browser context; treat the binary and invoking agent as having full browser-session authority.
  • Synchronizing a local profile or attaching to an authenticated browser may expose cookies, session tokens, history, and personal data; the supplied material shows no redaction or minimization controls.
  • cloud-start transfers session handling to an external provider and consumes API keys from environment variables; review provider terms, data residency, logging, and cost separately.
  • Failure traces are written under .browser-control/traces and may contain sensitive page, network, or console data; use BROWSER_CONTROL_NO_TRACE=1 where appropriate and define cleanup rules.
  • The prebuilt-install example downloads from latest and immediately extracts and installs; pin a specific release and verify its published SHA-256 checksum before execution.
Review evidence [1][2][3][4][5]
See the full review method →

What does this agent do, and when should you use it?

browser-control is a small Rust CLI that lets coding agents drive local or remote real browsers through the Chrome DevTools Protocol. It contains no LLM and requires neither MCP nor an agent framework; instead, it exposes snapshots, actions, scripts, and raw CDP calls as composable shell subcommands. `snapshot` returns actionable elements with stable `@e1` and `@e2` references, while CSS selectors and screen coordinates remain available. A hidden daemon retains bounded DOM event, network, and console histories, and command failures can produce diagnostic bundles under `.browser-control/traces/`. The CLI can launch local Chrome, attach to an existing CDP endpoint, or provision sessions through Browser Use, Steel, Hyperbrowser, and Browserbase presets. It is best suited to coding agents that already supply planning and retry behavior but need a debuggable browser execution layer.

An end-to-end session starts with browser-control init, which creates the .browser-control/ workspace, followed by launch <url> or connection through BROWSER_CONTROL_CDP_URL or BROWSER_CONTROL_CDP_WS. The agent runs snapshot—also available as observe—to read actionable page elements, then passes the returned @eN references to commands such as click, fill, select, upload, drag, press, and scroll; CSS selectors and coordinates are alternative targets. Observation commands expose page metadata, visible text, events, requests, console messages, frames, cookies, and tabs. eval runs JavaScript in the page, while cdp invokes raw Chrome DevTools Protocol methods. The CLI also waits for loads, network idleness, or elements; captures screenshots and PDFs; and manages tabs, viewports, downloads, and native dialogs. run executes workspace scripts with BROWSER_CONTROL_BIN and BROWSER_CONTROL_WORKSPACE, while the opt-in --from-stdin mode executes shell commands supplied on standard input. Its daemon communicates over .browser-control/daemon.sock, maintains small in-memory telemetry rings, and contributes available context to failure traces.

  1. A coding-agent developer can add browser navigation, form entry, and element interaction to an existing shell-capable agent without adopting a browser SDK.
  2. An engineer debugging a brittle web workflow can correlate snapshot, events, network, console, and failure traces to identify where an action broke.
  3. An automation author working with canvases, maps, or pages without stable DOM nodes can combine reference-based actions with coordinate clicks and drags.
  4. A team moving workflows between local Chrome and hosted browsers can retain the same command surface while changing the CDP endpoint or cloud-provider configuration.
  5. A CI or test maintainer can build reproducible browser flows around locked Rust dependencies, shell scripts, screenshots, PDFs, and scripts/verify.sh.

What are this agent's strengths and limitations?

Pros
  • Its shell-native interface emits compact text or JSON and introduces no required SDK, application server, MCP deployment, or language binding.
  • snapshot supplies agent-oriented stable @eN handles while preserving CSS selectors and coordinates for cases where references are unsuitable.
  • eval and raw cdp provide escape hatches when the convenience commands do not expose a required browser operation.
  • The same commands address local Chrome, existing CDP endpoints, and several preset hosted-browser providers.
  • Daemon-held event, request, and console histories feed automatic failure traces, giving an agent concrete evidence for diagnosis.
Limitations
  • It requires Chrome or Chromium reachable through CDP and does not document Firefox or Safari support.
  • Planning, retries, model inference, and broader agent behavior are intentionally outside the product, so adopters must supply that orchestration.
  • Operation relies on a writable .browser-control/ workspace, a daemon socket, state artifacts, and optional trace files that need filesystem access and lifecycle management.
  • Hosted sessions require provider credentials; Browserbase also requires a project ID, and custom providers need explicit API, authentication, path, and CDP-field configuration.
  • No native integration is documented for ChatGPT, Claude AI, the OpenAI API, or the Claude API; a host environment must be able to invoke the CLI itself.

How do you install or deploy this agent?

The shortest installation path uses crates.io:

cargo install browser-control-cli
browser-control --version

The crate is named browser-control-cli, but it installs the browser-control command. Prebuilt release archives are another option; the documented macOS/Linux example is:

curl -fsSL https://github.com/keon/browser-control/releases/latest/download/browser-control-aarch64-apple-darwin.tar.gz | tar xz
install -m 0755 browser-control /usr/local/bin/

To build from source:

git clone [email protected]:keon/browser-control.git
cd browser-control
rustup toolchain install
cargo build --locked --release
install -m 0755 target/release/browser-control /usr/local/bin/
browser-control --version

Runtime use requires a recent Chrome or Chromium build reachable over CDP. Source builds additionally require the Rust toolchain pinned in rust-toolchain.toml.

How do you use this agent?

A first local session can be started with:

browser-control init
browser-control launch https://example.com
export BROWSER_CONTROL_CDP_URL=http://127.0.0.1:9222
browser-control doctor
browser-control snapshot
browser-control click @e1
browser-control eval 'document.title'
browser-control cdp Browser.getVersion

To attach to an existing browser, skip launch and set BROWSER_CONTROL_CDP_WS or BROWSER_CONTROL_CDP_URL; the BU_CDP_WS and BU_CDP_URL aliases also work. For a hosted Steel session:

export BROWSER_CONTROL_CLOUD_PROVIDER=steel

export STEEL_API_KEY=...

browser-control cloud-start

The other built-in providers require BROWSER_USE_API_KEY, HYPERBROWSER_API_KEY, or both BROWSERBASE_API_KEY and BROWSERBASE_PROJECT_ID, as applicable. cloud-start prints the CDP endpoint to export, after which the regular snapshot, action, and observation commands are used.

How does this agent compare with similar options?

The project says it was inspired by Vercel's agent-browser and Browser Use's browser-harness. Its stated design emphasis is a deliberately small, shell-native Rust CLI that exposes CDP, snapshots, scripts, and browser state as general mechanisms while leaving planning, retries, and file editing to the coding agent. The supplied material does not provide feature-by-feature or performance comparisons with either alternative.

FAQ

Does it include an LLM or require an MCP server?
No. It contains no LLM and has no MCP requirement; the host agent only needs to execute shell commands and consume text or JSON.
Can it attach to a browser that is already running?
Yes. Set BROWSER_CONTROL_CDP_WS or BROWSER_CONTROL_CDP_URL to the existing CDP endpoint and omit launch.
What diagnostic evidence is available after a failure?
By default, a command failure creates .browser-control/traces/<timestamp>/ containing the error and any available daemon state, event, network, and console history. BROWSER_CONTROL_NO_TRACE=1 disables this.
Is cloud execution tied to one browser provider?
No. Presets are supplied for Browser Use, Steel, Hyperbrowser, and Browserbase, and environment-variable overrides can describe another provider that returns a CDP URL.
Must users compile it from source?
No. It can be installed with cargo install browser-control-cli or downloaded as a prebuilt release binary. A Rust toolchain is required only for the documented source-build path.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents