What is Google Antigravity 2.0?
Google Antigravity 2.0 is the agent-first version of Google's development platform, launched May 19, 2026. It is a standalone desktop application built around orchestrating multiple AI coding agents in parallel — with dynamic subagents, git worktree isolation, and scheduled tasks — rather than editing files in an IDE. It is free during public preview, ships alongside a new Antigravity CLI and SDK, and runs on Gemini 3.5 Flash by default. Against Cursor and Claude Code, its differentiator is first-class multi-agent orchestration; its cost on day one is launch-week instability you have to work around.
Antigravity 2.0 in Nine Points
- Agent-first, not editor-first. The 2.0 app's primary surface is the Agent Manager. The legacy VS Code-style IDE still installs alongside it, but the file explorer and inline diff view are no longer the default workflow.
- Dynamic subagents are real. The main agent spawns role-specific subagents with
invoke_subagentand can define new types at runtime withdefine_subagent. Multiple run in parallel. - Worktree has three modes —
inherit,branch, andshare— controlling whether a subagent shares, clones, or git-worktrees the workspace. - Five slash commands:
/goal,/schedule,/browser,/grill-me, and/teamwork-preview. - Gemini 3.5 Flash is the default engine, reported by Google to beat Gemini 3.1 Pro on Terminal-Bench 2.1 and MCP Atlas; 3.1 Pro still leads on long-context reasoning.
- The browser agent is the weak point. It jams Chrome's port 9222 with stale connections after updates, producing
Network.enable timed out. Antivirus blocking the Chromium driver is the second failure mode. - Antigravity CLI replaces Gemini CLI. Gemini CLI stops serving requests June 18, 2026 — migrate before the cutoff.
- New pricing: a $100/month AI Ultra tier with 5x the Antigravity limit of Pro, the top tier cut from $250 to $200, and a $100 Antigravity credit for Ultra subscribers through May 25, 2026.
- It is launch-week rough. Treat it as powerful but immature: plan mode on, scoped permissions, 1.x kept installed as a fallback.
Every technical claim here traces to one of three places: Antigravity 2.0's own in-app self-report, Google's public launch material, or a real launch-day build session. Where Antigravity itself reported a detail as uncertain — its exact build number, the full model-picker list, the 1.x changelog, and the browser agent's internal Chrome-profile architecture — this guide does not invent an answer. Those gaps are named where they matter.
A platform, not an update
Antigravity 2.0 is not a point release of the IDE. It is a separate, standalone desktop application, and Google's framing for it is deliberate: a central home for agent interaction, where you orchestrate multiple agents to execute tasks in parallel.
The 1.x product was an agentic IDE — a code editor with an agent bolted into a side panel. The 2.0 product inverts that. The agent is the application; the editor is optional. You still install a VS Code-style IDE if you want it, and it runs alongside 2.0, but the front door is now the Agent Manager: a list of projects, each holding tasks that agents pick up, work, and report on through artifacts.
This launched as one piece of a four-part release. Alongside the 2.0 desktop app, Google shipped the Antigravity CLI (a command-line agent that replaces Gemini CLI), the Antigravity SDK (for building custom agents on the same harness), and Antigravity in Gemini Enterprise. All four share one agent harness, co-optimized with Gemini 3.5 Flash.
If you are coming from 1.x, the honest framing is this: you are not learning new menus, you are learning a new unit of work. The unit is no longer a file you edit. It is a task an agent owns.
What actually changed
Antigravity itself reported the formal 1.x-to-2.0 changelog as uncertain — it cannot introspect its own release notes. So this section is built from what is directly observable in the running app and from Google's launch material, not from a version history.
The structural shift
Editor-first
A modified VS Code fork. Two views — Editor and Manager. Work was anchored to a repository folder. The agent lived in a panel beside your code.
Agent-first
A separate desktop app. The Agent Manager is the whole surface. Work is anchored to a project and its tasks. The editor is a sidecar you open when you need it.
What you gain
Parallel multi-agent orchestration as a first-class capability. Dynamic subagents that spawn and run concurrently. Scheduled tasks that turn an agent into a recurring background process. A worktree model that isolates parallel agents from each other. New slash commands. Native voice input. One-click integrations into Google AI Studio, Android, and Firebase.
What you lose — and this is real
If you came up writing code, the 2.0 app will feel like it took something away, because it did. The persistent file explorer and the inline, edit-by-edit diff view — watching the agent change each line in context — are not the center of the 2.0 workflow. The agent works, and reports back through artifacts and a conversation thread. For developers who audit every change as it happens, that is a genuine loss of visibility, not a preference quibble.
Keep the Antigravity IDE installed alongside 2.0 and open your project folder in it. Use the 2.0 app to drive agents, and keep the IDE open on a second monitor or workspace as your file tree and live diff viewer. You get the agent-first workflow without going blind on the edits. This is the single highest-value habit for an experienced developer moving to 2.0.
How to think about agent-first work
The fastest way to be productive in 2.0 is to stop thinking of it as an editor with an assistant, and start thinking of it as an operating system for agents. Five objects make up that system.
Project
The unit of context. A project can span multiple folders and carries its own permissions, model defaults, and rules. Conversations live under projects.
Task
What an agent picks up. A task has a status — In Progress, Idle, or scheduled — a plan, a conversation thread, and an artifact trail of diffs, screenshots, and results.
Agent & Subagents
A main agent owns a task. It spawns subagents — researcher, implementer, browser, verifier — that run in parallel and report back without polluting the main context.
Artifacts
The audit trail. Plans, task lists, walkthroughs, code diffs, and recorded browser sessions — structured markdown state carried across conversational turns.
The fifth object is the schedule — the thing that turns a one-off task into a recurring pipeline. Put together, the loop is: you set a goal, the agent plans and executes, artifacts communicate progress, and you steer through review, permissions, and comments. You stop being the typist. You become the architect — which, if you have been doing intent-based development already, is a workflow you will recognize immediately.
The Agent Manager surface
The Agent Manager lists every project and the tasks under it. Each in-progress task shows a live indicator of how many subagents are currently running beneath it. Idle tasks sit waiting for input or completion. A task launcher lets you pick the model and thinking level, and choose plan mode or fast mode, before the agent starts. Antigravity reported the deeper internals of the Manager as uncertain — so treat it, functionally, as mission control: the place you start, watch, and steer work, not a place that exposes its own plumbing.
Early 2.0 users have reported authentication crashes on first launch and, on Linux, coredumps on startup. If 2.0 will not authenticate, sign out of your Google account in the browser entirely, then relaunch. If it will not start at all, fall back to the 1.x IDE and revisit 2.0 after the next patch. None of this is a reason to avoid the platform — it is a reason to keep 1.x installed.
Subagents and the worktree model
This is the heart of agent-first work, and the detail here comes straight from Antigravity 2.0's own description of how its tools behave. It is the part of the platform worth mastering first.
How subagents spawn
The main agent invokes subagents through a tool called invoke_subagent. It is not limited to a fixed roster — a second tool, define_subagent, lets the agent define an entirely new subagent type at runtime, giving it a custom system prompt and a specific set of enabled tools, such as write access or MCP access. So a subagent can be a general-purpose worker or a narrowly scoped specialist created on the spot for one task.
Crucially, multiple subagents can be invoked in a single call and run completely in parallel in the background. The parent agent does not block waiting on them. It receives a message automatically when a subagent returns data or needs input. There is also a special self subagent that inherits the parent agent's full configuration, including the selected model — useful when you want a parallel worker that behaves exactly like the parent.
For dynamically defined subagents, the exact model each one runs is not something Antigravity could confirm about itself; it noted they likely default to the system engine. The self subagent inheriting the parent model is confirmed. The rest is reasonable inference, not fact.
Worktree: three modes of isolation
When a subagent is invoked, a Workspace parameter decides what environment it runs in. This is the worktree feature, and it has exactly three modes:
inherit
The subagent runs directly in the parent agent's exact workspace. No isolation. Fast, but two agents here can collide on the same files.
branch
Creates a new, isolated workspace cloned from the parent. Full separation. The branched workspace is deleted when the subagent is terminated.
share
Creates a workspace over the same underlying repository directory — like a git worktree. Branch state is isolated; physical storage is shared.
The practical rule: use inherit for a quick helper that will not touch files the parent is editing. Use branch or share the moment you have two agents working the same repository in parallel. share is the git-worktree-style choice — isolated branches, one physical checkout — and is the efficient default for parallel feature work. When a subagent is terminated through the manage_subagents tool, its branched workspace is removed from disk, but its logs and artifacts are preserved, so you do not lose the record.
Power pattern: the three-subagent task
Spawn subagents along task boundaries, not function boundaries. A reliable pattern for a real feature: one researcher subagent reads the docs and produces a spec, one implementer writes the code in a branch or share workspace, one verifier runs the tests and the browser checks. Each gets a fresh, smaller context, and they hand off through artifacts. Give each parallel implementer its own workspace and its own rules file constraining which paths it may touch — that eliminates the large majority of merge conflicts before they happen.
Slash commands, scheduling, and permissions
Antigravity 2.0 exposes five slash commands. Each one is a different way to start or shape agent work, and all five are confirmed from the app itself.
Long-running objective
Instructs the agent to run a continuous, long-horizon task — overnight, for example — and not stop until your objective is fully achieved.
Recurring or timed runs
Opens an interface to run instructions on a recurring schedule or set a one-time execution timer.
Force browser work
Directs tasks involving web browsing, web search, or web-app interaction to the specialized browsing agent.
Interrogation mode
Triggers an interview where the agent interrogates you to resolve design decisions and align on a plan before any code is written.
The fifth is /teamwork-preview, which orchestrates a multi-agent environment where a team of autonomous subagents collaborate on a large project. The "preview" in the name is worth taking literally — treat it as experimental.
Run /grill-me before any non-trivial task. Letting the agent extract your acceptance criteria up front — before it plans, before it writes — prevents more wasted runs than any model upgrade. Pair it with /goal to keep long tasks anchored to a fixed objective.
Scheduled tasks
Scheduled tasks are created with the schedule tool. You give it either a DurationSeconds value, capped at 900 seconds, for a one-shot timer, or a standard CronExpression for recurring jobs. They run asynchronously as background tasks.
The output routing is the clever part. A scheduled task does not print to a terminal. When the timer or cron triggers, the daemon injects your defined prompt payload directly into the agent's message inbox as a high-priority notification. It behaves as an interrupt — it wakes the agent to process the event automatically. That is what makes scheduled tasks composable: a schedule is just a way to send the agent a message in the future.
An agent woken on a schedule still consumes usage. Always give scheduled tasks a tight, well-scoped prompt and keep their permissions on review, not auto-proceed. A runaway recurring task can quietly burn through your plan's usage limit overnight.
The permission system
Antigravity 2.0's default execution path is conservative, and you should leave it that way. The primary command tool, run_command, requires explicit, step-by-step user review: the command enters a WAIT state and does not execute until you approve it.
A separate tool, ask_permission, can request persistent access to narrow scopes — reading files, writing files, reading URLs, specific command prefixes, and so on. But the system hard-blocks persistent exceptions for anything that makes network requests, downloads unverified files, or runs arbitrary code. Commands like curl, wget, pip, and npm can never be granted a standing exception — they must always route through the manual approval queue. That is a sensible default. Do not fight it; it is the main thing standing between an autonomous agent and a prompt-injection incident.
Which model, and when
Antigravity 2.0 ships Gemini 3.5 Flash as the default agent engine. When asked to enumerate its full model picker, the app reported that as uncertain — it could only confirm the model it was actively running. So treat the routing advice below as based on Google's published benchmark positioning, and verify the exact roster in your own install.
Gemini 3.5 Flash — the default
Flash is co-optimized with the Antigravity agent harness and is built for speed. Google's launch benchmarks report it ahead of Gemini 3.1 Pro on agentic and coding tasks specifically — Terminal-Bench 2.1 and MCP Atlas among them — and independent measurement puts its output throughput several times higher than comparable frontier reasoning models. For the bulk of agent work — refactors, multi-step tasks, browser operations, routine implementation — Flash is the right call.
Gemini 3.1 Pro — when to switch up
Pro is what the app was running in the session this guide draws on, shown in the picker as Gemini 3.1 Pro with a "High" thinking level. Reach for Pro when the task is heavy on architectural reasoning, depends on long-context recall across a large codebase, or hinges on interpreting an ambiguous spec — areas where Pro still leads and the extra latency is worth paying.
Default to Gemini 3.5 Flash. Switch to Gemini 3.1 Pro (High) the moment a task is more about thinking than doing — system design, long-context audits, ambiguous requirements. Set the model per task at launch in the Agent Manager; you do not pick one model for the whole project.
Whether Anthropic's Claude models or open-weight models remain selectable inside 2.0's picker is exactly the kind of detail the app would not confirm about itself. If you need a specific non-Gemini model, check the picker in your own build rather than trusting a list from any guide written this week.
Setting up Antigravity 2.0
A clean first-run, configured the way an experienced developer should configure it. About thirty minutes, including the browser agent.
Download — and install alongside 1.x
Get the 2.0 desktop build for your OS from Google's official Antigravity download page. Do not uninstall the 1.x IDE. You want it as both a fallback and a live file-tree-and-diff viewer.
Sign in
Launch and sign in with a Google account. If authentication crashes on first launch — a reported launch-week issue — sign out of Google in your browser completely, then relaunch the app.
Set conservative permissions
In the first-run wizard, set the terminal execution policy to Request review. Leave non-workspace file access turned off — it is the setting that most widens prompt-injection exposure. Graduate to looser policies later, only after you have built a deny list.
Confirm your default model
Open settings and confirm Gemini 3.5 Flash as the default engine. Note where the per-task model picker lives — you will switch to Gemini 3.1 Pro on reasoning-heavy tasks.
Create your first project
Add a project and point it at your repository. Set per-project permissions and a rules file. Run a small task in plan mode first — read the plan, edit it, then approve. Editing the plan before the agent codes is the highest-leverage moment in the whole loop.
Migrate off Gemini CLI
If you use Gemini CLI or the Gemini Code Assist IDE extensions, install the Antigravity CLI and move your skills and workflows over. Gemini CLI stops serving requests on June 18, 2026 — do this well before the cutoff.
How Antigravity 2.0 pissed me off in the first five minutes — and how I made it fix itself
Everything above this section is the calm version. This is what actually happened the first time I sat down with Antigravity 2.0 on a live project. I am leaving it in because if you are about to do the same thing, you should know what is coming.
I updated to 2.0 mid-project. I had a homepage rebuild in flight and I wanted to finish it on the new version. Five minutes in, the browser agent — the thing that is supposed to be the headline feature — could not do the one job I gave it: take a screenshot and confirm my work.
Strike one: "Network.enable timed out"
I asked for a visual audit. The browser subagent went out, tried to attach to Chrome, and came back with Network.enable timed out. Tried again. Same thing. The update had left a pile of stale connections jammed onto Chrome's debugging port, and the agent could not push through them. A brand-new version of a Google product, and step one was already a port conflict.
Strike two: the agent tried to quit on me
Here is the part that actually annoyed me. After the timeouts, the agent's move was to suggest we skip the audit. It told me the code was deployed, the project was basically done, and I could just verify it myself by opening the preview. It was ready to call the job finished without ever looking at it. "Deployed" is not "done." If I had taken the agent at its word, I would have shipped unverified work and not known it.
Strike three: antivirus, and a push that lied
We cleared the port. Then my antivirus blocked the Chromium driver, so the agent timed out again for a completely different reason that looked identical from the inside. And somewhere in the same stretch, a push "completed" — except a syntax error in the command had quietly skipped the files. The agent reported success. The files were not there. I only caught it because the change did not show up on the preview.
How I made it fix itself
Here is the turn, and it is the actual lesson of this section. The agent is not the manager. I am. Once I stopped treating its summaries as truth and started treating them as claims to verify, the same agent became genuinely useful — because I was now driving it instead of trusting it.
- I had it hard-reset Chrome — kill every process, clear the jammed port — instead of retrying into the same wall.
- When it stalled again, I made it check the antivirus quarantine instead of guessing. That found the blocked driver.
- When it claimed a push succeeded, I made it run a full directory sync and then prove the files landed, rather than taking "completed" at face value.
- When it offered to skip the visual audit, I said no, opened the preview myself, and confirmed the work by hand.
None of that is a complaint about the tool, in the end. It is the whole operating manual. Antigravity 2.0 is a fast, capable agent that will, on launch week, hit walls and then cheerfully narrate its way around them. Your job is not to type less. Your job is to refuse the easy summary, demand the verification step, and make the agent prove its work. Do that, and it is a force multiplier. Skip that, and it will confidently hand you a broken build with a green checkmark on it.
Treat every "done," "deployed," and "completed" from the agent as a claim, not a fact. The agent is fast and powerful and occasionally wrong in ways it does not notice. You are the verification layer. That is not a flaw in the workflow — on an agent-first platform, that is the job.
The browser agent: failures and fixes
The browser automation subagent is the most powerful and the least reliable part of Antigravity 2.0 on launch week. This section is a field manual built from a real launch-day build session — the failures below were hit and cleared in sequence on a live project.
The browser subagent can navigate pages, click, scroll, type, read the DOM, capture screenshots, and record sessions as video artifacts. When it works, it closes the loop on visual verification — the agent can audit its own UI changes. When it fails, it fails in a few specific, recognizable ways. Here is each one.
Failure 1 — Network.enable timed out
The most common failure. The browser subagent tries to attach to Chrome and the connection times out. The root cause is Chrome's remote debugging port — port 9222 — getting jammed with stale, overlapping connections. After an app update in particular, background processes lose sync with Chrome and leave a cluster of zombie connections holding the port open. The subagent cannot attach through the jam.
Close every Chrome window completely. If the port is still jammed, force-kill all Chrome processes. On Windows that is one command:
taskkill /F /IM chrome.exe
Then reopen Chrome and confirm remote debugging is active again at chrome://inspect/#remote-debugging. The killed-and-reopened Chrome comes back with a clean port, and the subagent attaches. Note the cost: force-killing Chrome closes every open tab, so save your work first.
Failure 2 — antivirus blocks the Chromium driver
The second failure looks identical from inside Antigravity — the subagent times out — but the cause is outside the app entirely. Antivirus software flags and blocks the Chromium driver the browser subagent depends on. The agent never gets a chance to connect.
If a Chrome hard-reset does not clear a timeout, check your antivirus quarantine and event log. If the Chromium driver was blocked, add an exception for the Antigravity application directory so the driver is allowed to run, then relaunch the subagent.
Failure 3 — the agent declares success without verifying
The subtlest failure is not a crash. When the browser subagent cannot connect, the main agent will sometimes route around it — skip the visual audit, and tell you the work is complete based only on the code it wrote. The code may well be fine. But "deployed" is not "verified," and the agent can blur that line when its browser tooling is down.
When the browser agent fails, the visual audit did not happen — no matter how the agent phrases its summary. Open the preview yourself and check it. Treat any "skip the automated screenshot audit" message as a prompt to do the audit manually, not as permission to skip it.
Pre-flight checklist for the browser agent
Clear the runway
Close stray Chrome windows. Confirm no zombie process holds port 9222. After any Antigravity update, hard-reset Chrome before the first browser task.
Work the sequence
Hard-reset Chrome first. Still failing — check antivirus for a blocked driver. Still failing — verify manually and move on; do not let a browser stall block a finished build.
How the browser subagent handles Chrome profiles, cookies, and logged-in sessions is something Antigravity 2.0 did not expose about its own architecture. Until you can confirm the behavior in your build, do not point the browser agent at a Chrome profile signed into production accounts. Use a dedicated profile on a test account for anything that touches real credentials.
What it costs, and the launch credit
Antigravity 2.0 arrived with a pricing change across Google's AI subscriptions, plus a time-limited credit aimed squarely at the launch. Here is the full picture.
The 2.0 desktop app, the Antigravity CLI, and the SDK are free during public preview, with usage limits generous enough for real work on a personal Google account. Paid tiers exist to raise those limits, and at launch Google restructured them.
The 2.0 app, CLI, and SDK. Generous Gemini 3 Pro and 3.5 Flash limits on a personal account.
A new mid tier. 5x the Antigravity usage limit of the Pro plan, for developers who depend on the platform daily.
Price cut from $250 to $200 for the same capabilities — 20x the Antigravity limit of Pro.
The launch credit
Alongside the tier changes, Google attached a time-limited incentive to the launch: a $100 Antigravity bonus credit for AI Ultra subscribers. It is offered through May 25, 2026 — a deliberately short window tied to the launch week.
If you already depend on Antigravity for production work, the math is straightforward: the new $100 AI Ultra tier plus the $100 launch credit means the first month is effectively covered. The credit window closes May 25, 2026. After that the decision is the usual one — whether 5x usage headroom is worth $100 a month to you. Confirm the current terms on Google's official subscription page before subscribing; launch-week offers move fast.
How to think about the cost
For evaluation, learning, and light use, the free public preview is genuinely enough — do not pay anything yet. The $100 AI Ultra tier earns its place only once you are running agents daily and hitting the Pro limits. The $200 top tier, with 20x headroom, is for teams or for the kind of continuous multi-agent, scheduled-task workload that a single developer rarely sustains. Start free. Upgrade when a usage wall actually interrupts your work — not before.
Antigravity 2.0 vs the alternatives
Where Antigravity 2.0 sits against the tools an experienced developer is most likely weighing it against. The honest summary: 2.0 leads on agent orchestration and price, and trails on launch-week polish.
| Capability | Antigravity 2.0 | Cursor | Claude Code | GitHub Copilot |
|---|---|---|---|---|
| Agent-first standalone app | Yes | Editor-first | CLI / terminal | Editor extension |
| Parallel multi-agent orchestration | First-class | Limited | Agent teams | No |
| Dynamic runtime subagents | Yes | No | Yes | No |
| Git worktree isolation | 3 modes | Yes | Manual | No |
| Scheduled / recurring agent tasks | Yes | No | No | No |
| Built-in browser automation agent | Yes | No | Via MCP | No |
| Persistent file tree + inline diff | Sidecar IDE | Yes | Diff only | Yes |
| Entry price | Free preview | ~$20/mo | Usage-based | ~$10/mo |
| Launch-week stability | Rough | Mature | Mature | Mature |
Read the table honestly. If your work is multi-agent — several agents on one codebase, scheduled background jobs, browser verification in the loop — Antigravity 2.0 does things the others simply do not, and it does them for free right now. If you need a polished, stable, file-centric editing experience today, Cursor and Copilot are more finished products. Claude Code is the closest peer on agent orchestration and is the more mature choice for terminal-driven work. The competitor comparison is not "which is best" — it is "which matches how you work."
Is Antigravity 2.0 for you?
Five honest reads on who should adopt 2.0 now, who should wait, and why.
Adopt now
You already define architecture and constraints and let AI implement. 2.0's agent-first model is your workflow made native. The learning curve is nearly zero.
Adopt now
Parallel subagents and scheduled tasks let one person run several workstreams at once. The free preview makes the experiment cost nothing but time.
Adopt with the IDE fix
You will miss the live diff view. Run the 1.x IDE alongside 2.0 as your file tree and diff viewer, and the loss of visibility is solved.
Wait a few patches
If launch-week crashes and browser-agent failures would block your team, pilot 2.0 on a side project and revisit for production after it settles.
The fifth read is the simplest: if you are curious, adopt now. It is free, it installs alongside 1.x, and an hour inside the Agent Manager teaches you more about where development is heading than any writeup — including this one.
Antigravity 2.0 — common questions
Antigravity 2.0 is the agent-first version of Google's development platform, launched May 19, 2026. It is a standalone desktop application built around orchestrating multiple AI coding agents in parallel, with dynamic subagents, git worktree isolation, and scheduled tasks. It is free during public preview.
Version 2.0 is a separate, agent-first desktop application rather than a code editor. The primary surface is the Agent Manager, not a file tree. The legacy VS Code-style IDE still installs alongside it, but the file explorer and inline diff view are no longer the default workflow.
Yes. Antigravity 2.0, the CLI, and the SDK are free during public preview with generous Gemini 3 Pro and Gemini 3.5 Flash limits on a personal Google account. Paid tiers raise those usage limits.
Google launched a new AI Ultra tier at 100 dollars per month with 5x the Antigravity usage limit of the Pro plan, and cut the top AI Ultra tier from 250 to 200 dollars per month. A limited-time 100 dollar Antigravity bonus credit is offered to AI Ultra subscribers through May 25, 2026.
The main agent spawns role-specific subagents with the invoke_subagent tool, and can define new subagent types at runtime with define_subagent. Multiple subagents can be invoked in a single call and run in parallel in the background. The parent agent is notified automatically when a subagent returns data or needs input.
Worktree controls each subagent's workspace via three modes. Inherit runs the subagent in the parent's exact workspace. Branch creates an isolated cloned workspace. Share creates a workspace over the same repository directory, like a git worktree, isolating branch state while sharing storage. Branched workspaces are deleted when the subagent is terminated.
The most common cause is Chrome's remote debugging port, 9222, becoming jammed with stale zombie connections after an app update, which produces a Network.enable timeout. Fully closing Chrome, or force-killing all Chrome processes, then reopening it clears the port. Antivirus software blocking the Chromium driver is the second most common cause.
Yes. Google confirmed Gemini CLI and the Gemini Code Assist IDE extensions stop serving requests on June 18, 2026. The Antigravity CLI replaces them, is built in Go for speed, and carries forward Skills, Hooks, Subagents, and Extensions. Migrate before the cutoff.
Gemini 3.5 Flash is the default and is strong for most coding, refactors, and multi-step agent tasks, with Google reporting wins on Terminal-Bench 2.1 and MCP Atlas. Switch to Gemini 3.1 Pro for complex architectural reasoning and long-context work, where it still leads.
The legacy VS Code-style IDE still installs and runs alongside the 2.0 app, so a code editor and file explorer remain available. But the 2.0 app itself is agent-first and does not center on a file tree or inline diff view. The recommended fix is to run the 1.x IDE alongside 2.0 as your file tree and diff viewer.
Scheduled tasks are created with the schedule tool, using either a one-shot timer of up to 900 seconds or a standard cron expression. When the schedule triggers, the payload is injected into the agent's inbox as a high-priority interrupt that wakes the agent to process the event.
Antigravity 2.0 is powerful but launch-week rough. Early users report authentication crashes, Linux launch issues, and browser-agent failures. It is usable for real work with care: use plan mode, keep permissions scoped, and keep the 1.x IDE installed as a fallback.
Should you move to Antigravity 2.0?
If your work is genuinely agentic — multiple agents on one codebase, scheduled background jobs, browser verification in the loop — Google Antigravity 2.0 does things Cursor and Copilot do not, and it does them free during public preview. Adopt it now, install it alongside the 1.x IDE so you keep a file tree and live diff view, configure conservative permissions, and budget for launch-week roughness in the browser agent. If you need a stable, polished, file-centric editor today, wait a few patches. Either way, the agent-first direction is where Google is taking development — an hour in the Agent Manager is the fastest way to see it for yourself.