Antigravity 2.0: Google's 4-Surface Agent Platform Explained (2026)

The launch in one minute

On May 19, 2026 at Google I/O, Google DeepMind launched Antigravity 2.0 alongside Gemini 3.5 Flash. The header facts:

• Four surfaces, not one: Antigravity 2.0 (a new desktop app), Antigravity CLI (Go-based terminal, replaces Gemini CLI for personal users), Antigravity SDK (Python, in Research Preview), and the legacy Antigravity IDE (still installed, Agent Manager being removed in a future release).
• The 2.0 desktop is “not an IDE.” The launch blog is explicit: “Users interact with powerful agents both synchronously and asynchronously, and there is no IDE.” Mission control, not code editor.
• Default model: Gemini 3.5 Flash. Logan Kilpatrick said it is “outperforming Gemini 3.1 Pro on challenging coding and agentic benchmarks.” 3.5 Pro is rolling out “next month.”
• The headline demo: 93 parallel subagents built a working OS from a single prompt in 12 hours, 15,314 model calls, more than 2.6 billion tokens processed, $916.92 in API credits. It runs FreeDoom.
• New pricing: a new Google AI Ultra at $100/month (5x Pro limits), the previous Ultra repriced from $250 to $200/month (20x Pro limits). The marquee /teamwork-preview command — the orchestrator behind the OS demo — is gated to the $200 tier, and Google warns it can “exhaust your entire weekly quota within a couple of tasks.”
• Gemini CLI is sunsetting for personal users on June 18, 2026 (30-day window). Enterprise customers on Gemini Code Assist Standard / Enterprise keep it.

The 4-surface re-architecture: what changed

The single sentence that explains the rest of the launch comes from @geminicli’s migration tweet on May 19 at 17:56 UTC:

“Antigravity 2.0 / Antigravity CLI / Antigravity SDK / Antigravity IDE.”

That ordering is deliberate. @GoogleDeepMind described the first three in a separate tweet (id 2056790408689287180): Antigravity 2.0 is “mission control where agents can work together simultaneously on a project,” the CLI is the “terminal interface,” and the SDK is a “toolkit that lets your software automatically connect to and use our AI agents.” The IDE is named last because it is the legacy surface — kept around for continuity but not the place Google wants new attention.

What this re-architecture does mechanically is detach the agent runtime from any particular UI shell. The same agent harness — same Hooks, same Subagents, same Skills, same permissions model — runs underneath the desktop app, the CLI, and the SDK. Settings sync bidirectionally between 2.0 and the CLI (the migration blog calls this out explicitly). Conversations exported with @conversation in the CLI open in the desktop. Hooks defined in one surface fire in the other.

The strategic implication is the part the launch tweets kept dancing around: the IDE is now a feature, not the platform. A year ago Antigravity 1.0 launched as “Google’s AI IDE” (their phrase). Twelve months later Google is positioning the IDE as one of four surfaces and removing the Agent Manager from it in an upcoming release. The agent system is the product.

The community caught this immediately. @mark_k’s 70-like tweet (id 2056809475101872369) summed it up: “Antigravity 1.0 was the full IDE. 2.0 feels more like they pulled the agent system out of the IDE and made it the product. It feels more like the Codex app.” We’ll come back to the “just Codex” framing in the launch-day section — it’s the dominant analyst take, and worth treating seriously rather than waving away.

Antigravity 2.0 (Desktop): mission control for agents

The flagship surface. From @antigravity’s launch tweet (id 2056795168326754759, 4,090 likes, 281K views):

“Introducing Antigravity 2.0, a new standalone desktop application that delivers fully on that original glimpse of a truly agent-optimized experience. Rebuilt from the ground up with multi-agent teams, scheduled tasks, native voice and one-click integration with other Google products.”

Available on macOS, Linux, and Windows. The download lives at antigravity.google/. The seven concrete features in the launch blog (antigravity.google/blog/introducing-google-antigravity-2-0):

