DDS Vibe Academy · Application
Antigravity IDE 2.0: Code It, Then Orchestrate It
The post-I/O 2026 guide to Google's Antigravity IDE: the Editor and Agent Manager surfaces, and how to dual-wield them with the standalone Antigravity 2.0 app. Shopify-framed, with a general-developer track alongside.
The dual-wield workflow IDE vs the 2.0 appQuick Answer
The Antigravity IDE is Google's agent-first code editor, a VS Code fork with an Editor for hands-on coding and an Agent Manager that orchestrates autonomous agents across editor, terminal, and browser. It is separate from the standalone Antigravity 2.0 app released at Google I/O 2026, and Google recommends dual-wielding them: the IDE for code, 2.0 for orchestration. Default model: Gemini 3.5 Flash.
Key takeaways
- The IDE (2025, still shipping) is the editor; Antigravity 2.0 (May 2026) is a separate, editor-free agent-orchestration app.
- The IDE has two surfaces: an Editor for coding and an Agent Manager running up to five parallel agents, toggled with Cmd/Ctrl+E.
- You verify agent work through Artifacts, plans, task lists, screenshots, recordings, not raw logs, and comment without halting the run.
- Planning mode plans then executes for complex work; Fast mode acts immediately for small changes.
- Autonomy is tunable: start at Review-driven, keep a tight browser allowlist and sandbox, and loosen as trust grows.
- Google recommends dual-wielding the IDE with the 2.0 app, sharing one set of context files (AGENTS.md, GEMINI.md, SKILL.md).
- For a Shopify store, the IDE builds and verifies theme sections; the 2.0 app handles scale and recurring jobs.
What the Antigravity IDE Is
The IDE is a heavily modified VS Code fork. If you know Cursor or Copilot, the Editor view will feel familiar; the Manager view is the new part. It supports model optionality (Gemini, Claude, GPT-OSS), AGENTS.md and GEMINI.md system prompts, and the SKILL.md skill format.
Google describes Antigravity as a platform that "combines a familiar, AI-powered coding experience with a new agent-first interface." In plain terms, it is a real code editor with an autonomous agent built into its core, one that can plan a task, write the code, run it in the terminal, and open a browser to verify the result.
Two facts matter for placing this class. First, the IDE is the original Antigravity product, from November 2025, and it is still shipping and still updated. Second, at Google I/O 2026 Google released a separate product, Antigravity 2.0, which is a standalone desktop app for orchestrating agents and is not an IDE. This class is about the IDE and how to pair it with that 2.0 app. If you want the 2.0 first-day playbook, that is the Antigravity On-Ramp masterclass; for the earlier foundation covering the IDE, the CLI, and AI Studio together, see the Gemini 3.1 Pro vibe coding guide.
For a Shopify store owner, the IDE is where you open your theme, edit Liquid sections, and have an agent build or fix store tooling while you watch and approve. It runs on your machine, on macOS, Windows, or Linux, free in public preview.
Source: Google Developers Blog, "Build with Google Antigravity," November 20, 2025.
The Paradigm Shift: From Writing Code to Orchestrating It
Mental model: you are now an engineering manager reviewing pull requests, not a typist. The agent produces Artifacts (plans, diffs, screenshots) you approve or redirect. The skill that matters shifts from syntax recall to specification, review, and knowing when to keep a human in the loop.
For a decade the IDE was a smart text editor that reacted to your keystrokes. Even the first wave of AI tools, autocomplete and chat sidebars, kept you as the author writing line by line. The agent-first model is a genuine break: the AI is treated as an autonomous actor that plans, executes, validates, and iterates, with you supervising rather than typing.
This is a real change to how work happens, and it is worth being honest about both sides. The upside is leverage: a single person can direct several agents and ship what used to need a team. The cost is that you must learn to specify clearly, review diffs and Artifacts critically, and set the right level of autonomy, because an agent that runs the terminal and browser can do real damage if you point it wrong.
The whole class is built around managing that trade. Done well, the IDE plus the 2.0 app turns you into the orchestrator of a small, capable team. Done carelessly, it is a fast way to merge code you never understood.
Source: Google Developers Blog; dated 2026 developer-tooling coverage (Baytech, Royal Cyber).
The Two Surfaces: Editor and Agent Manager
Manager layout: a left column of workspaces plus a Playground for throwaway experiments, and a middle Inbox that treats each agent task like an email thread. Each agent gets its own workspace context. Spawn one with Start Conversation, pick the workspace, the model, and the execution mode.
The Editor view is the part you already know: open a folder, edit files, accept tab completions, issue inline commands. For a Shopify build, this is where you hand-edit a Liquid section, tighten CSS, or read the diff an agent produced before you commit it. Nothing about your hands-on workflow is taken away.
The Agent Manager is where the shift happens. Google calls it "mission control": a dedicated surface to spawn, orchestrate, and observe agents working asynchronously. In the IDE you can run up to five agents in parallel, each in its own workspace, each with its own progress feed, so one agent can refactor a section while another writes tests and a third reproduces a bug. You toggle between Editor and Manager with Cmd+E (macOS) or Ctrl+E (Windows and Linux).
A defining feature is the browser subagent. When an agent needs to check a page, it invokes a subagent that drives an Antigravity-managed Chrome with a model specialized for operating web pages, separate from your main agent's model. For storefront work this means an agent can change a section, launch the theme preview, and visually verify the result, not just guess that the code is right.
Source: Google Developers Blog; Google Codelab, "Getting Started with Google Antigravity"; dated 2026 setup guides.
Artifacts: Verify the Work, Not the Logs
Two Artifact types to know: the Task List (the agent's live checklist and progress tracker) and the Implementation Plan (its proposed approach before it touches code, a pre-flight review). Save implementation plans as durable architecture docs; they double as a record of why something was built a certain way.
Delegating to an agent only works if you can verify what it did without reading a wall of tool calls. Antigravity's answer is Artifacts: the agent emits task lists, implementation plans, screenshots, and browser recordings as tangible deliverables you can scan at a glance. If something looks wrong, you comment directly on the Artifact, and the agent folds your feedback in without halting its execution flow.
For a Shopify owner this is the difference between trusting and hoping. When an agent rebuilds a collection section, the Implementation Plan tells you what it intends before it edits, the Task List tracks progress, and a browser recording shows the section actually rendering in the preview. You approve based on evidence, not faith.
The habit to build: treat the Implementation Plan as a pre-flight review. Read it, comment on anything off, and only then let the agent proceed. It is the cheapest possible place to catch a wrong assumption, before any code is written.
Source: Google Developers Blog, "Verify with Artifacts, not logs"; dated 2026 reviews (Scalable Path, LogRocket).
Planning Mode vs Fast Mode
Use Planning when the task spans files or needs research, and comment on the plan mid-flight to steer it. Use Fast for one-liners and tweaks. Quality is identical on simple tasks; Planning only pulls ahead on complex ones, where the deliberation and the plan artifact earn their cost.
In Planning mode the agent first generates an Implementation Plan document, completes the work against that plan, and then writes an overview describing the changes it made. You can comment on the plan while the agent works, and it adjusts. This is the mode for anything non-trivial: a new feature, a multi-file refactor, a section rebuild where the approach matters.
In Fast mode the agent just does it. This is right for small, localized changes: tweak a color, add a loading state, fix one function. For a string of micro-adjustments, three quick Fast-mode requests in a row are often faster than one deliberated Planning task.
A Shopify example: rebuilding a product section with new schema settings is Planning work, because you want to see the plan before it rewrites the file. Nudging the padding on a button afterward is Fast work. Matching the mode to the task is most of using the IDE well.
Source: dated 2026 coverage (LogRocket, SDH Global, domenicotenace.dev).
Autonomy, Review, and Safety
Granular settings: Terminal auto-execution (Off / Auto / Turbo or Request Review with allow/deny lists), Review policy (Always Proceed / Agent Decides / Request Review), Browser JS (Always Proceed / Request Review / Disabled), a browser URL allowlist against prompt injection, and a terminal sandbox toggle. For learning, set review to Request Review so you watch every step.
An agent that can run your terminal and drive a browser is powerful and, unmanaged, dangerous. Antigravity surfaces the controls directly. The terminal execution policy governs how freely the agent runs shell commands, from off, to request-review, to fully automatic with allow and deny lists. The review policy decides when the agent pauses for your approval of plans and Artifacts. The browser JavaScript policy controls whether the agent can execute JS in the managed browser, with disabled as the safest setting. A URL allowlist constrains which domains the browser subagent may visit, which is your main defense against prompt injection from untrusted pages, and a sandbox runs terminal commands with restrictions.
Four presets bundle these into autonomy levels: Secure (asks permission for almost everything), Review-driven development (pauses at key decision points, the recommended default), Agent-driven development (minimal checkpoints, fastest and riskiest), and Custom. The guidance is consistent across Google's own codelab and independent reviews: start at Review-driven, watch how the agent behaves in your codebase, and only then loosen the controls.
For Shopify work touching anything sensitive, payment logic, customer data, live theme files, keep review on and the allowlist tight. Reserve the looser, faster settings for greenfield scaffolding where a mistake costs nothing.
Source: Google Codelab; dated 2026 guides (Petronella, SDH Global, AI Builder Club, Royal Cyber).
The Knowledge Base and Context Files
Reference Knowledge Items directly in prompts ("follow the patterns in Knowledge Item #12") and the plan incorporates them. AGENTS.md holds coding standards; GEMINI.md holds the system prompt; SKILL.md uses the same format and trigger system that carries forward to the Antigravity CLI and 2.0 app.
Antigravity is built to accumulate context rather than start cold every time. Its Knowledge Base lets agents save useful patterns and snippets to improve later tasks, and you can view, edit, and manually add rules to it, then share it across a team. In Planning mode you can cite a saved Knowledge Item by reference and the agent folds it into the plan automatically.
Three context files do the heavy lifting and, importantly, carry across the IDE, the CLI, and the 2.0 app. AGENTS.md holds your coding standards. GEMINI.md holds the system prompt that shapes how the agent behaves. SKILL.md defines reusable skills using the same format and trigger system Google preserved through the CLI migration. Maintain these once and every surface benefits.
For a Shopify studio, this is where you encode your brand and platform rules, the certifications you may and may not claim, your Liquid conventions, your section-naming scheme, so every agent run produces on-brand, on-pattern output without you repeating yourself.
Source: Google Developers Blog; dated 2026 coverage (index.dev, domenicotenace.dev, agentpedia).
The Models Inside the IDE
Picker today: Gemini 3.5 Flash (default; agentic and coding), Gemini 3.1 Pro (deep reasoning, 1M context), Claude Sonnet 4.6, Claude Opus 4.6, and GPT-OSS-120B. Use Flash as the default, Pro for the hardest reasoning. In-Antigravity throughput for 3.5 Flash was pegged at about 800 tokens per second.
When the IDE launched in November 2025, Google gave it model optionality with generous rate limits on Gemini 3 Pro, plus full support for Anthropic's Claude and OpenAI's GPT-OSS, with additional frontier models reachable through Vertex AI Model Garden. The headline reasoning engine was Gemini 3 Pro.
At Google I/O 2026, Gemini 3.5 Flash became the new default model across Antigravity and Google's wider stack. Google states it runs roughly four times faster than other frontier models while matching or beating the older Gemini 3.1 Pro on coding benchmarks, with in-Antigravity throughput around 800 tokens per second. For nearly all IDE work it is the right default; reach for Gemini 3.1 Pro when a task needs the deepest reasoning or its one-million-token context.
One honest caveat: Google's own pages name Gemini 3 Pro as the IDE's headline engine, and the precise default Flash model in the earliest IDE builds is not cleanly documented. What is clear and current is that, after I/O 2026, Gemini 3.5 Flash is the default you will see.
Source: Google Developers Blog; Sundar Pichai and Varun Mohan statements at Google I/O 2026; model conflict labeled per the research dossier.
The IDE vs the Antigravity 2.0 App
Antigravity 2.0 adds custom subagent workflows (forkable, versionable chains), scheduled and cron tasks, native voice, and CodeMender security passes. It shares one agent harness with the new Antigravity CLI (Go, replacing Gemini CLI on June 18, 2026) so conversations sync across surfaces.
The single most common confusion in this topic is treating the two as one product. They are not. The IDE is the editor; the 2.0 app is the orchestrator. Here is the difference that matters day to day:
| Area | Antigravity IDE (2025, updated) | Antigravity 2.0 app (May 2026) |
|---|---|---|
| Primary surface | VS Code fork: Editor + Manager | Native desktop app, no editor |
| Code editor | Built in | None; use your own editor |
| Parallel agents | Up to five, each in a workspace | Unlimited parallel teams |
| Background work | Foreground only | Scheduled tasks and cron |
| Voice input | Not available | Native, on-device plus cloud |
| Default model | Gemini 3 Pro, then 3.5 Flash | Gemini 3.5 Flash |
| Custom subagent workflows | No | Yes, forkable and versioned |
| Security pass | Manual, via policies | CodeMender agent |
| Best at | Hands-on coding and reviewing the diff | Orchestrating agents that write code |
Neither replaces the other. Google itself recommends running both. The IDE is where a human reads and owns the code; the 2.0 app is where agents run wide and long. The next section is the workflow that connects them.
Source: TechCrunch and MarkTechPost, May 19, 2026; Google DeepMind launch statements; v1-vs-2.0 deltas per the research dossier.
The Dual-Wield Workflow
Six-step loop: decide where the work lives, plan in the IDE then scale in 2.0, keep one set of context files (AGENTS.md, GEMINI.md, SKILL.md, Knowledge Base) across surfaces, review Artifacts in the IDE, offload recurring jobs to 2.0 scheduled tasks, and gate everything through a CodeMender security pass before merge.
The pairing is a loop, not a choice. The practical workflow:
- Decide where the work lives. Hands-on coding, reading diffs, tight edits go in the IDE Editor. Long-horizon, parallel, or background work goes to the 2.0 app.
- Plan in the IDE, scale in 2.0. Use the IDE's Planning mode to produce an Implementation Plan for a feature; once the approach is sound, hand the parallelizable sub-tasks to 2.0's multi-agent teams.
- Keep one source of truth. Your AGENTS.md, GEMINI.md, SKILL.md, and Knowledge Base apply across surfaces. Maintain them once.
- Review on the IDE bench. Agents in either surface emit Artifacts; review and comment in the IDE, where you can open the actual files and run the diff.
- Offload the recurring to 2.0. Move repeating jobs, dependency bumps, CI triage, weekly reports, from "prompt every time" in the IDE to scheduled tasks in the 2.0 app.
- Gate on security. Run a CodeMender pass over code produced anywhere, including IDE-written or vendor code, before you merge.
One real caveat to know before you start: at the May 19 launch many developers hit "update" and the installer opened the new 2.0 app instead of the IDE, landing them in an empty workspace with no editor. Nothing was deleted; the two apps run side by side. If it happens to you, your projects are still on disk and the IDE still opens them.
Source: Google "dual-wield" positioning; dated 2026 coverage (Blur Brah Lab, antigravityide.org); launch-day issue per the research dossier.
For Shopify Builders: Where This Pays Off
The IDE edits any codebase; Shopify is just one. The same loop applies to a React storefront, a headless Hydrogen build, or a Python ops script: plan in the Editor, parallelize in 2.0, keep standards in AGENTS.md, gate with CodeMender. Nothing here is Shopify-specific except the examples.
Concretely, where the IDE earns its place in a Shopify workflow:
- Section and theme work. Open your theme folder, have an agent build or refactor a Liquid section in Planning mode, read the Implementation Plan, and let the browser subagent render it in the theme preview before you commit.
- Schema-to-setting accuracy. The agent can wire a section's
{% schema %}settings to the markup and verify the connection, the kind of detail that breaks silently when done by hand. - Store tooling. Build the small scripts and pages around the store, the same one-prompt tools covered in the One-Prompt App Library, but with a real editor and version control around them.
- Brand and certification rules in context. Encode your standards in AGENTS.md, including which certifications you may claim, so every agent run stays on-brand and compliant.
Then pair with the 2.0 app for the jobs that are too big or too repetitive for a single editor session: auditing every section file at once, or scheduling a weekly check that flags drift. The IDE keeps you close to the code; the app handles scale.
Source: Google Build-mode and integration documentation; DDS Vibe Academy build practice.
Your First Run
Install gotchas reported in 2026: on Windows, keep the default install path or risk a login loop; set Chrome as default browser before sign-in or the OAuth redirect can fail; personal Gmail is required in preview, Workspace accounts may not be supported. Enable the terminal sandbox from the start.
The first-run sequence that avoids the common traps:
- Install. Download from antigravity.google/download for macOS, Windows, or Linux. On Windows, keep the default install path; a custom path has been linked to sign-in loops.
- Sign in. Use a personal Google account, and set Chrome as your default browser first so the OAuth redirect completes.
- Open a project and set the autonomy preset to Review-driven development. Turn on the terminal sandbox.
- Add an AGENTS.md with your coding standards and, for a store, your brand and certification rules.
- Dispatch one task in Planning mode. Read the Implementation Plan, comment on anything off, then let the agent proceed and verify via its Artifacts.
What not to do first: do not start at Agent-driven autonomy, do not let the browser run arbitrary JavaScript on unknown domains, and do not merge a diff you have not read. The point of the first run is to learn how the agent behaves in your codebase before you give it room.
Source: Google Codelab; dated 2026 setup guides (Petronella, AI Builder Club).
Pros and Cons
Pros
- Keeps a real code editor in the loop: you read, edit, and own the diff, which the 2.0 app alone does not provide.
- Browser subagent verifies UI and flows end to end inside the IDE, ideal for checking a rendered storefront section.
- Artifacts (plans, task lists, screenshots, recordings) make agent work reviewable without log-diving; you comment without halting the run.
- Planning and Fast modes plus four autonomy presets let you match risk to task, tight for payments and auth, loose for scaffolding.
- Free in public preview, cross-platform, with model optionality across Gemini, Claude, and GPT-OSS.
- Knowledge Base and AGENTS.md / GEMINI.md / SKILL.md carry context across the IDE, the CLI, and the 2.0 app.
Cons
- Two apps to run and reason about; the May 19 auto-update confusion was real, though both apps coexist and nothing is deleted.
- The IDE caps at five parallel agents; heavy parallelism and scheduled background work require the 2.0 app.
- Early independent reviews in late 2025 flagged slowness, rate limits, and a security concern that made it unsuitable for sensitive-data projects at that time.
- Agent autonomy plus terminal and browser access is a real prompt-injection and data-exfiltration surface; it demands the safety policies, allowlists, and sandbox.
- Preview pricing is free now, but compute is costly; after I/O 2026, paid tiers are AI Pro at 20 dollars per month, a new AI Ultra at 100, and premium Ultra at 200 (down from 250).
- It is a fork of VS Code, not VS Code itself, so some extensions and workflows may differ.
Source: Google documentation; dated 2026 reviews; pricing per Google I/O 2026 coverage.
Common Mistakes
- Confusing the two products. The IDE is the editor; 2.0 is the orchestrator. Expecting a code editor in the 2.0 app, or unlimited parallel teams in the IDE, leads to frustration. Know which surface you are in.
- Starting at Agent-driven autonomy. Begin at Review-driven, watch the agent in your codebase, and loosen only as trust grows. Full autonomy on day one is how unwanted changes land.
- Merging unread diffs. Artifacts exist so you can review. Read the Implementation Plan and the diff before you commit; the agent is fast, not infallible.
- Loose browser policy. An agent browsing untrusted pages with JavaScript enabled is a prompt-injection risk. Keep a tight URL allowlist and disable browser JS for sensitive work.
- Wrong tool for scale. The IDE caps at five agents and runs foreground only. Heavy parallel sweeps and recurring jobs belong in the 2.0 app's teams and scheduled tasks.
- Skipping the context files. Without AGENTS.md and a Knowledge Base, you re-explain your standards every run. Encode them once so every agent stays on-pattern.
Source: Google Codelab guidance; dated 2026 reviews; this class's design notes.
Key Terms
| Term | What it means |
|---|---|
| Agent-first | A design philosophy where the AI is an autonomous actor that plans and executes, not a sidebar assistant. |
| Editor View | The IDE's standard VS Code-style coding surface, with tab completion and inline commands. |
| Agent Manager | The IDE's mission-control surface for spawning, monitoring, and steering agents; up to five in parallel. |
| Artifact | A tangible deliverable an agent produces for review: task list, implementation plan, screenshot, or browser recording. |
| Implementation Plan | The agent's proposed approach before it edits code; a pre-flight review you can comment on. |
| Task List | The agent's live checklist and progress tracker, surfaced as an Artifact. |
| Planning Mode | Execution mode where the agent plans first, then executes, then writes a walkthrough; for complex work. |
| Fast Mode | Execution mode where the agent acts immediately; for small, localized changes. |
| Browser subagent | A specialized agent that drives an Antigravity-managed Chrome to test and verify web pages. |
| Autonomy preset | A bundle of policies: Secure, Review-driven, Agent-driven, or Custom, controlling how freely the agent acts. |
| Review policy | The setting that decides when an agent pauses for your approval of plans and Artifacts. |
| Knowledge Base | The IDE's store of saved patterns and rules that agents reuse to improve future tasks. |
| AGENTS.md | A context file holding coding standards that agents read so they follow your conventions. |
| GEMINI.md | A system-prompt file that shapes agent behavior, carried across Antigravity surfaces. |
| Dual-wield | Google's recommended workflow: the IDE for code, the 2.0 app for agent orchestration, side by side. |
| CodeMender | A security agent in the 2.0 app that scans agent-written code for vulnerabilities and patches them. |
Source: Google Antigravity documentation, 2025-2026.
Frequently Asked Questions
Is the Antigravity IDE the same as Antigravity 2.0?
No. The IDE is the original product from November 2025, a VS Code fork with a built-in code editor. Antigravity 2.0, launched at Google I/O in May 2026, is a separate standalone desktop app for orchestrating agents and has no code editor. Google recommends running both together.
Which one should I use, the IDE or the 2.0 app?
Both, in a dual-wield workflow. Use the IDE for writing and reviewing code, where you can open files and read diffs. Use the 2.0 app for orchestrating many agents in parallel and for scheduled background tasks. They share context files and complement each other.
Is the Antigravity IDE free?
It is free in public preview. After Google I/O 2026, paid tiers exist for heavier use: AI Pro at 20 dollars per month, a new AI Ultra at 100, and a premium Ultra at 200 (reduced from 250). Compute for the underlying models is the real cost driver.
What model does the IDE use?
At launch it ran on Gemini 3 Pro with model optionality. After Google I/O 2026, Gemini 3.5 Flash became the default across Antigravity, running about four times faster than comparable frontier models while matching or beating Gemini 3.1 Pro on coding. You can also pick Gemini 3.1 Pro, Claude, or GPT-OSS.
What is the Agent Manager?
It is the IDE's mission-control surface, distinct from the Editor. From it you spawn, monitor, and steer agents working asynchronously across separate workspaces. In the IDE you can run up to five agents in parallel; toggle to it from the Editor with Cmd+E or Ctrl+E.
What are Artifacts?
Artifacts are the tangible deliverables an agent produces so you can verify its work without reading raw logs: task lists, implementation plans, screenshots, and browser recordings. You can comment on an Artifact like a document, and the agent incorporates your feedback without stopping.
What is the difference between Planning and Fast mode?
In Planning mode the agent writes an implementation plan, executes against it, and produces a walkthrough, which suits complex, multi-file work. In Fast mode the agent acts immediately, which suits small, localized changes. Quality is identical on simple tasks; Planning pulls ahead on complex ones.
How do I keep the agent from doing something destructive?
Use the autonomy controls. Set the terminal execution policy, the review policy, and the browser JavaScript policy, keep a tight URL allowlist, and enable the terminal sandbox. Start at the Review-driven preset so the agent pauses for approval at key steps, then loosen only as you build trust.
Can the IDE test a web page it built?
Yes. The agent invokes a browser subagent that drives an Antigravity-managed Chrome with a model specialized for operating web pages. It can launch the page, interact with it, and capture a recording or screenshot as an Artifact, so it verifies the result rather than guessing.
Is this only for developers, or can a store owner use it?
Both. The IDE is a real code editor, so it suits developers directly. A Shopify store owner can use it to build and maintain theme sections, schema settings, and store tooling with an agent that plans, edits, and visually verifies the work, while keeping a human review step.
How does the IDE help with a Shopify store specifically?
You open your theme folder and have an agent build or refactor Liquid sections in Planning mode, wire schema settings to markup, and render the result in the theme preview via the browser subagent. You encode brand and certification rules in an AGENTS.md so output stays on-brand.
What is AGENTS.md and why does it matter?
AGENTS.md is a context file holding your coding standards and rules. Antigravity reads it so agents follow your conventions without being told each time. Together with a GEMINI.md system prompt and SKILL.md skills, it carries across the IDE, the CLI, and the 2.0 app, so you maintain standards once.
What happened to the Gemini CLI?
Google is replacing it with the Antigravity CLI, a Go-based binary that shares the same agent harness as the 2.0 app. After June 18, 2026, the Gemini CLI stops serving consumer tiers, and IDE extensions depending on it stop working. Agent Skills, hooks, and subagents carry over.
Do agents remember anything between tasks?
The IDE has a Knowledge Base that lets agents save useful patterns and snippets to improve future tasks. You can view, edit, add, and share its rules across a team, and reference saved Knowledge Items directly in a prompt so the plan incorporates them.
Can I use Claude or other models in the IDE?
Yes. The IDE offers model optionality. Alongside Gemini 3.5 Flash and Gemini 3.1 Pro, it supports Anthropic's Claude (Sonnet and Opus) and OpenAI's GPT-OSS, with additional frontier models exposed through Vertex AI Model Garden.
Why did the IDE open into an empty app after I updated?
At the May 19 launch, updating sometimes opened the new 2.0 desktop app instead of the IDE, landing you in an empty workspace with no editor. Nothing was deleted. The two apps run side by side; your projects are still on disk and the IDE still opens them.
Is it safe to run on a production codebase?
Treat it with care. Independent reviews in late 2025 flagged slowness, rate limits, and a security concern that made it unsuitable for sensitive-data work at that time. Keep autonomy at Review-driven, tighten the URL allowlist and sandbox, and never merge a diff you have not read.
What operating systems does it run on?
The IDE runs on macOS, Windows, and Linux. On Windows, keep the default install path to avoid a reported sign-in loop, and set Chrome as your default browser before signing in so the authentication redirect completes.
How is this different from Cursor or GitHub Copilot?
Cursor and Copilot are assistance-first: they enhance editing and predict code while you drive. Antigravity is agent-first: it treats the AI as an autonomous actor that plans, executes across editor, terminal, and browser, and verifies its own work, with you supervising via Artifacts.
Does the IDE replace my whole development workflow?
No, and it is not meant to. It pairs with your editor and the 2.0 app rather than replacing them. The honest framing is leverage with oversight: you direct and review autonomous agents, but you remain accountable for the code, the security pass, and what gets merged.
Sources
- Google Developers Blog, "Build with Google Antigravity," Nov 20, 2025 — the IDE's two surfaces, Artifacts, Knowledge Base, models. developers.googleblog.com
- Google Codelab, "Getting Started with Google Antigravity" — Agent Manager, autonomy and review settings, sandbox. codelabs.developers.google.com
- Google Developers Blog, "Transitioning Gemini CLI to Antigravity CLI" — shared harness, June 18 migration. developers.googleblog.com
- TechCrunch, May 19, 2026 — Antigravity 2.0 launch: desktop app, CLI, SDK. techcrunch.com
- The Verge, Nov 18, 2025 — "agent-first coding tool built for Gemini 3." theverge.com
- antigravity.google — product home and download. antigravity.google
- Companion classes: the Antigravity On-Ramp (agent-first 2.0) and the Gemini 3.1 Pro vibe coding guide (the earlier IDE + CLI + AI Studio foundation).
Code it in the IDE, then orchestrate it in 2.0
Open the Antigravity IDE, set autonomy to Review-driven, and dispatch one task in Planning mode. When the job grows past a single editor, hand it to the 2.0 app's agent teams. Keep one set of context files across both.
Browse the DDS Vibe AcademyFree. No paywall. No signup. No certificate. Just the work.