TL;DR

ego lite is a Chromium-based browser from citrolabs, built so that you and your AI agents can use the same browser at the same time. Instead of handing your coding agent a headless automation framework it has to drive from the outside, ego lite gives each agent its own isolated “Space” inside a real browser — one that already has your logins, cookies, and extensions. On July 24, 2026 it hit #1 on GitHub Trending, riding a wave of interest in agent-facing web tooling.

Key facts:

  • Open source on GitHub at citrolabs/ego-lite — the repo (the ego-browser skill + docs) is MIT-licensed; the ego lite browser app is a separate free download.
  • macOS only today — Windows and Linux are on the roadmap.
  • Works with the agent you already use — Claude Code, Codex, Cursor, or a custom CLI, via the ego-browser skill layer. No built-in agent lock-in.
  • Code-based, not CLI-based — the agent writes a JavaScript snippet that calls browser tools in one pass, instead of the “run a command, look, run another” loop. citrolabs claims up to 2.5×–3.45× faster complex tasks with far fewer tokens.
  • Parallel Spaces — each agent (or each task) runs in its own isolated workspace; your tabs and your mouse stay untouched.
  • The catch: it’s beta, macOS-only, and it inherits your real logged-in sessions — which is exactly the convenience and the risk.

If you’ve ever watched an agent and yourself fight over the same Chrome window, this is the tool aimed squarely at that pain.

What ego lite actually is

Most “browser automation for AI” falls into two camps, and ego lite is trying to be a third.

Camp one — automation frameworks. Browser-Use and Vercel’s agent-browser are libraries your agent calls. They ship no browser of their own, so they spin up (or attach to) a separate Chromium instance. That works, but two things reliably go wrong: your logins rarely carry over cleanly, and if you point it at your everyday browser, you and the agent end up fighting for the same tabs.

Camp two — AI browsers. ChatGPT Atlas and Perplexity Comet ship a browser with a built-in agent. They’re pleasant to use, but only their agent can drive them. You can’t point Claude Code or Codex at Comet and say “go do this.”

ego lite splits the difference: it’s one real browser, designed from the start for you and any external agent to share. You browse in the front tabs. Your agent works in a background Space. Neither steps on the other. The connective tissue is a skill called ego-browser that any CLI agent can load — it exposes the browser as a set of in-page JavaScript tools (snapshot, fill, click, wait, navigate, capture) that the agent composes into a single script.

That “single script” detail is the whole thesis, so it’s worth slowing down on.

Why it writes JavaScript instead of CLI commands

Most browser tools give the agent a command-per-action interface: call click, wait for the result, read it, decide, call type, wait again. For a five-step form that’s five round trips, five model calls, and five chances for the context to balloon.

ego lite flips that. Because the capabilities are exposed as JavaScript functions the agent calls directly in the page, the agent can write the entire multi-step task as one snippet and run it in a single pass. The model does what models are already good at — writing code — instead of babysitting a command loop. citrolabs’ own Show HN thread was literally titled “why our browser agent writes JavaScript not CLI commands,” and their benchmark claim is that complex workflows finish up to 2.5× faster with higher success rates and far fewer tool calls per task. The landing page pushes an even bolder 3.45× vs agent-browser number for 100+ concurrent tasks.

Treat those numbers as vendor benchmarks (more on that in Limitations), but the architectural argument is sound: fewer round trips means fewer tokens and fewer places for a long-horizon browser task to derail.

Getting started

ego lite runs on macOS today. There are three install paths; pick whichever fits your flow.

Option 1 — download the app

Grab the DMG for your chip and open it:

# Apple Silicon
open https://cdn.ego.app/channel/github_github_referral/setup/macos/arm64/egolite.dmg

# Intel
open https://cdn.ego.app/channel/github_github_referral/setup/macos/x64/egolite.dmg

Installing the app also drops the ego-browser skill into every agent’s skills directory on your machine.

Option 2 — add just the skill with npx

If you’d rather let the agent pull you through app install on first run:

npx skills add citrolabs/ego-lite

The first time your agent runs a browser task, it walks you through installing the ego lite app.

Option 3 — let the agent set it up

Paste this into Claude Code or Codex:

Set up ego lite for me: https://github.com/citrolabs/ego-lite
Read `skills/ego-browser/references/install.md` and follow the steps to install ego lite.

On first launch, ego lite asks one question: whether to migrate your Chrome data. Say yes and the agent inherits your existing logins, cookies, extensions, and bookmarks. Per the README, ego lite only records whether you opted into migration — the browsing data itself stays on your device.

Actually driving it

Once installed, you talk to it in plain language. In your agent CLI, type /ego-browser followed by a space and describe the task:

/ego-browser follow @ego_agent on x.com for me

Under the hood the agent picks up the ego-browser skill, opens the page in its own Space, reads a Snapshot (the compressed text view a model uses to “see” the page), acts, and reports back — all while your own tabs stay untouched.

Because the tools are JavaScript, a more involved task compiles to a single snippet. Conceptually, an agent enriching a lead does something like:

// The agent composes one snapshot-act-verify pass instead of N round trips
await navigate("https://example.com/pricing");
const snap = await snapshot();              // compressed semantic view of the DOM
const planRow = snap.find(/Enterprise/i);   // locate the target region
await click(planRow.cta);                   // "Contact sales"
await fill("#work-email", "[email protected]");
await click("button[type=submit]");
return await snapshot();                    // report the resulting state back

