Headless browser vs real browser for AI agents

23 min read
Headless browser vs real browser for AI agents: an agent holding a real screen

Choose browser visibility, authorized account state and execution location separately. A headless browser can reuse approved saved state, while a visible browser can start empty. Use a visible session when the task needs inspection or takeover, and an unattended runner when its result can be checked without a window. Neither mode grants access or defeats site controls.

For permitted batch work, measure the cost of the actual browser and workload. For account work, identify who owns the state and where it lives. ego(lite) offers a visible local task Space and takeover; this does not constrain every tool the host Agent can call or keep every observation on the device.

Headless means no visible browser window. Headed means a window is displayed. A persistent profile and an approved storage-state file are separate ways to retain account data. This article uses real browser for an interactive browser environment, not as a promise of an existing login, isolation or permission.

Everything below is the evidence: the concrete tools on each side by name starting with the real-browser side, then the three deciding dimensions in depth (logins, detection, cost), and a task table you can pick from directly.

Match the browser to the task, not to a preference.

How do you decide: real browser or headless?

Choose display mode, account state and execution location separately. Modern Chrome shares its browser implementation between headless and headed modes. A visible window does not import a login; a headless context can use authorized saved state. Use a visible local browser when the task requires human inspection or takeover, and headless execution when an unattended job can verify its result without a window.

The official Chrome guide dates unified headless to Chrome 112. Since Chrome 132.0.6793.0, the old implementation is available only as the separate chrome-headless-shell binary. Comparing an old shell with a current desktop browser changes more than visibility. Record the browser build, controller and profile before attributing an outcome to headless mode.

This November 11, 2026 maintenance review checked the vendor documentation, not a new detection or login experiment. The August login runs and the three-mode detector case below remain historical observations on their recorded versions. They cannot establish a current success rate or isolate visibility as the cause of a difference.

DecisionAvailable choicesWhat to verify
DisplayHeadless or visible windowDoes the task need visual inspection or human takeover?
Account stateFresh context, authorized saved state or deliberate profile connectionWhich account is active, and has its state expired?
Execution locationLocal machine or hosted runtimeWhere do cookies, downloads and observations travel?
ControllerLibrary, MCP server or browser skillWhich runtime instructions and permissions apply?

Do agents need a persistent computer, not a sandbox?

For a one-shot script, an ephemeral sandbox is usually the right boundary. For an agent that returns tomorrow, a persistent computer is the more useful mental model: it keeps a filesystem, installed packages, browser profile, and task state between runs. Cloudflare describes this distinction as giving each agent a computer rather than only a container, while LangChain makes the same case for a filesystem, shell, package manager, and persistent state. Cloudflare's explanation and LangChain's runtime perspective spell out the infrastructure trade-off.

Persistence is not a reason to remove isolation. The useful design is an isolated, user-authorized workspace whose state survives the task, with explicit reset and handoff controls. A sandbox protects the host from untrusted code; a persistent computer protects the agent's continuity. They solve different problems and can be layered together. CNCF's analysis of agent sandboxing makes the same point: execution isolation alone does not provide the durable environment an agent needs for multi-step work. Read the CNCF analysis for the isolation context.

EnvironmentWhat survivesBest fitMain question to ask
Ephemeral sandboxOnly the outputs you explicitly exportUntrusted code, CI, one-off jobsWhat must be saved before teardown?
Persistent computerFiles, packages, memory, and browser stateLong-running, resumable agent workflowsWho can inspect, reset, or revoke it?
Isolated real-browser SpaceAn authorized profile and its live sessionsAccount work that needs continuity and oversightIs the action still user-approved?

An interactive local browser is useful when the task deliberately reuses an authorized account and needs inspection or takeover. ego(lite) can keep that browser state on the local machine; snapshots and other observations can still reach the host Agent and model provider. A Space organizes the task but does not establish an OS sandbox or override site permissions.

The real-browser tools, by name

The real-browser side has its own concrete roster, and it sorts into four families by how the agent reaches the browser: a shared-session browser built for the job, attach routes into the Chrome you already run, vendor extensions, and no-code recorders.

ego(lite)

The ego(lite) homepage: the real-browser side of the divide, built for sharing logged-in state with AI agents without giving up your window
The real-browser side, in the version built for agents (ours, for the record): ego(lite). Sessions come from the Chrome import; the window stays yours because the agent gets its own Space.

