How to connect AI agents to your existing browser

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 route | State source | Decision for the user |
|---|---|---|
| Extension or live DevTools connection | The selected running browser and its authorized state | Choose it when the current Chrome tab is the task. |
| ego(lite) | Supported imported state or a direct sign-in in ego | Choose it when you want a separate visible local browser shared with your coding Agents. |
| Copied or exported test state | A snapshot of supported credentials or storage | Use it for accounts and environments you control, and protect that state as a credential. |
| Hosted browser | A separate remote session or provider-managed state | Use 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-skillAfter 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'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 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.
| Route | Session conflict | Exposure surface | Site-side profile |
|---|---|---|---|
| Auto-connect | High; one window, two operators | Whole profile, permission-gated per session | Your real browser; looks like you |
| Extension injection | High; your tabs are the workspace | Whole profile, vendor permission model | Your real browser; looks like you |
| CDP takeover | High; documented tab-stealing incidents | Open local port; any process can connect | Real browser, unusual debug signals |
| State copies | None; separate browser entirely | The state file itself, wherever it lands | Transplanted session; sites may flag device mismatch |
| ego(lite), combined | Low; separate Space, handoff protocol for shared moments | Sessions granted to a second real browser you control | A 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.
| Checkpoint | Observed evidence | Required decision |
|---|---|---|
| Initial page observation | The account badge displayed alpha. | Record the intended account and tenant; this observation can become stale. |
| Second-tab session change | A 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 check | The first page's fresh session response identified beta. | The intended account was alpha, so this run did not dispatch a save. |
| Independent outcome check | The 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.




