ego lite: The Browser That Lets AI Agents Use Your Logged-In Web Without Stealing Your Tabs

TL;DR

Most AI browser automation fails at the most boring place possible: login. The agent can write code, reason through forms, and plan a ten-step workflow, then immediately gets stuck because the browser it controls is empty. No cookies. No extensions. No session. No real life.

ego lite fixes that by changing the unit of work. Instead of giving your agent a separate headless browser that knows nothing about you, it gives the agent a private workspace called a Space inside the browser you already use. The agent inherits your cookies, your extensions, and your logins. You keep browsing in your own tabs. The agent works next door.

The result feels less like “browser automation” and more like hiring a fast junior assistant who can use the same web you use without grabbing your mouse.

• Who it is for: developers using Claude Code, Codex, Cursor, or any agent CLI who want browser tasks to run without login drama.
• Why it matters: the winning agent workflow is not “one smarter chatbot.” It is many small agents doing web chores in parallel while you keep control.
• When to skip it: your task is purely code-level, or you need server-side headless automation in CI/CD, or you are not on macOS yet.

Repository: citrolabs/ego-lite

---

Beginner Map

If you are new to browser automation or AI agents, read this post in three passes:

1. Pass 1 — Read TL;DR and Part 1 (Foundations) to understand the core concept of Spaces and why logins matter.
2. Pass 2 — Read Parts 2 and 3 to see how ego lite works and how it compares to other tools.
3. Pass 3 — Go to Part 4 for the setup walkthrough and your first task.

Key vocabulary you will see throughout this post:

• Space — an isolated browser window owned by one agent, like a tab group the agent controls without touching yours.
• ego-browser — a small skill file that any agent CLI reads to know how to drive ego lite.
• Snapshot — a compressed, readable text view of a webpage that the agent reads to understand what is on screen.
• Agent CLI — the terminal-based AI tool you already use (Claude Code, Codex, Cursor, etc.)

Student First Assignment

Pick a website you visit every day — GitHub, a news site, or your email inbox. Open ego lite, type /ego-browser followed by “what are the top headlines on [your site] today?” and watch the agent navigate and report back. The whole thing should take under ten minutes. Write down: (1) what the agent did step by step, (2) one thing that surprised you, (3) one thing you would improve.

This exercise builds the habit of thinking about web tasks as things you can delegate — not just automate with a fragile script.

---

Part 1: Foundations — What It Really Means to Give an Agent a Browser

If you have never used browser automation before, here is the core mental model.

A web browser is how humans interact with websites: you read text, click buttons, fill forms. When an AI agent needs to do those same things — read a LinkedIn profile, submit a form, check a dashboard — it needs access to a browser. But the agent has no eyes or hands. So we need two things: (1) a way to show the agent what is on the page, and (2) a way for the agent to send actions (navigate, click, type) to the browser.

The key idea: a browser task is rarely hard because of clicking. It is hard because the web is stateful. You are logged in here, rate-limited there, blocked by 2FA over there, and carrying five tiny pieces of context the automation tool does not know about. A tool that cannot inherit that state is always fighting the wrong battle.

The traditional approach — a second, separate browser:

Tools like Playwright, Puppeteer, browser-use, and Vercel’s agent-browser all take this route. They spin up a headless browser (a browser with no visible window) that the agent remote-controls. The problem is that this second browser starts completely empty. It has no cookies, no saved passwords, no extensions, no session tokens. Every time you start an automation, you have to re-authenticate — CAPTCHA, 2FA, OAuth flows. This is fragile. Many sites block headless browsers outright.

ego lite’s approach — one browser, two workspaces:

There is only one browser: the one you already use. When an agent needs to do a task, ego lite opens a new Space — think of it as a private window within the same browser profile. Your tabs are on one side; the agent’s Space is on the other. Neither can see or touch the other. But because they share the same browser profile, the agent inherits everything: your Google account, your GitHub session, your Figma login. No re-authentication.