The real API surface is documented at lite.ego.app/document, but the shape is the point: snapshot → act → verify, expressed as code the agent runs in one pass.

The Spaces model

The feature that makes ego lite feel different in daily use is Spaces — parallel, isolated workspaces inside the same browser. Each Space gets its own agent or task, all running at once:

  • Claude Code enriching 10 leads across 10 parallel Spaces.
  • Codex scraping 5 competitor sites in 5 more.
  • You reading docs in your normal tabs, mouse where you left it.

You can see which Space has an agent running, and take it over or stop it whenever you want. That “watch and grab the wheel” affordance is genuinely nice for tasks where you half-trust the automation.

Community reaction

The Show HN threads have been lively rather than uniformly positive — which is the useful kind of reaction.

The strongest praise is for the shared-session model. One HN commenter noted that a browser running multiple agent-controlled sessions at once “basically turns multiboxing from a chore into a one-click experience.” For anyone who has manually cloned Chrome profiles to keep agent runs isolated, that resonates.

The most common pushback is philosophical: why a whole new browser, and why JavaScript as the interface? citrolabs’ answer — that Python and Rust are more “AI-friendly” languages but JavaScript is what runs in the page natively, so it avoids a serialization boundary — convinced some and not others. Skeptics point out that Browser-Use already does a lot of this, and that a bespoke Chromium fork is a heavy dependency to adopt for a beta tool.

The GitHub Trending #1 spot on July 24 and a jump past 1.2K+ stars say the pitch is landing with early adopters regardless. The signal to watch is whether the star curve holds once the novelty fades and Windows/Linux users (currently locked out) can actually try it.

Honest limitations

This is a beta tool with real, current constraints. Don’t skip this section.

  • macOS only. Windows and Linux are roadmap items, not shipping features. If your dev box is Linux, ego lite is a demo you can’t run yet.
  • It’s early beta. The repo is days-old-viral, not battle-hardened. Expect rough edges, breaking changes, and gaps in the docs.
  • The benchmarks are vendor-run. The 2.5×/3.45× “faster than agent-browser” figures come from citrolabs’ own four-task benchmark. They’re plausible given the architecture, but you should validate on your workload before quoting them.
  • Session inheritance is a double-edged sword. Migrating your Chrome logins is the killer feature and the biggest risk: an agent in a Space is one bad instruction away from acting inside your authenticated Gmail, bank, or admin panel. Scope what you let it touch, and don’t run untrusted task prompts against a fully logged-in profile.
  • “Coming soon” features aren’t here. The much-touted “experience accumulation” (skills that make repeated tasks up to 5× faster) is explicitly future work. Buy on what ships today, not the roadmap.
  • It’s a browser, not a framework you embed. If you need headless automation on a server or in CI, a library like Browser-Use fits that shape better than a desktop app built around a visible UI.

Who should actually use this

Good fit: macOS developers already living in Claude Code or Codex who do real browser work — lead enrichment, competitor scraping, form-filling, research — and are tired of the agent stealing their tabs or losing their logins. The parallel-Spaces model is a genuine quality-of-life upgrade for that person.

Wait-and-see: Windows/Linux users (blocked), teams needing headless CI automation (wrong shape), and anyone who needs a stable, supported tool today rather than a viral beta.

FAQ

Is ego lite free and open source? The GitHub repository — the ego-browser skill and documentation — is released under the MIT License. The ego lite browser app itself is a separate, free download. So “open source” applies to the integration layer and skill; the browser binary is free but distributed as an app, not built from the repo.

Which AI agents can drive ego lite? Any CLI agent that can load the ego-browser skill: Claude Code, Codex, Cursor, or a custom agent. Unlike ChatGPT Atlas or Perplexity Comet — where only the built-in agent can drive the browser — ego lite is deliberately agent-agnostic and works with the tool you already use.

How is this different from Browser-Use? Browser-Use is an automation framework your agent calls; it ships no browser and drives a separate one, so logins often don’t carry over and you and the agent compete for tabs. ego lite is one shared browser with isolated Spaces, inherits your real Chrome session, and exposes tools as in-page JavaScript the agent runs in a single pass rather than a command-by-command loop.

Is it safe to migrate my Chrome logins into it? It’s convenient but carries real risk. Once your cookies and sessions are inside ego lite, an agent working in a Space can act on authenticated sites. Only migrate if you’re comfortable with that, scope which tasks the agent runs, avoid pointing it at high-stakes accounts (banking, admin panels), and never feed it untrusted task instructions while a sensitive session is live.

The bottom line

ego lite is one of the sharpest answers yet to a specific, real annoyance: sharing a browser with your AI agent without the two of you colliding. The parallel-Spaces model and code-first interface are genuinely clever, and the GitHub Trending #1 finish shows developers feel the pain it targets. It’s also macOS-only, early beta, and asks you to inherit your logged-in sessions — so treat it as a promising experiment to run against scoped, low-stakes tasks today, not the automation backbone you standardize on. If you’re on a Mac and live in Claude Code or Codex, it’s worth an afternoon.

Repo: github.com/citrolabs/ego-lite · Docs: lite.ego.app/document