Google Antigravity browser automation: setup and fixes

Antigravity's current browser subagent connects to Google Chrome that is already running, through Chrome DevTools MCP. Start troubleshooting with Chrome, remote debugging, the user's connection approval and the IDE's Node.js environment. Then check site rules and organization policy.
The Chrome subagent uses the cookies and sign-ins of the connected Chrome Profile. Antigravity App also has a separate built-in browser; the IDE does not. Remote Control reaches a host's Antigravity session from another device and does not change either browser's session boundary.
The browser subagent can navigate, read and act on pages, capture screenshots and sometimes record interactions. A recording is not guaranteed. A screenshot or video also needs a task-specific result check before it counts as proof of completion.
So: the architecture in one section, correct setup, the fix checklist in symptom order, and the boundaries where a different tool is the answer. Everything quoted below comes from Google's own Antigravity docs, so you can verify each claim against the source as the product evolves.
What changed in the current Chrome connection workflow?
Google's current browser documentation, checked November 7, 2026, describes a connection to Chrome that is already running. The browser subagent uses that browser's cookies and sign-ins. The Antigravity App's built-in side-panel browser has separate persistent account sessions; the IDE has no built-in browser. Identify the surface before diagnosing a missing login.
The IDE starts Chrome DevTools MCP through npx, so Node.js and npx must be available to it. Open Chrome 144 or later, enable remote debugging at chrome://inspect/#remote-debugging, and approve Chrome's connection prompt yourself. Then invoke /browser with a narrow task and an explicit end condition. Antigravity does not launch Chrome for this route.
Browser Actuation Rules control which sites the subagent can open. A site without a rule prompts for a task, conversation or persistent grant. Rules cover domains and subdomains, not individual URL paths; Deny wins over Allow. Sensitive Google hosts such as accounts.google.com and mail.google.com require their own rules. Browser rules do not also govern non-browser page reads.
The visible workflow is documented, not newly tested here. Chrome attachment can reuse a signed-in account, but that does not make every account action authorized. ego(lite) remains a separate execution environment when the chosen Agent needs its supported browser workflow and task Space. It is no longer accurate to select it solely on a claim that Antigravity cannot reuse Chrome logins.
| Failure | Current check | Boundary |
|---|---|---|
| Browser will not connect | Running Chrome, remote debugging, user approval and npx in the IDE environment | Do not expose debugging access publicly |
| A site cannot open | Browser Actuation Rules and organization allowed domains | An organization restriction cannot be overridden locally |
| Page opens but JavaScript waits | Browser Javascript Execution Policy | A navigation grant does not approve custom JavaScript |
| No action video appears | Check artifacts after the subagent finishes | Recording is not guaranteed, even after interaction |
Current IDE browser mechanism Chrome profile and built-in browser distinction Browser Actuation Rules Browser recording limits ego-browser task controls
How does Antigravity's browser automation work?

Three pieces, per Google's docs. The driver is a specialized Browser Subagent that "operates on browser tabs as needed": your main agent delegates browser work to it rather than holding the wheel itself.
The current Chrome profile guide says the subagent attaches to Chrome already open on the computer. It shares that browser’s sign-ins and does not create an automation Profile. The App’s built-in browser is a separate surface with its own persistent account sessions.
Screenshots and action recordings can help inspect what happened. Google says recording.webm appears in the subagent artifacts when a recording is produced. Opening pages or taking screenshots alone does not produce one, and interaction does not guarantee one either.
Use the artifact trail to review the actions, then read the target application state again. A video of clicking Submit cannot establish that the server accepted the write.
It can improve review more than it changes automation. A task run that includes a recording of the flow being exercised gives reviewers another artifact alongside tests and logs; it does not replace rerunning a security- or data-sensitive workflow.
Connect, act and check the result. Recordings are optional evidence.
How do you set it up correctly?