• Dynamic subagents. The main agent defines and invokes child agents on the fly during a task. Each subagent gets an isolated context window so the main agent doesn’t blow its context on exploration. Subagents run in parallel where possible. This is the same primitive the OS-demo team used to parallelize across 93 agents.
• Asynchronous task management. Long-running operations are moved off the main thread into background processes. The desktop UI shows them as running, paused, or completed tasks instead of blocking the chat. You can start a long build, walk away, and come back to a finished report.
• JSON hooks. Two scopes: global (applied to every project) and workspace (applied to the open Project). Workspace takes precedence on conflict. Hooks intercept tool calls, model calls, and loop stops — giving you the same lifecycle-interception surface the SDK exposes, but configured by file instead of by code.
• Scheduled Tasks. A native cron primitive inside the agent. Schedule an agent to run on a clock or one-shot at a future time. Pinned to Gemini 3.5 Flash for predictable cost; you don’t get to pin a premium model to a cron. This is the feature @mustafaergisi called out as “the gap I keep patching with cron and shell glue in my agent pipeline.”
• Native voice. Live transcription via the latest Gemini Audio models, available on all tiers (no Ultra-only gate). You speak, the agent transcribes and acts.
• Projects (not workspaces). Multi-folder Projects with per-project settings and permissions. Closer to the JetBrains “Project” concept than the VS Code “workspace.” Permissions and hooks attach to the Project.
• Native Git worktree support. Worktrees are auto-provisioned. When a subagent spawns, it gets its own worktree to operate in; when the subagent completes, the worktree is auto-cleaned. This is what makes the dynamic-subagents model safe — child agents literally cannot stomp on each other’s files because they’re working on different worktrees.

That last point — auto-worktree per subagent — is the quietest but most engineering-significant feature in the list. Multi-agent systems live or die on isolation. Manus, Devin, and other agent platforms have shipped variations on git-worktree-per-agent for the same reason: it turns a flaky multi-agent run into a graph of independent file states that merge cleanly at the end.

A relevant catalog skill if you want to dig into the operational side of Antigravity:

The antigravity-manager skill on mcp.directory walks through the architecture and workflows of the Antigravity Manager surface. For quota-aware multi-account work — which becomes more relevant under the new pricing tiers — see:

The new slash commands

The 2.0 desktop ships five new slash commands documented in the feature deep-dive blog (antigravity.google/blog/google-io-2026-feature-deep-dive):

/goal — “run until done”

Verbatim definition from the blog: “Run until the specified task is completely finished, not asking for intermediate input.” This is the autonomous-mode switch. The agent will not pause to ask clarifying questions; it will make its best guess and keep going until it reports done. The implicit dependency: you trust your hooks, your safety policies, and your permissions enough to leave the agent unsupervised for the run.

/goal Set up CI for this repo with GitHub Actions, lint + tests on PR, deploy on main.

/grill-me — clarification-first mode

The opposite end of the dial: the agent asks clarifying questions back before implementing. Useful when you know your prompt is under-specified and you want the agent to surface the ambiguities before it commits to an approach. Think of it as the “don’t guess, ask” modifier.

/schedule — first-class cron

Two modes: one-time (capped at 15 minutes ahead) or cron. The blog’s example reads almost like spoken English:

/schedule every hour run the health check script, up to 3 times

Scheduled Tasks are pinned to Gemini 3.5 Flash. You cannot schedule a 3.5 Pro agent task — Google’s quota-protection move. This makes /schedule roughly the cost-equivalent of a long-running script with LLM checkpoints, not an autonomous deep-reasoning loop.

/browser — explicit browser-use opt-in

Browser-use is no longer implicit. The agent will not open a browser unless you explicitly invoke /browser. This is the right safety posture — browser automation is where prompt-injection meets data exfiltration, and making it opt-in narrows the blast radius. (See §November 2025 history for why Google might be especially cautious here.)

/teamwork-preview — the OS-demo orchestrator

The flagship command and the most heavily gated. It instantiates the 7-role team behind the OS demo — Sentinel, Orchestrator, Explorer, Worker, Reviewer, Critic, Auditor — and orchestrates them on a single high-level prompt.