Why JavaScript beats a command loop:

Most automation tools work like a conversation. The agent sends a command (“click the Login button”), waits for a response (“done”), reads the result, sends the next command. For a task with ten steps, that is ten round trips, each costing time and tokens.

ego-browser exposes the browser as JavaScript functions the agent calls directly. Instead of ten separate commands, the agent writes a single JavaScript snippet that does all ten steps in one pass. The benchmark from the ego lite team shows this runs up to 2.5× faster with substantially fewer tokens compared to the CLI loop approach. The harder the task, the bigger the gap.

---

Part 2: The Investigation — Three Components and How They Connect

Understanding ego lite means understanding three things and how they connect.

Component 1: ego lite (the browser app)

This is the actual browser — built on Chromium, like Chrome. It adds one key concept on top: Spaces. Each Space is a fully isolated browsing environment with its own history and agent state. You browse in your normal tabs. Your agent works in a Space. From the outside it looks like tabs inside tabs, but they are completely separate workspaces.

Component 2: ego-browser (the skill file)

This is a small configuration file that lives in your agent’s skills directory (usually ~/.claude/skills/ for Claude Code, or equivalent for Codex). It tells the agent which JavaScript functions are available for browser control: snapshot(), fill(), click(), navigate(), wait(), capture(). When you install ego lite, this file is placed automatically. You can also install it alone with:

npx skills add citrolabs/ego-lite

Component 3: Spaces in practice

Every task gets its own Space. You can run ten agents in ten parallel Spaces. Claude Code enriching ten leads simultaneously. Codex scraping five competitor pages at once. They never collide. You can see which Spaces have active agents in ego lite’s sidebar, take over any Space manually, or stop one at any time.

This is the pro move: stop thinking of the agent as a replacement for your browser session. Think of it as a parallel browser worker. You stay in the main lane. The agent gets a work lane. You can inspect, interrupt, or take over the lane whenever the task becomes sensitive.

Practical workflows that suddenly become realistic:

• Research: open five competitor pages, summarize pricing, capture screenshots, and return a table.
• Sales ops: enrich leads from a CRM, then verify details on LinkedIn or company websites.
• QA: log into a staging app, reproduce a bug, collect console-visible symptoms, and describe the steps.
• Content work: gather references from logged-in tools, pull page titles, and draft a source list.
• Personal admin: check dashboards, receipts, or account pages without handing the whole browser to the agent.

A task from start to finish:

1. You type /ego-browser get the follower count on @ego_agent on X in your agent terminal.
2. The agent reads the ego-browser skill to learn the available tools.
3. It writes a JavaScript snippet: navigate("https://x.com/ego_agent") → snapshot() → extract the follower count → return it.
4. ego-browser executes that snippet inside a new Space in ego lite.
5. The result appears in your terminal. Your own X tab was never opened or disturbed.

---

Part 3: The Diagnosis — Why the Old Way Is Painful

Three categories of tools try to solve the same problem. Here is what each category gets wrong.

Category 1: Browser automation frameworks (browser-use, Vercel agent-browser, Playwright)

These are libraries, not browsers. They drive a separate headless browser. Every run starts from scratch: no cookies, no logins, no saved state. If a site requires login, you either hard-code credentials (risky), build a full auth flow (tedious), or manually copy session tokens before each run (fragile). They also use a command-and-answer loop. Ten steps in a task means ten round trips. Each one burns tokens and time.

Category 2: AI browsers with built-in agents (ChatGPT Atlas, Perplexity Comet)

These ship with their own agent baked in. Only that agent can drive the browser. If you use Claude Code or Codex, they are off-limits. They are walled gardens — you adopt their entire stack or you do not use the browser at all.

Category 3: Headless mode (standard Playwright, Puppeteer solo)

No visible window. You cannot watch the agent work. Hard to debug when things go wrong. Many modern sites detect headless mode and block or redirect it.

