The core conclusion first: pick by situation, not by feature list. Unknown or constantly changing sites go to Browser Use's autonomous loop; automation living inside your product's codebase goes to Stagehand; daily tasks on your own accounts, driven by a coding agent you already have, go to ego (lite).
ego (lite)'s edge in that last slot: it's a free real browser sharing your logged-in state, and any shell-capable agent scripts it through the ego-browser skill, with whole workflows executing outside the model's context. Its published benchmark puts complex tasks at up to 3.45x faster than agent-browser, on fewer tokens.
Disclosure first: we build ego (lite). So this comparison sticks to each vendor's published claims and documented behavior, ours included, and lists our gaps with the same bluntness as theirs. Where numbers exist they're quoted with what they measure, because the three projects benchmark against three different baselines.
What are the three designs?
Browser Use:
a Python framework running a full perceive-decide-act loop with whatever LLM you plug in, over direct CDP since v0.6.0. You state a goal; it navigates. A CLI-and-skill route serves coding agents, and a cloud tier adds hosted models, proxies, and CAPTCHA handling. The design bet: navigation judgment belongs to the model.
Stagehand:
Browserbase's open-source SDK, self-described as "the SDK for browser agents" with the tagline "Playwright was built for testing, Stagehand is built for agents." You write Playwright-style code (goto, click, locator) and call AI exactly where determinism ends: sh.act("upvote the top story"), sh.extract(...) with a schema. Actions are self-healing when sites change. The design bet: code where you can, AI where you must.
ego (lite):
a free desktop browser built for sharing your logged-in browser state with AI agents, like Codex or Claude Code.
Your existing agent writes JavaScript and pipes it through the ego-browser skill; the whole workflow executes in the browser runtime, outside the model's context, inside an isolated Space that inherits your sessions without touching your window. The design bet: you already have an agent that writes code; what's missing is a browser that's really yours.
The same task, phrased to each tool, shows the three postures at a glance:
# Browser Use: state the goal, the loop finds the way
agent = Agent(task="Get the top 5 stories from Hacker News", llm=llm)
// Stagehand: code the route, AI reads the variable part
await page.goto("https://news.ycombinator.com")
const stories = await sh.extract("Extract the top 5 stories", schema)
# ego (lite): your agent writes and pipes one script
ego-browser nodejs <<'EOF'
await openOrReuseTab('https://news.ycombinator.com', { wait: true })
cliLog(await js("[...document.querySelectorAll('.titleline a')]" +
".slice(0,5).map(a => a.innerText).join('\n')"))
EOFThat ego (lite) line isn't a mockup: here's a real ego-browser session, run today against the same kind of page, with its actual output.
ego-browser nodejs <<'EOF'
const task = await egoBrowser.newTaskSpace('evidence-egobrowser-hn')
console.log({ taskSpaceId: task.id })
await task.page.goto('https://news.ycombinator.com/', { waitUntil: 'load', timeout: 20000 })
const title = await task.page.title()
const topStory = await task.page.locator('.athing .titleline > a').first().innerText()
const points = await task.page.locator('.subtext .score').first().innerText().catch(() => null)
console.log({ title, url: task.page.url(), topStory, points })
EOF
# Real output:
{
"taskSpaceId": 13
}
{
"title": "Hacker News",
"url": "https://news.ycombinator.com/",
"topStory": "Qwen 3.8 27B",
"points": "412 points"
}Four lines back, targeted fields only, no accessibility-tree dump: that's what "outside the model's context" looks like in practice, not just in the pitch.
Goal, route, or script: pick the posture that matches who on your desk is best at writing steps. If nobody writes code, that answer is Browser Use by default. If you already pay for a coding agent, the honest question becomes what the extra framework is buying you.
What do their published numbers actually claim?
Each project publishes performance numbers, and none of them measure the same thing, so read this table as three separate claims rather than one race.
| Project | Published claim | What it's measured against |
|---|---|---|
| Browser Use | 89% success on WebVoyager (its technical report) | A web-task benchmark; measures autonomy quality, not speed or cost |
| Stagehand | "2x faster than playwright" and "80% more token efficient"; e.g., click 97ms vs 364ms | Playwright, on its own operation benchmarks; hybrid accessibility-tree trimming drives the token claim |
| ego (lite) | Complex tasks up to 3.45x faster than agent-browser, on fewer tokens; heredoc execution: 44% fewer rounds, 35.5% fewer tool calls, 21.6% lower cost vs command-at-a-time | agent-browser, and its own REPL baseline; measures execution-model efficiency |
The honest synthesis: Browser Use's number says its autonomy works, Stagehand's says its primitives are fast and lean, ours says batching whole workflows out of the model loop pays. All three can be true at once, because they're answers to three different questions.
Three rulers, three measurements, zero podium.
Which fits which situation?
Unknown or constantly changing sites: Browser Use.
When you can't write the steps because nobody knows the pages, an autonomous loop is the only tool that ships. Pay the per-step model cost knowingly, and validate outputs like untrusted input.
Automation living inside your product's codebase: Stagehand.
If you're an engineer embedding browser automation into software (TypeScript, Python, or Go), its shape is right: deterministic code for the stable 90%, schema-validated AI calls for the variable 10%, self-healing when targets drift, and Browserbase hosting when it ships to production.
Daily tasks on your own accounts, with a coding agent: ego (lite).
If Claude Code or Codex is already on your machine and the tasks live behind your logins (dashboards, portals, communities), ego (lite) is the shortest path: no framework to adopt, no auth to script, tasks in parallel Spaces while you keep working, free. Simple tasks stay one prompt; complex ones become one script.
Notice the split runs on your situation, not on task difficulty: the same price-collection task lands differently depending on whether the sites are unknown (loop), inside your product (SDK), or behind your own logins (real browser). It also runs on who maintains the result: a loop's output needs a validator, an SDK's code needs an engineer, and a script in your agent's hands needs only the agent that wrote it.
What are each one's real gaps?
Browser Use:
cost and silence. Per-step model calls add up (field reports around 50K tokens per step on heavy pages), loops can stall at Step 1, and its documented worst failure is confident, fabricated data with no error raised. Real-Chrome session reuse remains unreliable per user reports and founder acknowledgment.
Stagehand:
it's a developer SDK, full stop. No codebase, no Stagehand; a non-engineer with a coding agent gets nothing from it directly. And its natural production home is Browserbase's paid cloud, which is the right architecture for products and a needless layer for personal daily tasks.
ego (lite):
no autonomous navigation (your agent writes the steps; unknown-site exploration isn't the product), no test framework or debugging panels, desktop-only (no headless CI), and closed source. If those four lines describe your need, one of the other two tools, or Playwright itself, is the right call.
See ego (lite) vs Stagehand in detail, or download ego (lite) for Mac, free, and run one logged-in task today.
FAQ
Is Stagehand built on Playwright?
It exposes Playwright-style APIs and positions itself directly against Playwright's testing heritage ("Playwright was built for testing, Stagehand is built for agents"), with its runtime living next to the browser and extras Playwright lacks: iframe-deep locators, self-healing actions, WebMCP, and OTel tracing.
Stagehand vs Browser Use: which for scraping?
Known sites with variable details: Stagehand, since deterministic navigation plus schema-validated extract calls is cheaper and steadier than a full loop. Unknown sites at discovery time: Browser Use. Your own logged-in sources: neither reliably carries your sessions, which is ego (lite)'s row.
Can all three work with Claude Code?
Yes, differently: Browser Use through its CLI-and-skill route or MCP mode, Stagehand as a library Claude Code writes code against, and ego (lite) natively: the /ego-browser skill installs into your agent during onboarding, and from then on you just tell it what you want.
Do any of the three get past CAPTCHAs and bot walls?
None promises it honestly. Browser Use's cloud advertises CAPTCHA handling with mixed community reports; Stagehand inherits whatever its hosting browser faces; ego (lite) sidesteps the issue for your own accounts specifically, because a session you opened yourself in a real daily browser rarely re-triggers the walls that fresh automation profiles hit.
Which is cheapest to run?
For explicit tasks, ego (lite): the software is free and workflows execute outside the model loop, so you pay single-digit agent rounds instead of per-step calls. Stagehand sits in the middle (AI only where invoked); Browser Use costs the most per task by design, since every step is a model call. For autonomy on unknown sites, that cost buys something real; elsewhere it's overhead.
