ego (lite) is just a browser, ego is your personal agent across devices.
Join waitlist
Download for Mac
Solutions
DocsEnterpriseChangelogBlog
ego lite vs agent-browser

The Best agent-browser Alternative

agent-browser is a CLI that drives a fresh headless Chromium: open, snapshot, click, snapshot again, one command per step, each a round trip through the model before the next step starts.

ego lite drives the browser you already log into, batching actions in JavaScript instead of one command per step. Across 31 live-site jobs it finishes 96.8% of tasks with a perfect score; agent-browser finishes 74.2%.

Try ego (lite) freeGitHub
Trusted by developers from
GoogleAmazonShopifyTikTokHarvardStanfordUSCUCLA

Browser automation benchmark: ego lite vs agent-browser

This is browser automation on the live web, not a sandbox CLI demo. We gave ego lite and agent-browser the same 31 multi-step tasks on real sites: several pages, several decisions, often a login you already have. A fresh headless profile stalls on those sessions. A real browser does not. Both ran the identical set, so the bars below compare the same jobs.

agent: pimodel: ChatGPT 5.6 Solthinking: max31 tasks

Task completion rate

How often the agent finished the job. Stuck at login, skipped a step, or returned the wrong result: that task is a fail. Higher is better.

ego lite96.8%30 of 31 tasks perfect
agent-browser74.2%23 of 31 tasks perfect

Cost per completed task

What one finished job costs in model spend. Failures still get billed, so they push this number up. Lower is better.

ego lite$1.98
agent-browser$3.72

Model turns per task

How many times the model had to look at the page and choose the next action. Extra looks mean extra tokens, extra waiting, and extra places to stall. Lower is better.

ego lite30.3
agent-browser45.6

Average task time

How long a job took from start to finish, on average, including time spent waiting on the model. Lower is better.

ego lite8m 38s
agent-browser11m 02s

We ran every tool twice and kept the better score. A failed task still counts against it.

Check the numbers, or rerun the tasks yourselfThe 31 tasks, the grading checklists, and the raw results are open source. If a number looks off, open the repo.ego-browser-benchmark-framework

Why ego lite is better than agent-browser

Both tools exist because coding agents deserve better than MCP config and raw HTML. The split is in the execution. agent-browser starts a fresh automation session behind a Rust daemon that drives Chrome directly; ego lite makes the browser you already live in agent-native, so tasks run with your real sessions, cheaper per task, and visibly enough that you can grab the wheel.

96.8% of tasks done perfectly. No other tool tops 84%.

agent-browser's core loop is open, snapshot, click @e2, snapshot again: each step a command the model reads before deciding the next one, and every extra round trip is another chance to lose the thread. On those 31 jobs, one agent-browser task in four ends short of a perfect score.

ego lite reaches the page as a compressed Snapshot with stable @N refs, and the agent acts on several of them in one JavaScript turn. Fewer round trips leave fewer places to stall: 96.8% of the same 31 tasks end perfect, at the fastest average task time of the five tools measured.

Time to finish a task, shorter is better
518 sego lite
662 sagent browser
Data source - Task: finish an average live-site job

Parallel multitasking, execute faster

agent-browser's parallelism is a set of --session flags you manage yourself, headless by default, so a hung dialog leaves you guessing from CLI output alone. The --headed flag meant to fix that has open bug reports of being ignored, or of Chrome crash-looping instead of showing a window.

In ego lite there's no cap on Spaces: each runs its own task at once, headful by default, on its own imported Chrome profile. None of them steal your tab, and you can watch or take over anytime.

No more back and forth Cost fewer tokens

A typical agent-browser flow is open, snapshot, click @e2, fill @e3, snapshot again: separate commands, each a round trip the model reads before deciding the next step. Its batch mode can queue steps, but the model can't act on a snapshot until the whole batch returns.

ego lite's agent writes a few lines of JavaScript that run several steps in one turn, reading the result as a compressed Snapshot. Stacked together, that keeps a whole task well below a command-per-action loop.