Where ego lite sits:

Feature	ego lite	browser-use / agent-browser	ChatGPT Atlas
Works with any agent CLI	✅	✅	❌
Inherits your logins	✅	❌	✅
Parallel Spaces	✅	❌	❌
Human can keep browsing	✅	❌	❌
Free	✅	✅	❌
macOS only	⚠️	❌	❌

When ego lite is not the right tool:

• You are on Windows or Linux — it is macOS-only as of mid-2026 (Windows and Linux are on the roadmap).
• You need a headless, server-side pipeline running in CI/CD — ego lite is a desktop app, not a library.
• You need to run tens of thousands of unattended scraping jobs on a cloud VM — ego lite is built for human-agent collaboration, not large-scale infrastructure scraping.

---

Part 4: The Resolution — Set Up ego lite in Under Ten Minutes

Step 1: Install

Download ego lite from the releases on the GitHub page:

• Apple Silicon (arm64)
• Intel (x64)

Open the .dmg and install as normal. On first launch ego lite will ask one question: do you want to migrate your Chrome data? Choose yes. This is what gives your agent access to your existing logins, bookmarks, and extensions. Your Chrome installation is never touched — ego lite copies the profile.

If you prefer to start with just the skill and install the app later, run:

npx skills add citrolabs/ego-lite

The next time your agent tries a browser task it will walk you through installing the app.

Step 2: Run your first task

In your agent terminal (Claude Code, Codex, or Cursor), type:

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

The agent will pick up the ego-browser skill, open a Space in ego lite, navigate to X, read a Snapshot of the page, find the follow button, click it, and report back. Your own tabs are undisturbed.

Step 3: Try parallel Spaces

Open two agent sessions side by side and give each a different browser task at the same time. Watch them run in parallel inside ego lite. Each one lives in its own Space. They never collide.

Step 4: Give better prompts

The best prompts are concrete and inspectable. Ask the agent to report what it saw, what it clicked, and what it could not verify. That turns browser automation from a magic trick into a reviewable workflow.

Bad prompt:

do research on competitors

Better prompt:

/ego-browser open these 5 competitor pricing pages, extract plan names, monthly prices,
free-trial terms, and one screenshot per page. Return a markdown table and list any
fields you could not verify.

That prompt is more boring, which is exactly why it works. Agents are strongest when the task has a visible source, a clear output format, and permission to admit uncertainty.

Available ego-browser tools at a glance:

Function	What it does
snapshot()	Returns a readable text model of the current page
navigate(url)	Opens a URL in the current Space
fill(selector, value)	Types a value into a form field
click(selector)	Clicks an element
wait(condition)	Waits for a page condition to be true
capture()	Takes a screenshot of the current Space

Full tool reference and integration guides: lite.ego.app/document

Community: Discord · GitHub Discussions · X @ego_agent

---

Final Take

ego lite solves one specific friction point: you have powerful AI agents, but every time they need to touch a website you end up babysitting login flows, watching your tab disappear, and counting expensive token round trips.

The core insight is simple — you already have a browser with all your logins. Why give the agent a separate, empty one? ego lite adds the concept of Spaces so you two can share the same browser without getting in each other’s way.

That is why this project is worth watching. It does not try to make a browser with one built-in assistant. It makes your browser agent-addressable. Claude Code, Codex, Cursor, or whatever comes next can all drive the same logged-in web through the same concept: isolated Spaces plus direct JavaScript actions.

It is not a server-side scraping infrastructure. It will not run a fleet of 10,000 headless jobs in CI. It is a tool for developers who want their agent to handle browser tasks while they keep working — and want it to “just work” on the sites they use every day.

If you are on macOS and use Claude Code, Codex, or Cursor: download it, say yes to Chrome migration, and type /ego-browser follow @ego_agent on x.com in your agent. That is the entire onboarding.