How to connect AI agents to your existing browser

10 min read
How AI agents connect to your existing browser and logged-in sessions

Choose a live connection when the task needs the current Chrome tab. Choose a separate browser when you want the Agent to use different task pages. DevTools auto-connect, extensions, CDP, and supported state copies have different setup and session behavior.

We build ego(lite). It provides the separate local browser route described below.

Look at what users keep building when nobody gives them the feature: bridge projects like codex-browser-bridge, browser-bridge-mcp, and kimi-chrome-bridge, all doing the same job of wiring an existing agent into an existing browser.

A fresh automation profile usually lacks the user's website sessions. A persistent or explicitly connected profile can provide them, subject to website verification and the account's permissions.

Do you need the current Chrome tab or a separate local browser?

Confirm the account, login state, and Profile before a browser task

Choose the required browser environment before choosing the tool. An extension or live DevTools connection operates the browser already running. ego(lite) imports supported state into a separate local browser and gives each task its own pages. Those routes solve different migration and workspace requirements.

Connection routeState sourceDecision for the user
Extension or live DevTools connectionThe selected running browser and its authorized stateChoose it when the current Chrome tab is the task.
ego(lite)Supported imported state or a direct sign-in in egoChoose it when you want a separate visible local browser shared with your coding Agents.
Copied or exported test stateA snapshot of supported credentials or storageUse it for accounts and environments you control, and protect that state as a credential.
Hosted browserA separate remote session or provider-managed stateUse it when remote execution is needed, after reviewing state handling.

Browser MCP and Playwright MCP's extension mode document access to an existing Chrome environment. BrowserOS documents Windows and Chrome import. Reusing login state is therefore not an exclusive ego capability. The useful distinction is where the browser runs, which state is used, which Agent can operate it, and how the user participates.

Our November 9 ego runtime tests verified a protected browser-session download, separate task pages, and a synthetic account change visible across two Spaces. They did not test importing a real Chrome Profile or moving an SSO account. Do not infer cookie isolation from the separate task pages.

Keeping a browser profile on your computer also differs from keeping all information local. Page observations can still go to the selected model. For a work task, confirm the target account and organization and define which sites and operations are authorized. If an existing API or connector already supplies the required information, browser control can be unnecessary.

Read Browser MCP's existing-browser connection

Read Playwright MCP's extension configuration

Confirm account state in an ego task Space

Why do agents need your login state at all?

Because the tasks people actually delegate live behind auth. The requests filling forums aren't "open example.com"; they're LinkedIn and Salesforce workflows, Gmail triage, internal tools, dashboards, member communities. An agent in a fresh profile meets a login wall at each of those, and scripted credentials break on 2FA, device checks, and CAPTCHA-gated sign-ins, when they're acceptable to your security posture at all.

So the engineering question inverted years of automation practice: instead of "how do we keep automation isolated from the user's browser," it became "how do we safely let it in." The four routes are four different answers to that question, and their differences come down to two things: where the agent's actions land (your window or its own), and where the session state lives (your real browser, a copy, or an inheriting one).

State and window: every route is a position on those two.

How do current AI browsers handle login state?

There are three materially different answers in current products. Hermes Agent's real-profile mode copies the active Chrome, Edge, Brave, or Chromium profile into a managed snapshot, then drives the copy; ChatGPT Work's cloud browser asks you to sign in to a separate remote browser and keeps that session for later tasks; Claude Cowork's built-in browser is deliberately separate from your own tabs and logins. 'Uses your login' is therefore not a sufficient comparison. Ask where the credentials live, whether the window is shared, and who can clear or revoke the session.

How does Hermes Agent real-profile browsing work?

Hermes enables it with browser.use_real_profile: true: it identifies the active Chromium-family profile, copies its cookies, saved logins, and preferences into a managed snapshot, and launches the agent against that copy. The live profile is never opened directly, and disabling the toggle removes the snapshot store on the next browser use. This is local session convenience with a credential-bearing copy, not a sandbox or a guarantee that every site will accept the session.

