Agent Browser

Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

view source

installs

stars

karma

SkillRank score ↗

8.2/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-06-12

agent-browser-3 provides comprehensive browser automation via command-line interface, covering navigation, element interaction via semantic refs, screenshots, video recording, network mocking, and multi-session parallel testing. includes authentication state persistence and proxy support.

structure

9.0

trigger phrases

8.0

procedure

9.0

edge cases

6.0

documentation

8.0

view original SKILL.md from clawhubclick to expand

---
name: agent-browser
description: Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.
allowed-tools: Bash(agent-browser:*)
---

# Browser Automation with agent-browser

## Quick start

```bash
agent-browser open <url>        # Navigate to page
agent-browser snapshot -i       # Get interactive elements with refs
agent-browser click @e1         # Click element by ref
agent-browser fill @e2 "text"   # Fill input by ref
agent-browser close             # Close browser
```

## Core workflow

1. Navigate: `agent-browser open <url>`
2. Snapshot: `agent-browser snapshot -i` (returns elements with refs like `@e1`, `@e2`)
3. Interact using refs from the snapshot
4. Re-snapshot after navigation or significant DOM changes

## Commands

### Navigation

```bash
agent-browser open <url>      # Navigate to URL (aliases: goto, navigate)
                              # Supports: https://, http://, file://, about:, data://
                              # Auto-prepends https:// if no protocol given
agent-browser back            # Go back
agent-browser forward         # Go forward
agent-browser reload          # Reload page
agent-browser close           # Close browser (aliases: quit, exit)
agent-browser connect 9222    # Connect to browser via CDP port
```

### Snapshot (page analysis)

```bash
agent-browser snapshot            # Full accessibility tree
agent-browser snapshot -i         # Interactive elements only (recommended)
agent-browser snapshot -c         # Compact output
agent-browser snapshot -d 3       # Limit depth to 3
agent-browser snapshot -s "#main" # Scope to CSS selector
```

### Interactions (use @refs from snapshot)

```bash
agent-browser click @e1           # Click
agent-browser dblclick @e1        # Double-click
agent-browser focus @e1           # Focus element
agent-browser fill @e2 "text"     # Clear and type
agent-browser type @e2 "text"     # Type without clearing
agent-browser press Enter         # Press key (alias: key)
agent-browser press Control+a     # Key combination
agent-browser keydown Shift       # Hold key down
agent-browser keyup Shift         # Release key
agent-browser hover @e1           # Hover
agent-browser check @e1           # Check checkbox
agent-browser uncheck @e1         # Uncheck checkbox
agent-browser select @e1 "value"  # Select dropdown option
agent-browser select @e1 "a" "b"  # Select multiple options
agent-browser scroll down 500     # Scroll page (default: down 300px)
agent-browser scrollintoview @e1  # Scroll element into view (alias: scrollinto)
agent-browser drag @e1 @e2        # Drag and drop
agent-browser upload @e1 file.pdf # Upload files
```

### Get information

```bash
agent-browser get text @e1        # Get element text
agent-browser get html @e1        # Get innerHTML
agent-browser get value @e1       # Get input value
agent-browser get attr @e1 href   # Get attribute
agent-browser get title           # Get page title
agent-browser get url             # Get current URL
agent-browser get count ".item"   # Count matching elements
agent-browser get box @e1         # Get bounding box
agent-browser get styles @e1      # Get computed styles (font, color, bg, etc.)
```

### Check state

```bash
agent-browser is visible @e1      # Check if visible
agent-browser is enabled @e1      # Check if enabled
agent-browser is checked @e1      # Check if checked
```

### Screenshots & PDF

```bash
agent-browser screenshot          # Save to a temporary directory
agent-browser screenshot path.png # Save to a specific path
agent-browser screenshot --full   # Full page
agent-browser pdf output.pdf      # Save as PDF
```

### Video recording

```bash
agent-browser record start ./demo.webm    # Start recording (uses current URL + state)
agent-browser click @e1                   # Perform actions
agent-browser record stop                 # Stop and save video
agent-browser record restart ./take2.webm # Stop current + start new recording
```

Recording creates a fresh context but preserves cookies/storage from your session. If no URL is provided, it
automatically returns to your current page. For smooth demos, explore first, then start recording.

### Wait