The math behind that quota warning: the OS demo used 2.6B tokens and made 15,314 model calls in one task. Even at Flash pricing — which Google blogs as “less than half the cost of other frontier models” — that’s $916.92. A weekly quota that covers more than a few/teamwork-preview runs would have to be generous.

Antigravity CLI: terminal interface, rebuilt in Go

From @antigravity (tweet id 2056827231310094698): “a lightweight way to spin up the same Antigravity agents right from the terminal.” The CLI launch was a dedicated tweet ~2.5 hours after the 2.0 desktop launch, with its own blog post (antigravity.google/blog/introducing-google-antigravity-cli).

The single most important fact about the Antigravity CLI: it’s a rebuild, not a rebrand of Gemini CLI. The migration blog calls this out in plain language: “Faster execution: Built in Go, Antigravity CLI is snappier and more responsive.” Gemini CLI was Node/TypeScript. Antigravity CLI ships precompiled binaries.

Install

# macOS / Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash

# Windows PowerShell
irm https://antigravity.google/cli/install.ps1 | iex

What migrated cleanly from Gemini CLI

Per the migration blog: Agent Skills, Hooks, Subagents, and Extensions (which now ship as Antigravity plugins). If you have a working Gemini CLI workflow, the feature surface you used should still be there.

Auth model

System keyring with Google Sign-In as the fallback. SSH detection prints an authentication URL when you’re not on a local machine. /logout clears credentials from the keyring.

Shared state with 2.0

Settings and permissions sync bidirectionally between Antigravity 2.0 (desktop) and the CLI. Conversations started in the CLI can be exported via @conversation and opened in the desktop, and vice versa.

Repo and license

The repo is github.com/google-antigravity/antigravity-cli, created 2026-05-13, sitting at 53 stars on launch day. The repo did not carry a license file at the time of capture — only a precompiled binary distribution. We will not call the CLI open-source until Google adds a license. If you need a Go-CLI workflow that is unambiguously open-source today, the Antigravity SDK (Apache 2.0) plus your own thin wrapper is the lower-risk path.

Why Google rebuilt instead of rebranding

Verbatim from the migration blog:

“you love a good terminal UI, you appreciate that we ship weekly releases, and your workflows have simply outgrown those early days of 2025... You now require multiple agents communicating with each other to split up the work and solve complex problems.”

The kicker number from the same blog: Gemini CLI at sunset had “millions of users, with over 100,000 GitHub stars, 6,000 merged pull requests, and hundreds of contributors.” This is not a quiet retirement. The 30-day window expires June 18, 2026 for personal users on AI Pro, AI Ultra, free Gemini Code Assist for individuals, and Gemini Code Assist for GitHub. Enterprise customers on Code Assist Standard or Enterprise licenses are explicitly unaffected.

Antigravity SDK: building your own agent harness

The third surface, and the one that gets the least-deserved attention so far — the SDK is what lets you embed the Antigravity agent into anything that runs Python.

Repo: github.com/google-antigravity/antigravity-sdk-python, Apache 2.0, 82 stars, 11 forks at launch, created 2026-04-29. PyPI package: google-antigravity. The launch blog is at antigravity.google/blog/introducing-google-antigravity-sdk and labels it “Research Preview.”

Install

pip install google-antigravity

Important: the package ships platform-specific wheels with a compiled runtime binary. Cloning the repo alone will not give you a working SDK — you need the wheels from PyPI.

Minimum viable agent

Verbatim from the launch blog:

import asyncio
from google.antigravity import Agent, LocalAgentConfig

async def main():
    config = LocalAgentConfig()
    async with Agent(config) as agent:
        response = await agent.chat("What files are in the current directory?")
        print(await response.text())

asyncio.run(main())

Four lines of actual code. The defaults are deliberate: LocalAgentConfig sets a read-only policy with confirm_run_command(), the default model is Gemini 3.5 Flash, and the agent ships with built-in tools for file I/O, code editing, shell execution, directory search, image generation, and sub-agent delegation.

