Browser Use Terminal is a Rust terminal UI for driving and steering LLM-powered browser agents in your own Chrome or a headless Chromium, aimed at developers who want to automate real web tasks from the command line.

What it is

Browser Use Terminal is a Rust TUI for browser agents: Rust owns the agent loop and durable state, while the browser runtime gives the model direct CDP control over Chrome. Its architecture stacks a custom Ratatui UI for watching, steering, stopping and resuming tasks; a Rust LLM harness providing tools, subagents, compaction and cancellation; a SQLite event log holding history, screenshots, artifacts and traces; and a CDP browser runtime handling profiles, doctor, recovery and ownership. The model receives raw browser capability in the form of CDP, page JavaScript, screenshots, files and helper code, while the terminal keeps the human in control with follow-ups and a custom Ratatui renderer for live work.

The problem it addresses is automating repetitive, account-bound web work that script-only scrapers cannot handle, such as getting a San Francisco parking permit, giving an employee admin permission in Azure, or finding the cancellation policy for a current hotel reservation. It lives in the browser automation ecosystem, replacing manual clicking through a terminal-based harness that works with your logged-in Chrome when a task needs real account state, and offering headless Chromium or the Browser Use cloud for clean or remote runs.

Key capabilities

• Runs browser tasks from a terminal UI with a custom Ratatui renderer, and lets you watch, steer, stop, retry and resume work while it runs.
• Works with your logged-in Chrome for real account state, and supports headless Chromium plus Browser Use cloud for clean or remote runs.
• Keeps local history, screenshots, artifacts and follow-ups in a SQLite event log.
• Exposes raw browser capability to the model: CDP, page JavaScript, screenshots, files and helper code.
• Offers slash commands inside the TUI (/auth, /model, /browser, /update) and shell commands such as browser auth status, browser config show and browser diagnostics.
• Plugs into coding assistants with browser-use-terminal skill install, then accepts browser-use-terminal browser exec snippets using new_tab(), wait_for_load() and capture_screenshot(), saving screenshots as files for Claude Code Read, Codex view_image and OpenCode read.
• Ships a managed ripgrep binary at bin/agent-tools/rg, prepended to PATH for agent shell commands, and disables telemetry entirely with BUT_TELEMETRY=0.

Who uses it and how

• Developers who automate account-bound administrative web tasks, relying on their real logged-in Chrome session rather than a fresh profile.
• Contributors running the full verification gate before merging terminal UI changes: cargo fmt --check, cargo test, uv run --with pytest python -m pytest -q scripts/verify-terminal-ui.sh, which executes Rust tests, Python tests, deterministic Ratatui dumps and a real tmux smoke test.
• Users of Claude Code, Codex or OpenCode who install the skill so the assistant learns the CLI and drives the browser runtime, reading saved screenshot paths with its native file-reading tools.
• Teams that need either clean headless runs or remote Browser Use cloud runs, switching between them with /browser.
• Operators who manage model and account configuration through /auth, /model, browser auth status and browser config show.

Getting started

Install with curl -fsSL https://browser-use.com/terminal/install.sh | sh, then launch the app with browser and sign in via /auth; add assistant integration with browser-use-terminal skill install.

How it compares

The project positions its Rust LLM harness as 2x cheaper and 2x faster than Browser Harness, while adopting Browser Harness-style CDP control so assistants get the same hands-on browser capability. Compared with wiring a coding assistant to a browser one script at a time, it hands over the whole persistent browser runtime between calls, with local artifacts kept on disk.

When to use it — and when not to

A self-hoster operates a local Chrome or headless Chromium, the local SQLite event log of history and artifacts, and a model account signed in through /auth, so it is a poor fit for someone who only wants a headless scraper without an LLM in the loop. It is also MIT-licensed and open, but with 15 open issues and a project whose rendering changes must clear a heavy tmux-and-Ratatui verification suite, expect a tool tuned to its own workflow rather than a general-purpose browser driver.

curl -fsSL https://browser-use.com/terminal/install.sh | sh
browser

you
 │
 ▼
browser terminal
 │
 ├─ custom Ratatui UI      watch · steer · stop · resume
 ├─ Rust LLM harness       tools · subagents · compaction · cancellation
 ├─ SQLite event log       history · screenshots · artifacts · traces
 └─ CDP browser runtime    profiles · doctor · recovery · ownership
      │
      ▼
 real Chrome  |  headless Chromium  |  Browser Use cloud

Get my San Francisco parking permit.

Give this employee admin permission in Azure.

Find the cancellation policy for my current hotel reservation.

browser

/auth      sign in
/model     choose a model
/browser   choose local, headless, or cloud browser
/update    update the app

browser auth status
browser config show
browser diagnostics

browser-use-terminal skill install        # registers the skill for detected assistants

browser-use-terminal browser exec <<'PY'
new_tab("https://example.com")
wait_for_load()
print(capture_screenshot())
PY

cargo fmt --check
cargo test
uv run --with pytest python -m pytest -q
scripts/verify-terminal-ui.sh