```bash
agent-browser wait @e1                     # Wait for element
agent-browser wait 2000                    # Wait milliseconds
agent-browser wait --text "Success"        # Wait for text (or -t)
agent-browser wait --url "**/dashboard"    # Wait for URL pattern (or -u)
agent-browser wait --load networkidle      # Wait for network idle (or -l)
agent-browser wait --fn "window.ready"     # Wait for JS condition (or -f)
```

### Mouse control

```bash
agent-browser mouse move 100 200      # Move mouse
agent-browser mouse down left         # Press button
agent-browser mouse up left           # Release button
agent-browser mouse wheel 100         # Scroll wheel
```

### Semantic locators (alternative to refs)

```bash
agent-browser find role button click --name "Submit"
agent-browser find text "Sign In" click
agent-browser find text "Sign In" click --exact      # Exact match only
agent-browser find label "Email" fill "user@test.com"
agent-browser find placeholder "Search" type "query"
agent-browser find alt "Logo" click
agent-browser find title "Close" click
agent-browser find testid "submit-btn" click
agent-browser find first ".item" click
agent-browser find last ".item" click
agent-browser find nth 2 "a" hover
```

### Browser settings

```bash
agent-browser set viewport 1920 1080          # Set viewport size
agent-browser set device "iPhone 14"          # Emulate device
agent-browser set geo 37.7749 -122.4194       # Set geolocation (alias: geolocation)
agent-browser set offline on                  # Toggle offline mode
agent-browser set headers '{"X-Key":"v"}'     # Extra HTTP headers
agent-browser set credentials user pass       # HTTP basic auth (alias: auth)
agent-browser set media dark                  # Emulate color scheme
agent-browser set media light reduced-motion  # Light mode + reduced motion
```

### Cookies & Storage

```bash
agent-browser cookies                     # Get all cookies
agent-browser cookies set name value      # Set cookie
agent-browser cookies clear               # Clear cookies
agent-browser storage local               # Get all localStorage
agent-browser storage local key           # Get specific key
agent-browser storage local set k v       # Set value
agent-browser storage local clear         # Clear all
```

### Network

```bash
agent-browser network route <url>              # Intercept requests
agent-browser network route <url> --abort      # Block requests
agent-browser network route <url> --body '{}'  # Mock response
agent-browser network unroute [url]            # Remove routes
agent-browser network requests                 # View tracked requests
agent-browser network requests --filter api    # Filter requests
```

### Tabs & Windows

```bash
agent-browser tab                 # List tabs
agent-browser tab new [url]       # New tab
agent-browser tab 2               # Switch to tab by index
agent-browser tab close           # Close current tab
agent-browser tab close 2         # Close tab by index
agent-browser window new          # New window
```

### Frames

```bash
agent-browser frame "#iframe"     # Switch to iframe
agent-browser frame main          # Back to main frame
```

### Dialogs

```bash
agent-browser dialog accept [text]  # Accept dialog
agent-browser dialog dismiss        # Dismiss dialog
```

### JavaScript

```bash
agent-browser eval "document.title"   # Run JavaScript
```

## Global options

```bash
agent-browser --session <name> ...    # Isolated browser session
agent-browser --json ...              # JSON output for parsing
agent-browser --headed ...            # Show browser window (not headless)
agent-browser --full ...              # Full page screenshot (-f)
agent-browser --cdp <port> ...        # Connect via Chrome DevTools Protocol
agent-browser -p <provider> ...       # Cloud browser provider (--provider)
agent-browser --proxy <url> ...       # Use proxy server
agent-browser --headers <json> ...    # HTTP headers scoped to URL's origin
agent-browser --executable-path <p>   # Custom browser executable
agent-browser --extension <path> ...  # Load browser extension (repeatable)
agent-browser --help                  # Show help (-h)
agent-browser --version               # Show version (-V)
agent-browser <command> --help        # Show detailed help for a command
```

### Proxy support

```bash
agent-browser --proxy http://proxy.com:8080 open example.com
agent-browser --proxy http://user:pass@proxy.com:8080 open example.com
agent-browser --proxy socks5://proxy.com:1080 open example.com
```

## Environment variables

```bash
AGENT_BROWSER_SESSION="mysession"            # Default session name
AGENT_BROWSER_EXECUTABLE_PATH="/path/chrome" # Custom browser path
AGENT_BROWSER_EXTENSIONS="/ext1,/ext2"       # Comma-separated extension paths
AGENT_BROWSER_PROVIDER="your-cloud-browser-provider"  # Cloud browser provider (select browseruse or browserbase)
AGENT_BROWSER_STREAM_PORT="9223"             # WebSocket streaming port
AGENT_BROWSER_HOME="/path/to/agent-browser"  # Custom install location (for daemon.js)
```

