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. On Real-World Bench, a 31-task benchmark against live sites run with the same model and the same judge across five tools, it finished 30 of 31 tasks perfectly (96.8%); Browser Harness, Browser Use's local version, finished 26 of 31 (83.9%). Stagehand was not in that run.
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
Browser Use is 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
Stagehand is 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)
ego (lite) is 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'
const task = await egoBrowser.newTaskSpace('hn-top-5')
await task.page.goto('https://news.ycombinator.com', { waitUntil: 'load' })
const titles = await task.page.locator('.titleline > a').allInnerTexts()
console.log(titles.slice(0, 5).join('\n'))
EOFThat ego (lite) line isn't a mockup: here's a recorded ego-browser session 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"
}A task id and one four-field JSON object back, 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. One genuine cross-comparison now exists, covering exactly two of the three; it comes right after the table.
| 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) | Published benchmark: 44% fewer execution 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 of the table: 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.
Until August 2026 that was the whole story. There is now one common ruler for two of the three: Real-World Bench (the ego-browser-benchmark-framework repo on GitHub) runs the same 31-task suite against live sites (from a cars.com payment estimate to a Census-and-SBA market-sizing brief to a ticket purchase that allows exactly one claim attempt) through five tools with the same model, gpt-5.6-sol at maximum effort, judged by the same independent agent on up to 6 binary rubrics per task (154 across the 31 tasks); a task counts as perfect only when every rubric passes, and each tool's score is its better complete 31-task round, with no per-task cherry-picking. Browser Use's entry is Browser Harness, Browser Use's local version; the cloud product was not benchmarked.
On that ruler: ego (lite) finished 30 of 31 tasks perfectly (96.8%, with a 99.3% average rubric score) in 30.3 model turns per task; Browser Harness finished 26 of 31 (83.9%, 88.9% average) in 51.2 turns, the highest turn count of the five tools measured, which is the per-step decision loop priced in round trips. Cost per completed task, the number that matters because the meter runs whether the task lands or not: $1.92 divided by 96.8% is $1.98 for ego (lite), and $2.55 divided by 83.9% is $3.04 for Browser Harness. ego (lite) was also the fastest of the five tools measured, at 518 seconds per task average, though that's the least important of these numbers.
Stagehand still brings its own ruler: it wasn't in the run, so its speed and token claims remain self-reported and shouldn't be ranked against these figures. Two rulers merged; the third is still its own.
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
Browser Use's gaps are 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
Stagehand is 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)
ego (lite) has 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 batched agent rounds instead of per-step calls. Real-World Bench measured the difference: $1.92 average per task, which is $1.92 divided by its 96.8% completion rate, or $1.98 per completed task, against Browser Harness's $2.55 and $3.04. Stagehand sits in the middle (AI only where invoked, no measured figure); 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.