ego(lite) (free) is our own product, stated plainly: the agent runs in its own Space with its own tabs, so the window stays yours.

It's the only entry in this roster that gives the agent real sessions without giving it your window.

What that isolated Space actually returns, run today against a live page: a real ego-browser session opens a task, navigates, and comes back with only the fields asked for, no accessibility-tree dump attached.

const task = await egoBrowser.newTaskSpace('evidence-egobrowser-hn')
await task.page.goto('https://news.ycombinator.com/', { waitUntil: 'load', timeout: 20000 })
const title = await task.page.title()
const topStory = await task.page.locator('.athing .titleline > a').first().innerText()
const points = await task.page.locator('.subtext .score').first().innerText().catch(() => null)

{
  "taskSpaceId": 13
}
{
  "title": "Hacker News",
  "url": "https://news.ycombinator.com/",
  "topStory": "Qwen 3.8 27B",
  "points": "412 points"
}

Download ego(lite) for Mac, free, or see the full session model in the logged-in browser guide.

Chrome DevTools MCP auto-connect

The official chrome-devtools-mcp configuration docs for the --autoConnect flag that attaches an agent to your signed-in Chrome
The auto-connect configuration, from the official chrome-devtools-mcp docs: the flag that puts an agent inside the Chrome you're signed into.

Chrome DevTools MCP auto-connect (Google, free) is the official attach route: on Chrome 144+, enable remote debugging at chrome://inspect, add the --autoConnect flag, and the agent operates inside your signed-in Chrome after a per-session permission dialog. Full sessions, real fingerprint, plus the debugging toolkit nothing else has; the cost is that it's your window being driven while it works.

Browser MCP

Browser MCP: an extension plus MCP server connecting AI apps to the browser profile you're already logged into
Browser MCP's one-line pitch: connect AI apps to your browser. The profile is yours, and so is the window while it works.

Browser MCP (browsermcp.io, free) is the community attach route: an extension-plus-server pair that connects Cursor, Claude, VS Code, and other MCP clients to your existing browser. Automation runs locally, uses your existing profile so your logins come along, and rides your real fingerprint; like every attach route, it drives the browser you're using, one task at a time.

Claude in Chrome and Codex for Chrome

Anthropic's Claude in Chrome page: reads the page you're signed in to, then clicks, types, and fills forms
The vendor-extension family's pitch in one line, from Anthropic's page: it reads the page you're signed in to, then acts on it.

Claude in Chrome and Codex for Chrome are the vendor-extension family: Anthropic's reads the page you're signed in to, then clicks, types, and fills forms, on all paid Claude plans; OpenAI's acts on sites where you're already signed in (its docs name LinkedIn, Salesforce, Gmail) with tasks grouped into Chrome tab groups.

Zero technical setup, mature per-site permission prompts, and two shared costs: each serves only its own vendor's agent, and each works in your window.

Axiom, Browse AI, and Simplescraper

Axiom, Browse AI, and Simplescraper are the no-code family: point-and-click recorders that capture a login-and-extract flow in a real browser session and replay it on a schedule. For a non-developer pulling one table from one portal they're the fastest first result on this page; the trade is brittleness when the site redesigns, and a hosted runner carrying your session on someone else's infrastructure.

ToolHow the agent reaches the browserThe trade
ego(lite)Separate browser inherits your sessions; agent works in its own Space via CLIDesktop only, no headless CI; free
Chrome DevTools MCPAttaches to your live Chrome via --autoConnect (Chrome 144+)Shares your window while it works; free
Browser MCPExtension + MCP server into your existing profileYour window, one task at a time; free
Claude in ChromeVendor extension in your signed-in ChromeClaude only, paid plans, your window
Codex for ChromeVendor extension, tasks in Chrome tab groupsOpenAI integration, configured browser connection and website permissions
Axiom / Browse AI / SimplescraperRecorded point-and-click flows, replayed on scheduleBrittle on redesigns; session lives on their runner

Read the trade column as a deployment constraint, not a universal ranking. Verify current browser support, authorized state and the task result on the route you choose.

The headless tools, by name

"Go headless" is a category, not a decision, so here's the category by name. It splits into three tiers: libraries you script against, tools built for agents specifically, and cloud fleets you rent when one machine stops being enough.