Claude Code · ego lite
>/ego-browser Add the first product to the cart, then check checkout loads
●Bash(
ego-browser nodejs <<'EOF' await openOrReuseTab('localhost:3000') await click('.product-card') await click('.add-to-cart') await click('a[href="/checkout"]') cliLog('checkout loaded') EOF
)
⎿Output:
[t=4480ms] checkout loaded
Done. Both steps work.
─── 1 tool call · ↑ 1.1k tokens ───
Claude Code · agent-browser
>Add the first product to the cart, then check checkout loads
$agent-browser open localhost:3000
⎿stdout
Navigated to http://localhost:3000
↑ 1.6k tokens sent so far
Storefront loaded. Need a snapshot to find the first product.
$agent-browser snapshot -i
⎿Snapshot
… +224 lines (ctrl+o to expand)
↑ 3.1k tokens sent so far
Found the first product card at @e18. Clicking it.
$agent-browser click @e18
⎿stdout
Clicked @e18
↑ 4.9k tokens sent so far
Product page loaded, but refs are stale now. Snapshotting again.
$agent-browser snapshot -i
⎿Snapshot
… +205 lines (ctrl+o to expand)
↑ 6.8k tokens sent so far
Add to cart button is @e7.
$agent-browser click @e7
⎿stdout
Clicked @e7
↑ 9.2k tokens sent so far
Added. Heading to checkout.
$agent-browser click @e24
⎿stdout
Clicked @e24
↑ 11.2k tokens sent so far
Confirming the checkout page actually loaded.
$agent-browser wait --url "**/checkout"
⎿stdout
Matched http://localhost:3000/checkout
↑ 13.6k tokens sent so far
─── 7 tool calls · ↑ 13.6k tokens ───
The same task, the same model. Left: one batched JavaScript call in ego lite, 1.1k tokens total. Right: agent-browser's CLI, one command per action, 7 round trips, tokens climb to 13.6k.

Same Chrome, agent-native

Getting agent-browser onto your real Chrome takes setup: a profile name copies your profile into a read-only snapshot, or a persistent path is supposed to carry logins across restarts, though there's an open report of it staying empty on Linux. The alternative, a remote-debugging port, exposes full browser control to any local process on it. Skip the setup and you get a fresh headless profile that stalls at every captcha and 2FA prompt.

ego lite imports your Chrome profile in one click, live.

ego lite Chrome profile import: one-click setup with all your logins

ego lite vs agent-browser

Feature comparison between ego lite and agent-browser.
Featureego liteagent-browser
Default browser stateYour imported Chrome profile: logins, cookies, extensionsFresh headless profile; reusing real Chrome needs a --profile snapshot copy or a manual CDP connection
How the agent acts on a pageBatches multiple actions in a few lines of JavaScript per turnOne command per action; batch mode can queue steps but can't branch on a snapshot mid-run
How the agent reads a pageCompressed Snapshot: accessibility tree with stable @N refsSimilar: compact accessibility snapshot with @e refs
Browser automation on live sites (31 tasks, same model)96.8% perfect, $1.98 per completed task, 8m 38s average74.2% perfect, $3.72 per completed task, 11m 02s average
Watch or take over a taskYes. Headful windows by default; click in and finish it yourselfHeadless by default; watching requires the separate --headed flag
Parallel tasksSpaces run tasks side by side, never touching your tabsMultiple isolated sessions via --session flags, managed and monitored from the CLI
Reusable skills (coming soon)Distills successful runs into reusable skills; up to 5x faster on complex tasks as the agent repeats them (limited beta)No built-in equivalent
SetupInstall the app, run /ego-browser in your agentnpm, Homebrew, or Cargo install, then agent-browser install to download a Chrome for Testing build
PriceFree, no subscription; ego-browser shell is MIT-licensedFree, open source
Last updated Aug 20, 2026

Make it a seamless transition

If agent-browser convinced you that coding agents should drive a browser directly, ego lite is the same conviction with your real browser attached. Switching is minutes, and nothing has to be uninstalled.

  1. Download ego (lite)

    Download ego lite and import your Chrome profile in one click. Logins, cookies, and extensions come with it, with no --profile flag or profile-directory copy required.

  2. Run your first task with /ego-browser

    Paste into your agent

    /ego-browser Open ego.app and check that the pricing page loads

    Paste one sentence into Claude Code, Codex, Cursor, or Gemini CLI and hit enter. No daemon to start, no CDP port to open, no session flag to manage.

  3. Watch it work
    ego lite Spaces overview with four browser tasks running side by side and visible at once, unlike agent-browser's headless --session instances: Claude Code tracking Apple stock on Yahoo Finance, Codex filtering cars by year on cars.com, Hermes finishing a SaaS back-office task, a user scraping X, and a hand tapping + to open another Space

    The task runs in its own Space, so your tabs stay untouched. The browser window is real: watch live or take over anytime. Results land back in your agent's CLI.

Keep agent-browser for headless CI checks if it's already wired into a pipeline there. ego lite covers the interactive work on your own machine and accounts.

When to use each tool

Choose ego (lite) when

  • Your tasks touch real accounts: Gmail, dashboards, anything behind SSO, and your imported profile is already signed in, live, with no profile-copy step or manually opened CDP port.
  • You want per-task token savings from Snapshot input plus multi-action JavaScript batches, stacked, instead of one CLI command round trip per action.
  • You want to watch tasks run headfully in parallel Spaces by default, and take over the moment one needs a human, with no separate flag or platform-specific display setup.
  • You want the browser you already live in to be the agent browser: no daemon to manage, no session flags, no CDP connection to wire up.