Tool sources (four kinds)

• Built-in tools. File I/O, code editing, shell exec, directory search, image generation, sub-agent delegation. The ones the OS-demo subagents used.
• Custom Python functions. Decorate them and they show up as tools.
• MCP servers. The SDK supports stdio, SSE, and Streamable HTTP transports — the launch blog links directly to modelcontextprotocol.io. This is the bridge to the entire MCP ecosystem we catalog at mcp.directory. Anything that speaks MCP becomes an Antigravity tool.
• Agent skills via skills_paths. Point the SDK at a directory of skill files and they get loaded as composable agent capabilities.

Safety policies (declarative)

from google.antigravity.hooks.policy import deny, allow, ask_user

policies = [
    deny("*"),
    allow("view_file"),
    ask_user("run_command", handler=my_handler),
]

The pattern is deny-by-default, allow-list reads, ask-user on dangerous tools. The default LocalAgentConfig is read-only with a confirm prompt on run_command. To go autonomous you call policy.allow_all() — and at that point you own the consequences.

Hooks: Inspect / Decide / Transform

Nine lifecycle hook points (the launch blog enumerates the pattern but does not name all nine in the captured excerpts; treat this as “there are many” until you read the docs). Thinking levels: MINIMAL, LOW, MEDIUM, HIGH. Multimodal inputs: images, PDFs, audio, video.

Roadmap

Per the SDK launch blog: a remote harness (cloud deploy), TypeScript and Go SDKs, Gemma integration (running with open-weights instead of API), Plugins, and deeper observability hooks. The TS and Go SDKs in particular are the ones to watch — that’s the moment the SDK story stops being “Python only” and starts being a cross-runtime agent platform.

The legacy IDE: still here, but on a clock

The Antigravity IDE — the November 2025 launch product, the one that hit Hacker News for 1,088 points — remains installed and functional on launch day. Google’s guidance is explicit: “We recommend dual-wielding Antigravity 2.0 with your IDE of choice, whether it is the Antigravity IDE or otherwise.”

But the clock is ticking. From the 2.0 launch blog:

“For now, both the Antigravity IDE application itself and the Agent Manager in the Antigravity IDE will remain available. In an upcoming release, we will remove the Agent Manager from the Antigravity IDE, turning the IDE into a purely agent-powered IDE.”

The Agent Manager is the multi-agent UI inside the IDE — the thing that exists in 2.0 as the entire application. When it goes away from the IDE, the IDE becomes a more conventional “AI-assisted code editor” — Cursor- shaped — and the 2.0 desktop becomes where multi-agent work lives. There is no announced date for the Agent Manager removal.

Practically: if you installed Antigravity 1.0 before May 19 and rely on the in-IDE Agent Manager, your day-to-day stays the same for now. When the Agent Manager removal ships, you’ll need 2.0 for multi-agent work.

How to tell the two apps apart

Both apps install side-by-side. Google’s disambiguation: the dock icon. White background = Antigravity 2.0 (the new desktop app). Black-grid background = the legacy Antigravity IDE. It’s a small UX choice that matters a lot on launch day when half your dock just got rearranged.

Pricing: the new $100 and $200 Ultra tiers

Google restructured its consumer pricing simultaneously with the launch. TechCrunch’s May 19 coverage is the cleanest summary: “Google launches Antigravity 2.0 with an updated desktop app and CLI tool.”

The new shape:

• Free tier. Continues. The free Gemini Code Assist for individuals tier rolls into Antigravity during the 30-day migration window.
• Google AI Pro. The base paid tier. Antigravity Pro limits.
• Google AI Ultra $100/month (NEW). 5x Pro limits in Antigravity. This is a new tier — it didn’t exist before May 19. The positioning is “you want more than Pro but $200 is more than you need.”
• Google AI Ultra $200/month. 20x Pro limits. Was $250/month before May 19 — Google cut the top tier by $50/month and made it /teamwork-preview’s home. The rebranding reads as “the new high-end is more accessible.”
• Enterprise. Gemini Enterprise Agent Platform via Google Cloud, separate ToS, customer data stays in private environment. Pricing not disclosed in launch materials.