## Example: Form submission

```bash
agent-browser open https://example.com/form
agent-browser snapshot -i
# Output shows: textbox "Email" [ref=e1], textbox "Password" [ref=e2], button "Submit" [ref=e3]

agent-browser fill @e1 "user@example.com"
agent-browser fill @e2 "password123"
agent-browser click @e3
agent-browser wait --load networkidle
agent-browser snapshot -i  # Check result
```

## Example: Authentication with saved state

```bash
# Login once
agent-browser open https://app.example.com/login
agent-browser snapshot -i
agent-browser fill @e1 "username"
agent-browser fill @e2 "password"
agent-browser click @e3
agent-browser wait --url "**/dashboard"
agent-browser state save auth.json

# Later sessions: load saved state
agent-browser state load auth.json
agent-browser open https://app.example.com/dashboard
```

## Sessions (parallel browsers)

```bash
agent-browser --session test1 open site-a.com
agent-browser --session test2 open site-b.com
agent-browser session list
```

## JSON output (for parsing)

Add `--json` for machine-readable output:

```bash
agent-browser snapshot -i --json
agent-browser get text @e1 --json
```

## Debugging

```bash
agent-browser --headed open example.com   # Show browser window
agent-browser --cdp 9222 snapshot         # Connect via CDP port
agent-browser connect 9222                # Alternative: connect command
agent-browser console                     # View console messages
agent-browser console --clear             # Clear console
agent-browser errors                      # View page errors
agent-browser errors --clear              # Clear errors
agent-browser highlight @e1               # Highlight element
agent-browser trace start                 # Start recording trace
agent-browser trace stop trace.zip        # Stop and save trace
agent-browser record start ./debug.webm   # Record video from current page
agent-browser record stop                 # Save recording
```

## Deep-dive documentation

For detailed patterns and best practices, see:

| Reference | Description |
|-----------|-------------|
| [references/snapshot-refs.md](references/snapshot-refs.md) | Ref lifecycle, invalidation rules, troubleshooting |
| [references/session-management.md](references/session-management.md) | Parallel sessions, state persistence, concurrent scraping |
| [references/authentication.md](references/authentication.md) | Login flows, OAuth, 2FA handling, state reuse |
| [references/video-recording.md](references/video-recording.md) | Recording workflows for debugging and documentation |
| [references/proxy-support.md](references/proxy-support.md) | Proxy configuration, geo-testing, rotating proxies |

## Ready-to-use templates

Executable workflow scripts for common patterns:

| Template | Description |
|----------|-------------|
| [templates/form-automation.sh](templates/form-automation.sh) | Form filling with validation |
| [templates/authenticated-session.sh](templates/authenticated-session.sh) | Login once, reuse state |
| [templates/capture-workflow.sh](templates/capture-workflow.sh) | Content extraction with screenshots |

Usage:
```bash
./templates/form-automation.sh https://example.com/form
./templates/authenticated-session.sh https://app.example.com/login
./templates/capture-workflow.sh https://example.com ./output
```

## HTTPS Certificate Errors

For sites with self-signed or invalid certificates:
```bash
agent-browser open https://localhost:8443 --ignore-https-errors
```

related skills

semantically similar in the cross-vendor index

clawhub

88% match

Cxz9909 Agentbrowser

A fast Rust-based headless browser automation CLI with Node.js fallback that enables AI agents to navigate, click, type, and snapshot pages via structured co...

don't have the plugin yet? install it then click "run inline in claude" again.

intent

automate browser interactions when you need to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from html. use this skill for any workflow that requires programmatic control of a headless or headed browser, including multi-step form submission, authenticated session management, data scraping, visual regression testing, and accessibility tree inspection.

inputs

required

browser access via agent-browser command (installed and in PATH)
target URL (http, https, file, about, or data protocol)

optional but important

AGENT_BROWSER_SESSION env var: isolate parallel browser instances by session name (default: unnamed session)
AGENT_BROWSER_EXECUTABLE_PATH env var: path to custom chrome/chromium binary if system chrome unavailable
AGENT_BROWSER_EXTENSIONS env var: comma-separated paths to browser extensions to load
AGENT_BROWSER_PROVIDER env var: cloud browser provider (browseruse or browserbase) if using remote browsers
AGENT_BROWSER_STREAM_PORT env var: websocket port for browser streaming (default: 9223)
AGENT_BROWSER_HOME env var: custom install location for daemon.js
proxy credentials: pass via --proxy http://user:pass@host:port or http basic auth with agent-browser set credentials user pass
http headers: pass custom headers as json via --headers '{"X-Key":"value"}' or agent-browser set headers '{"X-Key":"value"}'
cookies/storage: can be seeded via agent-browser cookies set or agent-browser storage local set or loaded from saved state file

