ego (lite) — это просто браузер, а ego — ваш личный агент на всех устройствах.
Записаться в лист ожидания
ego lite vs Puppeteer

The Best Puppeteer Alternative

Puppeteer is a Node.js library for scripting headless Chrome: you write the navigation code, tune the selectors, and patch the script whenever the target site redesigns.

ego lite skips the script. Your agent reads your logged-in Chrome directly and writes its own JavaScript, finishing whole tasks 3 to 4x faster than Puppeteer.

Trusted by developers from
GoogleAmazonShopifyTikTokHarvardStanfordUSCUCLA

Why ego lite is better than Puppeteer

For one-off scraping, form filling, testing, and back-office chores, the script was always the expensive part: writing it, then fixing it every time the page changed underneath you. ego lite moves that work to the agent you already use (Claude Code, Codex, or Cursor) through the open-source ego-browser shell.

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 the moment it loads and acts on it immediately, batching several steps into one JavaScript call per turn. That adds up to whole tasks finishing 3 to 4x faster than Puppeteer.

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

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 suitesNo: interactive agent tasks, not committed test codeYes: deterministic, scriptable, CI-friendly
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
PriceFree, no subscriptionFree, open source
Last updated Jul 28, 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 covers the interactive, changes-every-week browser work.

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.