The documented edge case is Windows: Chrome, Edge, or Brave must be fully quit, including background or tray processes, before Hermes can copy its cookie and login databases. macOS and Linux can copy while the browser is running. Hermes also says the feature is off by default, consent-gated, and should be treated as acting with your real account authority.

How does Tencent BrowserSkill connect an agent?

Tencent BrowserSkill is a local bridge rather than a hosted browser. Its official repository describes two runtime pieces: a bsk CLI/daemon and a browser extension. The bridge connects shell-capable agents (including Cursor, Claude Code, Codex, OpenClaw, and Hermes Agent) to an already logged-in Chrome or Edge session, while a separate visible Agent Window keeps the browser work observable.

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/Tencent/BrowserSkill/main/install.sh | sh
bsk --version
bsk install-skill

After installing the CLI, the documented setup adds the BrowserSkill extension from the Chrome Web Store or Edge Add-ons, then installs the agent skill with bsk install-skill. BrowserSkill says tasks can borrow an existing tab explicitly, return it when done, and leave the rest of the browser alone. Its built-in human-in-loop flow pauses for CAPTCHA, login, confirmation dialogs, or other human-only steps; it does not remove those access controls.

The trade-off is architectural: BrowserSkill shares a local browser through an extension and Agent Window, while ego(lite) is itself the browser, with no extension or daemon bridge between agent and page. Both can preserve a human handoff; they differ in whether the agent works beside your browser or in a separate browser built for agent work.

OpenAI's Cloud browser help makes the opposite trade-off: the remote browser has its own cookies and signed-in sessions, does not use your device's tabs, history, saved passwords, extensions, or existing sign-ins, and pauses for secure sign-in, two-factor authentication, or consequential-action confirmation. Anthropic's Cowork announcement likewise says its built-in browser needs no extension and keeps your own tabs and logins out. Both are isolated from the daily window; neither starts with your existing local session.

For an AI browser login-state decision, use this short rule: choose a copied profile when you need local execution and can accept re-sync and credential-copy risks; choose a cloud session when background work matters and you are comfortable signing in remotely; choose a shared-window extension or DevTools attach when the task must see the live tab. Choose ego(lite) when your existing sessions should stay on your own machine, with a one-time Chrome import and human handoff for challenges.

A bounded public-data task is a concrete next step: the AI social media scraper workflow keeps each source in a visible browser Space and returns source-linked rows. Use it only for information your authorized session can display.

What are the four routes?

Route 1: DevTools auto-connect

Chrome DevTools MCP configuration documentation for --autoConnect and --browserUrl, the two official flags for attaching an agent to a running Chrome
Routes 1 and 3, documented side by side in the chrome-devtools-mcp readme: --autoConnect is the sanctioned attach, --browserUrl the manual debug-port route with its Chrome 136+ caveats.

Chrome DevTools MCP's --autoConnect (Chrome 144+) attaches your agent to the browser you're signed into: enable remote debugging once at chrome://inspect, add the flag, click Allow per session. Official, sanctioned, and complete: the agent reaches your tabs, cookies, and storage. The mechanism's honest cost: it's your window being driven, turn by turn, and the grant covers your whole profile.

Route 2: extension injection

Vendor extensions install the agent into your browser: Claude for Chrome and Codex for Chrome for their respective agents, Browser MCP as the agent-agnostic protocol version using "your existing browser profile." Zero technical setup and the most polished permission systems in this list. Same structural cost as route 1 (shared window, whole-profile scope) plus vendor lock for the first two.

Route 3: CDP takeover

Launch Chrome with --remote-debugging-port and point any CDP client at it. Maximum flexibility, two documented sharp edges: Chrome 136+ ignores the flag on your default profile (you need a dedicated --user-data-dir you sign into separately), and the open port is reachable by any process on the machine, which is why the practitioners who document this route also document closing it.

