ego (lite) is just a browser, ego is your personal agent across devices.
Join waitlist
ego lite vs Puppeteer

The Best Puppeteer Alternative

Puppeteer gives developers an API for driving Chrome. ego (lite) gives the agent the browser itself.

ego (lite) skips selector maintenance and keeps work in your authorized local browser. Compact Snapshots and batched actions reduce model turns and token use.

Trusted by developers from
GoogleAmazonShopifyTikTokHarvardStanfordUSCUCLA

Why ego lite is better than Puppeteer

With Puppeteer, the workflow is a program you write and keep in sync with the page. With ego (lite), your coding agent works from the outcome and adapts as it goes, whether it is finding information, extracting rows, filling forms, checking a flow, or handling a logged-in site. No selector tree or separate runner is required for each task.

From task to done, faster

Puppeteer's own issue tracker is full of waitForSelector timeouts that fire even when the element is sitting right there in the DOM, burning an afternoon proving it's a timing bug and not your code.

ego (lite) skips the wait-and-poll dance: your agent reads the page as a compressed Snapshot and batches several steps into one JavaScript call per turn. Across our published benchmark, it had the fastest average completion time.

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

Puppeteer developers who move past a single script learn that parallelism means running your own pool: launch options, browser contexts, and a queue library like puppeteer-cluster to cap concurrency before Chrome eats all your RAM.

In ego lite there's no pool to size. Every task gets its own Space inside one browser, and you open as many as you want, each on its own imported Chrome profile. None of them touches the tab you're using, and you can watch or take over any Space anytime.

No more back and forth Cost fewer tokens

Raw Puppeteer scripts don't burn tokens; they don't call a model at all. The cost shows up the moment you wrap Puppeteer for an agent through an MCP server like the original Puppeteer MCP reference implementation, because every wrapped action becomes a separate tool call that re-sends context through the model, and without an accessibility snapshot tool it leans on screenshots to check its own work.