edge cases to handle

network timeouts: long-running navigations on slow connections may exceed default wait timers
auth expiry: saved session state (cookies, tokens) may expire between invocations
rate limits: rapid requests to the same host may trigger 429 responses
stale refs: element references (@e1, @e2) become invalid after page navigation or significant dom mutation; re-snapshot after state changes
empty result sets: snapshot or get queries may return no elements if selectors no longer match
javascript errors: page may load but have console errors; check agent-browser errors before interacting
dialog handling: unexpected alerts or modals block interaction until dismissed or accepted

procedure

1. open and inspect page

input: url (required) output: browser window open, page loaded, accessibility tree ready

agent-browser open <url>
# or with protocol inference:
agent-browser open example.com         # auto-prepends https://
agent-browser open file:///local.html  # local file

notes:

if protocol omitted, https:// is prepended
supported protocols: http, https, file, about, data
page waits for network idle by default
use --headed flag to see browser window: agent-browser --headed open <url>

2. snapshot page to discover elements and refs

input: page must be open; optional css selector to scope snapshot output: accessibility tree with interactive element refs (@e1, @e2, etc.)

agent-browser snapshot -i               # interactive elements only (recommended)
agent-browser snapshot -i --json        # machine-readable format
agent-browser snapshot -c               # compact output
agent-browser snapshot -d 3             # limit tree depth to 3 levels
agent-browser snapshot -s "#main"       # scope to css selector
agent-browser snapshot                  # full accessibility tree (verbose)

decision point: use -i flag for most workflows; full snapshot useful only for deep debugging.

notes:

refs are stable until page navigation or significant dom changes
refs are local to current frame; switch frames with agent-browser frame "#iframe" if needed
snapshot may fail if page is still loading; wait for load state first: agent-browser wait --load networkidle

3a. navigate and wait (if changing pages)

input: action type and target output: new page loaded or state changed

agent-browser back                      # go back in history
agent-browser forward                   # go forward in history
agent-browser reload                    # reload current page
agent-browser wait --load networkidle   # explicit wait for network idle
agent-browser wait --url "**/dashboard" # wait for url pattern match
agent-browser wait --text "Success"     # wait for text on page
agent-browser wait 2000                 # wait milliseconds

decision point: after navigation, refs from previous snapshot are invalid; re-snapshot to get new refs.

3b. interact with elements using refs

input: ref from snapshot (e.g., @e1), optional text or value output: element state changed (clicked, filled, focused, etc.)

agent-browser click @e1                 # click element
agent-browser dblclick @e1              # double-click
agent-browser focus @e1                 # focus (for text inputs)
agent-browser fill @e2 "text"           # clear input and type
agent-browser type @e2 "text"           # type without clearing
agent-browser press Enter               # press single key
agent-browser press Control+a           # press key combo
agent-browser keydown Shift             # hold key down
agent-browser keyup Shift                # release key
agent-browser hover @e1                 # hover mouse
agent-browser check @e1                 # check checkbox
agent-browser uncheck @e1               # uncheck checkbox
agent-browser select @e1 "value"        # select dropdown option by value
agent-browser select @e1 "a" "b"        # select multiple options
agent-browser scroll down 500           # scroll page 500px down (default 300)
agent-browser scroll up 300             # scroll up
agent-browser scrollintoview @e1        # scroll element into viewport
agent-browser drag @e1 @e2              # drag-drop element
agent-browser upload @e1 file.pdf       # upload file to input

edge cases:

if element is not visible, use scrollintoview first
if element is disabled, interaction will fail; check agent-browser is enabled @e1
if ref is invalid (page changed), re-snapshot and get new ref
upload file paths must exist on local filesystem

3c. extract information

input: ref or page context output: text, html, value, attribute, title, url, or bounding box

agent-browser get text @e1              # element inner text
agent-browser get html @e1              # element innerHTML
agent-browser get value @e1             # input value
agent-browser get attr @e1 href         # specific attribute
agent-browser get title                 # page title
agent-browser get url                   # current url
agent-browser get count ".item"         # count elements matching selector
agent-browser get box @e1               # bounding box (x, y, width, height)
agent-browser get styles @e1            # computed styles (font, color, bg)
agent-browser --json get text @e1       # json output for parsing