Agents connected this way also collide with you: field reports include agents navigating the tab the user was reading.

Route 4: profile and state copies

Export session state (Playwright's storageState, cookie files, or supported profile copies) and load it into automation browsers. This is useful for headless CI and controlled test accounts. Other configurations can also run headless.

Its maintenance is structural: copies expire on the site's schedule, drift when sites bind sessions to device signals, and the state file is a credential-grade secret. Full profile copies add flakier failure modes; tools attempting live profile reuse have documented instability, including Browser Use's founder acknowledging its real-Chrome connection feature was unreliable.

ego(lite): a separate local task browser

The ego(lite) homepage: a browser built for sharing your logged-in browser state with AI agents like Codex or Claude Code, without disturbing you
The combined route is our product, so weigh the screenshot accordingly: ego(lite), free, one Chrome import, and the agent works in its own Space instead of your window.

The practical choice is whether the task needs the currently running browser or a separate environment. ego(lite) changes task-page organization and user handoff. Website authority, session expiry, and result verification remain part of the job.

The coding Agent reads the installed ego-browser Skill and runs the documented Page API against ego(lite). It does not need the user to expose the daily Chrome profile through a new debug-port configuration. This does not establish a security boundary against every local process.

From routes 1 and 2 it takes the thing they exist for: your real sessions. Imported browser state can help start an authorized task, but sites can expire or revoke it and may require another sign-in. A Space gives the task its own work tabs; it is not, by itself, a promise of independent credentials or a session that never expires.

The agent-facing surface stays simple: any agent that can run a shell command drives it through the ego-browser skill, writing JavaScript that runs as whole workflows, with 2FA and similar challenges handled by a hand-off-and-resume flow instead of a hard failure. The combined route is also the measured one: on Real-World Bench, a public 31-task suite run against live sites with the same model and judge across five tools, ego(lite) finished 93.5% of 31 tasks perfectly, the highest completion rate and lowest cost per completed task of the five, and was 47% to 63% faster than the other four tools measured. The tasks are the shape this article is about: checking an OpenTable reservation surfaced through a Yelp search behind the operator's logins, or ranking two metros for a retail expansion from BLS and Census data.

This route requires adopting a separate desktop browser and confirming its website sessions. Keep a suitable headless or hosted setup when that is what the task needs.

How do the risks compare, route by route?

Three risk classes matter: session conflict (agent and human corrupting each other's work), exposure surface (what a compromise or mistake can reach), and account risk on the sites you automate. No route zeroes all three, and any guide promising zero ban risk anywhere is selling something.

RouteSession conflictExposure surfaceSite-side profile
Auto-connectHigh; one window, two operatorsWhole profile, permission-gated per sessionYour real browser; looks like you
Extension injectionHigh; your tabs are the workspaceWhole profile, vendor permission modelYour real browser; looks like you
CDP takeoverHigh; documented tab-stealing incidentsOpen local port; any process can connectReal browser, unusual debug signals
State copiesNone; separate browser entirelyThe state file itself, wherever it landsTransplanted session; sites may flag device mismatch
ego(lite), combinedLow; separate Space, handoff protocol for shared momentsSessions granted to a second real browser you controlA real daily browser; ordinary usage signals

Recheck the account after another tab changes the session

Verify the current account close to the action, not only when connecting the browser. In an owned local case on October 26, 2026, the original page still displayed synthetic account alpha after a second tab changed that fixture's session to beta. A fresh session request from the first page returned beta. The driver stopped before Save; the independent record contained zero save requests and zero stored rows.

CheckpointObserved evidenceRequired decision
Initial page observationThe account badge displayed alpha.Record the intended account and tenant; this observation can become stale.
Second-tab session changeA second tab signed into the same local fixture as beta.Do not assume a tab label pins the account used by later requests.
Fresh pre-action checkThe first page's fresh session response identified beta.The intended account was alpha, so this run did not dispatch a save.
Independent outcome checkThe server journal showed zero save requests for W1.Record the blocked action separately from successful business completion.

This was one scripted check using a synthetic localhost cookie and two pages in the same task Space. It did not test another site's login, multi-profile isolation, extension permissions, or a separate Space's cookie behavior. A client-side check also is not a transaction lock: an application must enforce authorization on the write itself, because state can change between checking and submitting.

Download the account-switch fixture, request journal and replay recipe

Chrome documents the profile-wide authority of auto-connect

Playwright explains why authentication state needs careful handling

Using a connected session can avoid typing a password into an Agent prompt, but it still grants access to actions and data available to that account. Google's auto-connect guide explicitly includes profile data such as cookies and storage. For ego(lite), use the intended Space and verify the visible account and fresh application state before a consequential action. Workspace separation and credential isolation answer different questions.

Which route is yours? Two questions decide

Question one: can you share your window during tasks? If yes (occasional, supervised work), routes 1 and 2 are the low-setup answers: pick auto-connect for debugging-shaped work and an extension for errand-shaped work. If no, you're in route 4 territory, or the combined setup.

Question two: do tasks need to run in parallel, or unattended-headless? Parallel with your sessions points to ego(lite), the only setup here built for simultaneous isolated tasks against inherited logins. Headless CI with test accounts points to route 4, the only one that doesn't need a desktop at all. Route 3 remains the specialist's tool: maximum control for people who accept managing ports, profiles, and the collisions.

Most working setups land on one route plus the combined setup: a route for supervised moments, ego(lite) for the recurring work. The pairing we see most, for what it's worth: an extension or auto-connect for the occasional in-your-tabs task, ego(lite) for everything daily.

Walk one real week through the two questions to see them bite. A developer wants an agent to check three vendor dashboards each morning, file a weekly expense report, and occasionally debug a flaky page in their own session.

Question one splits it immediately: the debugging is share-your-window work, so it goes to auto-connect, where watching the agent drive your live page is the point.

The dashboards and the expense report are not: they run better while you do something else, which is question two answered, so they go to ego(lite), three Spaces in parallel against inherited logins. Nobody picked a single winner; the tasks sorted themselves once the two questions were asked in order.

Download ego(lite) for Mac, free, or start from the login-wall guide if your entry point is a specific agent.

FAQ

Does an AI browser use my existing Chrome login?

Only some do, and the mechanism matters. A shared-window extension or DevTools auto-connect can reach the live profile; Hermes real-profile browsing copies the active profile into a managed snapshot; ChatGPT Work's cloud browser and Claude Cowork's built-in browser use separate sessions and do not inherit your device's existing sign-ins. ego(lite) imports your Chrome profile into its own browser and runs the agent in a separate task Space, so your daily Chrome window remains untouched.

Is there a cheaper alternative to full AI browser platforms for this?

Yes; that's much of this article. Every route here runs on free software (auto-connect, Browser MCP, storage state) or a free product (ego(lite)); the paid platforms' session features mostly wrap these same mechanisms. Pay for hosted scale when you need fleets, not for session access you can grant locally.

What about headless browser services with session support?

Cloud browser platforms (Browserbase, Browserless) accept injected state (route 4's mechanism, hosted), which fits scaled scraping with test accounts. Shipping your personal accounts' sessions to hosted infrastructure is a different risk decision than any local route here, and for daily personal tasks the local answer is strictly simpler.

Can multiple agents share one browser's sessions safely?

On routes 1-3, poorly: one window or one debug connection serializes everything, and documented multi-session conflicts (profile locks, daemon collisions) are the norm. ego(lite)'s combined route is the architecture built for this: each agent's task gets its own Space against the same inherited sessions.

Does any route avoid CAPTCHAs and 2FA entirely?

No route should promise that. What the session-based routes change is frequency and recovery: challenges bind to real sessions once instead of per-run, and a hand-off flow (you complete the challenge, the agent resumes) turns them from failures into pauses. Fresh-profile automation re-earns every challenge every time.

Keep reading