Start with running Chrome 144 or later. Enable remote debugging for that browser instance and approve its connection prompt yourself. For the IDE route, confirm Node.js and npx are available before invoking /browser.
In Antigravity IDE, open Browser settings to inspect Browser Actuation Rules and Browser Javascript Execution Policy. Confirm Node.js provides npx in the IDE environment. An organization can disable browser access or restrict allowed domains.
For a harmless setup check, invoke /browser on a local page, ask it to read a visible label, perform one reversible interaction and capture the resulting state. Inspect the returned screenshot and application result. A missing recording alone does not mean setup failed.
If navigation and the reversible action work, the connection is established for that task. Check site rules, custom-JavaScript approval, browser changes and target-site responses separately when a later action fails.
Browser not working or won't open: the checklist
Symptom-ordered, cheapest checks first. These map to the architecture above rather than to any secret knowledge, which is exactly why they work.
| Check | Why it's the likely cause |
|---|---|
| Browser access is available under organization policy | If an administrator disabled the browser subagent, settings show a notice and /browser is unavailable. Confirm the supported surface before changing local configuration. |
| Chrome exists, is current, and isn't wedged | The current route attaches to running Chrome 144 or later. Check remote debugging and Chrome’s connection prompt. Keep unrelated browser work intact while diagnosing the connection. |
| The target URL passes the allowlist/denylist | A site without an actuation rule prompts for access. Inspect Allow, Ask and Deny rules, the actual domain and any organization restriction instead of assuming a silent connection failure. |
| Restart the IDE after Chrome or setting changes | Subagent-to-browser wiring is established at session level; state from before your fix can linger until relaunch |
| Update Antigravity itself | The browser feature is under active development (docs track IDE releases); a version behind can mean known-fixed behavior |
Where does it end, by design?
Three boundaries matter. First, the Chrome subagent works in a signed-in browser when that Profile is connected, so site and action permissions matter even for familiar accounts. The App’s built-in browser has separate sessions. Neither route makes page instructions trustworthy.
Antigravity manages its browser subagent inside its own Agent workflow. Another Agent can use a supported Chrome DevTools MCP integration independently, but that does not transfer Antigravity conversations, permissions or artifact history. Check the receiving client’s own setup and access policy.
Antigravity can support a development workflow of actions, screenshots and optional recordings. Those observations still need acceptance checks, and a signed-in Profile does not authorize unattended actions on every account.
What are the alternatives past those edges?