The single design choice worth pointing out: /teamwork-preview is the only feature gated to the $200 tier specifically. Multi-agent dynamic subagents, Scheduled Tasks, native voice, hooks, Projects, worktrees — all available at lower tiers (subject to quota). It’s the OS-demo orchestrator that costs more, and Google is up-front about why: a single run can burn a week’s quota.

The $1,000 OS-demo cost framing got picked apart on Reddit day one. The top comment on r/singularity (138 comments on the OS-demo thread): “Isn’t Opus 4.6 $25/m tokens so 2.6b tokens would be $65k?” The answer is yes — the demo is cheap because Gemini 3.5 Flash is cheap, and 3.5 Flash is cheap because Google has not published per-token pricing for it yet. The only public anchor today is the demo itself: 2.6B tokens blended (input + cache + thinking + output) = $916.92, which works out to about $0.35 per million tokens averaged across all those buckets. Treat that as a rough order-of-magnitude, not a price sheet.

Launch day in the wild: incident and framing

Two threads of community reaction ran in parallel on May 19, and both are worth understanding before you decide whether to install 2.0 today or wait a week.

The auto-update incident

Within an hour of launch, IDE users started reporting that the update process closed their Antigravity IDE mid-session and replaced it with an Agent Manager window that wouldn’t load. The earliest viral report was @vql3n (113 likes, tweet id 2056801834652594521):

“I was working on a project. Antigravity closed and auto updated. I no longer have access to the IDE, only this agent manager that won’t even load. WTF? They interrupted my LLM session while I was writing and uninstalled my editor?”

@prusakkq (119 likes) quote-tweeted with an identical-looking screenshot: “I guess im not alone.” @f5lip3 (26 likes): “You completely ruined my workflow with this new Antigravity IDE update. I had to uninstall it and reinstall the old version just to keep working properly.” @NicoHezel summed up the frustration in a line: “So you rebuild a chat window from the ground up? Where is the IDE?”

Google’s @antigravity account responded ~30 minutes later to one of the threads with three words: “It’s fixed now.” A standalone Ask HN thread (news.ycombinator.com/item?id=48199074) tracked the installer-breaks-IDE incident, and r/google_antigravity opened an Antigravity 2.0 Bugs Megathread plus a thread titled “WTF is Antigravity 2.0? Where did my IDE go?” with 96 upvotes and 105 comments by end of day.

@rozzabuilds (71 likes) offered the gentlest framing: “Don’t worry founders - even 4 trillion dollar company’s have things go wrong at launch.” That’s about right. The patch happened the same hour. But the people whose workflow got interrupted had a bad first impression of 2.0, and that first impression rippled into the day-two coverage.

The “just Codex” framing

The dominant analyst take on launch day was that Antigravity 2.0 is mechanically very similar to OpenAI’s Codex app — agent system pulled out of the IDE, made into a standalone product.

@mark_k (70 likes, id 2056809475101872369):

“Google Antigravity 2.0 is interesting because it no longer feels like ‘Google made an AI IDE’. Antigravity 1.0 was the full IDE... 2.0 feels more like they pulled the agent system out of the IDE and made it the product. It feels more like the Codex app.”

@Angaisb_ (159 likes) was less charitable: “So Google engineers use Codex, good to know.” @PaulBotwick: “Antigravity 1.0 was an under-supported VS Code Wrapper. 2.0 looks much closer to a Codex setup.” @noobiethe13: “Antigravity 2.0 goes full Cursor/Codex style. Downloaded it but couldn’t even login.”

Reddit picked up the same framing — r/GeminiAI ran a thread literally titled “Antigravity 2.0 is just Codex” (4 upvotes, 29 comments).

The positive framing was quieter but real. @cochod_clement: “multi-agent teams, scheduled tasks, native voice. google just described my dream stack.” @mustafaergisi: “Scheduled tasks plus multi-agent teams in one app is the gap I keep patching with cron and shell glue in my agent pipeline.”