Playwright

Playwright's official installation and quickstart docs: install, write a test, run it headless or headed
Playwright's own quickstart, where the execution loop this section describes begins: install, write a test, run it. Source labeled on the image.

Playwright supports Chromium, Firefox and WebKit with language bindings for Node.js, Python, Java and .NET. Locator checks and browser contexts help with timing and job state, but an auto-waited click still needs an application-level result check. Saved authentication is independent of whether a window is shown.

Headless is its native habitat in CI, and for agent use there's Playwright MCP on top of the same engine.

Puppeteer

Puppeteer's getting-started guide showing installation and a first script
Puppeteer's getting-started guide: the lean install-and-first-script loop that keeps scraping fleets on it.

Puppeteer provides JavaScript and TypeScript browser control. Its current documentation supports Chrome and Firefox through WebDriver BiDi, with unsupported operations listed separately; Chrome uses CDP by default and Firefox uses BiDi. It does not provide a WebKit target. Choose it for a compatible Node workflow, not because Firefox support is still beta.

Selenium

Selenium's first-script documentation walking through the WebDriver session lifecycle
Selenium's first-script walkthrough: the WebDriver session lifecycle step by step, the same flow a Grid then distributes.

Selenium offers WebDriver tooling, multiple official language bindings and Grid infrastructure. Its BiDi APIs add bidirectional browser capabilities. Keep it when the required browser, language or existing Grid fits the task; measure the actual workload instead of inferring speed from a protocol name.

agent-browser

agent-browser's docs opening with real install and run commands: npm install -g agent-browser, then npx agent-browser open example.com
agent-browser's docs open with the actual commands: install, then npx agent-browser open example.com. Compact text output for agents is the stated design goal.

agent-browser (Vercel Labs, ~40K stars, Apache-2.0) is what the agent-native tier looks like: a Rust CLI with a daemon speaking raw CDP, driving a downloaded Chrome for Testing. The agent runs agent-browser snapshot to get an accessibility tree with refs like @e1, then acts on them with commands like click @e2. Sessions are deliberately isolated, output is filterable to stay token-lean, and the whole design assumes no human is watching.

Browser Use

Browser Use's open-source quickstart: install the package, define an Agent with a task string, run it
Browser Use's quickstart: an Agent with a task string and a run call. The autonomous loop in a handful of lines.

Browser Use supplies an Agent control loop rather than a guarantee about browser identity or account access. Its execution host, profile and model determine what state and observations are available. Use a visible browser for authorized inspection or takeover when needed, and stop at access controls in either mode.

The archived demonstration below shows a perceive-decide-act loop on its recorded Browser Use and model versions. It illustrates the control flow; it is not a new November 11 run or a comparison with the other libraries.

agent = Agent(
    task="Go to https://news.ycombinator.com/ and tell me the exact title text of the #1 story on the front page, plus its points count.",
    llm=llm,
)
history = await agent.run(max_steps=8)

INFO     [Agent] Starting a browser-use agent with version 0.13.7, with provider=openai and model=gpt-4.1-mini
INFO     [Agent]   navigate: url: https://news.ycombinator.com/, new_tab: False
INFO     [tools] Navigated to https://news.ycombinator.com/
INFO     [Agent] Step 1:
INFO     [Agent]   Eval: Successfully located the #1 story title and its points count on the Hacker News front page.
INFO     [Agent]   Memory: Located the top story on Hacker News with title 'Qwen 3.8 27B' and points count '415 points'.
INFO     [Agent]   Next goal: Report the exact title text and points count of the #1 story to the user.
INFO     [Agent]   done: text: The #1 story on Hacker News front page is titled "Qwen 3.8 27B" with 415 points., success: True
Final Result:
The #1 story on Hacker News front page is titled "Qwen 3.8 27B" with 415 points.
INFO     [Agent] Task completed successfully

Browserbase and Stagehand

Browserbase docs introduction: one API key gives your agent access to cloud browsers, web search, page fetching, and a sandbox runtime
Browserbase at its docs: the platform pitch is one API key for cloud browsers, fetch, search, and runtime. The Stagehand tab in its nav shows how tightly the SDK and the infrastructure ship together.
Stagehand's act() documentation: a one-line natural-language action call, await stagehand.act, with add to cart as the instruction
Stagehand's act() docs: one natural-language action call, chained into automations that survive site changes. Code where you can, AI where you must.