Match the alternative to the edge you hit.
Logged-in daily tasks: consider ego(lite), a free Chromium browser that can import a Chrome profile so the agent works from logins you already hold instead of an empty profile. Session expiry, account permissions, site policy, and the supported-agent list still apply.
One data point for that recommendation: on Real-World Bench, 31 tasks against live sites with the same model and judge, ego(lite) completed 93.5% of them perfectly, which describes that task set rather than every workload. The dataset and judging harness are open on GitHub.
Deep page diagnosis (traces, heap snapshots): Chrome DevTools MCP, which pairs fine with any of the above. Cross-browser test infrastructure: Playwright, as ever.
Choose the browser environment by the Agent, task and review controls it supports. Antigravity can operate a signed-in Chrome Profile. An ego(lite) workflow can be useful when its task Space and supported Agent connection fit the job, rather than because one route has logins and the other cannot.
For a development check, retain the screenshot and any available recording, then verify the application state. For recurring account work, define the account, authorized actions and final result regardless of which browser executes it.
Download ego(lite) for Mac, free, or read the login-wall guide for the session model.
What is Antigravity Remote Control and how do you enable it?
Antigravity Remote Control is a browser dashboard for connecting to and driving Antigravity 2.0 sessions running on your own laptops, desktops, or servers. It lets you view conversations, start tasks, review plans, inspect artifacts, and keep working from another device; it is remote access to an Antigravity workspace, not a new browser profile or a way for another agent to borrow the session.
Google's official setup is short:
- In Antigravity App, open Settings, choose Application and turn Enable Remote Control on. Set a Device Name when several hosts are available.
- From any device, open the Antigravity Remote Control Dashboard and sign in with the same Google Account used by the desktop app. Select the named machine in the instance switcher, then review the session before starting or approving work.
- For another environment, follow the current platform-specific Remote Control guide. Do not reuse a historical daemon command without verifying that the current documentation still supports it.
Remote Control reaches a privileged host session. Enable it only on machines you control and identify the selected device before starting work. If a host is missing, check the setting, internet connection, sleep state and Google Account. Running tasks require the host to remain available.
Read Google's Remote Control documentation for the current setup and troubleshooting. Remote access to a host is separate from choosing which browser session a task operates in.
How do Antigravity quotas and token costs work?
Antigravity usage is governed by the Google account, plan, model, and current capacity—not by a single universal token price. A browser task can consume more quota when it loops, retries, captures screenshots, or asks a model to inspect a large page. Treat the quota indicator and any plan documentation as the source of truth, and measure cost per accepted result rather than counting prompts.
- Set a task budget. Use a bounded objective, maximum actions, and a time limit. Stop a run after repeated identical actions instead of waiting for a quota warning.
- Reduce observations. Ask for one element or state at a time, avoid unnecessary screenshots, and use a deterministic script for repeated navigation or parsing.
- Compare models on your tasks. A cheaper or faster model may be adequate for a static page but fail on a dynamic UI. Record retries, accepted outputs, and manual recovery before changing plans.
When a Gemini model appears to consume quota unusually quickly, stop parallel tasks, save the current work, and inspect the model, context, screenshots, and retry history. Key rotation or a second account does not solve an oversized workflow and can violate account policy.
How do you fix Antigravity browser connection and extension failures?
Diagnose the IDE route in dependency order: Node.js and npx, running Chrome, remote debugging and the user’s connection approval, then site rules and organization policy. Reproduce with a harmless page before an authenticated task. Installing a browser extension is not the documented prerequisite for this route.
- Confirm the browser target. Confirm Google Chrome 144 or later is already running. Open chrome://inspect/#remote-debugging, enable remote debugging for that instance and respond to Chrome’s connection prompt yourself.
- Check browser rules and permissions. Review Browser Actuation Rules for the target domain and Browser Javascript Execution Policy for page scripts. A domain rule includes subdomains but not path-level restrictions; organization allowed domains remain an outer limit.
- Check the connection boundary. For CDP on WSL or a VPS, bind and forward only the intended local interface and port. Confirm firewall, proxy, and user permissions; never expose a debugging port to the public internet.
If an environment variable or custom path is missing, restore it in the supported service or shell configuration and start a fresh session. Do not set a broad home directory, disable OS security, or copy another user's profile as a workaround.
How do you stop Antigravity browser loops and control mistakes?
Prevent loops by making each browser step observable and bounded: name the expected state, use one stable locator, set a retry limit, and stop when the page does not change. A model that keeps clicking a confirmation button or rewriting the same file needs a kill switch and a smaller task, not an instruction to try harder.
- Define done. State the URL, visible success marker, expected file, or test assertion that ends the task. Ask the agent to report that evidence.
- Separate plan from execution. Approve a short plan before destructive edits, then run one browser action at a time. Keep terminal commands and browser actions in the same visible task log.
- Stop on unchanged state. After two identical screenshots, URLs, or DOM states, pause for review. Capture the error and continue only with a new hypothesis.
Prompt injection is another control failure: page text can instruct the agent to ignore its task or reveal secrets. Treat page content as untrusted, keep approvals on for side effects, and scope the browser profile and allowlist to the current task.
How do you recover from Antigravity timeouts, 429s, and data loss?
Recover by preserving the last known good state, classifying the error, and retrying only the safe class. A 429, 503, or capacity message calls for backoff and a smaller queue; an agent-terminated run calls for a saved checkpoint; a data-loss report calls for version control and backups before another refactor.
- Save before retrying. Commit or copy the current code, preserve screenshots and artifacts, and record the exact prompt, model, and task status. Never let an automatic retry overwrite the only copy of a result.
- Back off capacity errors. Wait according to the service guidance, reduce concurrency, and retry once. If capacity or rate limits persist, schedule the work later or use an approved model; do not run a tight retry loop.
- Resume from checkpoints. Split a large refactor or scrape into named steps and validate each accepted result. Reopen the last artifact instead of asking the agent to reconstruct an unknown state.
An extension or MCP that keeps Antigravity stuck on “working” is not evidence that the task is still progressing. Cancel it, inspect the process and logs, disable optional integrations one at a time, and retry with a minimal page. Keep a manual path for work that cannot be safely replayed.
How do you fix Antigravity login and session issues?
The Chrome browser subagent shares the connected Profile’s cookies and sign-ins. If a login is missing, identify the Chrome Profile or the App’s built-in browser before changing credentials. Use the normal sign-in flow and pause for MFA, device checks or account policy. Remote Control also needs the same Google Account on the host and dashboard.
- Verify the account boundary. Check the account used by Antigravity and the Remote Control dashboard separately from the website account in Chrome. Name the host clearly and remove old sessions you no longer control.
- Complete verification manually. Pause for OAuth, 2FA, CAPTCHA, recovery, or account-unlock steps. Do not automate verification codes, scrape a refresh token, or copy cookies from your personal browser.
- Revoke stale access. After a failed or unknown setup, review the connected Chrome Profile, site rules and Google Account sessions. Remove access you cannot attribute to a machine or an authorized task.
What security and privacy controls should Antigravity users apply?
Treat Antigravity as a privileged tool with explicit account and action boundaries. Its Chrome subagent can access signed-in sites, while the surrounding Agent may use project files and terminal tools. Browser site rules and host permissions govern different resources. A separate App browser session does not make the host disposable.
- Keep secrets out of the task. Use scoped environment variables and least-privilege accounts. Do not place API keys, password exports, or recovery codes in prompts, screenshots, artifacts, or source control.
- Review extensions and integrations. Verify the source of MCP integrations and the installed Node.js toolchain. Review changes to executable helpers and browser permissions before granting access.
- Protect remote access. Keep Remote Control enabled only when needed. Protect the Google Account and turn the feature off when the host should no longer be reachable.
Local execution, a VPN, or a password manager is not a guarantee against prompt injection or harmful approved actions. Treat web pages as untrusted input, limit the allowlist, require review before publishing or sending, and keep a kill switch outside the agent.
How do you install and upgrade Antigravity on Linux?
Use the current Linux artifact and installation instructions published by Google Antigravity, then verify the archive and preserve your workspace before upgrading. Antigravity distributions and package formats can change; do not treat an unofficial Flatpak, deb conversion, or copied binary as equivalent to the supported release.
- Back up and record the current version. Commit code, export important artifacts and record the installed version and settings. Stop active tasks before changing the installation.
- Install the supported tar or package. Download from the official Antigravity channel, unpack into a user-owned directory, and create a desktop entry or service only with the documented paths. Verify executable permissions and the Chrome dependency.
- Upgrade as a controlled change. Stop running Agents and follow the current official upgrade instructions. Test one disposable workspace before restoring optional integrations, and keep a recoverable copy of the old workspace.
If an integration works in a terminal but fails inside the IDE, compare the environment, Node.js and npx paths, running Chrome and debugging approval. Avoid using root privileges to hide a configuration failure.
How do you migrate or integrate Antigravity with other tools?
Keep Antigravity's project, browser artifacts, and credentials separate when moving to another IDE, CLI, or browser agent. Export code and documented configuration; do not assume conversations, extension state, OAuth grants, or MCP connections survive an app split. Re-authenticate through the provider and verify every integration in a disposable workspace.
- For Gemini CLI or another coding agent. Move the repository and task instructions, then configure browser access in the receiving client. A separate Chrome DevTools MCP connection does not import IDE-managed conversations, review decisions or artifact history.
- For phone or remote monitoring. Use Remote Control for the same Antigravity workspace when the host and account are online. It is not a public API and does not turn the Browser Subagent into a general-purpose remote browser.
- For logged-in recurring browser work. Use an explicitly supported external browser workflow such as ego(lite), with authorized sessions, and keep Antigravity for its verify-and-record development loop. Do not share raw cookies or debugging ports between tools.
After migration, run a small acceptance set: open a public page, test one allowed internal page, produce an artifact, stop the agent, and confirm that secrets and permissions remain scoped. A green launch is not proof that every old connection or policy carried over.
FAQ
What is Google Antigravity Remote Control?
Remote Control connects a browser dashboard to Antigravity desktop sessions and CLI instances on your machines. It provides access to conversations, plans and artifacts from another device. The host and dashboard must use the same Google Account. It does not change which browser session a task uses.
How do I enable Antigravity Remote Control?
In Antigravity App, open Settings > Application and turn on Enable Remote Control. Open the dashboard in another browser, sign in with the same Google Account and choose the intended machine. Use the current platform-specific guide for other environments instead of an older daemon installer.
Can I use Remote Control from my phone?
Yes, when the host machine is online and the Remote Control service is signed in. Google documents a browser-based dashboard and optional installation as a mobile web app for push notifications. A phone can monitor and approve the Antigravity session, but it does not turn the host into a general remote desktop or bypass a machine that is asleep, offline, or signed out.
Does Remote Control share my Antigravity logins with another agent?
It exposes the existing Antigravity workspace to the Google Account and browser session you authorize, including the host's files, build tools, credentials, and environment variables. It does not make those resources public, but it is still privileged access. Use it only on machines you control, keep the account protected, review prompts before approving actions, and disable the feature when remote access is no longer needed.
Is there a Google Antigravity browser extension?
The current IDE browser route uses Chrome DevTools MCP, started through npx. It attaches to running Chrome through approved remote debugging. A store extension is not a documented prerequisite for this setup.
Can Antigravity's browser use my logged-in accounts?
Yes. The current browser subagent uses the cookies and sign-ins of the Chrome instance it connects to. Antigravity App’s built-in browser has separate persistent sessions. Verify the connected Profile and allowed domains before any account action.
Can I turn browser automation off entirely?
An administrator can disable the browser subagent. For site-level control, use Browser Actuation Rules to deny domains, and review Browser Javascript Execution Policy separately. Check the current settings for the installed Antigravity surface.
Can I control which sites the agent browses?
Browser Actuation Rules let you Allow, Ask or Deny sites. Deny takes precedence, and organization domain restrictions still apply. Non-browser page reading is governed by separate network permissions. A path in a rule does not narrow access to that URL path.
How does it compare to Cursor's built-in browser?
Both are IDE-integrated development workflows, but compare the actual browser connection, site permissions and artifact behavior of the installed versions. Antigravity’s Chrome route now reuses the connected Profile. Cursor’s own browser documentation describes that product’s workflow. Compare session ownership and action permissions on the installed versions rather than assuming that both products exclude personal sign-ins.



