ego (lite) è solo un browser; ego è il tuo agente personale su tutti i dispositivi.
Iscriviti alla lista d'attesa
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. In our benchmark, it finishes whole tasks 3.45x faster: 81.8 seconds against 282.9.

Trusted by developers from
GoogleAmazonShopifyTikTokHarvardStanfordUSCUCLA

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.

3.45x faster, measured against this exact tool

agent-browser's core loop is open, snapshot, click @e2, snapshot again: each step a command the model reads before deciding the next one. Its batch command can queue steps but can't branch on a snapshot mid-run, so state-dependent tasks still pay per step.

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. This is the exact matchup our benchmark measures: 3.45x faster, 81.8 seconds against 282.9.

Time to finish a task, shorter is better
81.8 sego lite
282.9 sagent browser
Data source - Task: scrape the main posts from the X account from the last 7 days

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
Time to finish the same task81.8 seconds in our benchmark282.9 seconds in the same benchmark: 3.45x slower
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 Jul 28, 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.

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

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.

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 in whole-task token counts, not in any single step.

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.