When the fleet outgrows your machine, the cloud tier takes over. Browserbase sells managed browser infrastructure at the scale of thousands of concurrent sessions (36.9M unique sessions in a March 2026 monthly count, 10,000+ companies), with Stagehand (23.7K stars) as its open-source SDK layering act, extract, and observe primitives over Playwright-style code.

Browserless

Browserless documentation: REST endpoints and BrowserQL callable from any HTTP pipeline
The Browserless docs: browser work as HTTP endpoints, which is exactly what makes it fit pipelines that can't host a browser.

Browserless plays the same position with an API-first shape: REST endpoints for /screenshot, /pdf, /content, and /scrape, an /unblock endpoint for bot-detection handling, and BrowserQL for multi-step flows, callable from anything that can send an HTTP request, n8n workflows included.

The stealth layer

And one honest layer on top: the stealth ecosystem. Selenium has undetected-chromedriver and SeleniumBase; Puppeteer's puppeteer-extra-plugin-stealth is the mature classic, and playwright-extra can load its plugins; Camoufox and Patchright currently support only Playwright. Treat all of it as a moving target rather than a purchase: practitioners on r/webscraping report cases where a stealth fork got blocked while default Playwright passed.

ToolWhat it isWhere it fits headless work
PlaywrightCross-engine library, 4 official language families, auto-waitingDefault for CI, testing, and scripted scraping
PuppeteerChrome-first JS/TS library from the Chrome DevTools teamLean PDF, screenshot, and crawl jobs
SeleniumWebDriver ecosystem, 5 documented language bindings, Grid distributionLegacy estates and widest language/browser reach
agent-browserRust CLI + daemon, snapshot refs, isolated sessionsAgent-driven stateless automation, token-lean
Browser UseAutonomous Python agent loop over direct CDPGoal-driven scraping where steps can't be scripted
BrowserbaseCloud browser infrastructure; Stagehand SDK on topThousands of parallel sessions, managed ops
BrowserlessHosted browser API: REST endpoints + BrowserQLHTTP-callable browser work from any pipeline

These tools all require deliberate browser-state management. A fresh context, saved storage state and persistent profile each have setup and expiry costs. Inspect the actual connection before choosing a separate interactive browser route; a headless library does not forbid account continuity.

Which one has your logins?

Headless does not mean login-free. A fresh context starts empty, but Playwright can restore authentication through storageState or a persistent profile. The real difference is how much work it takes to prepare that state, reuse it, and recover after the server expires it.

On August 21, 2026, we ran each path five times against the same first-party login fixture on an M4 Mac. Playwright 1.59.1 used Chromium 147; ego(lite) was 0.4.7.1.

State pathReusable preparationMedian first usableAfter server expirySecurity boundary
Fresh Playwright contextNone saved; three-step login every run1.61sRun login again, 0.19sNo auth file; credentials enter each run
Playwright storageStateFour steps, 1.81s1.60sLog in and rewrite JSON, 0.26sJSON contains session cookies and tokens
Playwright persistent contextThree steps, 2.39s1.42sLog in inside the profile, 0.18sProfile directory stores broader browser state
ego(lite) inherited sessionThree steps once, 0.78s0.43sSign in once; new Spaces inherit it, 0.13sThe Space receives the account's active privileges

All four paths completed five of five runs without a retry. With a session ready, a fresh ego(lite) Space reached the protected page in 0.43 seconds, versus 1.42 to 1.61 seconds for Playwright. Reusing any session also gives the agent that account's permissions.

Zillow stays a field observation

In a separate read-only run, fresh Playwright stopped at Zillow's Press & Hold screen, while ego(lite) with an inherited session reached the homepage and account menu. Read Zillow's current terms before automating. Login state, automation signals, defenses, and profile history changed together, so this remains a field observation rather than a causal benchmark.

Zillow Press and Hold challenge shown to Playwright headed Chromium with a fresh profile
Playwright headed with a fresh profile: the workflow stopped at Zillow's Press & Hold human-verification screen before it could reach an account task.
Zillow homepage loaded in ego(lite) with the inherited signed-in account menu highlighted and personal initials redacted
ego(lite) with an inherited session: the normal homepage loaded and the account menu was present. We replaced the account initials with ‘Signed in’; no other page content was changed.