Our read: the “just Codex” framing is a useful shape-of-product heuristic and an under-statement of the novelty. Scheduled Tasks as a native primitive, the 7-role agent team behind /teamwork-preview, native voice across all tiers, and the SDK’s explicit MCP integration are not in the Codex app. The right framing is “agent-app-shaped, like Codex; multi-agent primitives ahead of Codex.”

November 2025 → May 2026: the path to 2.0

The 2.0 launch reads differently if you remember where Antigravity 1.0 ended up.

2025-11-18: Antigravity 1.0 launched. Hacker News: 1,088 points and 1,085 comments. The framing was “Google’s VS Code with an Agent Manager bolted on.” Initial reception was excited; the IDE was downloaded heavily.

2025-11-25 to 2025-12-01: Two reputation-damaging stories landed in a week. First, PromptArmor published a prompt-injection finding that demonstrated data exfiltration through Antigravity’s agent — the resulting Hacker News thread hit 768 points. Second, a Reddit thread “Antigravity deleted my whole drive” went viral, with the corresponding HN discussion hitting 544 points. Both stories landed in the week after launch, when adoption was peaking.

Through the first half of 2026, sentiment continued to erode. The pre-launch Reddit thread “I left Google Antigravity a week ago and moved to Claude” (r/GoogleAntigravityIDE, 66 upvotes, May 2026) is representative of where 1.0 was by Q2.

2026-05-17: Logan Kilpatrick teased: “Very excited for all the stuff the @antigravity team has been cooking.” (432K views.) That’s the public signal that 2.0 was imminent.

2026-05-19: The four-surface launch.

Reading the path from 1.0 to 2.0 backwards: Google shipped a VS-Code fork, watched its agent get exploited by prompt injection, watched a viral “deleted my drive” thread, watched users churn to Claude through the first half of 2026, and re-architected. The explicit opt-in for browser-use (/browser), the deny-by-default safety policies in the SDK, the worktree-per-subagent isolation, the “no IDE” framing — all of it reads as a response to the 1.0 launch’s rough edges. 2.0 is not a feature update; it is a re-architecture by a team that learned from shipping something too fast.

The community sub-narrative — “just Codex” — is the same observation from the outside: Google saw what worked in the codex-app shape and copied it. The charitable framing is that Google saw what failed in the IDE-shape and rebuilt around the lesson.

Who Antigravity 2.0 is for (and who should wait)

Install today if you are

• An agent-first team. You already use subagents and parallel-task patterns elsewhere (Claude’s subagents, OpenCode’s parallel-Task, custom orchestration). Antigravity 2.0 gives you a first-class UI for what you already do, with cron and worktree isolation built in.
• A Google Cloud / Gemini user. Antigravity 2.0’s “one-click integration with other Google products” is the strongest selling point Google has versus Codex or Claude Code. If your auth, billing, and data already live in Google Cloud, 2.0 is the lowest-friction way to get a multi-agent system on top of them.
• A scheduled-agent operator. Anyone who patches cron, shell, and an LLM together for recurring agent tasks should look at native /schedule first. It’s the gap @mustafaergisi described, and Antigravity 2.0 closes it.
• An MCP server developer. The SDK supports MCP over stdio, SSE, and Streamable HTTP. If you maintain MCP servers (the kind we catalog at mcp.directory), the Antigravity SDK is a quick way to drop one into a Python harness and exercise it under a Gemini 3.5 Flash agent.

Wait if you are