3d. check element state

input: ref output: boolean result

agent-browser is visible @e1            # is visible in viewport
agent-browser is enabled @e1            # is enabled (not disabled)
agent-browser is checked @e1            # is checked (for radio/checkbox)

4. alternative: use semantic locators (instead of refs)

input: role, text, label, placeholder, alt, title, testid, or css selector output: action performed on matched element

agent-browser find role button click --name "Submit"
agent-browser find text "Sign In" click
agent-browser find text "Sign In" click --exact    # exact match only
agent-browser find label "Email" fill "user@test.com"
agent-browser find placeholder "Search" type "query"
agent-browser find alt "Logo" click
agent-browser find title "Close" click
agent-browser find testid "submit-btn" click
agent-browser find first ".item" click
agent-browser find last ".item" click
agent-browser find nth 2 "a" hover

decision point: use semantic locators if refs are unstable or refs not available; slower than snapshot-based refs but more resilient to dom changes.

5. capture output (screenshots, pdf, video)

input: optional output path output: file written to disk

agent-browser screenshot                       # save to temp dir
agent-browser screenshot path.png              # save to specific path
agent-browser screenshot --full                # full page screenshot
agent-browser pdf output.pdf                   # save as pdf
agent-browser record start ./demo.webm         # start video recording
agent-browser click @e1                        # perform actions
agent-browser record stop                      # stop and save video
agent-browser record restart ./take2.webm      # stop current, start new

notes:

video recording creates fresh context but preserves cookies/storage
if no url provided to record start, automatically returns to current page
explore page first before starting recording for smooth capture

6. manage browser state (cookies, storage, sessions)

input: optional key-value pairs output: state persisted or retrieved

agent-browser cookies                    # get all cookies
agent-browser cookies set name value     # set cookie
agent-browser cookies clear              # clear all cookies
agent-browser storage local              # get all localStorage
agent-browser storage local key          # get specific key
agent-browser storage local set k v      # set localStorage value
agent-browser storage local clear        # clear all localStorage
agent-browser state save auth.json       # save browser state to file
agent-browser state load auth.json       # load browser state from file
agent-browser --session test1 open url   # create isolated session named test1
agent-browser session list               # list all active sessions

decision point: use state save and state load for login flows; subsequent runs can load auth state instead of re-logging in.

7. configure browser (viewport, device, geolocation, headers, auth)

input: setting name and value(s) output: browser behavior changed for this session

agent-browser set viewport 1920 1080        # set viewport dimensions
agent-browser set device "iPhone 14"        # emulate device (mobile, tablet, etc.)
agent-browser set geo 37.7749 -122.4194     # set geolocation (lat lon)
agent-browser set offline on                # toggle offline mode (on/off)
agent-browser set offline off               # return online
agent-browser set headers '{"X-Key":"v"}'   # extra http headers
agent-browser set credentials user pass     # http basic auth
agent-browser set media dark                # emulate dark color scheme
agent-browser set media light               # emulate light color scheme
agent-browser set media reduced-motion      # emulate reduced motion preference

notes:

these settings persist for the session
headers are scoped to target url origin
device emulation affects user-agent, viewport, and touch behavior
offline mode simulates network disconnection

8. handle network interception

input: url pattern, optional mock body or abort flag output: requests intercepted or mocked

agent-browser network route "https://api.example.com/*"           # watch requests
agent-browser network route "https://api.example.com/*" --abort   # block requests
agent-browser network route "https://api.example.com/*" --body '{"data":"mock"}'  # mock response
agent-browser network unroute "https://api.example.com/*"         # remove route
agent-browser network requests                                     # view all intercepted requests
agent-browser network requests --filter api                        # filter by string

9. advanced: tabs, windows, frames, dialogs, javascript

input: tab/window/frame identifier, dialog action, or js code output: context switched or action executed

agent-browser tab                       # list tabs
agent-browser tab new [url]             # open new tab
agent-browser tab 2                     # switch to tab 2
agent-browser tab close                 # close current tab
agent-browser tab close 2               # close tab 2
agent-browser window new                # open new window
agent-browser frame "#iframe"           # switch to iframe by selector
agent-browser frame main                # switch back to main frame
agent-browser dialog accept [text]      # accept dialog/alert
agent-browser dialog dismiss            # dismiss dialog
agent-browser eval "document.title"     # run javascript, return result