How big is the detection gap?

Less different than it used to be, and the reason is a specific change. Chrome shipped a new headless mode (--headless=new) that runs the same browser binary as the visible one, replacing the old separate headless implementation that leaked obvious tells.

Historical headless implementations could expose different user-agent, plugin and rendering values. Current behavior depends on the selected binary, version and flags; the Chrome unification announcement does not establish that every signal now matches a desktop profile.

What still leaks is subtler and rarely lives in the user agent. Automation flags (navigator.webdriver set true unless suppressed), the absence of a real display and its device-scale quirks, timing and interaction patterns no human produces, and connection signals from datacenter IPs all remain visible to a determined defender.

Detection in 2026 is a scoring problem, not a single check: no one signal condemns you, but a stack of them does. That's why the honest framing is baseline plus behavior, not headless-bad, real-good.

Our three-mode detection test

In the archived Sannysoft case, we opened the public detector on the same Apple M4 Mac and network with Playwright 1.62.1 default headless Chromium, headed Chromium with a fresh profile, and ego(lite) with persistent state. Each configuration ran three times. Chromium versions and profile state differed, so this was not a controlled visibility-only experiment or a current access test.

Visible signalPlaywright headlessPlaywright headed, freshego(lite) persistent
User agentHeadlessChrome/151Chrome/151Chrome/150
WebDriverpresent (failed)present (failed)missing (passed)
Plugins0; PluginArray failed5; PluginArray passed5; PluginArray passed
Languagesen-USen-US, enen-US, en, zh-CN
WebGL rendererSwiftShaderApple M4 via MetalApple M4 via Metal
Sannysoft results for Playwright default headless Chromium showing HeadlessChrome, WebDriver present, zero plugins, and SwiftShader
Playwright default headless, run 1 of 3: the page reported HeadlessChrome, WebDriver present, no plugins, a missing Chrome object, and SwiftShader. Runs 2 and 3 showed the same visible values.
Sannysoft results for Playwright headed Chromium with a fresh profile showing a normal Chrome user agent and Apple M4 renderer but WebDriver present
Playwright headed with a fresh profile, run 1 of 3: the normal Chrome user agent, plugins, Chrome object, and Apple M4 renderer appeared, while WebDriver remained present.
Sannysoft results for ego(lite) showing WebDriver missing, five plugins, the Chrome object, and an Apple M4 renderer
ego(lite), run 1 of 3: WebDriver was missing rather than false. The page reported five plugins, the Chrome object was present, and WebGL used the Mac's Apple M4 renderer. The same visible values appeared in all three runs.

This detector case supports only the values observed on that page in those configurations. The browser builds and profile states differed, and the page did not measure account authorization, IP reputation or production task success. Do not use it to promise access to another target.

There is another important version detail: Playwright distinguishes its default Chromium headless shell from the newer headless mode available through the Chromium channel. Our default-headless result must not be generalized to every modern Chrome headless configuration. If detection matters, record the exact package, browser build, launch channel, flags, profile, network, and date.

What the tools felt like to run

Playwright was the cleaner choice for a controlled fresh-context test. The browser version and launch mode were explicit, the run could be repeated, and the screenshot was easy to capture at a fixed viewport. The friction appeared when the task crossed into account state: headed mode gave us a window, but the fresh profile was still fresh. We would need to authenticate, import state, or maintain a persistent profile before doing useful account work.

ego-browser took a different approach: it created an isolated Space and opened YC Hacker News inside ego(lite). The screenshot below shows the actual run, including the browser chrome, the agent's Browsing Hacker News cursor, and the live control panel. The agent works in its own tabs while the user can watch progress, take over, or stop the task at any time.

YC Hacker News open in an ego(lite) Space while an AI agent is in control
A real ego(lite) Space while ego-browser browses YC Hacker News. The browser remains visible, the agent's current action appears beside its cursor, and the control panel lets the user take over or stop immediately.

That experience also made the split between the products clearer. We would use a fresh Playwright context when a public test needs a controlled, disposable environment. When the task depends on an authorized existing session, ego(lite) skips profile recreation and lets the agent begin from the state you already prepared.

