Google released a substantial update to its AI development stack at I/O 2026 — the keynote demo walks through Google AI Studio for rapid prototyping and Antigravity 2.0 for taking the engineering to production. Here's what's actually new in each, and how you'd use it in a real project.
Quick orientation: AI Studio is the prototyping playground; Antigravity 2.0 is the ADE (agentic development environment). They're designed to hand off to each other, but each is useful on its own.
One caveat to anchor everything below: “vibe code to production” sounds clean in a demo, but the process in reality is much more than typing prompts and watching a working output appear. The new tooling closes part of the gap — and there's real value in what shipped — but a lot of what production engineering actually involves sits outside the IDE entirely. We'll cover what's genuinely useful first, then circle back to what the demo conveniently skips.
What's new in AI Studio
The “build a business” demo shows several features that have grown into real workflows.
Deep Research agents — market analysis on demand. Give it a market or product area, get back a synthesis of competitors, market size, and trends. How to use: before committing to a product direction, run a 5-minute Deep Research pass. It won't replace real customer interviews, but it'll save you a day of basic competitor scanning.
Agentic Focus Groups — synthetic user sentiment. Describe a product idea, get back simulated reactions from different user personas. How to use: good for pressure-testing copy, naming, and positioning. Don't trust it for behavior prediction (synthetic users have no skin in the game), but it's a fine way to spot obvious misfires before you ask real users.
Stitch for design — landing pages generated from prompts, integrated with the rest of the AI Studio flow. How to use: great for prototype-quality landing pages and design exploration. For production polish, still bring a designer — but the rough cut you'd normally ask a designer for can now happen in 5 minutes.
Workspace integration (Sheets, Docs) — your inventory dashboard, lookup table, or operations log can live in Sheets and feed an AI Studio app. How to use: perfect for the internal-tools gap. Operations tooling that used to require a custom dashboard now sits in a Sheet plus a small AI Studio app on top.
Marketing assets and ad campaigns — copy, images, ad variants from a single brief. How to use: skip the manual draft-and-revise cycle for early-stage marketing. Be honest about the quality bar — output is good enough for testing copy, not for shipping under a brand you've invested years in.
What's new in Antigravity 2.0
The big shifts are operational — the things that turn an agent demo into an agent in production.
One important heads-up before we dig in: the previous Antigravity IDE isn't the default 2.0 experience. Google sadly reorganized the product around an agent-first desktop app, an Antigravity CLI, and an Antigravity SDK. I use Antigravity IDE for everything so I had to restore the version and then install 2.0 IDE separately. If you want the original IDE workflow, it's still available — just as a separate download from antigravity.google/download. The shift reflects Google's bet that agent orchestration — not file editing — should be the primary interaction model. Whether that bet works for your team depends on how you actually develop.
Four surfaces, not just an IDE
Before getting into individual features, it's worth knowing that Antigravity 2.0 ships as a multi-surface platform, not a single app. The four ways to use it:
- Desktop app — agent-first GUI for individual developers. The default experience for most teams.
- Antigravity CLI — terminal-first access to the same agent capabilities. For devs who live in tmux or want to script agentic workflows.
- Antigravity SDK — programmatic access for embedding agent orchestration into your own tools or platform.
- Managed Agents in the Gemini API — hosted agent runtime accessible via API call. For teams that want the agent capabilities without operating the orchestration themselves. Includes a Gemini Enterprise Agent Platform tier for regulated workloads, where inference runs inside your secure cloud boundary.
Pick the surface that matches how you work. Most individual devs will start with the desktop app; power users and platform teams might prefer the CLI or SDK; enterprise buyers will care most about the Managed Agents / Enterprise tier.
Sub-agents — the main agent delegates specific tasks to specialized sub-agents in parallel. How to use: break long tasks into a planner + specialists. Example: “refactor this module” → main agent plans, sub-agents handle individual file changes in parallel. Faster than serial execution, less context conflation.
Asynchronous background tasks — long-running commands (installs, builds, test suites) don't block the foreground conversation. How to use: kick off the heavy stuff in the background while keeping the agent conversation moving. Anyone who's stared at a CLI during a pip install knows why this is overdue.
Hooks and artifacts — programmable observability surfaces. How to use: hooks for logic injection (e.g., log every tool call to your own observability stack); artifacts for visible inspection of what the agent did (code, text, structured output). Critical if you're running agents in environments where “what did the agent actually do” is a question that gets asked.
Projects and per-project permissions — multiple repositories grouped as one project, with fine-grained tool/permission scoping per project. How to use: don't give the agent global access; scope per project to the minimum required. The “AI agent with production write access” failure mode we wrote about in the Security card is exactly what this addresses.
Multi-model support — Antigravity 2.0 isn't Gemini-only. Out of the box it supports Gemini 3 Pro, Gemini 3.5 Flash (default), Anthropic's Claude Sonnet 4.5, and OpenAI's GPT-OSS. How to use: match model to task — Sonnet 4.5 for nuanced code review and architectural reasoning, Gemini 3.5 Flash for fast iterative editing, smaller models for narrow tasks. A flagship Google IDE shipping with Claude and OpenAI support out of the box is a strong “open platform” signal.
/goal and /browser — two new slash commands worth knowing.
/goal— declarative task framing. Describe what you want; the agent plans the steps. Use it when you want the agent to commit to the shape of the work before starting./browser— end-to-end browser testing inside the agent loop. Closes the gap where agents were blind to whether their changes actually worked in a real browser.
Plus: native voice command support (not just transcription — issue instructions by voice), scheduled autonomous tasks, and native integrations with AI Studio, Android, and Firebase.
A note on pricing. Google introduced a new AI Ultra tier at $100/month with 5× higher Antigravity limits than the Pro plan. The previous top-tier plan dropped from $250 to $200/month (20× Pro limits). For teams evaluating the tool seriously, pricing is now in a more reasonable place than the initial launch.
Putting it together
The interesting bit is the handoff. The demo frames it as: prototype the whole business in AI Studio (research, design, ops scaffolding, marketing), then move the production engineering into Antigravity 2.0.
In practice the handoff is rougher than the demo implies — AI Studio prototypes are not directly importable into Antigravity 2.0. You're still rebuilding the engineering portion deliberately. But the workflow Google is sketching is real: fast exploration in one tool, rigorous build in another.
What most demos don't cover
The demo walk-through is impressive, but the demo only shows the happy path — idea, design, code, mostly through a clean greenfield project. Real builders spend most of their time elsewhere:
- Local testing infrastructure — unit tests, integration tests, fixtures, mocks. The demo runs
/browserfor end-to-end checks, but a real test suite is much bigger than that. - Cloud services selection — AWS vs GCP vs Azure, plus the dozens of smaller services you stitch them together with. The agent picks a stack; you live with the cost and architectural implications for years.
- Deployment pipeline — moving code from local to production reliably. Blue/green, canary, rollback, zero-downtime migrations. None of this is in the demo.
- CI/CD — the actual pipeline that gates code from a branch into production. Test runs, security scans, deploy approvals, env promotion.
- Code quality — linting, formatting, type checking, dependency vulnerability scanning. Not glamorous, not in the demo, still essential.
- Observability — logs, metrics, traces, alerting. The demo shows artifacts for agent observability; application observability is its own world and the demo doesn't go there.
- Security review — secrets management, IAM scoping, dependency audits, SAST. AI-generated code doesn't get a pass on any of these.
- Code review — human eyes on PRs before merge. Antigravity 2.0 writes the code; you still need a workflow for someone to sign off.
- Documentation and onboarding — for the next engineer (or AI session) that has to read the code.
- Production incident response — runbooks, on-call rotation, alert routing. The day something breaks at 2am, none of this comes from the IDE.
This isn't a critique of the tools. AI Studio and Antigravity 2.0 are doing their job well in their layer. But “shipping a production app” is the union of all these things, and the demo covers maybe 30% of it on a generous read.
The pattern we keep seeing: teams that overestimate what the demo covers end up with great prototypes that nobody can deploy, monitor, or maintain. Don't fall into that. AI Studio and Antigravity 2.0 are tools in a larger toolchain, not a complete engineering organization.
This is, not coincidentally, the gap our 6-week MVP service covers. AI Studio and Antigravity 2.0 will get you to a working prototype; we handle the production layer — local testing, cloud architecture choices, CI/CD, deployment, observability, security review, the runbook. If you've vibe-coded something and need help taking it the rest of the way, the easiest next step is to book a 15-min intro call.
What to try first
If you're already using agentic coding tools (Claude Code in your terminal, Cursor as an IDE, or similar): try Antigravity 2.0's sub-agents and /browser first — both are genuine differentiators worth evaluating.
If you don't use agentic coding tools yet: Antigravity 2.0 is a reasonable starting point because the operational primitives are baked in. You skip a year of building scaffolding yourself.
For AI Studio: easiest entry is Deep Research on a product idea you've been kicking around. Five minutes, low commitment, see what shows up. Same for Stitch on a landing page — worst case it's a free design exploration; best case it's a usable prototype.
The real test: pick one feature, use it on a real project this week, decide whether to keep going. Most of these features earn their place; some won't fit your workflow. The only way to know is to try one.