ego lite's agent batches several actions into a few lines of JavaScript per turn, and stacked with Snapshot input, the same task completes on far fewer tokens overall, measured per task.

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 · Puppeteer MCP
>Add the first product to the cart, then check checkout loads
puppeteer - puppeteer_navigate (MCP)(url: "localhost:3000")
Screenshot
[image: screenshot://home]
1.6k tokens sent so far
Storefront rendered. Opening the first product.
puppeteer - puppeteer_click (MCP)(selector: ".product-card:first-child")
Result
Clicked selector
3.1k tokens sent so far
Product page is up. Now the Add to cart button.
puppeteer - puppeteer_click (MCP)(selector: ".add-to-cart")
Result
Clicked selector
4.9k tokens sent so far
Added, probably. There's no accessibility snapshot to confirm it, so a screenshot is the only way to check.
puppeteer - puppeteer_click (MCP)(selector: "a[href='/checkout']")
Result
Clicked selector
6.8k tokens sent so far
Checking whether the checkout page actually rendered.
puppeteer - puppeteer_screenshot (MCP)(name: "checkout")
Screenshot
[image: screenshot://checkout]
9.2k tokens sent so far
Hard to tell from a screenshot alone. Probing the DOM directly.
puppeteer - puppeteer_evaluate (MCP)(script: "document.querySelector('.checkout-form') !== null")
Result
true
11.2k tokens sent so far
Confirmed. Reading the console for any errors along the way.
puppeteer - console://logs
Console
… +12 lines (ctrl+o to expand)
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: Puppeteer MCP, 7 round trips, tokens climb to 13.6k.

Same Chrome, agent-native

Puppeteer launches a clean, blank Chrome with no cookies or sessions, so anything behind a login means scripting the auth flow and hoping the site doesn't throw a captcha or 2FA prompt at a browser it doesn't recognize. That blank-profile wall is the single most common reason a script that works in dev fails on the real site.

Built on Chromium, ego lite imports your entire Chrome setup in one click. Your agents inherit your logins, cookies, and extensions without ever getting stuck.

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

Selector-free scraping, with guardrails

A Puppeteer scraper can only click or extract what its code identifies: CSS selectors, XPath, or a hand-written DOM query. AI-generated selectors are useful scaffolding, but they still become stale when a class name, list order, or accessible label changes, so a production job needs validation, logging, and a reviewed fallback.

With ego lite, describe the outcome in natural language—such as ‘collect the visible product names and prices from this results page’—and the agent reads the current Snapshot before writing JavaScript. It can re-check the result and stop for human review when the page no longer matches the task, instead of silently exporting the wrong fields.

Anti-bot boundaries, no bypass tricks

Puppeteer and other browser frameworks may be challenged by a site's robots policy, rate limits, login checks, or Cloudflare and CAPTCHA pages. A stealth plugin or fingerprint workaround is not a reliable or appropriate answer, and no tool can promise that a site will not detect automation; scraping should stay within the site's terms and applicable law.

ego lite runs in a normal, user-controlled Chrome profile, which avoids the blank-browser mismatch that often triggers extra verification, but it does not defeat access controls. If a challenge appears, the agent should pause, surface the page, and let an authorized person complete it or choose an approved data source.

Dynamic pages need evidence, not fixed waits

Modern sites often render data after load through fetch, WebSockets, or embedded JSON state. A fixed waitForSelector timeout in Puppeteer can be too short for a slow response and wasteful for a fast one; robust scripts wait on a meaningful network or application signal, capture the response they rely on, and record what happened when the signal never arrives.

An ego lite agent can inspect the rendered Snapshot, page text, and permitted in-page data together, then use JavaScript to parse an embedded JSON object or wait for a visible state change. That makes the extraction path explicit and reviewable without assuming that every site's internal API is stable or authorized for direct use.

Reliable pipelines still need JavaScript judgment

JavaScript remains a strong choice for web automation because it runs beside the browser, has first-class DOM and network APIs, and fits Node.js services and CI. Puppeteer is the better option when you need deterministic, versioned code, repeatable retries, PDF or screenshot generation, and high-volume jobs on a controlled site.

ego (lite) is for browser work that is expensive to encode as selectors: search, research, changing back-office workflows, testing, and tasks that require a person's existing session. Use checkpoints, bounded page counts, structured outputs, and an alert on missing fields so an agent-driven pipeline fails visibly instead of turning a layout change into bad data.

ego lite vs Puppeteer

Feature comparison between ego lite and Puppeteer.
Featureego litePuppeteer
How work gets doneDescribe the task; your agent drives the browserWrite and maintain Node.js scripts
Handles page changesAgent re-reads the Snapshot and adaptsSelectors break; you patch the script
Logged-in sites (SSO, 2FA)Inherits your real Chrome profile and sessionsBlank profile; script the login, export cookies
SetupInstall the app, run /ego-browser in your agentNode project, npm install, launch config
Parallel tasksSpaces isolate tasks inside one browser, no pool to sizeManage browser pools, contexts, and memory yourself
Works with AI agentsBuilt for them: Claude Code, Codex, Cursor via ego-browserNot natively; needs MCP wrappers or custom glue
Daily-use browserYes: humans and agents share one browser, separate SpacesNo, headless automation tool
Best for CI test suitesNot a script runner; agents handle browser work directlyYes: deterministic, scriptable, CI-friendly
Reusable skills (coming soon)Distills successful runs into reusable skills for repeat tasks (limited beta)No built-in equivalent
PriceFree, no subscriptionFree, open source
Last updated Aug 30, 2026

Make it a seamless transition

You don't port Puppeteer scripts to ego lite. You stop writing them. Take the tasks you scripted, or gave up scripting, and hand them to your agent.

  1. Download ego (lite)

    Download ego lite and import your Chrome profile. The logins your scripts could never get past come along with it.

  2. Run your first task with /ego-browser

    Paste into your agent

    /ego-browser Open ego.app and check the page for console errors

    Run /ego-browser in Claude Code, Codex, or Cursor.

  3. Watch it work
    ego lite Spaces overview with four browser tasks running side by side: 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

    Pick a task you'd normally script, like scraping a listings page or filling a back-office form, and describe it to the agent in a sentence.

Keep Puppeteer where scripts genuinely win: deterministic CI suites and high-volume scheduled jobs. ego (lite) handles browser work that benefits from agent judgment, live state, or a visible handoff.

When to use each tool

Choose ego (lite) when

  • The task changes every week. An agent adapts to page changes instead of breaking on a stale selector.
  • You need real login state: scraping your own accounts, filling back-office forms, testing behind SSO.
  • You never got around to scripting it. Describe the task to Claude Code, Codex, or Cursor and it's done.
  • You want several tasks running in parallel Spaces without sizing a browser pool or watching memory.

Choose Puppeteer when

  • You need deterministic, repeatable scripts committed to a repo and running in CI.
  • You're doing high-volume scheduled jobs: thousands of identical runs where an agent adds cost, not value.
  • You need headless execution on servers with no desktop environment.
  • You're generating PDFs or screenshots programmatically. That's Puppeteer's bread and butter.

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 Puppeteer compares with the other tools in the same space.

FAQ

Puppeteer is the Chrome team's Node.js automation library, controlling Chrome and Firefox over the DevTools Protocol and WebDriver BiDi. It's mature, fast, free, and a common choice for developers scripting Chrome-only scrapers, PDF generation, and headless testing, even as Playwright has pulled ahead in general test-framework adoption. Its own issue tracker documents real flakiness in waitForSelector around navigation and reconnection, and teams running it at scale end up managing browser pools, contexts, and memory by hand, but for hand-tuned, committed automation code running in CI, Puppeteer remains excellent. The comparison below is about what happens when an AI agent, not a script, does the browsing.

For AI-agent-driven browser work, yes: it removes the script layer entirely and runs tasks in your real logged-in Chrome, making it one of the few Puppeteer alternatives built for agents rather than more scripting. For committed, deterministic automation code in CI, Puppeteer is still the better tool. Many developers use both: Puppeteer for pipelines, ego lite for everything they never got around to scripting.

All three are script-first automation libraries, and playwright vs puppeteer or puppeteer vs selenium usually comes down to what you're testing and in what language. Puppeteer wins when you're Chrome-only in Node and want a lean DevTools-level API. Playwright generally pulls ahead for new test suites: multi-browser coverage, auto-waiting, and a stronger test runner. Selenium vs Puppeteer is closer, and which is better, selenium or puppeteer, usually comes down to language and CI setup rather than raw capability: Selenium's edge is the W3C WebDriver standard and the widest language and legacy-browser support, at the cost of more boilerplate. ego lite doesn't compete in that debate at all, since it's an agent browser where an AI agent does the browsing instead of any of the three scripting it. See our ego lite vs Playwright and ego lite vs Selenium pages for those comparisons.

MCP wrappers around Puppeteer give an agent browser access, but every action is a separate tool round-trip through the model, and the browser is still a blank profile underneath. ego lite batches actions in JavaScript and inherits your real login state, so per-task token cost stays low and the agent never hits an SSO wall the wrapper can't get past.

Selectors are tied to a page's exact markup: class names, DOM order, ARIA structure. A redesign, an A/B test, or a framework upgrade on the target site changes that markup and your waitForSelector calls start timing out, often intermittently, which is exactly the kind of flakiness reported repeatedly against Puppeteer's own tracker. ego lite's agent doesn't hold a fixed selector at all. It reads the current page as a Snapshot each time and reasons about what's actually there, so a redesign is something it adapts to on the next run instead of something that breaks the script.

No. Scaling Puppeteer past a single script usually means standing up a pool (puppeteer-cluster, generic-pool, or your own queue) to cap concurrency before Chrome's memory use gets out of hand. ego lite's Spaces run inside one browser process you already have open, so running five tasks at once doesn't mean five browser instances to babysit.

Yes. Any CLI agent that writes code plugs in through the MIT-licensed ego-browser shell: Claude Code, Codex, Cursor, Gemini CLI, Opencode, and custom in-house agents.

Yes. Free, no subscription, and the ego-browser shell is open source.

JavaScript runs in the browser's execution model and exposes the DOM, events, fetch, and browser tooling directly. Node.js also makes it easy to share code between a web app and a CI worker, which is why Puppeteer is a practical choice for deterministic scripts. ego lite keeps that JavaScript capability but lets an agent write short, task-specific code against the current page instead of asking you to maintain a selector tree for every workflow.