What does each cost to run?

We ran five cold starts per mode on the same M4 Mac and first-party page. Playwright 1.59.1 used Chromium 147; ego(lite) was 0.4.7.1. We recorded time, RSS, retries, and failures.

ModeStartup median (range)Idle to loaded RSSCompletion medianSuccess
Default headless shell0.50s (0.47 to 0.73)238 to 263 MB0.64s5/5
New headless0.96s (0.70 to 3.21)593 to 627 MB1.16s5/5
Headed fresh1.71s (0.79 to 2.68)578 to 641 MB1.89s5/5
ego(lite) fresh Space0.46s (0.43 to 0.52)175 to 178 MB incremental1.09s5/5

The default shell was the leanest full Playwright process tree at 263 MB loaded. New headless and headed reached 627 and 641 MB, only 2.2% apart. The ego(lite) Space started fastest and added 178 MB of Space processes; its row excludes the running shared app, GPU, and network processes. All 20 runs succeeded without retries.

End-to-end agent cost adds another layer. In our 31-task benchmark with the same model and judge, ego-browser recorded the lowest average cost per task at $1.64. Playwright CLI recorded $3.42 and Chrome DevTools CLI recorded $4.95 under the same setup.

Average cost per task for five browser agent tools in a 31-task benchmark, with ego-browser lowest at $1.64
Average cost per task across 31 tasks from the same 31-task suite. The benchmark used gpt-5.6-sol at max effort and the same judge; lower is better. ego-browser recorded $1.64 per task, compared with $2.43 for Browser Harness, $2.66 for Agent Browser, $3.42 for Playwright CLI, and $4.95 for Chrome DevTools CLI. These are end-to-end agent-run costs, not browser hosting prices.

Which browser for which task?

The three dimensions collapse into a task lookup. Find the row that matches what you're actually doing; the pull is rarely ambiguous once the task is named honestly.

TaskConfiguration choiceRequired check
Authorized account taskDeliberate saved state or profile connectionVerify the account and expiry in either display mode
Access challengeStop and seek a supported pathA window does not grant access
Interactive account workVisible session when takeover is neededSpace organizes the task, not host isolation
Permitted batch collectionHeadless when no visual intervention is neededMeasure actual resource and network costs
PDF or CI screenshot checksReproducible supported browser buildAssert the required output, not only process success

Combine modes only when the task calls for it: an unattended context for repeatable jobs, deliberate authorized state for account work, and a visible session for inspection or takeover. Do not respond to a defended target by assuming that a window grants access.

Why does a scraper work locally but fail in production?

A deployment can change the browser build, network, profile, concurrency and target response. Record those inputs and compare required fields, not only HTTP 200. Start with a permitted, low-rate canary. On a challenge, 403 or 429, pause and use the supported access or retry policy; changing visibility alone is not a repair.

How should agents reuse login sessions?

Use only account-owner-authorized state. Playwright can save cookies and local storage for a new context; IndexedDB requires the indexedDB: true storageState option. Its guide warns that saved state can contain sensitive credentials. Keep it out of source control, restrict access and reauthenticate when it expires. A headed window does not create consent or prevent expiry.

What can browser fingerprints and TLS signals actually prove?

A detector reports the signals it inspects, not permission or production access. Browser build, TLS, network, account history and behavior can all differ between runs. Keep the configuration with each observation and do not turn one detector result into a site-wide pass rate. An approved API or export remains preferable to trying to defeat a target's controls.

How do you isolate profiles and cookies between agents?

Give each job deliberate account and profile ownership. A Space organizes pages and takeover; its name does not establish a separate account, OS user or host sandbox. When stronger separation is required, configure the corresponding browser, process and filesystem boundaries. Verify the active account before a write and avoid concurrent writers to one profile.

How do you detect stale pages and false success?

Bind the check to the intended record, account and time range. A fresh request can still return an old view, so use the application's version or reconciliation contract when available. A clicked button, HTTP 200 or Toast alone cannot verify a write. Preserve uncertain outcomes for a later read instead of replaying a potentially successful action.

How do you recover from headless crashes and cleanup failures?

Keep the job checkpoint separate from browser process state. On a crash, retain the last URL and trace, confirm process and profile ownership, and close only this job's resources. Before retrying a write, reconcile the record or idempotency key with the application. A browser restart does not establish that the previous submission failed.