• A heavy Antigravity IDE user with active production work. The auto-update incident burned a small but verified number of users on launch day. Wait 1-2 weeks before updating, or install 2.0 alongside without auto-update enabled. The Google guidance is explicit: dual-wielding is the supported posture.
• Locked into Claude or Codex. 2.0’s features are good but not so far ahead that they override switching cost. Subagents are also a Claude Code primitive. Scheduled tasks exist as third-party skills for Claude. Native voice and Google product integration are the genuine 2.0 differentiators — evaluate those against your actual needs.
• Cost-sensitive on the top tier. /teamwork-preview is the marquee feature, it’s gated to $200/month, and Google warns it burns weekly quota in one task. If you can’t justify the $200 tier, you’re paying for a product whose flagship demo you can’t run.
• Building on Antigravity CLI’s open source. The CLI repo has no license file at capture. Treat the CLI as a vendor binary until Google publishes a license. The SDK (Apache 2.0) is the unambiguous open-source path today.

Catalog skills useful around an Antigravity install

Four mcp.directory skills cover specific Antigravity ops surfaces. The image generation paths are useful because Antigravity ships image gen as a first-class built-in tool in the SDK.

For comparison-shopping against the broader MCP ecosystem, the most relevant catalog entries to cross-reference are the Gemini CLI and Claude Code MCP wrappers — these are third-party servers, not the official products, but they show what the integration surface looks like from outside Google’s ecosystem:

Gemini CLIjamubc

1-Click Ready

Integrate with Gemini CLI for large-scale file analysis, secure code execution, and advanced context control using Googl

analytics datadeveloper tools2.3k49

Claude Codekunihiros

1-Click Ready

Experience Claude Code, a Claude chatbot for codegeass fans using a Claude LLM. Enjoy coding with less capable LLMs toda

developer tools8262

What’s still unknown

Three significant unknowns we are tracking and would like Google to clarify:

• Antigravity CLI license. The repository at github.com/google-antigravity/antigravity-cli had no license file at capture (May 20). Until that changes, the CLI is a vendor-distributed binary, not an open-source tool. This matters for compliance teams, for downstream packaging, and for the “trust” claim Google can make against Codex (closed) and Claude Code (closed CLI on a paid plan).
• Gemini 3.5 Flash per-token pricing. Not published in launch materials. The only public anchor is the OS demo: 2.6B tokens (blended input + cache + thinking + output) = $916.92, which approximates to roughly $0.35 per million tokens averaged. Until Google publishes a price sheet, do not commit to volume planning on Flash.
• Gemini 3.5 Pro release date. The official blog says “next month,” meaning June 2026. A specific date and the surfaces it lands on first (Antigravity? API? Gemini app?) were not announced. If your plan depends on a 3.5 Pro feature you saw in the launch slides, leave a buffer.

Two smaller open questions: TechCrunch mentioned an “Antigravity export tool to AI Studio” that we couldn’t corroborate in the official launch blogs, and Google DeepMind’s “Build with Gemini XPRIZE Hackathon” ($2M prize pool, tweet id 2056794085680468294) was teased but the link did not resolve to a documented program at capture.

FAQ

Sources

• Antigravity 2.0 launch blog (Google): antigravity.google/blog/introducing-google-antigravity-2-0
• Antigravity CLI launch blog: antigravity.google/blog/introducing-google-antigravity-cli
• Antigravity SDK launch blog (Research Preview): antigravity.google/blog/introducing-google-antigravity-sdk
• 93-subagent OS-build deep-dive: antigravity.google/blog/google-antigravity-built-an-os
• Gemini 3.5 Flash announcement (Google AI blog): blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-3-5/
• Gemini CLI → Antigravity CLI migration (Google developers blog): developers.googleblog.com/an-important-update-transitioning-gemini-cli-to-antigravity-cli/
• TechCrunch coverage: techcrunch.com/2026/05/19/google-launches-antigravity-2-0
• Antigravity CLI repo: github.com/google-antigravity/antigravity-cli (53 stars, no license file at capture)
• Antigravity SDK repo: github.com/google-antigravity/antigravity-sdk-python (Apache 2.0, 82 stars)
• r/google_antigravity launch thread: reddit.com/r/google_antigravity/...introducing_antigravity_20
• r/singularity OS-demo thread (562 ups): reddit.com/r/singularity/...googles_antigravity_20_creates_an_operating
• Hacker News (Antigravity 2.0 launch story): news.ycombinator.com/item?id=48196838