10. debug and diagnose

input: optional filter or output path output: trace, console logs, or error list

agent-browser console                   # view console messages
agent-browser console --clear           # clear console
agent-browser errors                    # view page errors
agent-browser errors --clear            # clear errors
agent-browser highlight @e1             # visually highlight element (headed mode)
agent-browser trace start               # start recording browser trace
agent-browser trace stop trace.zip      # stop and save trace (for devtools)
agent-browser --headed open url         # show browser window for debugging
agent-browser --cdp 9222 snapshot       # connect via chrome devtools protocol
agent-browser connect 9222              # alternative connect syntax

11. close and cleanup

input: none output: browser closed, session ended

agent-browser close                     # close browser (aliases: quit, exit)

decision points

when to use snapshot refs vs. semantic locators:

if page structure is stable and refs are known, use snapshot refs (@e1, @e2) for speed
if dom is dynamic or refs frequently become stale, use semantic locators (find role button click --name "Submit")
if element has no stable identifier, use css selector or xpath as fallback

when to use state save/load vs. re-login:

if login is slow or rate-limited, save state after first login: agent-browser state save auth.json, then agent-browser state load auth.json on subsequent runs
if session expires frequently, re-login each time to ensure fresh credentials
if 2fa or passwordless auth required, you must manually log in once and save state; automated re-login not possible

when to use network interception:

if you need to mock api responses for testing: agent-browser network route "api.example.com/*" --body '{...}'
if you need to block tracking or third-party scripts: agent-browser network route "*.analytics.com/*" --abort
if you need to test slow or failing api: use mock body or abort to simulate failure

when to wait for networkidle vs. explicit element wait:

use agent-browser wait --load networkidle after navigation to a new page if you expect async data loading
use agent-browser wait @e1 if you need to wait for a specific element to appear
use agent-browser wait --text "Success" if text content is dynamic and you're polling for confirmation

when to re-snapshot:

after any navigation (open, back, forward, reload)
after executing javascript that modifies dom
after waiting for async content to load
before interacting with new elements (don't reuse old refs)

when to use --headed mode:

debugging: agent-browser --headed open url to see browser window
visual validation: ensure ui renders as expected
interactive exploration: manually click around before automating
for production headless workflows, omit --headed flag

when to handle auth errors:

if set credentials user pass fails, verify basic auth is supported (not oauth)
if cookies expire, use state save/load instead
if 2fa required, perform manual login once and save state

when proxy is required:

set proxy globally: AGENT_BROWSER_PROXY=http://proxy:8080 (env var method, if supported)
or per-command: agent-browser --proxy http://proxy:8080 open example.com
if proxy requires auth: agent-browser --proxy http://user:pass@proxy:8080 open example.com
for socks5: agent-browser --proxy socks5://proxy:1080 open example.com

output contract

snapshots return accessibility tree in text format (or --json for structured):

button "Submit" [ref=e3] visible:yes enabled:yes
textbox "Email" [ref=e1] visible:yes enabled:yes
textbox "Password" [ref=e2] visible:yes enabled:yes

get text, get html, get value return string (or json if --json flag used):

user@example.com

get count returns integer count:

get box returns bounding box object (json format):

{"x": 100, "y": 200, "width": 300, "height": 50}

screenshots saved to specified path or temp dir (png format):

/tmp/agent-browser-abc123/screenshot.png

pdf saved to specified path:

./output.pdf

video saved to specified path (webm format):

./demo.webm

state file saved to specified path (json with cookies, storage, auth tokens):

./auth.json

list commands (session list, tab, network requests) return text or json:

session: default (1 tab)
session: test1 (3 tabs)

trace saved as zip file for import into chrome devtools:

./trace.zip

outcome signal

successful navigation: page loaded, no console errors, new url visible in agent-browser get url

successful snapshot: refs returned (@e1, @e2, ...), elements match expected roles/text

successful interaction: element state changed (text filled, button clicked, checkbox checked); verify with agent-browser get text @e1 or agent-browser is checked @e1

successful extraction: data returned matches expected format and content; agent-browser get count ".item" returns non-zero for valid selectors

successful state save: file created at specified path; check file size > 0 bytes

successful state load: browser continues with saved cookies/storage; subsequent navigations don't require login

successful screenshot: file created at specified path (png readable by image viewer)

successful video: file