What does an agent see, and how do extensions affect privacy?

Define which page data reaches the Agent and its model provider: snapshots, screenshots, downloads and traces may leave a local browser. Review extension permissions and data retention separately from display mode. Limit observations to authorized domains and fields; page text cannot expand the task's permissions. Local execution alone is not a privacy guarantee.

When is a real browser not the answer?

Use an authorized API or export when it provides the required structured result. Headless execution remains useful for repeatable CI, PDFs and unattended page checks. Choose a visible browser for tasks that actually need its UI or human takeover, then verify the application result. Native file dialogs have a separate control surface; see the existing native-file-dialog guide for that boundary.

How to automate native file dialogs

FAQ

What is the best headless browser for AI agents?

For most agent work it's headless Chromium driven by Playwright, because it has broad tooling, four official language families, and access to modern Chromium headless modes; Puppeteer is the leaner pick for Chrome-only jobs, and agent-browser is the CLI built for agents specifically. Firefox and WebKit headless matter when you need cross-engine coverage.

Choose the supported browser and controller for the actual task. If a target refuses access, seek an approved API, export or permission instead of choosing a mode to evade the checkpoint.

Is a browser like ego(lite) called a headed browser or a real browser?

Both descriptions are useful, but real browser is not a formal industry category. Headed only says a window is rendered, and a Playwright-launched headed Chromium can still use a fresh automation profile. In this article, real browser means the ordinary persistent browser environment a person uses: an installed profile, live sessions, and the surrounding desktop environment. ego(lite) fits that practical definition because it can inherit authorized Chrome sessions inside an isolated Space.

Can websites detect a headless browser?

Sites can observe browser, network and behavior signals in either mode. Unified Chrome headless shares its implementation with headed Chrome, but that does not promise identical signals under every build and launch setting. A detector result cannot establish permission or a production success rate.

Should Browser Use run headless or not?

Choose display mode for inspection and takeover needs; choose authorized saved state separately for account work. A headless Browser Use workflow can have saved state, and a visible one can start empty. Stop at an access challenge in either mode.

Is a real browser always safer from bans?

No browser mode guarantees freedom from restrictions. Account permissions, traffic volume, target policy and other signals still apply. Verify the supported access path and stop when the task is challenged or denied.

Does headless mean faster?

Not universally. Binary choice, workload, rendering, process sharing and network waits affect the result. The historical local resource table in this article describes its recorded configurations; it cannot establish a current speed ranking for every headless and headed deployment.

Can I share my logins with a headless browser?

Yes. Playwright can load a saved authentication state, add cookies, or launch a persistent context, but that state must be created, protected, refreshed, and debugged as it expires. If an existing authorized login is the point, a real-browser tool that inherits the user's session inside an isolated Space can remove the injection step, at the cost of being a desktop browser rather than a CI-friendly headless one.

Do AI agents need persistent computers instead of sandboxes?

They need the right combination for the job. An ephemeral sandbox is valuable for isolating untrusted, one-off code; a persistent computer is valuable when the agent must keep files, installed tools, memory, or a browser session between runs. The strongest design layers the two: isolate the workspace, persist only the state the workflow needs, and give the user a clear way to inspect, reset, revoke, or take over.

What is the difference between a headless browser and a real browser?

A headless browser runs without a visible window and is well suited to scripted, parallel work on servers. In this article, a real browser means an ordinary persistent desktop browser environment with a user-authorized profile and live sessions. The practical divide is often state management: fresh automation contexts begin empty, while an existing persistent session is already prepared.

Do stealth plugins make a headless browser undetectable?

No. Plugins like puppeteer-extra-plugin-stealth or forks like Camoufox and Patchright suppress known signals, but detection is a moving target and practitioners report cases where a stealth fork got blocked while default Playwright passed. Stealth changes a few signals; it does not buy invisibility, permission, or reliability. When a legitimate task depends on an authorized session, a real browser can reduce profile-mismatch without promising access through a control.

Choose the next step

If your choice is between a fresh Playwright workflow and an isolated session-carrying browser, read the ego(lite) vs Playwright comparison. If the task needs an existing authorized login, download ego(lite) and start in a separate Space rather than handing an agent your active browser window.

Keep reading