Choose agent-browser when

  • You're running in headless CI environments or serverless functions where a desktop browser isn't available and disposable sessions are the point.
  • You're building on Vercel Sandbox or already deep in the Vercel ecosystem and want a tool designed alongside it.
  • You want a minimal footprint on servers: a Rust CLI and daemon with no Playwright or Node.js runtime dependency, installable via npm, Homebrew, or Cargo.
  • You need iOS Safari coverage through WebDriver, which ego lite, Chromium only, doesn't cover.

Give your agent a real browser

Free, runs on your Mac, imports your Chrome profile in one click. Works with Claude Code, Codex, Cursor, and any CLI agent that writes code.

Try ego (lite)

Keep reading

Still weighing your options? See how agent-browser compares with the other tools in the same space.

ego (lite) vs Puppeteerego (lite) vs Playwright MCPego (lite) vs Claude Chrome extensionego (lite) vs Browser Harnessego (lite) vs Browserbaseego (lite) vs Stagehandego (lite) vs Playwrightego (lite) vs Seleniumego (lite) vs Codex browserego (lite) vs Kimi Chrome extensionego (lite) vs Codex Chrome extensionAll comparisonsBrowser automation solutions

FAQ

agent-browser, also known as Vercel agent-browser since Vercel Labs built it, is an open-source browser automation CLI built for AI coding agents: a Rust CLI in front of a pure Rust daemon that drives Chrome directly over the DevTools protocol, with no Playwright or Node.js runtime required to run it. Its snapshot command returns a compact accessibility tree with @e refs, so agents click and fill against stable references instead of brittle selectors, and it ships as a skill for Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, and most other coding agents, with an MCP server available as an optional subcommand rather than the default path. It's free, well-designed, and widely adopted.

Yes, if the tasks you care about involve your real accounts or benefit from being visible. Both give a coding agent a browser through a CLI or skill rather than an MCP-first setup; ego lite adds your imported Chrome profile live by default, headful windows you can take over, parallel Spaces, and multi-action JavaScript execution. agent-browser remains a clean choice for disposable headless automation in scripts and CI.

We ran both tools on the same 31 browser automation tasks on live websites, driven by the same pi agent with the same model (gpt-5.6-sol, thinking effort max) and graded by the same written checklist. Each tool keeps its better of two full runs, so a failed task still counts. ego lite finished 30 of 31 tasks perfectly (96.8%) at $1.98 per completed task, averaging 8 minutes 38 seconds per task; agent-browser finished 23 of 31 (74.2%) at $3.72, averaging 11 minutes 2 seconds. The tasks, the checklists, and the raw results are open source in the ego-browser-benchmark-framework repository on GitHub, so every number can be audited or reproduced.

Yes, with extra setup, and it isn't fully reliable yet. Pass a profile name and agent-browser copies that Chrome profile into a temp directory as a read-only snapshot, so it launches with your existing logins but nothing written during the session copies back to your real profile; on Windows you also have to close Chrome first, since profile files can be locked. There's also a persistent-profile mode meant to carry cookies and login state across restarts on its own, but it has an open bug report of the profile directory staying empty between runs. Connecting to a running Chrome over CDP works too, but the project's own docs flag that port as exposing full browser control to any local process. In ego lite the logged-in browser is the default: import your profile once and every agent task starts from it, live, with no extra flags.

The snapshot is only half of it. agent-browser's batch mode can fire a fixed list of commands in one process launch, but the model still can't act on what a snapshot returns until the whole batch finishes, so a task where each step depends on the last ends up as a long chain of command-then-model-reads-the-result cycles. ego lite lets the agent batch several actions in one JavaScript execution and reason about the result immediately, reading it as a compressed Snapshot. The savings come from the two stacked together, and they show up per task: across those 31 jobs, ego lite averages 30.3 model round trips to agent-browser's 45.6, which works out to $1.98 per completed task against $3.72.

No. That's a philosophy both tools share. agent-browser's primary interface is its CLI, with an MCP server available as an optional subcommand for clients that want one. ego lite connects through the ego-browser shell by running /ego-browser inside your agent. Neither requires editing MCP config files as the default path.

Yes. They don't conflict. Some developers keep agent-browser for headless checks in CI or on Vercel Sandbox, and use ego lite for everything interactive: logged-in tasks, parallel research, anything worth watching. In practice the logged-in tasks are most of them.

Yes. ego lite is free with no subscription, and the ego-browser shell your agent connects through is MIT-licensed open source.