Browser automation tools are designed for humans, not agents. Playwright, Puppeteer and Selenium return massive DOM dumps or screenshots that burn through tokens. Most agent-specific solutions are locked into their own ecosystems.
Seebro takes a different approach: compact text and element refs over HTTP and MCP. One small Go binary controls Chrome (or the lightweight obscura engine). Any agent can drive it with plain HTTP calls, and Claude (or any other MCP client) can use it as a native toolset. For plain navigation the agent doesn't even have to steer step by step: hands "get me to the pricing page" to a small decision model and returns when it's there.
🪼 Give your AI agent eyes (Lightweight 9MB AI browser automation library for Go) with MCP Server
스타
2
도구
—
가동 시간
—
/goal
# Interactive elements on screen — ~650 tokens for a Wikipedia article
curl "localhost:9867/snapshot?filter=interactive&format=compact&viewport=true"
# Act on them by ref
curl -X POST localhost:9867/action -d '{"kind":"click","ref":"e12"}'
# Or hand over a whole navigation: one call, several clicks
curl -X POST localhost:9867/goal -d '{"task":"Find the pricing page","startUrl":"https://vercel.com"}'
# Or let Claude drive it directly
claude mcp add seebro -- seebro mcp
Features at a Glance
Area
What you get
Reading
Page text as clean text or markdown (headings, lists, links, tables) with paging; interactive-element snapshots with stable refs, a viewport-only mode and diffs; full accessibility tree; element inspection (attributes, box, HTML, computed styles)
iframes
Snapshots, text and actions reach into iframes, including cross-origin ones (payment forms, embedded logins, editors)
Interaction
Click, double click, click at coordinates, type (fast insertText), fill (React/Vue-safe), whole forms in one call, keys and combos (Enter, Control+A), hover, select, scroll, drag & drop (HTML5 + mouse), file upload, human-like mouse and typing
Navigation
Load URLs, back / forward / reload, waitUntil load / network idle, wait for text / element / URL (reacts instantly to DOM changes), multiple tabs
Goal navigation
POST /goal / navigate_goal: a whole multi-step navigation in one call. The Jev decision model (TypeSafe, OpenRouter or Vercel AI Gateway) picks each click, search or dropdown choice; an offline matcher works without a key and takes over when a model call fails. Stop gates, no-effect recovery, bot-wall detection and a step trace with confidences and cost
Engines
Chrome (default) or obscura, a Rust headless browser using ~20x less memory; both together in one server, chosen per tab
DevTools
Network log with headers, POST data and response bodies, WebSocket and Server-Sent Events, console and uncaught exceptions, JS dialogs, HAR export, performance metrics and Web Vitals
Emulation
Mobile viewports and touch, dark mode, reduced motion, geolocation, network and CPU throttling, user agent, extra headers, timezone, locale
Output
Screenshots (JPEG/PNG/WebP; viewport, full page or element; auto-scaled for LLMs), screen recording to MP4 in real time with every click and input highlighted, PDF export, downloads (CSV/PDF exports land in a known folder)
Scripting
JavaScript in the page with awaited promises: fetch('/api/…') runs with the page's own login
Sessions
Persistent Chrome profile (logins survive restarts), cookies, isolated incognito-like contexts for parallel agents or second accounts
Multi-agent
One shared browser for all MCP clients, tab locks that are actually enforced, per-session identity
Robustness
Hung or crashed tabs are detected and can be reset; idle tabs are closed automatically; JS dialogs never block a call; Cloudflare challenge and block pages are recognised instead of clicked around on
Stealth
Passes common bot checks: no webdriver flag, no "HeadlessChrome" in user agent or client hints, real plugins, native-looking overrides, live self-check
Security
Loopback by default, web pages can't reach the API (CSRF/DNS-rebinding guard), token enforced beyond loopback
Agent integration
HTTP API, MCP server (stdio + Streamable HTTP, 46 tools), Claude skill
How It Compares
Seebro
Typical Browser Tools
Token cost
~650 (on-screen elements) / ~800 (text)
10,000+ (full DOM/screenshot)
Interface
HTTP + MCP – works with any agent
Framework-specific
Output format
Compact refs, text, markdown
Raw HTML or pixels
Multi-step navigation
One /goal call, a small model decides each step (~$0.0002–0.0006 per step)
One large-model round trip per click
Engines
Chrome or obscura (32 MB idle), per tab
One browser
Bot detection
Built-in, self-checking stealth
Manual configuration
Session handling
Persistent profile + isolated contexts
Usually ephemeral
Deployment
Single ~9 MB binary
Complex dependencies
Performance
Measured on the same machine against the previous release (Chrome 155, headless):
Operation
Before
Now
Interactive snapshot, Wikipedia article (27k a11y nodes)
1,248 ms, 10 MB transferred from Chrome
77 ms
…same, only elements on screen (viewport=true)
– (83 KB ≈ 20k tokens)
73 ms, 2.6 KB ≈ 650 tokens
Interactive snapshot, GitHub repo page
251 ms
18 ms
Navigate to a page without <title>
2,394 ms
108 ms
Type 300 characters
495 ms
7 ms
Full-page screenshot, Wikipedia (16,384 px)
timeout, tab hung for good
673 ms
Text of Hacker News
lines glued together
correct line breaks
Two Engines: Chrome and obscura
Seebro can drive two browsers with the same API, MCP tools and refs:
Measured with scripts/loadtest.py on a MacBook Pro (Intel Core i9-9980HK, 8 cores / 16 threads), local test site, 30–60 s per run, 0 errors in every run.
Rule of thumb: obscura for many parallel, simple-to-medium pages where memory matters (scraping, reading, standard forms); Chrome for large or script-heavy pages, iframes, dialogs and anything visual. All obscura pages share one JavaScript thread, so throughput stops growing beyond ~4 parallel tabs; BRIDGE_OBSCURA_WORKERS adds processes but helps only a little (8-worker mixed load: 33.8 → 41.8 ops/s).
BRIDGE_ENGINE=obscura seebro # obscura only, no Chrome
curl -X POST localhost:9867/tab -d '{"action":"new","url":"https://example.com","engine":"obscura"}' # hybrid
MCP: tab_new {url, engine: "obscura"}. health lists the available engines.
Goal Navigation with Jev
Normally an agent drives Seebro one call at a time: snapshot → think → click → wait → snapshot. Every hop costs a full round trip through a large model, and every intermediate page passes through its context. POST /goal (MCP: navigate_goal) hands the whole navigation to a small decision model instead and returns when the goal is reached.
Set up (once): give Seebro one Jev key. Without a key /goal still works with the offline matcher.
AI_GATEWAY_API_KEY=vck_… seebro # Vercel AI Gateway (needs paid gateway credits)
# or TYPESAFE_API_KEY=… / OPENROUTER_API_KEY=sk-or-…
Use:
curl -X POST localhost:9867/goal -H "Authorization: Bearer $TOKEN" -d '{
"task": "Go to the source code repository of the Go programming language on GitHub",
"startUrl": "https://go.dev/"
}'
From Claude: navigate_goal {tabId, task, startUrl}, then get_text on the page it ends on.
How a step works
Each step:
Seebro's snapshot engine lists the interactive elements; they become named options (click_e73, search_e4, type_e9 / submit_e9, select_e12, plus scroll_down, scroll_up, back, done). Noise (edit links, citation markers, javascript:) and duplicate targets are dropped; when a page has more than 240 options, those that match the task survive the cap first.
One decider call answers three independent questions: which action? (a probability per option), is the goal reached?, are we stuck?
Stop gates run before acting (goal > 0.85, stuck > 0.85 after step 2, done). An action that had no visible effect and is proposed again is replaced by the next most probable one.
Seebro executes the action, waits for the navigation or page update, and records the outcome in the history the decider sees next. The page it observes afterwards is reused for the next step, so a step costs one snapshot.
Search boxes get the query (default: the task's keywords) as real key presses and Enter; a search field hidden in a collapsed header is filled and its form submitted instead. Dropdowns get a second question, "which option?". Ordinary text fields are only filled from inputs, never with a guess. Don't put passwords in inputs; do logins yourself (or once in headed mode, the profile keeps the session).
The run stops on Cloudflare challenge or block pages (status: "blocked" with evidence and guidance) instead of clicking around on them. Other end states: goal_achieved or done (arrived), stuck, max_steps, max_seconds, error.
Options
Field
Meaning
task
What to achieve (required)
startUrl
Navigate here first; otherwise start from the tab's current page
Text for search boxes (default: the task's keywords)
inputs
{"email": "[email protected]"}: text for fields whose label contains the key. Without an entry nothing is typed into ordinary fields.
noTyping
Only click, never type
record, recordPath
Record the run as an MP4
Deciders
Everything runs inside the Seebro binary: its own Chrome, its own snapshot engine, and plain HTTPS calls to the model. No Playwright, Node or jev-browser is needed.
decider
Behaviour
auto (default)
Jev when a key is configured, otherwise the offline matcher. If a Jev call fails after its retries (network, rate limit, credits used up, malformed answer), the matcher decides that step and the run continues.
jev
Jev only; a failed call ends the run with status: "error" and the provider's message
local
Offline keyword matcher: follows links named after the task's words in order and uses search boxes. Free and instant, fine for "go to X, then Y" and searches, no judgment
Each step's decided_by and fallback_reason show who answered and why.
Jev is TypeSafe's decision model: it answers typed questions (pick one option, is this statement true?) with probabilities instead of generating text. Through the Vercel AI Gateway a step took 0.5–1 s and cost $0.0002–0.0006 (the billed cost is reported in usage). Set one key in Seebro's environment:
Variable
TYPESAFE_API_KEY
TypeSafe API (TYPESAFE_BASE_URL to override the endpoint)
OPENROUTER_API_KEY
OpenRouter decisions API (sk-or-…)
AI_GATEWAY_API_KEY
Vercel AI Gateway (vck_…, model typesafe-ai/jev; needs paid gateway credits, free tier is refused)
JEV_PROVIDER, JEV_MODEL
Force a provider (typesafe, openrouter, vercel); pick a model snapshot (default jev-latest)
Results
Measured (Wikipedia, same decisions for every contestant, median of 3, same machine and Chrome):
Task
jev-browser (Playwright)
Seebro /goal
Seebro, step by step
Coffee → Espresso
2,436 ms
2,155 ms
2,288 ms
Search "Ristretto"
1,939 ms
1,640 ms
1,610 ms
Coffee → Espresso → Ristretto
4,215 ms
3,184 ms
2,652 ms
With the real Jev model (Vercel AI Gateway) Seebro solved all of these open tasks without help, each in one call: Espresso → inventor's article (2.6 s, 2 steps), Hacker News "newest" (3.4 s), Vercel pricing page (3.0 s, $0.0004 billed), go.dev → github.com/golang/go (8.6 s, 3 steps), python.org → "Using Python on macOS" docs (9.0 s, 7 steps), Wikipedia search for Mount Everest (2 steps).
The browser side of /goal is 1.1–1.3× faster than jev-browser. The real gain is in the agent: a three-hop navigation is one tool call instead of about nine, and none of the intermediate pages pass through the large model's context.
When to use it
Good fit: getting to a page ("pricing", "newest submissions", "the docs page about X"), following a known path, searching a site, the same navigation across many sites (monitoring, scraping) where a large model per click would be slow and expensive.
Not a fit: reading and judging content, filling forms with real data, logins, purchases or messages. Let the agent do those itself with the normal tools; /goal is for getting there.
Release builds (-ldflags "-s -w", as produced by goreleaser):
Platform
Size
macOS arm64
9.3 MB
macOS amd64
9.8 MB
Linux arm64
9.0 MB
Linux amd64
9.6 MB
Windows amd64
9.9 MB
At runtime the Seebro process uses about 15 MB of RAM; Chrome runs as separate processes. Network, console and WebSocket logs are fixed-size per-tab ring buffers (300 / 200 / 200 entries); response bodies stay in Chrome (capped at 5 MB per resource, 25 MB per tab) and are fetched only when asked for. Chrome itself starts with background services disabled (~9% less memory than a default Chrome) and idle tabs are closed after 30 minutes in headless mode. Goal navigation, the Jev client and the recorder add no dependencies; recording needs ffmpeg on the machine, obscura is a separate optional binary.
seebro mcp is a thin proxy mode of the same binary that forwards JSON-RPC to POST /mcp.
If no server answers on localhost, it starts one in the background (headless, log in ~/.seebro/seebro.log, rotated at 10 MB) and restarts it if it disappears mid-session.
All MCP clients share one Chrome and one profile. Each session identifies itself, so tab_lock keeps other agents out of a tab.
Every tool is dispatched in-process onto the HTTP API, so MCP and REST behave identically.
The token is read from BRIDGE_TOKEN or ~/.seebro/config.json.
Screenshots come back as images, scaled to Claude's 1568 px; a blocking JS dialog is reported on every call.
MCP tools
Group
Tools
Tabs
tabs_list, tab_new (optionally in an isolated context or the obscura engine), tab_close, tab_focus, tab_reset, tab_lock, tab_unlock, contexts
the core loop: tab → text/snapshot → act by ref → wait → re-snapshot
when to hand a navigation to navigate_goal, and how to check its result
getting data out of web apps: capture the app's own API calls (HTTP and WebSocket), call its API from inside the page with fetch, read the DOM as markdown, or use the app's export plus downloads
Chrome runs invisibly. This is what Seebro is optimized and tested for. seebro mcp starts the server headless. Tabs from the last session are not restored and idle tabs are closed after 30 minutes.
Headed (Development)
./seebro
Opens a Chrome window you can watch and use. Useful for debugging and manual logins: log in once in headed mode, then restart headless — the session stays in the profile. Tabs are restored and never closed automatically.
Core Concepts
Snapshots & Refs
/snapshot?filter=interactive lists everything an agent can act on, one line per element:
The list is computed inside the page by a small engine running in an isolated JavaScript world. The page can't see it, and only matching elements leave the browser. That makes it ~15x faster than reading Chrome's accessibility tree on large pages.
Refs are stable.e12 keeps pointing at the same element across snapshots for as long as it exists. A ref from a previous page fails with a clear "stale" error and never hits a different element.
f1e3 lives in iframe f1. Cross-origin iframes are included.
viewport=true keeps only what's on screen; diff=true returns only what changed; links=true adds link URLs.
filter=all returns Chrome's full accessibility tree (refs a0, a1 …, main frame only).
Token Efficiency
Measured on a Wikipedia article:
Method
Tokens
Full accessibility tree (format=compact)
~100,000
Interactive elements (?filter=interactive&format=compact)
~20,000
Interactive elements on screen (&viewport=true)
~650
Text, first page (/text?maxChars=30000)
~7,500
Screenshot of the viewport (1366×681)
~1,250
Session Persistence
Log in once, stay logged in. Seebro maintains a Chrome profile at ~/.seebro/chrome-profile/ that keeps cookies and storage across restarts. Isolated contexts ("context": "name" when opening a tab) live only in memory.
Network, Console & WebSocket Recording
Every tab records its HTTP requests, WebSocket frames, Server-Sent Events and console output from the moment Seebro attaches. Lists default to "since the last navigation" (all=true includes earlier entries still in the buffer).
API Reference
All endpoints accept tabId. Without it, the last tab used is taken. GET endpoints take query parameters, POST endpoints a JSON body. Errors are {"error": "…"}.
Reading State
Endpoint
Purpose
GET /health
Connection status
GET /tabs
Open tabs with lock owner, open dialog, health and context
MCP over stdio (proxies to the server, starts it if needed)
seebro config init / seebro config show
Create / show the config file
seebro --version
Print version
Stealth Mode
Automation signals are removed at the browser level, where they leave no JavaScript traces:
navigator.webdriver is false, as in a normal Chrome (--disable-blink-features=AutomationControlled)
user agent and client hints say Chrome, not HeadlessChrome
real plugins, mime types and window.chrome (new headless mode)
the injected script lives in a closure (no globals), and every override keeps native descriptors and toString()
light (default) changes nothing else. full adds seeded canvas, WebGL and font noise, WebRTC relay and hardware values that stay stable within a session. GET /stealth/status runs the same checks bot detectors use and scores them. On bot.sannysoft.com every check passes.
Seebro is a translation layer. Agents speak HTTP or MCP, browsers speak CDP. Seebro adds an in-page snapshot engine, records network and console activity, handles stealth, sessions and tab health, compresses everything to save tokens, and can run whole navigations itself with a decision model. Details: docs/ARCHITECTURE.md.
Security Notice
Seebro gives agents real browser access with your real accounts. Anyone who can call it can act as you: read messages, make purchases, read cookies and auth headers from the network log.
What Seebro does for you:
listens on 127.0.0.1 only, unless you set BRIDGE_BIND; then a token is mandatory and generated if missing
rejects requests from web pages (any Origin or cross-site Sec-Fetch-Site not explicitly allowed) and foreign Host headers, so a site you visit can't drive Seebro through your browser (CSRF, DNS rebinding)
answers CORS only for origins you allow — never *
refuses to write output files into hidden files or folders (~/.ssh, dotfiles) outside its state directory
enforces tab locks between agents
What you should do:
set BRIDGE_TOKEN if other users or containers share the machine
treat ~/.seebro/ as sensitive — it contains your browser profile
start with test accounts until you trust your agent
Think of it as handing someone an unlocked laptop. Powerful when intentional. Dangerous when careless.
Everything else, including the MCP server and the Jev client, is Go standard library. The goal-navigation loop and bot-wall detector are ported from jev-browser (MIT); see THIRD_PARTY_LICENSES.md.
Chrome or Chromium (or obscura alone: scripts/install-obscura.sh)
Optional: ffmpeg for screen recordings (not in the Docker image), a Jev key for model-steered /goal
Development
git clone https://github.com/ChrisFeldmeier/seebro.git
cd seebro
go build -o seebro .
go test ./... # ~200 unit tests, no Chrome or API key needed
go test -tags integration ./... # with a real headless Chrome
# load test (see the script header for scenarios)
python3 scripts/loadtest.py --write-site /tmp/seebro-site
python3 -m http.server 8765 --bind 127.0.0.1 --directory /tmp/seebro-site &
python3 scripts/loadtest.py --engine obscura --scenario flow --workers 4 --duration 60
# recorded demo: Wikipedia search, scrolling, links, back
python3 scripts/demo-wikipedia.py --out /tmp/seebro-wikipedia.mp4
Script
Purpose
scripts/loadtest.py
Load test for both engines (small, large, click-through, mixed, real sites)
scripts/demo-wikipedia.py
Automated tour that produces a video
scripts/install-obscura.sh
Install the obscura engine into ~/.seebro/bin
scripts/install-autostart.sh
Run Seebro at login (launchd / systemd)
scripts/check.sh
The CI checks, locally
Contributors
OpenClaw Integration
Seebro works natively with OpenClaw, the open-source AI assistant. Use it as your agent's browser backend for efficient, low-cost web automation.
S
Seebro
ChrisFeldmeier·스타 2개·
🪼 Give your AI agent eyes (Lightweight 9MB AI browser automation library for Go) with MCP Server