Google Launches Antigravity Harness to Run Autonomous Coding Agents
Google for Developers
Alphabet is shifting its engineering stack from passive conversational assistants to autonomous agents that independently write code, fine-tune models, and deploy software across mobile and web platforms.
Google transitioned its core developer strategy from conversational AI to autonomous agentic workflows, anchoring development across Android, Chrome, and the cloud within the unified Antigravity platform. (0:00)
Managed Agents in the Gemini API and AI Studio reached general availability, providing developers with zero-configuration autonomous agents paired with Google-hosted remote Linux sandboxes. (2:18)
Google previewed early experimental Android Studio tooling, including the Migration Assistant with natural-language Journeys for translating iOS codebases into native Jetpack Compose architectures in hours. (37:02)
Chrome is entering the agentic web era with the proposed WebMCP standard entering Origin Trial in Chrome 149 and the introduction of Chrome DevTools for agents to close runtime feedback loops. (47:18)
Detailed notes
## Background
Published by Google for Developers on YouTube on May 19, 2026, this keynote video covers the latest platform and product updates showcased at Google I/O 2026. The session highlights developer-centric advancements spanning agent development, Antigravity, native Android workflows, and modern web capabilities in Chrome.
## TL;DR
The keynote outlines Google's strategic shift toward autonomous, goal-oriented agent systems anchored by the Antigravity development platform and Gemini-powered toolchains. Presenters detail how developers can build and ship agents through AI Studio, Cloud Run, and the Antigravity SDK, as well as execute remote fine-tuning of Gemma 4 models directly from the command line. The presentation also showcases native Android enhancements—including an automated Migration Assistant, App Links tooling, and on-device Gemini Nano execution—alongside transformative browser capabilities such as WebMCP, agentic DevTools audits, and HTML in Canvas in Google Chrome.
## Atmosphere & style
The presentation carries an energetic, forward-looking tech keynote atmosphere, marked by applause, swift pacing, and slick live demonstrations across cloud sandboxes and mobile emulators. Co-presenters maintain a collaborative and enthusiastic banter—punctuated with dry humor about CI/CD verbosity and product management habits—while smoothly trading off complex on-stage tasks like fine-tuning open models and rendering WebGL interfaces. The arc moves from high-level strategic announcements to increasingly granular, tangible workflows, evoking a sense of genuine excitement about reducing developer friction through autonomous agents.
## Bulletin
- [00:00](https://www.youtube.com/watch?v=aqmpZocmR8o&t=0s) Google transitioned its core developer strategy from conversational AI to autonomous agentic workflows, anchoring development across Android, Chrome, and the cloud within the unified Antigravity platform.
- [02:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=138s) Managed Agents in the Gemini API and AI Studio reached general availability, providing developers with zero-configuration autonomous agents paired with Google-hosted remote Linux sandboxes.
- [37:02](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2222s) Google previewed early experimental Android Studio tooling, including the Migration Assistant with natural-language Journeys for translating iOS codebases into native Jetpack Compose architectures in hours.
- [47:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2838s) Chrome is entering the agentic web era with the proposed WebMCP standard entering Origin Trial in Chrome 149 and the introduction of Chrome DevTools for agents to close runtime feedback loops.
## Key takeaways
- [00:00](https://www.youtube.com/watch?v=aqmpZocmR8o&t=0s) Gemma 4 was released under an Apache 2.0 license, recording over 100 million downloads in its debut month for offline mobile, robotics, and edge deployment.
- [02:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=138s) The Interactions API and Managed Agents in the Gemini API automate infrastructure by packaging agent instructions, tools, and remote Linux sandboxes into a single call.
- [07:41](https://www.youtube.com/watch?v=aqmpZocmR8o&t=461s) AI Studio enables rapid deployment from prompts directly to Google Cloud Run URLs without requiring setup or credit cards.
- [12:16](https://www.youtube.com/watch?v=aqmpZocmR8o&t=736s) AI Studio introduced browser-based native Android app compilation and previewing, alongside direct-to-device installation and Google Play internal test track publishing.
- [14:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=896s) Google Antigravity 2.0 serves as an agent-first mission control desktop client capable of orchestrating parallel subagents and cron-based scheduled routines.
- [16:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1016s) Antigravity 2.0's native speech understanding supports direct voice prompting to generate LoRA fine-tuning code and evaluation scripts for open models like Gemma 4.
- [19:13](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1153s) The Antigravity CLI brings the unified agent harness to headless terminal environments, introducing the `/btw` command to fork quick side queries without polluting the primary context.
- [26:08](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1568s) Antigravity incorporates an embedded Android CLI, official Android Skills, and a curated Knowledge Base, reducing token usage by roughly 70% and accelerating task completion up to 3x.
- [30:43](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1843s) Mobile architectures can implement hybrid fallback patterns using Firebase AI logic to prioritize on-device Gemini Nano execution and fall back to cloud inference when offline acceleration is unavailable.
- [33:14](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1994s) Android Studio's automated R8 Analyzer Skill audits keep rules and activates R8 full mode to optimize bytecode and prune dead code via a single natural-language instruction.
- [44:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2696s) Modern Web Guidance arms coding agents with Baseline-aligned, token-efficient skill files, boosting benchmark web development pass rates by an average of 37 percentage points.
- [47:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2838s) The proposed WebMCP standard exposes structured JavaScript application hooks directly to browser agents like Gemini in Chrome for deterministic web interactions.
- [50:52](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3052s) Chrome DevTools for agents uses MCP and CLI integrations to provide autonomous feedback loops, including specialized Lighthouse audits for WebMCP, `llms.txt`, and ARIA accessibility trees.
- [53:44](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3224s) The HTML in Canvas API launched in Origin Trial, allowing real, accessible, and styleable DOM elements to be rendered directly inside interactive 3D WebGL scenes.
- [55:40](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3340s) Google launched the $2 million Build with Gemini XPRIZE hackathon and provided Google AI Ultra subscribers with $100 in bonus Antigravity credits.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=aqmpZocmR8o&t=0s) Google's Agentic Shift and the Antigravity Platform
Josh Woodward welcomes developers back to Google I/O, remarking on the staggering rate of progress achieved in just a single year. After highlighting the morning’s key model announcements—including the new Gemini Omni model and the Gemini 3.5 series—he focuses on open source milestones, noting that Gemma 4 was released the previous month under an Apache 2.0 license. Gemma 4 is purpose-built for advanced reasoning and agentic workflows, packing enough intelligence into an efficient footprint that it can run entirely offline on mobile phones, power terrestrial robots, and operate on satellites in outer space. The developer reception has been massive, logging 100 million downloads in its debut month alone and pushing lifetime Gemma family downloads beyond 500 million.
```mermaid
flowchart TD
accTitle: Google End-to-End Agentic Stack
accDescr: Diagram showing the layers connecting models, the Antigravity agent harness, target platforms, and cloud infrastructure.
subgraph Foundation["Models & Frameworks"]
A["Gemini 3.5 & Omni Models"]
B["Gemma 4 (Apache 2.0)"]
end
subgraph CoreAgent["Agent Layer"]
C["Google Antigravity Platform"]
D["Interactions API & Managed Agents"]
end
subgraph Execution["Target Surfaces & Hosting"]
E["Android & Web Platforms"]
F["Isolated Cloud Run Sandboxes"]
end
Foundation --> CoreAgent
CoreAgent --> Execution
```
Woodward outlines Google's overarching strategic transition from conversational assistants to goal-driven autonomous systems: “And as you saw this morning, the big shift is our move towards agents, from AI that simply assists you to agents that help you get stuff done, under your direction and faster.” At the core of this strategy sits Google Antigravity, an agentic development platform designed to enable developers to construct, deploy, and scale agents across Google's infrastructure, self-hosted environments, Android devices, and the web. Woodward emphasizes that Google is engineering solutions up and down the full vertical stack—from foundational frontier models to runtime tooling and user-facing surfaces.
- **Gemma 4:** Released under Apache 2.0; surpassed 100 million downloads in month one, bringing cumulative family downloads over 500 million.
- **Antigravity Platform:** Positioned as the unified agent harness linking model reasoning directly to production tool execution.
---
[02:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=138s) Managed Agents in the Gemini API and AI Studio
Logan Kilpatrick takes the stage to reveal how Google is democratizing autonomous workflows for external developers. Recalling the introduction of the Interactions API the previous December—which first powered the autonomous Deep Research agent—Kilpatrick announces that the internal Antigravity harness powering tools like Gemini Spark and AI Studio's coding agent is now exposed publicly via Managed Agents in the Gemini API. Rather than requiring developers to orchestrate intricate scaffolding, a single API call supplies custom system instructions, tool definitions, contextual data, and a fully managed runtime environment.
Kilpatrick explains that running agents in production typically forces teams into an operational bottleneck around sandbox security: “And solving that on your own is an infrastructure nightmare. That's why every managed agent comes paired with a remote Linux environment hosted by Google.” By combining execution sandboxes and models into a single API abstraction, early adopters are shipping sophisticated workflows. For example, Google Labs' design tool Stitch utilizes managed agents to ingest a developer's GitHub repository, inspect code architectures, and output a bespoke `design.md` file representing their design system. External enterprise partners including Ramp, Resemble AI, and Klipy have similarly integrated managed agents into their production stacks.
Kilpatrick switches to a live demo within the AI Studio playground, showing prebuilt open-source agent templates configured entirely through structured markdown files containing goals, skills, and tools. Initiating an AI Talk Radio agent, Kilpatrick requests a five-minute audio radio show summarizing the day's top discussions on Hacker News. Behind the scenes, the agent spins up a remote Linux sandbox and executes an autonomous pipeline defined inside an `AGENTS.md` file:
```mermaid
flowchart LR
accTitle: AI Talk Radio Generation Pipeline
accDescr: Pipeline of the autonomous AI Talk Radio agent executing tasks inside an isolated Linux sandbox.
A["Hacker News Research"] --> B["Script Writing"]
B --> C["Multi-Speaker TTS"]
C --> D["Lyria Music Generation"]
D --> E["Audio Mixing"]
E --> F["Nano Banana Cover Art & MP3"]
```
Reflecting on how declarative markdown instructions replace thousands of lines of fragile procedural logic, Kilpatrick quips: “Honestly, it feels like the hottest new programming language is Markdown, and I'm here for it.”
- **Interactions API & Managed Agents:** General availability launched today; supplies autonomous execution within Google-hosted Linux sandboxes in a single API call.
- **`AGENTS.md` Pipeline:** Leverages Hacker News scraping for topic research, Lyria for dynamic background music scoring, multi-voice TTS, and Nano Banana for cover art production.
- **Ecosystem Partners:** Early access production testing completed with Ramp, Resemble AI, Klipy, and internal Google Labs teams like Stitch.
---
[07:41](https://www.youtube.com/watch?v=aqmpZocmR8o&t=461s) Paige Bailey on Rapid Cloud Run Deployment and Cloud-Backed Android Builds
Paige Bailey steps on stage to demonstrate taking the AI Talk Radio agent from a playground prototype to a production deployment. Calling Google AI Studio “the fastest path from prompt to app,” she showcases a full-featured web client built around the agent via minimal prompting. The application leverages the agent's real-time outputs to drive rich interface elements: an interactive audio player, dynamic speaker avatars, and hyperlinked transcripts that let users scrub directly through dialog markers based on the agent's generated metadata. Playing back the generated audio, the synthetic hosts debate modern developer culture, posing the question: “If you can go from writing 200 lines of code a day to 2,000 with an AI agent, are you actually a better engineer, or are you just vibing?”
Bailey showcases the one-click deployment pipeline from Google AI Studio directly into Google Cloud Run. Developers can link existing Google Cloud projects or have AI Studio provision a project dynamically. She unveils a major platform update: starting immediately, new developers can deploy containerized applications to live, public Cloud Run URLs instantly with zero setup and no credit card required.
Beyond container hosting, Bailey highlights several major expansions to the AI Studio Antigravity coding agent stack:
- **Firebase & Firestore Support:** Native integration allows autonomous agents to scaffold persistent databases, backend rules, and OAuth authentication flows.
- **Google Workspace Connectivity:** Direct agent integration with Gmail, Google Docs, and Google Calendar via prompting without leaving the environment.
- **Search & Generative Assets:** Integrated web searching alongside on-the-fly multimodal generation using Nano Banana.
Transitioning from web endpoints to native mobile environments, Bailey tackles mobile development friction: “So starting today, you can go from an idea to an Android app directly in AI Studio. No software to install, no SDKs to manage, and no local environment needed.” By selecting "Build an Android App" and feeding in the same natural-language prompts used for the web radio project, AI Studio scaffolds, compiles, and runs an idiomatic, native Android application written entirely in Kotlin in the cloud.
[12:16](https://www.youtube.com/watch?v=aqmpZocmR8o&t=736s) Streamlining App Deployment and Introducing the Antigravity SDK
Developers can preview their applications using an integrated Android Emulator directly inside Google AI Studio. When moving from emulation to physical hardware, developers simply plug in their phone to install and run the build locally. In addition, Google AI Studio is adding native support for Google Play Store publishing. By opening the Publish menu and connecting an existing Play Developer Account, developers can push an application directly to an internal test track within minutes—installing it onto physical devices without ever navigating away from the AI Studio environment. Device testing is available immediately, with broader sharing to trusted tester tracks scheduled to roll out later in the summer.
Recognizing that development does not happen solely at an office desk, Google announced a brand-new AI Studio mobile application that brings the full build experience to smartphones, rolling out in a few weeks with pre-registration opening immediately. While managed agents inside AI Studio provide substantial power without configuration overhead, developers and researchers needing programmatic control can turn to the new Antigravity SDK. The SDK provides the identical Gemini-optimized agent harness while granting full flexibility over how and where code executes. To solve the traditional friction of switching from rapid cloud prototyping to local development, AI Studio introduces a one-click export to Antigravity that ports the complete file system and execution context rather than isolated code snippets.
- Direct previewing via an in-browser Android Emulator in Google AI Studio.
- One-click publishing pipeline from AI Studio directly to Google Play Store test tracks.
- AI Studio mobile app scheduled to release within weeks, with pre-registration active.
- Launch of the Antigravity SDK for custom, programmatic deployment of Gemini agent harnesses.
- One-click context-preserving export from Google AI Studio directly into Antigravity.
[14:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=896s) Google Antigravity 2.0: Dynamic Subagents and Scheduled Automations
Anshul Ramachandran introduced Google Antigravity 2.0, framing it as an agent-first desktop application designed not just to help users write agents, but to fundamentally alter how software is built with them. “We aren't just making it easier to build agents; we're making it easier to build with agents,” Ramachandran emphasized. Antigravity 2.0 acts as a mission control center capable of orchestrating multiple autonomous agents running concurrently across distinct projects and Git worktrees without merge collisions—allowing one agent to write front-end code, another to generate design assets, and a third to architect project infrastructure simultaneously alongside any preferred IDE.
To prevent complex development tasks from overwhelming a single agent context, Antigravity 2.0 introduces dynamic subagents. Agents can now automatically spin up specialized assistants—such as dedicated QA reviewers or data science analysts—working in parallel to divide and conquer large initiatives. To support unattended routines, Antigravity 2.0 adds Scheduled Tasks using standard cron syntax, placing agents on proactive autopilot to execute recurring operations like morning pull request summaries or hourly cloud health diagnostics.
[16:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1016s) Fine-Tuning Gemma 4 via Voice Prompting
Kevin Hou joined Anshul Ramachandran to demonstrate Antigravity 2.0 using a real-world machine learning workflow: fine-tuning Google's Gemma 4 open model to eliminate verbosity when generating CI/CD bash commands. Hou highlighted that while LLMs excel conversationally, using them inside automated build pipelines often fails because models wrap remediation commands in conversational explanations, multiple code blocks, and markdown text when a clean, single-line command is needed. “Democratizing AI means allowing anyone to take open models, like Gemma 4, and fine tune them,” Hou stated. “Historically, that meant complex pipeline wrangling by ML engineers. Not anymore.”
```mermaid
flowchart LR
accTitle: Gemma 4 Fine-Tuning Pipeline
accDescr: Step-by-step workflow of generating training code via Antigravity 2.0 voice commands to remote execution in Antigravity CLI.
A["Voice Input (LoRA Fine-Tune Prompt)"] --> B["Antigravity 2.0 Generates Plan & Code"]
B --> C["Git Commit to Main"]
C --> D["Remote GPU VM (SSH)"]
D --> E["Antigravity CLI Starts Training Job"]
```
Rather than typing out the configuration, Hou leveraged the platform's native audio understanding model to dictate the instructions. The speech system cleanly transcribed machine learning terminology like "LoRA" without error:
> "OK, so I want to fine tune Gemma 4 to directly give me a Bash command response with no additional fluff, so that I can use the response directly in my CI pipeline. I have a data set of prompt to Bash commands. Write the training and eval code for doing a LoRA fine tuning over this data set, as well as the code to deploy my custom Gemma 4 model on my laptop."
The Antigravity agent processed the vocal request, researched the dependencies, generated a complete implementation plan, and authored both the training and local evaluation code, which Hou approved and committed directly to his repository.
[19:13](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1153s) Remote Training Execution with the Antigravity CLI and `/btw` Branching
While Antigravity 2.0 provides a rich visual desktop interface, Ramachandran announced the Antigravity CLI, extending the identical agent harness, tools, and models straight to the terminal for developers who work primarily over SSH or inside headless environments. The CLI respects individual developer setups, incorporating custom keybindings, terminal color themes, and shell configurations. Connecting to a remote GPU-enabled cloud virtual machine via SSH, Hou pulled the newly generated code from the repository and initiated the LoRA fine-tuning run through the CLI without opening a graphical window.
“In minutes, we used Antigravity to go from no code to fine tuning Gemma 4 on our own custom use case,” Hou noted while the job was processing. “And if all that seems a little bit too simple, that is the point.”
While monitoring the background process, Hou demonstrated the new `/btw` command. This feature allows a developer to fork an active terminal conversation temporarily without losing the primary execution state or polluting the main context window. Hou invoked `/btw` to query Gemini for an on-the-spot joke:
> "Why did the neural network refuse to run on the TPU? Because it heard the TPU was always a bit too tensor."
Ramachandran jokingly rated the punchline "a 5 out of 10" and quipped that they would follow up with the Gemini team on its humor. Switching back to the primary process thread, the agent analyzed the raw output logs, verifying that the training run had completed 1%, the gradient norm was stable, and the training loss was trending downward. To demonstrate the end result without waiting for the full job to finish, Hou retrieved a completed model checkpoint from an identical run initiated earlier, switching back into Antigravity 2.0 to instruct the desktop agent to spin up a local playground running the newly fine-tuned, zero-fluff Gemma 4 model on his laptop.
[23:07](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1387s) Fine-Tuning Gemma on Stage and Unifying the Antigravity CLI
Wrapping up the live demonstration, Kevin Hou points out the running server logs, noting that the client has started and the fine-tuned model is live. Clicking over to the playground to issue the exact same prompt demonstrated earlier reveals a dramatic difference: the model now outputs pure, clean command syntax without any conversational filler or "fluff." Kevin highlights the milestone: “So we just fine tuned Gemma 4 on stage, which is pretty remarkable. And this really is the new reality of building—your workflows across surfaces you already use.”
```mermaid
flowchart LR
accTitle: Unified Agent Development Architecture
accDescr: Flow diagram showing how developer surfaces and skill bundles feed into the Antigravity CLI harness and connect to backend targets.
subgraph Input ["Developer Inputs"]
CLI["Antigravity CLI"]
Skills["Skills & Domain Bundles\n(Science, Android)"]
end
subgraph Core ["Agent Harness"]
Harness["Antigravity 2.0 Core"]
end
subgraph Ecosystem ["Target Surfaces"]
Google["One-Click Setup\n(Android, Firebase, Web)"]
Cloud["Google Cloud / Enterprise"]
end
CLI --> Harness
Skills --> Harness
Harness --> Google
Harness --> Cloud
```
Taking over, Anshul Ramachandran outlines Google's broader strategy of unifying all agent-first tooling under Antigravity. Insights gathered from Gemini CLI usage have been directly incorporated into the Antigravity CLI, which is now generally available to all Gemini CLI users alongside published migration guides to transition custom skills. Anshul emphasizes that developers receive the exact same harness powering Antigravity 2.0, creating a consistent agentic development loop regardless of the development surface.
- Antigravity is built completely stack-agnostic with zero vendor lock-in, yet includes one-click setup integrations for Android, Firebase, and web development.
- A new Science Skill bundle launches today, providing specialized agent primitives for health, biology, and scientific research.
- Enterprise integration allows Antigravity to connect directly into Google Cloud projects under standard enterprise terms, with rollouts planned for existing Gemini Enterprise customers in the coming months.
[26:08](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1568s) Bringing Antigravity to Native Android and Display Glasses
Anshul welcomes Florina Muntenescu and Adarsh Fernando to demonstrate modern agentic workflows for native Android. Florina explains that following native support in AI Studio, official Android support is arriving in Antigravity to streamline the creation of high-quality Kotlin apps across emerging form factors. To demonstrate, Adarsh introduces a sample travel application capable of aggregating itineraries and transcribing audio diary entries locally via Gemini Nano 4. Joking about the tight keynote schedule, Adarsh quips that they will rely on their newest capability—"time travel"—to jump straight to completed agent builds.
Their first challenge is building an augmented reality experience for display glasses so travelers with their hands full at an airport can view flight info at a glance. Setting up Android toolchains without an IDE is traditionally tedious, but Antigravity now embeds a stable Android CLI that lets agents autonomously download SDKs, initialize projects, and run builds on target hardware. Because display glasses represent an emerging hardware category where general-purpose LLMs lack training data, Google provides two critical assets:
1. **Android Knowledge Base:** A specialized, curated data repository enabling agents to fetch and read Google's latest official developer guidance.
2. **Open-Source Android Skills:** Ready-made best-practice modules for complex architectural workflows, such as implementing edge-to-edge layouts or migrating codebases from XML to Jetpack Compose and Jetpack Navigation 3.
Adarsh reports impressive developer efficiency numbers from their trials: “We saw in our internal testing agents leveraging Android CLI, Skills, and Knowledge Base use about 70% fewer tokens and complete tasks up to three times faster.” Skipping ahead, the agent successfully applies the Jetpack Compose Glimmer skill (part of the Android XR SDK), consults Android Studio for correct dependency versions, checks modified files for errors, and deploys the running UI directly to an emulator.
[30:43](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1843s) Hybrid AI Summaries, Android Studio Interop, and Device Streaming
Florina pushes the agent further by requesting an on-device AI trip summary alongside automatic before-and-after visual screenshots. Examining the agent's work, Adarsh discovers it configured a resilient hybrid architecture using Firebase AI logic—prioritizing on-device execution and only falling back to cloud-hosted models when local hardware acceleration is unavailable. To verify execution, the agent leveraged the Android CLI to spin up the app on an emulator, navigate the interface, and capture before-and-after UI screenshots without human intervention.
```mermaid
flowchart TD
accTitle: Hybrid AI Fallback and Device Verification Flow
accDescr: Diagram illustrating how the app chooses between on-device Gemini Nano and cloud models, followed by verification in Android Studio and Device Streaming.
A["User Travel Request"] --> B{"On-Device Model Available?"}
B -->|"Yes"| C["Gemini Nano (Offline)"]
B -->|"No"| D["Cloud Model Fallback\n(Firebase AI Logic)"]
C --> E["Android CLI / Emulator\n(Auto-Capture Screenshots)"]
D --> E
E --> F["Android Studio Preview\n(Compose Previews & AI Actions)"]
F --> G["Android Device Streaming\n(Samsung Galaxy S26 Ultra in Airplane Mode)"]
```
While Antigravity orchestrates the heavy lifting, Florina underscores that the ultimate developer setup pairs Antigravity directly with Android Studio for production-grade polish. Adarsh prompts the agent to open the relevant Jetpack Compose previews inside Android Studio, allowing them to inspect multi-theme rendering, dark mode, and various screen sizes.
To validate offline readiness on physical hardware, Adarsh turns to Android Device Streaming, connecting to a physical Samsung Galaxy S26 Ultra (slated to arrive on Device Streaming later in the summer). By switching the remote flagship into airplane mode, they confirm that the Gemini Nano summary operates entirely offline without an active internet connection.
[33:14](https://www.youtube.com/watch?v=aqmpZocmR8o&t=1994s) Automated Performance Optimization with R8 and Android 17 Prep
Moving from UI design to runtime health, Florina opens the App Quality Insights window in Android Studio, pointing out production crash spikes and the necessity of preparing for upcoming Android 17 memory limit changes. She issues a single natural-language directive: “OK, Gemini, fix and analyze my app's optimization and performance.” Florina explains that optimizing performance fundamentally relies on R8 to prune dead code, strip unused resources, and rewrite bytecode for runtime speed, ultimately reducing Application Not Responding (ANR) events and shaving down app binary sizes.
Jumping forward in time, Adarsh reviews the output generated by the R8 Analyzer Skill:
- The agent recommended updating the build configuration to activate R8's full mode.
- It ran the new R8 Configuration Analyzer to audit existing ProGuard/R8 keep rules and produced a scorecard covering optimization, obfuscation, and shrinking metrics.
- Prior to the prompt, virtually none of the travel app's codebase was optimized; after applying the agent's suggested rule adjustments, R8 successfully optimized nearly the entire codebase, resulting in a noticeably leaner, faster application from just one instruction.
[35:08](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2108s) App Links Assistant and Direct Play Store Publishing
Florina Muntenescu and Adarsh Fernando continue their Android demonstration by tackling user engagement through deep links. Clicking a link inside an email booking confirmation currently leads nowhere, but ensuring users jump straight to their upcoming itinerary inside the app is critical. In the latest release of Android Studio, developers can use a dedicated App Links Assistant. By navigating to Tools > App Links Assistant > URL Mapping Editor, setting the host (such as `Jetpacker Demo`), picking the activity that handles deep link intents, and passing in a sample URL, the developer lets AI step in. The agent analyzes the sample URL against the existing project codebase, formulates a tailored implementation strategy, and injects routing logic that parses trip parameters directly from the URL. Returning to the test device and tapping the confirmation link immediately opens the personalized trip view.
Florina cannot contain her enthusiasm, immediately chanting, “Ship it, ship it, ship it.” When Adarsh jokingly asks, “Are all PMs like that or just me?” Florina fires back dryly, “Just you.” Adarsh highlights that closing the loop between building and distribution is now significantly tighter: developers can publish updates directly from Android Studio to Google Play. Selecting Build > Generate Signed App Bundle reveals a new toggle to upload straight to Play. A couple of clicks later, the build is uploaded to an internal test track so quality assurance testers can start exercising the release while the developer finalizes the store listing.
- **App Links Assistant**: Accessible via Tools > App Links Assistant > URL Mapping Editor; automatically inspects intents, URLs, and code to generate custom deep-link routing.
- **Direct Play Store Deployment**: Native upload integration within the Generate Signed App Bundle workflow pushes builds directly into the Google Play internal test track.
---
[37:02](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2222s) Sneak Peek: Android Studio Migration Assistant and Journeys
Adarsh and Florina present a “super early” preview of a suite of tools engineered to migrate and extend existing codebases to Android, whether originating from React Native, standard web frameworks, or native iOS. To demonstrate how moving an existing iOS application to Android’s 3 billion-plus users can shrink from a multi-week engineering effort into a matter of hours, Florina walks through an experimental Migration Assistant. Selecting File > New Project > Migrate to a New Project prompts the developer to pick a source app and choose between full AI autonomy or a step-by-step Guided Migration. Developers can supply reference screenshots or custom skills. Rather than requiring manual verification of every translated screen, the tool introduces Journeys—structured natural language instructions describing critical user paths that the agent runs, evaluates, and iterates against autonomously.
To showcase the capability live, the team selected Metropolis, an open-source gamified companion app for the Paris public transit network that rewards riders with points for logging trips and badges for riding entire transit lines. Running the iOS simulator alongside the Android emulator, Florina enters line 1 of the Paris Métro, taps Start Travel, sets the route from La Défense to Les Sablons, and confirms the journey. The migrated Android application mirrors the source functionality seamlessly. Behind the scenes, the assistant constructs a feature map before laying out the project plan. Leveraging its understanding of Xcode storyboards, it converts iOS view hierarchies into native Android screens, maps strings across localized resource files, and transforms vector assets like SVGs and PDFs into Android vector drawables. On the implementation layer, it emits idiomatic code incorporating Jetpack Compose, Room, ViewModels, and platform best practices like predictive back navigation.
```mermaid
flowchart TD
accTitle: Android Migration Assistant Workflow
accDescr: Pipeline showing how the Migration Assistant converts an iOS project into a production-grade Android application.
subgraph Agent ["Android Studio Migration Assistant"]
D["Feature Mapping & Project Plan"]
E["Asset & Resource Translation"]
F["Agentic Validation Loop"]
end
subgraph Output ["Native Android App"]
G["Jetpack Compose UI"]
H["Room DB & ViewModels"]
I["Vector Drawables & Predictive Back"]
end
A --> D
B --> E
C --> F
D --> G
D --> H
E --> I
F -.->|"Iterates & Fixes"| G
```
- **Target Audience Scale**: Aimed at porting apps to Android's ecosystem of over 3 billion active users in hours instead of weeks.
- **Journeys Validation**: Replaces manual UI verification with natural language task scripts that the agent runs in emulation, inspecting outcomes and refining code.
- **Idiomatic Android Architecture**: Auto-generates Kotlin code using Jetpack Compose, Room persistence, architecture ViewModels, and predictive back navigation.
- **Roadmap**: Migration Assistant arrives in Android Studio later in the year, with forthcoming support planned for migrations directly to Kotlin Multiplatform (KMP) to enable shared cross-platform business logic.
---
[41:00](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2460s) Unifying Android Tooling and Chrome’s Agentic Web Era
Adarsh summarizes the broader vision for Android: pairing Antigravity and the Android CLI with the professional polish of Android Studio creates a unified developer toolchain that yields dramatic productivity leaps across any target form factor. “Teams of all sizes and skill levels can build cutting-edge Kotlin apps and deploy them to Google Play in record time,” Adarsh asserts, before turning over the keynote to explore how agentic workflows extend beyond mobile operating systems into the browser.
Una Kravets takes the stage to thunderous applause, framing the web as the single environment where AI-driven transformation is moving fastest. With Gemini integrated directly into Chrome, the web browser is transitioning from a passive viewing surface into an active partner with built-in assistants. Developers no longer need to spend months wrestling with new feature adoption before trying ambitious ideas; rather, agentic coding tools furnish the guidance, automated debugging, and novel browser APIs required to experiment at unprecedented velocity.
> “AI agents are transforming the landscape of development everywhere.” — Una Kravets
---
[43:08](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2588s) Baseline and Modern Web Guidance
Addressing the common developer dilemma of keeping pace with the dozens of new web platform APIs rolling out every few months, Una explains that developers face two distinct hurdles: determining if a feature is widely supported across browsers, and learning how to implement it correctly. Baseline has successfully solved the compatibility question. With 100% of web platform features now cataloged, Baseline serves as the industry standard for cross-browser feature availability.
To address the implementation challenge, Google is launching Modern Web Guidance—an expert-vetted, comprehensive repository of skills that arms coding agents with actionable blueprints for modern web capabilities. Grounded in Baseline data, Modern Web Guidance ensures agents do not default to obsolete design patterns or yesterday’s libraries. Instead, agents generate code targeting recent Chrome additions and contemporary standards that match the developer's specified Baseline target tier. When a developer selects a Baseline cutoff, the agent respects those boundaries, automatically offering robust fallback patterns and polyfills for bleeding-edge platform capabilities that have yet to achieve universal cross-engine support.
- **Baseline Coverage**: 100% of web platform features are now indexed to provide clear visibility across major browser engines.
- **Modern Web Guidance**: Vetted skill files that constrain coding agents to modern, standards-compliant APIs matching a project's target Baseline profile.
- **Automatic Fallbacks**: Built-in alternative implementation paths for newly introduced platform features lacking broad multi-browser adoption.
---
[44:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2696s) Dynorun, WebMCP, and Benchmark Performance
To demonstrate Modern Web Guidance in action, Una welcomes Matthias Rohmer to the demo desk. Matthias shares Dynorun, a playful React web application inspired by Chrome’s offline dinosaur runner that serves as an interactive car configurator. Dynorun relies on CSS scroll-driven animations to deliver a fluid, narrative storytelling experience that flows straight into vehicle customization controls. As Matthias toggles between exterior paint options like green and cerulean, Una remarks that wading through dense sliders and configuration menus can feel overwhelming: she would prefer asking a browser agent to assemble a vehicle matching her exact needs.
Matthias points out that bridging this gap used to be complex, but can now be achieved via WebMCP—a proposed browser standard designed to expose web application capabilities directly to browser-based agents. WebMCP informs external agents of precisely how, where, and through which structured actions they should interact with a website, yielding deterministic, reliable execution. Rather than authoring these interfaces by hand, Matthias pivots into Antigravity and issues a plain-language prompt: “Please implement WebMCP tools for the car configurator on this page.”
Behind the prompt lies Modern Web Guidance's modular, token-efficient Markdown skill files, which ground the agent in best practices without consuming unnecessary context. The structured guidance produces dramatic quality improvements: for web development tasks, pass rates improve by an average of 37 percentage points when using guided agent workflows compared to unguided ones. Matthias accepts the agent’s generated adjustments and inspects the underlying WebMCP skill guide driving the implementation.
> “With WebMCP, we can now make this web page agent-ready in minutes.” — Matthias Rohmer
- **Dynorun Tech Stack**: Built in React utilizing native CSS scroll-driven animations for narrative progression.
- **WebMCP Proposed Standard**: Exposes structured client-side tools and interaction hooks to browser agents for deterministic page control.
- **Guided Coding Pass Rate**: Equipping agents with Modern Web Guidance skills yields an average jump of 37 percentage points in pass rates on web development benchmarks.
[47:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=2838s) WebMCP and Gemini in Chrome: The Auto-Configured Party Car
Matthias Rohmer demonstrates how Modern Web Guidance demystifies emerging web standards for developer agents, breaking down how the Web Model Context Protocol (WebMCP) exposes standard JavaScript functions to browser agents through a structured API. Modern Web Guidance can be installed inside Antigravity with a single click during onboarding or enabled later via Settings, and it is also distributed as a standalone skills package compatible with other coding assistants across frameworks like Angular and React. Once the background agent finishes implementing the code, Matthias opens an experimental prototype of Gemini in Chrome featuring native WebMCP support, noting that while the current preview is Chrome-specific, WebMCP tools are designed to work across any browser agent supporting the protocol once standardized.
To test the site’s new agentic capabilities, Una Kravets provides a multi-constraint user prompt: “Can you prompt in Gemini in Chrome, configure the ultimate party car. I want immersive audio, and some interior lighting would be great. Plus, enhanced visibility for night driving to keep me safe. And I don't want to go too crazy, so keep it under $40,000. But give me as many add-ons as you can under that.” Matthias approves the resulting auto-browse execution plan, allowing Gemini to invoke an imperative `Update Car Configuration` tool that Antigravity generated alongside a full schema definition. Rather than guessing clicks across complex web forms, the agent targets the API directly, selecting all compatible packages within budget. Kravets jokes about discussing the resulting exterior color later, but emphasizes that the workflow spares users from manually hunting through complicated option menus.
- Modern Web Guidance supports over 100 use cases across dozens of web platform features and is available in early preview.
- The experimental WebMCP API will officially enter Origin Trial starting in Chrome 149.
- Gemini in Chrome will roll out direct support for custom WebMCP tools following active ecosystem partner experiments.
---
[50:52](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3052s) Chrome DevTools for Agents and Agentic Lighthouse Audits
Matthias addresses a common bottleneck when building with AI assistants: “They've gotten a lot better, but you still don't always get what you prompted for. And that's because your coding agent can't actually see what it's coding.” To solve this blindness, Google introduced Chrome DevTools for agents, combining an MCP server, a dedicated CLI, and tailored Skills to construct a complete runtime feedback loop. Demonstrating the workflow in Antigravity, Matthias prompts the agent to audit the WebMCP implementation using Lighthouse. A browser window automatically launches, loads the target page, and runs an automated inspection just as a human engineer would within DevTools.
```mermaid
flowchart TD
accTitle: Chrome DevTools for Agents Feedback Loop
accDescr: Diagram illustrating how Antigravity issues tool calls, runs Chrome Lighthouse audits, and inspects results autonomously.
subgraph AgentEnv["Agent Workspace"]
A["Antigravity Agent"] -->|"invokes CLI / MCP"| B["Chrome DevTools for Agents"]
end
subgraph BrowserEnv["Runtime Browser"]
B -->|"launches & audits"| C["Chrome Browser Instance"]
C -->|"runs Agentic Category"| D["Lighthouse Engine"]
end
subgraph AuditReport["Feedback & Remediation"]
D -->|"validates WebMCP & llms.txt"| E["Structured Audit Report"]
E -->|"direct feedback"| A
end
```
The audit includes a dedicated "agentic browsing" category that validates tool registrations, checks declarative metadata across forms, and inspects the site's `llms.txt` file—an emerging standard providing models with a curated map of site content. Una highlights that Lighthouse also evaluates accessibility trees, explaining that proper ARIA roles and labels directly empower autonomous browsing agents that read accessibility trees to navigate. As Una puts it: “When an issue is surfaced through Lighthouse, you don't need to be the human clipboard anymore, copying an error from DevTools, passing it into a chat, and hoping that the agent guesses the right fix.” Instead, the agent autonomously consumes the report, applies fixes, and re-runs the audit.
- Chrome DevTools for agents is available for Antigravity as well as more than 20 third-party coding agents.
- The new Lighthouse agentic browsing audit category tests WebMCP registrations, declarative form semantics, `llms.txt` files, and ARIA roles.
---
[53:44](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3224s) HTML in Canvas: Merging Real DOM Elements with Rich 3D Graphics
Returning to the 3D car configurator running in HTML Canvas, Matthias switches to the interior cabin view to reveal an unexpected architectural feat: the vehicle's central digital dashboard is an interactive, native HTML interface embedded directly inside the 3D WebGL render. Matthias demonstrates this by sliding ambient lighting controls on the rendered screen and inspecting the element in DevTools, confirming that the controls are genuine DOM nodes rather than painted pixel textures. “The new HTML in Canvas API now does the impossible,” Matthias explains. “With this, you can now integrate real DOM elements directly into your Canvas environment. Now, you no longer have to choose between visually complex and stunning or interactable and accessible.”
Una details the technical advantages of bringing true DOM elements into Canvas surfaces: because the elements reside in the DOM tree, they retain native browser capabilities including text selection, searchability, accessibility hooks, auto-translation, and browser Autofill. Developers can style embedded components using ordinary CSS utility classes or incorporate them into complex WebGL textures and 3D scenes. The HTML in Canvas API is officially launched in Origin Trial, allowing developers to experiment with novel user interface modalities that combine high-performance graphics with native document semantics.
---
[55:40](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3340s) The Agentic Web and Josh Woodward’s Closing Announcements
Una reflects on the collective milestone represented by Modern Web Guidance, WebMCP, HTML in Canvas, and Chrome DevTools for agents, remarking: “In this new era of agentic web development, there's never been a more inspiring time to create.” She welcomes Josh Woodward back to the stage to close out the keynote. Josh summarizes the common theme across the day’s product reveals—from Google AI Studio and Antigravity to Android and Chrome—stating: “You focus on the big idea, and the agents can do the heavy lifting.”
To rally the global developer ecosystem around agentic computing, Josh announces the Build with Gemini XPRIZE hackathon, a global competition offering $2 million in prize funding for developers creating applications that tackle major real-world challenges with the goal of positively impacting a billion lives. To support developers building compute-heavy agentic workflows, Josh references the newly announced $100 per month Google AI Ultra plan with simplified tier pricing. To kickstart weekend development, all Google AI Ultra subscribers receive $100 in bonus credits, claimable directly inside the Antigravity application to cover usage once base quota limits are reached. Josh invites attendees to follow additional sessions and on-demand technical deep dives at io.google before wrapping up the keynote.
- The Build with Gemini XPRIZE hackathon features a $2 million prize pool focused on high-impact real-world solutions.
- The Google AI Ultra plan is priced at $100 per month under a revised, simplified structure.
- Active Ultra subscribers receive an immediate $100 credit bonus redeemable inside Antigravity.
## Notable quotes
> [14:56](https://www.youtube.com/watch?v=aqmpZocmR8o&t=896s) We aren't just making it easier to build agents; we're making it easier to build with agents. — Anshul Ramachandran
> [50:52](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3052s) When an issue is surfaced through Lighthouse, you don't need to be the human clipboard anymore, copying an error from DevTools, passing it into a chat, and hoping that the agent guesses the right fix. — Una Kravets
> [02:18](https://www.youtube.com/watch?v=aqmpZocmR8o&t=138s) Honestly, it feels like the hottest new programming language is Markdown, and I'm here for it. — Logan Kilpatrick
> [55:40](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3340s) You focus on the big idea, and the agents can do the heavy lifting. — Josh Woodward
> [53:44](https://www.youtube.com/watch?v=aqmpZocmR8o&t=3224s) Now, you no longer have to choose between visually complex and stunning or interactable and accessible. — Matthias Rohmer
## Mentioned
Josh Woodward, Logan Kilpatrick, Paige Bailey, Anshul Ramachandran, Kevin Hou, Florina Muntenescu, Adarsh Fernando, Una Kravets, Matthias Rohmer, Google, Gemini Omni, Gemini 3.5, Gemma 4, Google Antigravity, Google Antigravity 2.0, Antigravity CLI, Antigravity SDK, Interactions API, Google AI Studio, Deep Research, Gemini Spark, Cloud Run, Firebase, Firestore, Google Workspace, Nano Banana, Lyria, Google Play Store, Android Studio, Android CLI, Gemini Nano 4, Android Device Streaming, Samsung Galaxy S26 Ultra, R8, Metropolis, Chrome, Baseline, Modern Web Guidance, WebMCP, Dynorun, Chrome DevTools for agents, Lighthouse, Build with Gemini XPRIZE, Google AI Ultra
## Video description
Learn about the latest updates to our developer products and platforms.
At Google I/O '26, Google executives outlined a company-wide shift toward autonomous, goal-driven agents powered by the Antigravity development harness across cloud backends, native Android, and the web. The platform couples models like Gemma 4 and Gemini 3.5 with managed runtime sandboxes, modular domain skills, and emerging protocol standards to automate end-to-end software delivery.
Unified Agent Harness and Managed Sandboxes (2:18)
Google framed its software strategy around moving beyond conversational assistants to autonomous agents capable of direct execution. To solve the infrastructure friction of securing execution environments, Google launched Managed Agents in the Gemini API. This interface couples model instructions with remote, Google-hosted Linux sandboxes in a single API call, relying on declarative markdown templates like AGENTS.md rather than procedural scaffolding. Keynote demos illustrated this setup via an AI Talk Radio pipeline combining web scraping, TTS, dynamic music via Lyria, and image generation.
Full-Stack Deployment and Multi-Agent Orchestration (14:56)
For rapid delivery, Google AI Studio introduced zero-setup container deployments to public Google Cloud Run URLs without requiring a credit card, alongside native Kotlin app generation for Android. For complex projects, Antigravity 2.0 acts as a desktop mission control center capable of coordinating parallel, dynamic subagents across distinct Git worktrees without merge collisions, supplemented by cron-based scheduling for recurring maintenance like health checks. Developer Kevin Hou also demonstrated using Antigravity's audio model and the Antigravity CLI over SSH to generate code and execute a LoRA fine-tuning run on Gemma 4 to produce concise CI/CD shell outputs.
Automating Native Android Lifecycles (26:08)
Antigravity and Android Studio introduced automated toolchains designed to reduce token overhead and accelerate native development. Adarsh Fernando reported that combining the Android CLI, curated knowledge bases, and architectural skills cut token consumption by roughly 70% and tripled task completion speeds in internal tests. The agents demonstrated hybrid local execution on Gemini Nano with cloud fallback, automatic R8 bytecode optimization for upcoming Android 17 constraints, and direct deployment to Google Play test tracks. Google also previewed an experimental Migration Assistant that converts iOS codebases into native Jetpack Compose architectures, validated autonomously through user journey scripts.
Bridging Agent Capabilities and Modern Web Standards (43:08)
On the web, Google targeted compatibility and automated inspection via Modern Web Guidance—a repository of token-efficient skills mapped to Baseline browser support standards that improved benchmark task pass rates by an average of 37 percentage points. To allow browser agents to interact deterministically with web applications, Google introduced the proposed Web Model Context Protocol (WebMCP), entering Origin Trial in Chrome 149. Furthermore, Chrome DevTools for agents introduced a runtime feedback loop via an agentic Lighthouse audit that evaluates tool registrations, ARIA roles, and site llms.txt files without manual clipboard transfers, while an Origin Trial for HTML in Canvas embeds accessible DOM elements directly into 3D WebGL environments.
To drive ecosystem adoption, Google announced the $2 million Build with Gemini XPRIZE hackathon and a $100 monthly Google AI Ultra plan bundled with $100 in Antigravity credits. While Google demonstrated broad multi-platform automation, experimental features like WebMCP and the Android Studio Migration Assistant remain early previews or Origin Trials awaiting cross-industry standardization and wider release later in the year.
Source quotes
[14:56] Anshul Ramachandran: We aren't just making it easier to build agents; we're making it easier to build with agents.
[50:52] Una Kravets: When an issue is surfaced through Lighthouse, you don't need to be the human clipboard anymore, copying an error from DevTools, passing it into a chat, and hoping that the agent guesses the right fix.
[2:18] Logan Kilpatrick: Honestly, it feels like the hottest new programming language is Markdown, and I'm here for it.
[55:40] Josh Woodward: You focus on the big idea, and the agents can do the heavy lifting.
[53:44] Matthias Rohmer: Now, you no longer have to choose between visually complex and stunning or interactable and accessible.
Original transcript
[0:00] [MUSIC PLAYING]
[0:09] JOSH WOODWARD: All right,
welcome back, developers.
[0:11] How's everybody doing?
[0:12] [CHEERING]
[0:14] All right.
[0:15] It's great to see
you again, and it's
[0:17] wild to think back about
where we were just a year ago.
[0:20] This morning, you've heard
all about the advancements
[0:23] across Gemini.
[0:24] We've got the new Omni
model, the new Gemini 3.5
[0:28] series of models.
[0:29] And last month, we
also shipped Gemma 4
[0:33] under an Apache 2.0 license.
[0:35] [APPLAUSE]
[0:38] It's our smartest
open model yet.
[0:40] It's purpose-built for advanced
reasoning, agentic workflows,
[0:45] and the response
has been incredible.
[0:47] 100 million downloads
in the first month,
[0:50] and it's pushing Gemma
downloads past half a billion.
[0:56] [APPLAUSE]
[0:59] Gemma 4 packs
massive intelligence
[1:02] into a footprint small enough
to run offline on your phone.
[1:07] And it's deployed in
everything from robots
[1:10] to satellites in outer space.
[1:12] And as you saw this
morning, the big shift
[1:15] is our move towards agents,
from AI that simply assists you
[1:20] to agents that
help you get stuff
[1:22] done, under your
direction and faster.
[1:25] At the center of it all
is Google Antigravity.
[1:28] It's our agentic
development platform
[1:30] that enables you to
build with agents.
[1:33] The core platform is the
Antigravity agent itself.
[1:37] And today, we're
going to show you
[1:38] how you can build
with it anywhere,
[1:41] on our infrastructure or your
own, on Android or the web.
[1:46] And when you step back, you
can see how all of these pieces
[1:50] are coming together
across Google,
[1:52] from the cutting-edge
models, to the agentic tools
[1:56] like Antigravity, to the
platforms where users experience
[2:00] the magic, and to the
infrastructure that
[2:03] makes it all possible.
[2:05] We're working up and down
the stack to help you build.
[2:09] So let's jump into some demos
and keep the launches rolling.
[2:12] Please welcome
Logan to the stage.
[2:14] [MUSIC PLAYING]
[2:16] [APPLAUSE]
[2:21] LOGAN KILPATRICK: Thanks, Josh.
[2:22] Our latest models help you build
for the next era of agents.
[2:26] And we're putting the
full power of agents
[2:28] directly into your hands, no
matter what you're building.
[2:32] Need complex research done?
[2:34] Check.
[2:35] A data science task?
[2:36] Check.
[2:38] Your own personal radio show?
[2:40] We'll get to that one.
[2:42] Last December, we introduced
the Interactions API.
[2:45] It gives you one simple
and powerful interface
[2:48] for both models and agents.
[2:51] Deep Research was the first
agent we made available
[2:53] through the Interactions API.
[2:55] It showed what's
possible when you
[2:57] give a model a goal and the
freedom to go find the answer.
[3:02] But Deep Research was
just the beginning.
[3:04] Inside Google, we're
using the Antigravity
[3:07] harness to empower our agents
to intelligently tackle
[3:10] the most complex tasks.
[3:12] It's the same technology behind
Gemini Spark and our coding
[3:15] agent in Google AI Studio.
[3:18] And today, we're making
that same Antigravity
[3:21] harness available to you with
managed agents in the Gemini
[3:24] API.
[3:25] [APPLAUSE]
[3:30] You can easily start
creating your agents
[3:32] by adding custom
instructions, tools,
[3:34] and data through a single
call to the Gemini API.
[3:38] But building agents is
one part of the puzzle.
[3:41] In production, these workloads
need secure, isolated execution.
[3:45] And solving that on your own
is an infrastructure nightmare.
[3:49] That's why every managed agent
comes paired with a remote Linux
[3:53] environment hosted by Google.
[3:56] In a single API call, you
get an agent and the sandbox.
[4:00] We handle the infrastructure
so you can focus on building.
[4:04] We've been testing this with
developers both internally
[4:07] and externally.
[4:08] To give you an example,
the team at Stitch,
[4:10] our vibe design
product and labs,
[4:12] used managed agents
to enable their users
[4:15] to import their project's design
system directly from their code
[4:18] base.
[4:19] Their managed agent connects
to a user's GitHub repo,
[4:22] analyzes the code
base, and generates
[4:24] a ready-to-use design.md
file, giving Stitch
[4:27] everything it needs to
create on-brand designs.
[4:31] And because it's
a managed agent,
[4:33] we handle the
infrastructure so Stitch
[4:35] can scale to millions of users.
[4:38] Now, Stitch is just one
example of how powerful
[4:40] managed agents can be.
[4:43] Externally, early
access customers
[4:44] like Ramp, Resemble
AI, and Klipy
[4:47] are also seeing the
power of building agents
[4:49] at a pace like never before.
[4:51] And we can't wait to
see what you build.
[4:54] Managed agents are
available starting today.
[4:57] And thanks to our
ecosystem partners,
[4:59] you can start building with your
preferred stack from day one.
[5:02] Let's jump into a demo.
[5:05] I'm here in the AI
Studio playground,
[5:07] where earlier this
year, we added support
[5:09] for interacting with agents.
[5:11] To help you get started, we've
added a set of new custom agents
[5:14] that you can run instantly.
[5:20] These open-source
agent templates
[5:22] come preloaded with
instructions, skills, and tools
[5:25] as markdown so you can
customize the source files,
[5:27] like in this customer
support agent.
[5:33] So I told you I'd come back
to my own personal radio show.
[5:37] So let's select AI
Talk Radio agent.
[5:40] This agent can produce
a complete talk radio
[5:43] show about anything you want.
[5:45] You give it a topic,
and it handles the rest.
[5:48] Of course, I want mine to
cover today's top tech news.
[5:51] So let's see what the Hacker
News comments have to say.
[6:00] I've asked it to generate
a 5-minute radio show based
[6:02] on the latest from Hacker News.
[6:05] What's happening right now
is the agent's environment
[6:07] is provisioning, and it's
getting ready to run.
[6:09] While that happens, let me
show you what's under the hood.
[6:17] In the AGENTS.md file, you can
see we created a specific set
[6:21] of skills for the agent
to produce the show--
[6:24] research to pull top tech
stories from Hacker News,
[6:27] script writing to compose
the show's script,
[6:29] TTS generation to generate
multiple speaker voices,
[6:32] music generation with Lyria to
create dynamic background music,
[6:36] and audio mixing to
bring it all together.
[6:39] Finally, it generates metadata,
uses Nano Banana for cover art,
[6:42] and saves a complete
ready-to-stream
[6:45] MP3 in its sandbox environment.
[6:47] I didn't write any
orchestration logic.
[6:50] I simply define the skills
and tools in Markdown files,
[6:53] and the agent does the rest.
[6:55] Honestly, it feels like
the hottest new programming
[6:57] language is Markdown,
and I'm here for it.
[7:01] Since the agent is taking
care of everything,
[7:03] it's going to take
a few minutes.
[7:04] Let's switch to a tab where
the agent finished and left
[7:07] us a nice summary of its work.
[7:15] Research, script, speech, music,
mixing, and image generation
[7:20] completed all from one API call.
[7:24] The playground and AI Studio is
great to see what Gemini models
[7:27] and agents can do.
[7:28] But the real magic begins when
you bring this to real apps.
[7:32] And to show you that
magic, here's Paige.
[7:35] [MUSIC PLAYING]
[7:36] [APPLAUSE]
[7:41] PAIGE BAILEY: Awesome.
[7:42] Thank you, Logan.
[7:44] Google AI Studio is the fastest
path from prompt to app.
[7:48] So let's dive in.
[7:50] I've always wanted to build
my own personalized radio
[7:53] station to get the latest
news that I care about.
[7:56] And it's not just because Logan
just showed us what his AI Talk
[8:00] Radio agent can do.
[8:02] OK, maybe.
[8:05] Earlier today, I took
the AI Radio Show agent
[8:08] and wrapped it in a real
app with just a few prompts.
[8:12] Since I'm also a fan of
Hacker News, let's go ahead
[8:15] and give it a try.
[8:17] Just like Logan showed
in the playground,
[8:19] my app is calling a managed
agent on the Gemini API.
[8:23] The agent spins up in
a sandbox environment,
[8:26] reads through the
skills, makes a plan,
[8:29] and then assembles
the complete episode.
[8:33] This is going to take
a minute to generate,
[8:35] so I'll switch over
to where I ran it
[8:37] a little bit earlier today.
[8:39] And let's hear what
Hacker News has to say.
[8:43] [VIDEO PLAYBACK]
[8:43] - If you can go from writing
200 lines of code a day to 2,000
[8:49] with an AI agent, are you
actually a better engineer,
[8:54] or are you just vibing?
[8:56] Good afternoon.
[8:57] [END PLAYBACK]
[8:58] PAIGE BAILEY: Awesome.
[8:59] Pretty cool, right?
[9:00] [APPLAUSE]
[9:02] Excellent.
[9:04] As you can see, the agent
generated the MP3 for the show
[9:09] and created metadata
to display the script.
[9:12] So now I can even jump to
different speakers in the show.
[9:15] [VIDEO PLAYBACK]
[9:15] - --the new one.
[9:16] And for the accessibility
community, it's massive.
[9:20] You can--
[9:21] [END PLAYBACK]
[9:22] PAIGE BAILEY: This is so cool.
[9:23] The app defines the
UX, and then the agent
[9:26] creates the content and metadata
needed for it on the fly.
[9:30] And I love this
fun cover art that
[9:32] was generated with Nano Banana.
[9:35] So Logan showed you how the
playground lets you experiment.
[9:39] And what I just showed you
is how build lets you ship.
[9:43] And speaking of shipping, let's
go ahead and deploy my app so I
[9:48] can share it with the world.
[9:52] Deploying from AI Studio to
Cloud Run is just a few clicks.
[9:58] You can either pick an
existing Google Cloud project,
[10:01] or if you don't
have one, AI Studio
[10:03] will generate one for you.
[10:06] And starting today,
brand new users
[10:10] can deploy to a live URL
on Cloud Run instantly.
[10:14] No credit card required.
[10:17] [APPLAUSE]
[10:20] Awesome.
[10:22] Now, while we're
waiting, Cloud Run
[10:25] is just our latest integration.
[10:28] We recently rebuilt our
coding agent with Antigravity
[10:31] and added Firebase
and Firestore support,
[10:34] so you can easily build real
world full-stack apps backed
[10:39] with databases and OAuth.
[10:41] And today, we're
officially announcing
[10:44] support for Google Workspace.
[10:47] Woo!
[10:48] Yeah.
[10:49] Clap, clap, clap.
[10:50] [APPLAUSE]
[10:51] You can just prompt
to connect apps
[10:52] like Docs and Gmail and Calendar
and stay completely in the flow.
[10:56] And if you combine that
with multi-chat, web search,
[10:59] and image generation
with Nano Banana,
[11:02] we are completely redefining
what you can build with agents.
[11:06] And, oh awesome, it looks
like my app has deployed.
[11:10] So you can see right here
the status, the live URL,
[11:14] and even unpublish right
here without leaving
[11:16] AI Studio for a second.
[11:18] That really was pretty magical.
[11:21] Awesome.
[11:23] I love that I can deploy
my web app in minutes.
[11:26] But what good is a radio show
if I can't listen on the go?
[11:30] So starting today, you can go
from an idea to an Android app
[11:37] directly in AI Studio.
[11:39] No software to install,
no SDKs to manage,
[11:43] and no local environment needed.
[11:46] [APPLAUSE]
[11:47] Yes.
[11:48] Hallelujah.
[11:50] Awesome.
[11:51] Yep.
[11:52] To start, all you have to do
is select Build an Android App
[11:55] and start prompting.
[11:57] So let's switch over to one
I baked a little bit earlier
[12:00] today.
[12:01] I used the same exact prompts,
but this time asked the app
[12:05] to build an Android app.
[12:08] And notice the app is
built entirely in Kotlin.
[12:13] AUDIENCE: Woo!
[12:14] PAIGE BAILEY: Woo.
[12:14] Yeah.
[12:15] [APPLAUSE]
[12:16] You can even preview your
app with the Android Emulator
[12:19] directly in AI Studio.
[12:22] And when I'm ready to start
testing on my own device,
[12:25] I simply plug in my
phone to install it.
[12:29] We're also adding support for
Google Play Store publishing
[12:33] in AI Studio.
[12:35] Yeah, keep clapping.
[12:37] [APPLAUSE]
[12:38] I just open Publish, connect
my Play Developer Account,
[12:42] and push the app straight to
the test track in minutes.
[12:44] And after that, it's ready
to install on my phone
[12:47] without ever leaving AI Studio.
[12:49] You can start testing
it on your own device
[12:51] today, and sharing with
trusted testers will roll out
[12:54] later this summer.
[12:55] [APPLAUSE]
[12:58] But speaking of
apps, great ideas
[13:03] don't just happen at your desk.
[13:06] And that's why we're bringing
the AI Studio build experience
[13:10] to your pocket with our
brand new mobile app.
[13:14] Woo.
[13:15] Yeah.
[13:16] [APPLAUSE]
[13:16] The app rolls out
in a few weeks,
[13:18] and you can pre-register today.
[13:21] With managed agents,
you get serious power
[13:24] without the complex setup.
[13:26] But if you want total
programmatic control
[13:28] to customize and deploy
on your own terms,
[13:32] today we're launching
the Antigravity SDK.
[13:36] Yeah.
[13:36] [APPLAUSE]
[13:38] It gives developers and
researchers the exact same agent
[13:42] harness optimized
for Gemini, but
[13:44] with the ultimate flexibility
to run it wherever
[13:47] and however you want.
[13:49] And now, of course,
building a great agent
[13:52] isn't just a single event.
[13:54] It's an entire lifecycle, from
that first spark of an idea
[13:57] to a deployed application.
[14:00] And while Google AI
Studio is the fastest path
[14:03] from prompt to app,
as your team evolves,
[14:06] moving to a local
development platform
[14:08] can help with faster iterations.
[14:10] And moving y'all's projects
used to mean copying files,
[14:15] losing context, and
completely rebuilding state.
[14:18] But not anymore.
[14:21] Today, we're launching a
one-click export to Antigravity.
[14:25] And we aren't just
sending snippets.
[14:27] We are porting the complete file
system and every single ounce
[14:31] of context, so you can pick
up exactly where you left off
[14:35] in AI Studio.
[14:37] [APPLAUSE]
[14:39] And now, to show you what
we're cooking in an Antigravity
[14:42] itself, please welcome Anshul.
[14:45] [MUSIC PLAYING]
[14:47] [APPLAUSE]
[14:56] ANSHUL RAMACHANDRAN: All right,
let's talk more about agents,
[14:59] shall we?
[15:00] We aren't just making it
easier to build agents.
[15:04] We're making it easier
to build with agents.
[15:07] As you heard
earlier today, we're
[15:09] introducing Google
Antigravity 2.0, a new desktop
[15:13] application that is
unabashedly agent first.
[15:17] You can kick off multiple
agents in multiple projects
[15:20] simultaneously.
[15:21] One agent vibe codes
your marketing website,
[15:24] another generates brand assets,
and a third plans your project
[15:27] architecture, operating
in multiple work trees,
[15:31] collaborating
without collisions.
[15:33] For coding tasks, you
can use Antigravity 2.0
[15:36] alongside your IDE of choice.
[15:39] But we all know there is much
more to do than just code.
[15:43] Antigravity 2.0 is your mission
control for orchestrating agents
[15:48] for all sorts of tasks.
[15:51] Now, we've all seen
single agents get
[15:54] overwhelmed by massive tasks.
[15:57] That's why, today, we're
introducing dynamic subagents.
[16:02] Now your agent can spin
up specialized helpers,
[16:05] like a QA or data
science subagent, that
[16:08] worked in parallel to get
the job done faster and more
[16:11] effectively.
[16:13] Now, that might
sound impressive.
[16:15] But what if you want the
process to run autonomously?
[16:17] For example, you
might have tasks
[16:19] that you want agents to repeat
on a predefined schedule.
[16:23] Today, we are making that a
reality with Scheduled Tasks.
[16:28] You can now use
standard cron schedules
[16:31] to put your agents on autopilot.
[16:34] So tell your agent to summarize
pending PRs every morning,
[16:38] or monitor your cloud
health every hour.
[16:41] And this is just the
beginning of making
[16:43] your agents truly proactive.
[16:47] To show you Antigravity
2.0 in action, let's
[16:50] invite Kevin to stage.
[16:51] [APPLAUSE]
[16:56] KEVIN HOU: Thanks, Anshul.
[16:57] Let's give Antigravity
2.0 a challenge.
[17:00] As you heard from
Josh at the beginning,
[17:02] the momentum we're
seeing behind Gemma 4
[17:04] is absolutely incredible.
[17:07] Democratizing AI
means allowing anyone
[17:09] to take open models, like
Gemma 4, and fine tune them.
[17:13] Historically, that meant
complex pipeline wrangling
[17:16] by ML engineers.
[17:18] Not anymore.
[17:19] With Antigravity,
anyone can do it.
[17:22] Let me show you.
[17:24] The other day, my CI pipeline
broke, which gave me this idea.
[17:28] Why not have an
LLM automatically
[17:30] self-heal the pipeline?
[17:32] I'd just feed it the stack
trace with the build error
[17:34] and say, fix this, to generate
a remediation Bash command.
[17:38] Anshul, can you explain
while I get this set up?
[17:40] ANSHUL RAMACHANDRAN: Yeah.
[17:41] So the challenge here is
that LLMs, as we know,
[17:43] have trained to
be conversational.
[17:46] So they bury the Bash command
in paragraphs of explanation.
[17:49] In fact, when we asked for a
simple Git work tree command
[17:52] earlier, the response came back
with two separate code blocks,
[17:56] a conversational introduction,
and a detailed breakdown
[17:58] explaining how to
choose branch names.
[18:01] But all Kevin cares
about is the command.
[18:04] And so what he needs
to do is fine tune
[18:06] Gemma 4 to not return the fluff
and just give him the command.
[18:10] KEVIN HOU: Exactly.
[18:11] So rather than watch
me type, let's go ahead
[18:13] and use the mic, powered by
our latest audio understanding
[18:16] capabilities.
[18:21] OK, so I want to fine tune
Gemma 4 to directly give me
[18:25] a Bash command response
with no additional fluff,
[18:28] so that I can use the response
directly in my CI pipeline.
[18:32] I have a data set of
prompt to Bash commands.
[18:35] Write the training and eval
code for doing a LoRA fine
[18:37] tuning over this
data set, as well as
[18:40] the code to deploy my custom
Gemma 4 model on my laptop.
[18:44] ANSHUL RAMACHANDRAN:
So as Kevin runs
[18:45] that, I want to highlight
a couple of things.
[18:48] He was able to
just use his voice,
[18:50] and the audio model could
recognize terms like LoRA.
[18:54] It seems like the agent
is doing some research
[18:56] and has generating an
entire implementation
[18:58] plan for the training code.
[19:01] KEVIN HOU: OK, so I approved
the implementation plan,
[19:03] and now it's writing a bit
of code to make this happen.
[19:06] Once this is done, I'm going
to take this and push it
[19:08] to my repo.
[19:09] And because we're
training a model,
[19:11] I'll need a GPU-enabled
cloud machine.
[19:13] ANSHUL RAMACHANDRAN: Great.
[19:14] So while Kevin
does that, you just
[19:16] saw Antigravity 2.0,
our new standalone app
[19:20] that is your mission control
for orchestrating agents.
[19:23] But we know that for
a lot of developers,
[19:26] the real magic happens
in the terminal.
[19:28] So that's why we're thrilled to
announce the Antigravity CLI.
[19:33] [APPLAUSE]
[19:38] It's a lightweight way to spin
up these same Antigravity agents
[19:42] right from the terminal.
[19:44] So it gives you the exact
same harness and same models,
[19:47] but with a product
experience that is
[19:49] tailored for the command line.
[19:51] It adapts entirely to you--
[19:53] your themes, your workflows,
your key bindings.
[19:57] Kevin, we're good to go?
[19:58] KEVIN HOU: We are all set.
[19:59] So let's pick up
where I left off.
[20:01] As you can see, I have SSH'ed
into my GPU-enabled VM,
[20:04] and I'm going to pull down the
code from main that we just
[20:07] wrote in Antigravity 2.0.
[20:09] I already have the Antigravity
CLI installed on this machine,
[20:12] and it's running in a separate
tab, no GUI necessary.
[20:16] ANSHUL RAMACHANDRAN: Yeah, so
we know that GUI versus CLI is
[20:19] mostly a matter of preference.
[20:21] But since Kevin's already in the
terminal SSH'ed into a machine,
[20:25] the CLI is perfect.
[20:27] KEVIN HOU: So I
just asked the agent
[20:28] to start the training
job that we just wrote.
[20:30] And to give you a
little bit of context,
[20:32] this is a lightweight
LoRA fine-tune.
[20:34] But even so, it's going to take
some time before we get results.
[20:38] So while this is cooking,
let's just take a step back
[20:40] for a minute.
[20:41] In minutes, we used
Antigravity to go
[20:43] from no code to fine tuning
Gemma 4 on our own custom use
[20:47] case.
[20:48] And if all that seems a
little bit too simple,
[20:51] that is the point.
[20:52] Antigravity makes
building something
[20:54] of this scale not just possible,
but way easier than you'd
[20:57] expect.
[20:58] All right, now that
it's been a few moments,
[21:00] I'm going to use the
CLI to do a quick sanity
[21:02] check on the first
few steps to make
[21:03] sure the loss is trending
in the right direction
[21:05] and everything is healthy.
[21:07] I'll head over to
my agent and just
[21:08] ask, how is the
training run going?
[21:12] Is everything healthy?
[21:16] And as you can see, it's
going to look through some
[21:18] of the output files, actually
read the code that it wrote
[21:20] in 2.0, tell us that
it needs to look
[21:23] at a couple of the log files.
[21:24] And hopefully it should
give us some indication
[21:26] of how training is going.
[21:29] Looking like it's looking
through the test logs.
[21:32] And you see that "sleep 10."
[21:34] It looks like training
has not progressed
[21:36] long enough for us to actually
get meaningful results.
[21:39] So let's come back in
a couple of seconds.
[21:41] ANSHUL RAMACHANDRAN: Sure.
[21:42] OK, so if we have some time,
let's ask Gemini for a joke.
[21:45] Using the brand
new /btw command.
[21:49] It did give us the results.
[21:50] Let's ask for the joke anyways.
[21:51] KEVIN HOU: It already came back,
but we'll get the joke anyway.
[21:52] ANSHUL RAMACHANDRAN:
Let's just get the joke.
[21:54] Why not?
[21:54] We have some time.
[21:58] KEVIN HOU: So I used /btw,
which, in the same conversation,
[22:00] will effectively fork.
[22:02] And now you can see
this amazing joke.
[22:04] Why did the neural network
refuse to run on the TPU?
[22:08] Because it heard the TPU
was always a bit too tensor.
[22:11] [LAUGHTER]
[22:13] ANSHUL RAMACHANDRAN: Eh.
[22:15] I think we'll give
it 5 out of 10.
[22:17] We'll talk to the
Gemini team about humor.
[22:19] But let's scroll
back up, because I
[22:21] think we saw some of
the training results.
[22:23] KEVIN HOU: OK.
[22:24] So it looks like
it did about 1%.
[22:26] It says the gradient
norm is stable.
[22:28] So it looks things
are going well.
[22:30] I imagine this will probably
take some time to finish.
[22:33] ANSHUL RAMACHANDRAN: Yeah.
[22:33] I mean, so the loss is
turning down nicely.
[22:35] The run is perfectly healthy.
[22:36] But we'll fast forward
a bit and keep this one
[22:39] cooking in the background.
[22:40] KEVIN HOU: Sure.
[22:41] In fact, I actually kicked off
this same exact run earlier.
[22:45] I let it run for a
few hours, so I'm just
[22:47] going to use that
checkpoint and ask
[22:49] my agent to deploy that
resulting model to my laptop
[22:52] so that we can all see that
this does, indeed, work.
[22:54] So I'll head back over
to Antigravity 2.0.
[22:57] I'm going to start
a new conversation.
[22:59] And I'm just going to instruct
it to run the playground using
[23:02] the fine-tuned model
that is specified
[23:04] at this particular
path from earlier.
[23:07] As you can see, it is
running the server.
[23:08] And if we click over here,
you can see the logs.
[23:11] Looks like it's running
this particular model.
[23:14] It's also starting the client.
[23:16] And if I just go ahead
and click on the link
[23:18] that it's telling me to click
and try that same exact prompt
[23:20] in the same playground
that you saw earlier,
[23:23] we now see a fine tune where
we just get the command, none
[23:27] of the additional fluff.
[23:28] [APPLAUSE]
[23:33] So we just fine tuned
Gemma 4 on stage,
[23:35] which is pretty remarkable.
[23:36] And this really
is the new reality
[23:38] of building-- your workflows
across surfaces you already use.
[23:42] ANSHUL RAMACHANDRAN: Awesome.
[23:43] Thanks, Kevin.
[23:44] KEVIN HOU: Thank you.
[23:46] [APPLAUSE]
[23:51] ANSHUL RAMACHANDRAN: Wrapping
up on the Antigravity CLI,
[23:53] we are unifying on Antigravity
as the only platform you need
[23:57] for agent-first development.
[23:59] So we took everything we learned
from how you use Gemini CLI
[24:02] and rolled those insights into
the Antigravity CLI as well.
[24:06] So starting today,
the Antigravity CLI
[24:08] is available to all
Gemini CLI users.
[24:11] We've published the
migration guides
[24:13] to help you port your
custom skills over.
[24:15] And as always, send us your
feedback as you get started.
[24:19] You'll now get the same
harness as Antigravity 2.0
[24:23] and a unified agentic experience
across all of your surfaces.
[24:28] All right, let's move along.
[24:30] Antigravity is completely
stack agnostic, letting
[24:33] you use the tools you love
with zero vendor lock-in.
[24:37] However, if you are building
in the Google ecosystem,
[24:41] we've made it easy, with
one-click setup across Android,
[24:44] Firebase, and
building on the web.
[24:47] [APPLAUSE]
[24:52] We're also making it
easier to push agents
[24:54] into highly specialized
fields by introducing
[24:57] domain-specific skills bundles.
[25:00] So starting today,
our first release
[25:02] is a new Science Skill
bundle, equipping your agents
[25:06] with the specific
primitives needed
[25:08] to accelerate health, biology,
and scientific research
[25:11] workflows.
[25:13] [APPLAUSE]
[25:18] So everything you
just saw is incredible
[25:21] for individual developers,
but we are not stopping there.
[25:25] So today, for enterprises,
we're allowing Antigravity
[25:28] to be connected directly to
your Google Cloud projects,
[25:32] applying the same enterprise
terms that you expect.
[25:37] And for our existing Gemini
Enterprise customers,
[25:39] you'll soon see Antigravity
rolled out in the coming months.
[25:43] [APPLAUSE]
[25:47] From cutting-edge research
to standard enterprise apps,
[25:50] whether you're one developer
with an idea or an organization
[25:54] deploying at scale,
Antigravity is your platform.
[25:58] Now let's take a deep dive
into these agentic workflows
[26:01] for your Android development.
[26:03] Here to show us how
that's done, please
[26:05] welcome Florina and Adarsh.
[26:07] [MUSIC PLAYING]
[26:09] [APPLAUSE]
[26:21] FLORINA MUNTENESCU:
No matter where
[26:23] you are in your
development journey,
[26:25] we want to make it fast and easy
to build high quality Kotlin
[26:29] Android apps.
[26:31] As Paige showed you earlier,
native Android development
[26:35] is fully supported in AI Studio.
[26:38] Today, we're also bringing
official Android support
[26:41] to Antigravity so you
can more easily deliver
[26:45] the most performant
experiences for your users,
[26:48] no matter where they are or
what kind of devices they have.
[26:53] We want to ensure
you have access
[26:55] to the latest innovations
on the Android platform
[26:59] and that building for the newer
form factors is frictionless.
[27:03] ADARSH FERNANDO: OK, we'll
have a few demos that we
[27:06] need to cover in the next few
minutes, but not that much time.
[27:09] So let's rely on our latest
skill, time travel, travel,
[27:14] travel, travel.
[27:15] We'll use it every once in a
while to jump into the future
[27:18] and check out the results.
[27:20] Now, for the demos, we've
created a travel app.
[27:23] You can use it to view all of
your travel plans in one place
[27:27] or transcribe
audio diary entries
[27:29] using our latest on-device
model, Gemini Nano 4.
[27:33] FLORINA MUNTENESCU: So using
Antigravity, let's show you
[27:35] how you can build an
augmented experience today
[27:38] for display glasses.
[27:40] AUDIENCE: Woo!
[27:40] [APPLAUSE]
[27:43] ADARSH FERNANDO: Now,
setting up the environment
[27:45] without Android Studio
is kind of a pain.
[27:48] But now Antigravity has our
new Android CLI built in.
[27:53] Now that it's stable, it comes
with a set of tools for agents
[27:57] to handle everything from
downloading the SDK to creating
[28:00] a project and running
your app on devices, all
[28:04] much more easily
and efficiently.
[28:08] OK, Flor, for this app,
we've heard from our users
[28:10] that they really wish
there was an easier way
[28:13] to view important travel
info when they're on the go.
[28:16] So let's try this out.
[28:18] In a single prompt,
let's add the capability
[28:21] to display updated flight and
travel information directly
[28:24] on the glasses, which could
be pretty useful for users
[28:27] at the airport with
their hands full.
[28:29] FLORINA MUNTENESCU: Building
for display glasses is new,
[28:31] so most LLMs don't know
how to do this yet.
[28:35] So as part of Android CLI,
we're giving our models
[28:38] access to the latest information
with two key resources.
[28:42] First, the Android Knowledge
Base-- it's our specialized data
[28:46] source that enables
agents to search and fetch
[28:49] the latest developer guidance.
[28:52] And second, we open
source the Android
[28:54] skills to help LLMs understand
and execute best practices.
[28:59] For example, you've told us
that building support for edge
[29:03] to edge, migrating from XML to
Compose or to Jetpack Navigation
[29:07] 3 is time-consuming.
[29:10] So we made sure to add skills
to help with just that.
[29:15] ADARSH FERNANDO: We saw in
our internal testing agents
[29:18] leveraging Android CLI,
Skills, and Knowledge Base
[29:22] use about 70% fewer tokens and
complete tasks up to three times
[29:27] faster.
[29:29] Now, Android CLI
also provides access
[29:31] to the powerful capabilities
of Android Studio,
[29:34] like finding usages
and declarations,
[29:37] analyzing files for issues,
and looking up the latest
[29:40] info on dependencies.
[29:42] By running Android Studio
alongside Antigravity,
[29:46] the agent can leverage these
capabilities to run tasks
[29:49] much more quickly
and efficiently,
[29:51] all while under your control.
[29:54] OK, let's jump forward in
time to see what the agent did
[29:57] to build our new glasses UI.
[30:01] OK, so the agent's
done its thing,
[30:03] and I can see that it
used the recommended Skill
[30:05] to build the UI using Jetpack
Compose Glimmer, which
[30:09] is part of the Android XR SDK.
[30:11] If I scroll a little
further, I can
[30:14] see it's also using Android
Studio to look up versions
[30:17] of dependencies it needs.
[30:19] And then a little further,
it's also analyzing files
[30:23] that it's modified for issues.
[30:26] Finally, it deployed
the app to the emulator
[30:29] so that I can try it out myself
and see flight information,
[30:34] hotel information, and more.
[30:36] [APPLAUSE]
[30:43] FLORINA MUNTENESCU:
We're just scratching
[30:45] the surface of the Android
capabilities in Antigravity.
[30:48] How about adding a helpful
AI summary of the entire trip
[30:54] and asking Antigravity to give
us before and after screenshots
[30:58] of the app?
[31:00] ADARSH FERNANDO: OK, so
switching to an earlier result,
[31:04] I can see that the agent
has implemented hybrid mode
[31:09] by using Firebase AI
logic, which is great
[31:14] because that way the app
only uses the cloud device
[31:17] model as a fallback when an
on-device model isn't available.
[31:21] FLORINA MUNTENESCU: OK.
[31:22] But did it actually work?
[31:23] ADARSH FERNANDO:
That's a good question.
[31:25] So if I scroll a
little further down,
[31:28] I can see the before
and after screenshots
[31:30] that we asked for, with
the feature implemented.
[31:32] I can also see that the
agent used the Android
[31:35] CLI to deploy the
app, navigate the UI,
[31:39] and take those screenshots.
[31:40] So yeah, I think it worked.
[31:42] FLORINA MUNTENESCU: So these
screenshots are nice and all,
[31:44] but we need to
see how this looks
[31:45] across multiple configurations
and whether that AI
[31:49] summary really works offline.
[31:51] Antigravity enables you to
orchestrate your agents,
[31:54] but the ideal setup
is to use Antigravity
[31:58] alongside Android Studio.
[31:59] ADARSH FERNANDO: That's right.
[32:00] And you can easily transition
to Android Studio at any time
[32:05] and get that production
grade polish.
[32:07] For example, with
the agent, I can ask,
[32:10] open the Compose
previews for the home
[32:12] screen in Android Studio.
[32:15] And then, pixels
percolating, there it is.
[32:20] [APPLAUSE]
[32:25] FLORINA MUNTENESCU:
We can see how
[32:27] the UI looks across
multiple themes
[32:30] and also how it adapts to
different screen sizes.
[32:33] And then if there's
anything we need to tweak,
[32:35] we just go to AI Actions.
[32:37] Now, we need a real phone
to test the on-device AI
[32:41] capabilities.
[32:42] ADARSH FERNANDO: I agree.
[32:44] In Android Studio, I can deploy
to a number of real Android
[32:48] devices, whether
I own them or not.
[32:50] For example, here's the app
running on a real Samsung Galaxy
[32:54] S26 Ultra, which is coming
to Android Device Streaming
[32:57] a little later this summer.
[32:59] While the device is
in airplane mode,
[33:02] I can easily check that
the AI trip summary feature
[33:06] uses the on-device Gemini Nano.
[33:09] [APPLAUSE]
[33:14] FLORINA MUNTENESCU: All right.
[33:15] Now, a high quality app
needs to be performant.
[33:19] Since I'm in Android Studio,
I can view the App Quality
[33:22] Insights window.
[33:24] And I can see that my
app has been crashing
[33:26] too much in production.
[33:28] And on top of that,
we also want to be
[33:30] ready for some of the
memory limit changes
[33:33] for performance
optimization in Android 17.
[33:36] So let's get that fixed.
[33:38] I'm going to go to the
agent and say, OK, Gemini,
[33:43] fix and analyze my app's
optimization and performance.
[33:48] The agent knows that one of the
main ways an app can improve
[33:51] its performance is with R8.
[33:54] It streamlines your app
by removing unused code
[33:57] and resources and
rewrites bytecode
[34:00] to optimize runtime performance.
[34:03] Effective R8 configurations lead
to fewer ANRs, reduced app size,
[34:08] and quicker startup times.
[34:11] ADARSH FERNANDO: Let's use
that time machine and jump
[34:13] to the results.
[34:15] OK, the agent's done
its thing, and I
[34:17] can see that it's used the
R8 Analyzer Skill to actually
[34:21] recommend changes to
the build configuration
[34:23] to enable R8's full mode.
[34:25] That's great.
[34:26] So if I scroll down
a little further,
[34:28] I can see that it's using
the new R8 Configuration
[34:31] Analyzer, which means in
the final report, great,
[34:35] I have my updated
optimization, obfuscation,
[34:39] and shrinking scores.
[34:41] Now, to achieve these
scores, the agent
[34:44] has audited and
suggested updates to my
[34:46] keep rules to maximize
the effectiveness of R8.
[34:50] Previously, almost none of
the app's code was optimized.
[34:54] With these changes, R8 was
able to optimize almost all
[34:57] of the code.
[34:58] It's now faster and smaller,
all from a single prompt.
[35:02] FLORINA MUNTENESCU: This app
is getting better and better.
[35:04] But let's add one more
feature before we ship it.
[35:08] We need deep links to
maximize engagement and ensure
[35:12] that our users are taken
directly to their upcoming trip
[35:15] right inside the app.
[35:17] So if I click on this link
in the booking confirmation,
[35:21] this doesn't
currently go anywhere.
[35:23] In the latest version
of Android Studio,
[35:25] we have a dedicated
App Links Assistant
[35:28] to help you implement the
deep links in your app.
[35:30] So if I go to Tools, App Links
Assistant, open the URL Mapping
[35:34] Editor, and then I have my
host, Jetpacker Demo, then I
[35:39] can select which activity
to handle my intents,
[35:43] my deep links.
[35:44] And then I pass a
sample URL to process.
[35:47] And that's it.
[35:48] AI is doing its job now.
[35:50] ADARSH FERNANDO: All right,
you all know the drill.
[35:52] Let's jump over to the results.
[35:55] OK, so here, I can see
that the agent has analyzed
[35:58] that URL along
with the app's code
[36:03] to recommend a custom
implementation plan.
[36:06] And with that plan,
it's implemented
[36:08] the exact routing logic that
uses the trip data from that URL
[36:12] it parsed.
[36:13] So if I go back to
that device and click
[36:17] on that action in the email, it
goes to the personalized trip
[36:20] right in the app.
[36:21] FLORINA MUNTENESCU: Nice.
[36:22] Ship it, ship it, ship it.
[36:24] ADARSH FERNANDO: Are all
PMs like that or just me?
[36:25] FLORINA MUNTENESCU: Just you.
[36:26] ADARSH FERNANDO: OK.
[36:27] Well, the good news
is that now you
[36:30] can publish updates of your
app from Android Studio
[36:34] directly to Google Play.
[36:35] Check this out.
[36:37] All I need to do to get started
is go to Build and Generate
[36:41] a Signed App Bundle.
[36:42] Then after a couple
of clicks and making
[36:45] sure to check this new option
that I want to upload to Play,
[36:51] I'm ready to upload a new
version of my app to Play.
[36:55] And after I click Next, it's
off to the internal test track
[36:58] so testers can test while I
get the Play Store page ready.
[37:02] FLORINA MUNTENESCU: OK.
[37:03] Now, one last thing.
[37:06] ADARSH FERNANDO: Let's give
you an early sneak peek--
[37:09] FLORINA MUNTENESCU:
Like, really early.
[37:11] ADARSH FERNANDO: Super early--
[37:12] into a suite of
tools we're building
[37:14] to easily migrate and extend
your app to Android, regardless
[37:18] of whether your source is React
Native, a web framework, or even
[37:22] iOS.
[37:23] FLORINA MUNTENESCU: So let's
say your company is looking
[37:25] to expand an existing iOS app to
Android's over 3 billion users.
[37:31] To make this a matter of
hours rather than weeks,
[37:34] we're experimenting
with a new migration
[37:36] assistant in Android Studio.
[37:39] Here's how we're
thinking for doing this.
[37:41] Go to File, New
Project, and then select
[37:45] Migrate to a New Project.
[37:47] I can choose which
app I want to migrate.
[37:55] OK.
[37:56] Then I can decide whether I want
to let the AI make decisions
[38:00] for me, or whether I
prefer to be more involved
[38:03] by selecting Guided Migration.
[38:06] I can attach reference images
or even some custom skills.
[38:10] But then, instead of doing
the validation myself,
[38:14] I can let the agent handle
that for me with Journeys.
[38:17] It creates a set of natural
language instructions following
[38:20] our app's user journeys.
[38:22] And then the agent
executes, evaluates,
[38:25] and iterates on the app.
[38:27] ADARSH FERNANDO:
Just for this demo,
[38:29] we've selected this open-source
project called Metropolis.
[38:32] It's a gamified companion
for the public transit
[38:35] network in Paris.
[38:36] It's really fun.
[38:37] You get points when you
track your routes and badges
[38:40] when you ride the full
length of a transit line.
[38:42] FLORINA MUNTENESCU: We
ran the migration earlier
[38:44] and then spend a bit of
time on a few polish tasks,
[38:48] like adding Maps SDK support
and fancier animations.
[38:56] Do you want to see?
[38:58] ADARSH FERNANDO: I want to see.
[38:59] Do you all want to see?
[39:01] [APPLAUSE]
[39:03] FLORINA MUNTENESCU: All right.
[39:05] So here's the iOS
simulator and the app
[39:09] running in the iOS simulator,
and then the Android
[39:11] app in an emulator.
[39:13] So let's say that we want to
take the metro number one.
[39:19] Then we press Start Travel.
[39:24] And then we go to from La
Défense to Les Sabions.
[39:32] And then Confirm Journey.
[39:37] Wow.
[39:37] Look at all the progress
the agent made for us.
[39:40] [APPLAUSE]
[39:46] OK, let's see how we got here.
[39:48] So the Android Studio's
Migration Assistant first
[39:51] creates the feature
mapping, and only
[39:53] afterwards, the project plan.
[39:57] Since the agent knows the
typical iOS and Android
[40:00] projects, the agent
looks at the Xcode
[40:03] storyboard to create the
corresponding Android screens.
[40:07] It knows how to handle
things like migrating strings
[40:11] from iOS to Android,
and even how
[40:13] to convert assets like SVGs
and PDFs to vector drawables.
[40:19] And then, when implementing
the Android code,
[40:22] libraries like Jetpack
Compose, Room, and ViewModels
[40:26] are used together
with best practices,
[40:29] like predictive back navigation.
[40:32] To perfect your app and
make it production-ready,
[40:35] you can use all the
great agents and tools
[40:37] that are already within
Android Studio, since this
[40:41] is a native Android app.
[40:43] The Migration Assistant is
coming to Android Studio
[40:46] later this year.
[40:48] We are also planning on
providing support for migration
[40:51] to Kotlin Multiplatform
to make it
[40:53] even easier to maintain shared
business logic for Android
[40:57] and iOS.
[40:59] ADARSH FERNANDO: By combining
Antigravity and Android CLI
[41:02] with the pro capabilities
and production-grade polish
[41:05] of Android Studio,
we're unifying
[41:07] our most powerful tools for
incredible productivity gains.
[41:12] No matter what form factor
you're building for,
[41:14] you can bring your ideas
to life easier than ever,
[41:17] while maintaining
Android best practices.
[41:20] Teams of all sizes
and skill levels
[41:23] can build cutting-edge
Kotlin apps
[41:25] and deploy them to Google
Play in record time.
[41:29] And in this new era of
development with Google,
[41:32] we're extending that same
level of agentic coding
[41:35] across every platform.
[41:38] Now, let's hear
from Una to tell us
[41:41] how this digital workforce is
delivering incredible new web
[41:45] experiences.
[41:46] [MUSIC PLAYING]
[41:48] [APPLAUSE]
[41:52] UNA KRAVETS: Hello.
[41:53] [MUSIC PLAYING]
[42:01] AI agents are transforming
the landscape of development
[42:05] everywhere.
[42:06] And nowhere is that
transformation happening
[42:08] faster than on the web.
[42:10] Take the browser.
[42:12] With Gemini now
built in, Chrome has
[42:14] evolved to put AI assistants
right at your fingertips,
[42:18] unlocking a new era of
interactivity and possibility
[42:22] for users and developers.
[42:25] It's an exciting time to
experiment without barriers,
[42:29] to build with
confidence, to finally
[42:32] bring to life all those
ideas you've envisioned,
[42:35] now with a clarity
and a velocity that
[42:38] just a few months ago
seemed impossible.
[42:42] What it means to build for
the web is rapidly evolving.
[42:46] Today, you'll see how you can
harness agentic coding tools
[42:50] to orchestrate all-new
web experiences
[42:54] with intelligent guidance,
automated debugging,
[42:57] and powerful new APIs.
[43:00] This is the future of
the web, imagined by you
[43:05] and supercharged by AI.
[43:07] Let's dive in.
[43:09] When I talk about modern web
capabilities, the question
[43:12] that I hear the most from
fellow developers is,
[43:15] how do I even keep up with
all of these new features?
[43:18] Yes, it's exciting to see
the web platform accelerate
[43:22] with dozens of new APIs
added every few months.
[43:26] But first, you have to
figure out if they'll even
[43:28] work for your users.
[43:30] And then you have to
learn how to use them.
[43:33] Baseline solves
that first problem.
[43:36] With 100% of web platform
features now mapped,
[43:40] Baseline is a definitive
industry standard
[43:42] that gives you visibility
into web feature availability
[43:46] across the major browsers.
[43:48] Now, for that second
problem, there really
[43:50] hasn't been a solution to
keeping up with new features
[43:54] until now.
[43:56] Today, we're
launching a new tool
[43:58] to supercharge your agents,
Modern Web Guidance,
[44:02] a comprehensive and
expert-vetted set of skills
[44:06] providing AI agents with
a blueprint for modern web
[44:09] features.
[44:10] Building on our
experience with Baseline,
[44:13] it ensures that your agent isn't
using yesterday's technology,
[44:16] but implementing the latest
web platform features
[44:19] and most recent
Chrome innovations
[44:21] compatible with your
Baseline target.
[44:24] Modern Web Guidance
empowers you to stay
[44:27] in the flow of
experimenting and iterating
[44:30] while the agent handles
the implementation.
[44:33] You can target a specific
Baseline version,
[44:36] and the agent will
constrain its suggestions.
[44:39] The guidance even contains
fallback solutions
[44:41] and alternatives for the newest
platform features that don't
[44:45] have wide browser support yet.
[44:47] To show you how
powerful and easy
[44:49] it is to use Modern Web Guidance
with your coding agent, let's
[44:53] welcome Matthias
to the demo desk.
[44:56] [APPLAUSE]
[45:01] MATTHIAS ROHMER: Thanks, Una.
[45:02] Here's something I've
been working on, Dynorun,
[45:05] our Chrome dyno-inspired
car site built in React.
[45:09] Using CSS scroll-driven
animations,
[45:12] our site unfolds as a fluid,
narrative-lead experience,
[45:16] and after that, leads us
into the Model Configurator.
[45:18] Let's check it out.
[45:24] Give it a second to load.
[45:27] All right.
[45:28] So what color
should we pick, Una?
[45:30] What do you think
about this green,
[45:32] or should we rather
go for cerulean?
[45:35] UNA KRAVETS: Now, Matthias,
this looks amazing.
[45:37] But you know what?
[45:38] All of these menus,
options, and sliders--
[45:42] if I was really using this, I'd
want a shortcut like a browser
[45:45] agent to do the heavy
lifting and just help
[45:47] me build a car to fit my needs.
[45:50] So you know what
I'm going to ask.
[45:51] Can we make this work
seamlessly with agents?
[45:54] MATTHIAS ROHMER: You
know, a few months ago,
[45:56] that would be a
really hard question
[45:57] to answer, but not anymore.
[46:00] With WebMCP, we can now make
this web page agent-ready
[46:04] in minutes.
[46:05] This proposed browser standard
lets you expose web capabilities
[46:09] to browser-based agents.
[46:11] In other words, it
lets you tell agents
[46:13] how and where to
interact with your site,
[46:16] making those interactions
more precise and reliable.
[46:20] UNA KRAVETS: Now, we could
implement this ourselves
[46:22] on the stage, but with
Modern Web Guidance,
[46:25] our agent has the skills
to do it on its own.
[46:28] All we need to do is ask.
[46:29] Matthias, could
you give it a try?
[46:31] MATTHIAS ROHMER: Absolutely.
[46:32] Let me open Antigravity,
where I can just prompt.
[46:35] Please implement WebMCP tools
for the car configurator
[46:39] on this page.
[46:41] And off we go.
[46:44] Modern Web Guidance is a
set of text-based skills
[46:47] that are internally tested,
benchmark-proven, and
[46:50] token-efficient.
[46:52] So for web development
tasks, the jump
[46:54] in pass rates in guided
compared to unguided coding
[46:58] is an average of 37
percentage points.
[47:02] And you can even read the
Markdown files yourself.
[47:07] Well, let's go ahead
and allow this all.
[47:10] There we go.
[47:12] Let me pull up an
example for a guide.
[47:15] This Skill contains
knowledge about WebMCP
[47:18] so your coding agent can jump
start the development process
[47:22] and handle the groundwork
with confidence, giving you
[47:25] a solid foundation
to test and refine.
[47:28] Here you can see how it
explains that WebMCP is made up
[47:32] of JavaScript functions
that are exposed
[47:34] to agents through an API.
[47:37] We've made accessing
and implementing
[47:40] Modern Web Guidance
as easy as possible.
[47:43] In Antigravity, it's easy
to install with one click
[47:46] during onboarding or
later on from Settings.
[47:49] But if Antigravity is not
your coding agent of choice,
[47:52] you can install it as a
ready-made package of skills
[47:55] for other coding tools.
[47:57] And because the guidance
is explaining core platform
[48:00] features, it adapts
to your framework
[48:02] of choice, no matter if it's
Angular, React, or any other.
[48:08] All right, let's check on
progress in Antigravity.
[48:11] All right, looks
like it's finished.
[48:14] So I'm switching back
to Chrome, and I'm
[48:17] going to click Ask
Gemini in the top right.
[48:21] This brings up a
prototype of Gemini
[48:24] in Chrome with experimental
WebMCP support.
[48:28] Since this is still
in active development,
[48:30] the final version may differ
from what we'll see today.
[48:33] And while this demo is
Chrome-specific for now,
[48:35] once WebMCP
stabilizes, these tools
[48:38] will be compatible with any
browser-based agent that
[48:42] supports WebMCP.
[48:43] Una, let's prompt away.
[48:46] UNA KRAVETS: OK,
let's have some fun.
[48:48] Can you prompt in
Gemini in Chrome,
[48:51] configure the
ultimate party car.
[48:53] I want immersive audio,
and some interior lighting
[48:56] would be great.
[48:58] Plus, enhanced visibility for
night driving to keep me safe.
[49:01] And I don't want to go too
crazy, so keep it under $40,000.
[49:05] But give me as many add-ons
as you can under that.
[49:09] MATTHIAS ROHMER: All right, this
sounds like an excellent build.
[49:11] I'm briefly double
checking the prompt.
[49:14] And here we go.
[49:15] Now Gemini in Chrome
creates an auto browse plan
[49:18] and briefly passes it back
to me for confirmation.
[49:21] I'll briefly approve the
task, and then off it goes.
[49:26] UNA KRAVETS: With WebMCP, Gemini
in Chrome and other browser
[49:29] agents have one more
tool in their box
[49:32] to interact with a website.
[49:34] In test runs with
this site, Antigravity
[49:36] has implemented an imperative
tool called Update Car
[49:40] Configuration, with all
configuration options listed
[49:43] in the schema definition.
[49:45] Now, Gemini in Chrome can use
this specific targeted WebMCP
[49:50] tool for the job.
[49:51] MATTHIAS ROHMER: And
through Modern Web Guidance,
[49:53] we were able to
implement it and make
[49:55] this app ready for the
agentic web in no time.
[49:59] Una, your build has
finished, meanwhile.
[50:01] What do you think?
[50:03] UNA KRAVETS: Let's talk
about the color later on.
[50:05] But this is so much easier than
finding all of the right options
[50:09] myself.
[50:10] Modern Web Guidance, with
support for over 100 use cases
[50:14] for dozens of the
latest features,
[50:16] is available for
early preview today.
[50:20] [APPLAUSE]
[50:25] I'm also excited to announce
that the experimental WebMCP
[50:29] API will enter origin trial
starting in Chrome 149.
[50:34] [APPLAUSE]
[50:38] And Gemini in Chrome will soon
support your WebMCP tools,
[50:42] building on the active
experiments we're running
[50:44] with our ecosystem partners.
[50:47] [APPLAUSE]
[50:49] It's exciting.
[50:52] OK, so we've added some new
features to our website.
[50:54] But could we have
the coding agent now
[50:57] test this like a
real user would?
[50:59] MATTHIAS ROHMER: Yes, we could.
[51:00] I think by now most folks here
have tried building with agents.
[51:04] They've gotten a lot better,
but you still don't always
[51:07] get what you prompted for.
[51:09] And that's because your
coding agent can't actually
[51:12] see what it's coding.
[51:14] That all changes with the new
Chrome DevTools for agents.
[51:18] Thanks to-- go ahead.
[51:20] [APPLAUSE]
[51:24] Thanks to incredible feedback
from our early preview,
[51:27] we've evolved it
to do even more.
[51:30] Now your agent can finally see
how the code that has written
[51:33] performs at runtime.
[51:35] With the MCP server, the CLI,
and a set of tailored Skills,
[51:39] it finally creates a closed
feedback loop for agents.
[51:43] That's phenomenal for building,
validating, and debugging.
[51:47] To see its capabilities,
let's go back to Antigravity,
[51:50] where I again prompt, please
check the WebMCP implementation
[51:55] with Lighthouse.
[51:59] Now, what will
happen in a second is
[52:01] you'll see Chrome popping
up, loading our page,
[52:05] basically the same
thing that would
[52:06] happen if you ran a Lighthouse
audit through the DevTools UI.
[52:10] But I think I need to
allow one more tool call.
[52:14] There we go.
[52:16] There is Lighthouse running.
[52:18] And Lighthouse runs with a
new agentic browsing category,
[52:23] which enables Lighthouse to
run a comprehensive health
[52:25] check for the agentic web.
[52:27] It validates your WebMCP
tool registrations
[52:30] and ensures your forums have the
declarative metadata that agents
[52:34] need to be successful.
[52:37] UNA KRAVETS: It also
verifies your llms.txt file,
[52:40] a new standard for giving models
a clear map of your site's
[52:44] content.
[52:45] And it's reevaluating a lot
of the familiar Lighthouse
[52:48] accessibility audits.
[52:50] Because most agents
navigate the web using
[52:53] the accessibility tree,
every ARIA role or label
[52:56] that you optimize doesn't
just help a human.
[52:59] It makes your site more
actionable for an agent, too.
[53:03] When an issue is surfaced
through Lighthouse,
[53:05] you don't need to be the
human clipboard anymore,
[53:08] copying an error from DevTools,
passing it into a chat,
[53:11] and hoping that the agent
guesses the right fix.
[53:14] The agent reads the report for
itself, attempts a solution,
[53:18] and can rerun audits to see
if that solution worked.
[53:22] It's a supercharged
workflow that
[53:24] automates the busy work, leaving
you free to spend your time
[53:27] innovating.
[53:29] If you want to give it a try,
Chrome DevTools for agents
[53:32] is available today
for Antigravity
[53:35] and more than 20 other
coding agents of your choice.
[53:38] [APPLAUSE]
[53:44] OK, Matthias, I think that we
have one more surprise hidden
[53:47] away in our car configurator.
[53:49] MATTHIAS ROHMER: Yeah, we do.
[53:50] Let's go back to your party
car running in Canvas.
[53:53] Let me switch to
the interior view.
[53:56] Do you see the
screen in the center?
[53:58] UNA KRAVETS: Yep.
[53:58] MATTHIAS ROHMER: It's
actually interactive.
[54:00] I can click through to the
Settings screen of our car
[54:03] and adjust the ambient lighting
just by pulling the sliders.
[54:07] And you know what?
[54:08] If we do a quick
inspect in DevTools
[54:11] and select those elements,
the full display UI
[54:15] is actually native.
[54:16] Those are native HTML elements
rendered into the Canvas.
[54:21] UNA KRAVETS: Woo!
[54:22] [APPLAUSE]
[54:24] I know what some of you out
there might be thinking.
[54:28] HTML elements
inside of a Canvas?
[54:30] Well, that shouldn't
be possible.
[54:33] MATTHIAS ROHMER: The
new HTML in Canvas API
[54:35] now does the impossible.
[54:37] With this, you can now integrate
real DOM elements directly
[54:40] into your Canvas environment.
[54:42] Now, you no longer
have to choose
[54:44] between visually complex and
stunning or interactable and
[54:47] accessible.
[54:48] UNA KRAVETS: Exactly.
[54:49] Because it's part of the DOM,
every element in your Canvas
[54:53] is now searchable, accessible,
selectable, translatable,
[54:57] and interacts with your built-in
browser features like Autofill.
[55:02] And that creates some really
interesting possibilities.
[55:04] MATTHIAS ROHMER: Yeah.
[55:05] For example, you can style them
just like any other DOM element
[55:09] by adding a little
class like this one.
[55:14] UNA KRAVETS: Nice.
[55:15] We've already seen the community
build amazing demos with WebGL
[55:19] textures, 3D interfaces,
and entirely new modalities
[55:23] for interaction with
real DOM content.
[55:27] HTML in Canvas is
an origin trial now,
[55:30] so you can test,
experiment and build.
[55:34] [APPLAUSE]
[55:40] Now, I know a lot
of web developers
[55:41] are really excited
to try this out,
[55:43] and that's because this is
more than just a new feature.
[55:47] Alongside everything
else you've seen today,
[55:50] it represents a fundamental
shift in how we build,
[55:54] who can build, and
even what we can build.
[55:57] In this new era of
agentic web development,
[56:00] there's never been a more
inspiring time to create.
[56:04] With tools like
Modern Web Guidance
[56:07] to help you quickly and
reliably implement new features
[56:10] like WebMCP, HTML in
Canvas to truly expand
[56:15] accessible, interactive,
creative new UI on the web,
[56:19] and Chrome DevTools for agents
to autonomously debug and test
[56:24] performance, the future of
the web is imagined by you
[56:28] and supercharged by AI.
[56:31] But this isn't
just about the web.
[56:33] It's about how we
build everything.
[56:36] So to bring it all together,
please welcome back Josh.
[56:39] [MUSIC PLAYING]
[56:41] [APPLAUSE]
[56:47] JOSH WOODWARD: All right.
[56:48] What a show.
[56:49] From Google AI Studio
to Antigravity,
[56:51] from Android to the
open web, today you've
[56:55] seen agents completely transform
the developer experience.
[56:59] The common thread across
all of this is simple.
[57:02] You focus on the big
idea, and the agents
[57:04] can do the heavy lifting.
[57:06] And it's never been a
better time to build.
[57:09] We hope you'll take
what you've seen today
[57:11] and push it to the limits.
[57:13] To get you started, we've
created the ultimate platform
[57:16] to make an impact.
[57:17] We are officially
launching the Build
[57:19] with Gemini XPRIZE hackathon.
[57:22] This global hackathon is
going to offer up $2 million
[57:26] in prizes for builders
who create apps that solve
[57:30] actual real world challenges.
[57:33] And the premise is simple.
[57:35] Pick a problem worth solving.
[57:37] Build with Gemini.
[57:38] And let's all try
to positively impact
[57:40] the lives of a billion people.
[57:43] To build at that
scale, you're going
[57:45] to need some serious power.
[57:47] And as you heard
this morning, we
[57:49] announced a new $100 per
month Google AI Ultra plan,
[57:53] alongside a simplified
pricing structure,
[57:56] based on your feedback.
[57:57] And to keep those agents
humming over the long weekend,
[58:01] we're giving all
Ultra subscribers
[58:02] $100 in bonus credits today.
[58:05] You can claim the offer
right in the Antigravity app.
[58:10] And the credits will kick
in when you hit your limits.
[58:12] So let's get going.
[58:14] You can visit io.google
for the live stream
[58:17] sessions and all
on-demand content
[58:19] we'll be releasing
over the next few days.
[58:22] Thanks for coming, and
have an amazing IO.
[58:24] [APPLAUSE]
[58:26] [MUSIC PLAYING]