This is a submission for the Google I/O Writing Challenge
Google I/O 2026 wrapped on May 20 at the Shoreline Amphitheater in Mountain View, and I've spent the last two days reading every blog post, watching every session replay almost but not all, and digging through the actual documentation. The headline everyone ran with was "Gemini Spark is your new 24/7 AI agent" and "Antigravity 2.0 built an operating system from scratch." Those are flashy. They make good tweets.
But something much more interesting happened at this I/O, something that actually changes how Android developers will write code starting after the keynote address, and most of the coverage missed it entirely. I want to talk about that. I also want to walk through Antigravity 2.0 in detail, because Google fundamentally rebuilt it, and the technical decisions they made reveal a lot about where developer tooling is heading. Finally, I want to look at the bigger picture of what Google announced and what it means for the people who actually have to ship apps.
There's a lot to cover. I'll try to keep it useful.
The big picture: Agents aren't a demo anymore
Before diving into the specific tools, let's establish what actually launched.
Gemini 3.5 Flash is the new default model powering most of this. It outperforms last year's Gemini 3.1 Pro on coding and agentic benchmarks: 76.2% on Terminal-Bench 2.1, 83.6% on MCP Atlas, 1656 Elo on GDPval-AA, and 84.2% on CharXiv Reasoning for multimodal understanding.That last number matters because it means the same model handles code and visual output, which is how agents can now render Compose previews and understand what they're looking at. It runs about four times faster than other frontier models, and the pricing is $1.50 per million input tokens and $9.00 per million output tokens, with cached input at $0.15 per million.
Gemini Spark is Google's 24/7 personal AI agent. It runs on Google Cloud infrastructure so it doesn't need your device to stay on. It connects to Gmail, Docs, Calendar, and can interact with the web through Chrome and third-party services.You feed it context (wedding plans, a research project, whatever) and it keeps working. It's exclusive to Google AI Pro and Ultra subscribers, rolling out in beta in the U.S. first.
Antigravity 2.0 graduated from an AI coding tool into a full agent orchestration platform. Standalone desktop app. No IDE. CLI. SDK. Multiple agents running in parallel. I'll break this down in detail below.
Android CLI 1.0 reached stable. This is the one I keep coming back to. More on this in a moment.
Android XR smart glasses made with Samsung. Gemini Omni for video generation. Native Android app building directly in Google AI Studio. A new intelligent Search box that generates custom UIs in real time. There's a lot.
I genuinely don't know how to feel about all of it. The technology is real. The demos are real. A personal agent that monitors your inbox and handles calendar gymnastics while you sleep? That's genuinely useful. An AI that can port an iOS app to native Android in hours instead of weeks? That solves a real problem for small teams. But there's something unsettling about agents churning through your email at 3am while nobody's watching, and I don't think that tension goes away just because the demos are impressive.
For developers specifically, the message was unmistakable: Google doesn't care which AI agent you use anymore. They shipped Android CLI 1.0, which gives Claude Code, OpenAI Codex, and Antigravity programmatic access to Android Studio's toolchain from the command line.That's a remarkable concession from a company that spent years building walled gardens. They looked at how developers actually work (switching between Claude Code, Codex, and Gemini depending on the task) and decided to make Android tooling available to all of them instead of forcing everyone into their own stack.
Pichai said the industry is in a period of "hyper progress" but also "where people want to see real value in the products they use on a day-to-day basis." That's the right thing to say. Whether the products deliver is a separate question.
Antigravity 2.0: What actually changed under the hood
Antigravity 2.0 is not an IDE update. Google ripped the agent manager out of the original Antigravity IDE and built it into a standalone desktop application available on macOS, Linux, and Windows.The IDE itself still exists as a separate product, but 2.0 is a completely different thing. It's a desktop app where the primary interaction model is conversation with an agent, not a code editor with AI features bolted on.
The interface is built around conversations and artifacts. You describe what you want. The agent works on it. You review the artifacts it produces (code, documents, screenshots, browser operation recordings) and provide feedback directly on those artifacts to guide toward your desired outcome.
This is a philosophical shift. In the old model, you wrote code and the AI helped. In the new model, the AI does the work and you supervise. Whether that feels like progress or like being demoted to code reviewer depends on your disposition. I'm still figuring out where I land.
Dynamic subagents
The most technically interesting feature in 2.0 is dynamic subagents. The main agent can define and invoke child agents during execution to handle focused subtasks.These subagents are spawned dynamically, run in parallel, and get destroyed when their work is done.
Why this matters: every LLM has a finite context window. If you ask an agent to build a complex system, the intermediate steps (reading files, making edits, running tests) fill up that window fast. The agent starts forgetting what it was doing, or starts making decisions based on stale context. Dynamic subagents solve this by isolating subtasks into separate context windows that don't pollute the main agent's working memory.
Google's launch demo used 93 parallel subagents to build a functional operating system from scratch. The primary agent acted like a CTO: it understood the system architecture, broke the goal into domains, and spawned specialized subagents (one for the kernel, one for memory management, one for the filesystem, one for video drivers, one for keyboard drivers). Those subagents worked independently and returned their results to the main agent for integration.
The numbers: 15,314 model requests, 339 million input tokens (with cache reads, output, and thinking tokens, that goes to over 2.6 billion), 12 hours of wall-clock time, and under $1,000 in API costs using Gemini 3.5 Flash.The OS could run FreeDoom, which is a real open-source Doom implementation.
The OS was not production quality. It had no floating-point math support, no hardware acceleration, no complex multi-threading, no sandboxing, no JIT compilation.But it was built from a single high-level prompt with zero human guidance. That's the part that sticks with me.
Asynchronous task management and scheduled tasks
Tasks in Antigravity 2.0 can run asynchronously. You can fire off a long-running task and continue having other conversations with the agent while it works in the background.The results eventually surface in the main conversation when the task completes.
Scheduled Tasks are cron-style invocations. You define a schedule and the agent triggers automatically at the specified time.The /schedule slash command lets you write things like "every morning at 9am, summarize my inbox" directly in natural language.This moves the agent from a tool you call to something closer to a persistent automation pipeline.
JSON hooks
Hooks let you intercept and control agent behavior at key execution points. You define them in a JSON configuration file. When the agent hits a trigger event, the hook fires and can allow, deny, or ask the user before proceeding.The hooks system supports deny, allow, ask_user, and enforce rules per tool, which gives you fine-grained control over what the agent can and cannot do without reading the underlying code.
Projects, not repositories
In Antigravity 1.0, agent conversations were grouped by workspace, which meant one repository. In 2.0, they're grouped by "project," which can span multiple folders and enforce its own agent settings and permissions.This matters for real-world development where a single product often spans multiple repositories or codebases.
Slash commands
The four new slash commands are worth knowing:
/goal tells the agent to keep running until the specified task is completely finished, no intermediate input from you.This is for fire-and-forget work where you trust the agent enough to not need check-ins.
/grill-me flips the interaction: before starting to implement, the agent asks you clarifying questions to align on the specific details of the plan.I've found this genuinely useful for avoiding the "agent confidently builds the wrong thing" problem.
/schedule creates a one-time timer or recurring schedule for agent invocation.
/browser explicitly tells the agent to use browser primitives. Google found that agents were still not capable enough to determine on their own when to use the browser, so they made it an explicit command for now.
Voice input
The mic icon next to text input boxes now does live transcription instead of collecting raw audio files to pass to the model.It's a small feature, but it changes the interaction dynamic. You can think out loud while the agent works, which feels more natural than typing everything.
The SDK
The Antigravity SDK gives you programmatic access to the same agent harness that powers Antigravity 2.0 and the Antigravity CLI. Your agent inherits a rich built-in toolset, a declarative safety-policy engine, lifecycle hooks for observing and steering every tool call, and stateful multi-turn sessions that persist across interactions.You can define custom agent behaviors and host them on your own infrastructure.
The SDK supports MCP integration for connecting to external Model Context Protocol servers, and the policy system lets you define permission rules at the tool level.
Pricing and availability
Antigravity 2.0 is free for all users. The new Google AI Ultra plan starts at $100/month with a 5x higher usage limit than the Pro plan, and there's a limited-time $100 bonus credit for new and existing subscribers who hit their quota limit.The top-tier Ultra plan was cut from $250 to $200/month (20x the Pro limit).
Gemini Spark is gated behind Pro and Ultra subscriptions. Android CLI 1.0 requires Android Studio Quail 2 Canary 1 or later for the android studio commands.
Android CLI 1.0: The announcement that actually changes things
Everyone's talking about Antigravity 2.0 building an operating system. That's a great demo. But the announcement that actually matters for working Android developers is Android CLI 1.0 reaching stable. Here's why.
For years, if you wanted to build Android apps with an AI coding agent, you had two options. Option one: use Google's tools (Android Studio with Gemini). Option two: struggle. Third-party agents like Claude Code couldn't access Android Studio's static analysis engine, its refactoring tools, its Compose preview renderer, or its dependency management. They were flying blind. They generated code without being able to verify it against the actual Android toolchain.
Android CLI 1.0 fixes that. Through a new android studio command group, any AI agent can now perform semantic symbol resolution, analyze files for warnings, render Jetpack Compose previews, and execute end-to-end UI tests, all from the terminal without opening the IDE.
Google is positioning this explicitly as supporting whatever agent you want to use: Gemini in Android Studio, Antigravity, Claude Code, or Codex.That is a real shift in strategy.
The android studio command
The April preview release of Android CLI gave agents a clean binary for scaffolding projects, managing emulators, and running apps. Useful, but nothing that forced a workflow change. The stable 1.0 release adds the 'android studio' command group, which is the part that actually matters.
Here's what agents can now do from the terminal:
android studio find-declaration performs semantic symbol resolution. Your agent can ask "where is HotelDetailScreen defined?" and get the actual answer, not a text-match guess.
android studio find-usages finds every reference to a symbol across the entire project.
android studio render-compose-preview renders a Jetpack Compose preview to an image file from the terminal.This is the one that changes things. Your agent can literally see what your Composable looks like before suggesting changes, instead of pattern-matching on text and hoping the layout looks right.
android studio analyze-file runs Android Studio's full static analysis engine on a file: lint warnings, R8 hints, deprecation alerts.
android studio version-lookup queries live repository data and returns the actual latest stable version of a dependency.This is quietly excellent because agents guessing at Compose or AGP versions and hallucinating dependency coordinates is a common failure mode. version-lookup eliminates that entire class of error.
These commands require Android Studio Quail 2 Canary 1 or later to be running alongside the CLI. If you're on the stable Android Studio channel, the android studio commands do nothing.
Why the token numbers are real
Google's internal experiments showed that Android CLI reduced LLM token usage by over 70% for project setup tasks, with agents completing work up to 3x faster.These numbers are not vague marketing.
The reduction comes from how Android CLI structures its output. Traditional agent workflows dump full text logs, entire file contents, and verbose SDK manager output at the model. Android CLI returns structured JSON and supports a --diff mode that sends only the elements that changed since the last snapshot.
Here's a concrete example: android layout --diff. Instead of re-processing the entire UI hierarchy on every iteration, the agent sees only what changed. On a complex screen with dozens of composables, that's the difference between 8,000 tokens and 400.Multiplied across a development session, the savings compound quickly and translate directly into lower API costs.
Agent Skills
Android CLI ships with a skills system: modular markdown instruction sets that auto-trigger when a prompt matches their metadata. No manual context-stuffing, no copying documentation into system prompts.
The stable release adds five skills not present in the preview: build for display glasses (Jetpack Compose Glimmer for Android XR glasses), implement AppFunctions (expose app workflows to Android's AI agent layer), analyze Perfetto traces (root cause latency, memory, and jank issues), use Perfetto SQL (natural language to Perfetto SQL query translation), and set up testing strategy (unit, UI, and screenshot test scaffolding).
There are 16 skills total available. The full library lives at github.com/android/skills and follows the agentskills.io open standard, which means community-contributed skills work in the same pipeline. Third-party repositories for Compose performance optimizations and Jetpack-specific workflows already exist.
Adding a skill for Claude Code is one command:
android skills add --agent=claude-code --skill=migrate-xml-views-to-jetpack-compose
The skills cover XML-to-Compose migration, AGP 9 upgrade, Navigation 3 setup, edge-to-edge display modernization, and R8 configuration auditing, among others.
Journeys: agent-driven UI testing
Stable 1.0 also ships Journeys support, which lets agents execute natural language user experience tests.Instead of writing Espresso test code, you describe a user flow in plain English and the agent navigates through it, reporting what it finds.
Installation
Android CLI is free. Installation varies by platform:
# macOS
brew install android-cli
# Linux and Windows
# Follow the setup guide at:
# https://developer.android.com/tools/agents/android-cli
If you already have it installed from the preview, update with android update.
Once installed, creating a new project and verifying it works:
android --version
android create project --name MyApp --package com.example.myapp
For Antigravity 2.0 users, the Android bundle (including Android CLI and skills) can be installed during onboarding or later from Settings > Customizations > Build With Google Plugins.
Getting started: what to try first
If you want to cut through the noise and try something that'll actually make a difference this week, here's my recommendation.
Option A: Install Android CLI and pair it with your existing agent.
This is the low-friction path. If you already use Claude Code or Codex, add Android CLI and watch your agent suddenly get smarter about Android development. The difference is immediate. Agents stop hallucinating Compose APIs. They stop guessing at dependency versions. They can actually check their own work.
After installing, try asking your agent to scaffold a new project, render a Compose preview, and check for warnings, all in one flow. That workflow used to require switching between terminal, IDE, and manual inspection. Now it's programmatic.
Option B: Download Antigravity 2.0 and try the /grill-me workflow.
Go to antigravity.google/download and grab the installer for your platform. Start a new project. Don't try to build an operating system. Ask it something concrete: "create a Jetpack Compose screen with a list of items, pull-to-refresh, and a detail view using Navigation 3." Then use /grill-me to force the agent to ask clarifying questions before it starts coding. Review the artifacts it produces. Get a feel for the interaction model.
The voice transcription button (the mic icon) is surprisingly useful. Talking through what you want while watching the agent work feels more natural than typing prompts, and you catch things you'd miss in text.
8Option C: Both.*
Install Android CLI for your agent of choice. Download Antigravity 2.0. Spend an afternoon with both. They address different needs: Android CLI is infrastructure that makes any agent better at Android, while Antigravity 2.0 is an opinionated platform that wants to be your primary interface to agents. You might end up using both.
What to expect
Antigravity 2.0 feels different from traditional coding. You're not writing code line by line with AI autocomplete. You're describing goals and reviewing what comes back. It takes adjustment. I found myself over-specifying things at first (old habits), then gradually learning how much detail the agent actually needs. The /grill-me command helps with that by forcing the agent to ask questions instead of charging ahead with assumptions.
Android CLI is more straightforward. It's a bridge. If you already use Claude Code or Codex for non-Android work, adding Android CLI means those same agents can suddenly speak Android Studio's language. The productivity gains come from fewer context switches and fewer hallucinated APIs. There's no learning curve; the agent just gets better at its job.
What I actually think
Here's what gets me about this I/O.
The demos are spectacular. An operating system built from a single prompt. Agents that never sleep. Video generated from any input. These are genuinely impressive technical achievements, and I'm not going to pretend otherwise.
But spectacular demos have a short half-life. What lasts is whether the tools actually make developers' lives easier three months from now, when the keynote glow has faded and you're debugging a Compose layout at 11pm and wondering why your agent suggested a deprecated API from three versions ago.
Android CLI 1.0 will make developers' lives easier. I'm confident about that one. It's boring infrastructure, but boring infrastructure is what lets the exciting stuff actually ship. The 70% token reduction isn't marketing. The --diff mode on layout inspection isn't marketing. The version-lookup command that eliminates dependency hallucination isn't marketing. These are concrete improvements to the development workflow that compound across hours and days of work.
Antigravity 2.0 is harder to evaluate. The subagent architecture is smart. The 93-subagent OS demo proves the orchestration layer works at scale. The scheduled tasks and JSON hooks are genuinely useful primitives. But the interaction model (describe a goal, wait for artifacts, review, repeat) is still unproven for day-to-day development work. Some developers will love it. Some will find it slower than just writing the code themselves. The truth is probably somewhere boring in the middle.
The agents? I'm still figuring out where I land. The technology is real. The demos are real. But there's a gap between "look what it can do" and "look what it does reliably in production," and that gap is where most developer skepticism lives. Google seems to know this. The Android CLI release, the openness to third-party agents, the emphasis on guardrails (JSON hooks, per-project permissions, /grill-me for alignment) are all signs they understand that adoption depends on trust, not just capability.
What I keep coming back to is the openness. Google spent years building walled gardens around Android development. Android Studio was the center of gravity and everything else orbited it. Android CLI 1.0 is the opposite: it makes Android Studio's capabilities available to whatever agent you prefer, from Claude Code to Codex to your own custom setup. That's not a concession born of weakness. It's a strategic bet that if you make Android the easiest platform to develop for with any AI tool, more developers will build for Android regardless of which agent they use. It's smart, and it's more developer-friendly than anything Google has done with Android tooling in years.
Go install Android CLI and see if your agent of choice gets smarter about Android. That's a bet I'm comfortable making today. Antigravity 2.0 is worth trying too, especially if you're curious about what agent-first development actually feels like in practice.
We'll see how it plays out. The tools are free. The documentation is live. The rest is up to us.
Note: The above cover image generated by AI
Top comments (0)