Google I/O 2025: Developer Features You Should Prioritize This Week

Google I/O 2025 ran long and moved fast. Between the keynote theatrics and the 150-plus session catalog, it's easy to walk away with a vague sense that a lot happened but no clear idea of what to actually open your laptop and do about it.

This article cuts through the announcement list and focuses on the features that have working APIs, usable SDKs, or imminent GA dates — the ones worth your time this week, not six months from now.

What You'll Learn

• Which Gemini model updates ship with meaningful capability changes versus marketing refreshes
• How Jules, Google's async coding agent, fits into a real CI workflow
• What the Live API unlocks for real-time multimodal apps
• Key Android 16 changes that require code updates before your next release
• How Veo 3 and Imagen 4 are exposed as API endpoints you can call today

What Landed at Google I/O 2025

Google organized this year's I/O around three pillars: reasoning models, agentic tooling, and on-device AI. Each pillar had a mix of production-ready and preview-stage releases, and the distinction matters a lot if you're deciding where to spend engineering hours.

The safest mental model: anything surfaced through the Gemini API or Google AI Studio with a stable endpoint is actionable now. Anything described as an "early preview" or requiring a waitlist is worth bookmarking but not blocking a sprint on.

Gemini 2.5 Pro: The Reasoning Upgrade Developers Need to Test

Gemini 2.5 Pro received a substantial update that focuses on long-context reasoning and code execution accuracy. The context window holds at 1 million tokens, but the model now handles retrieval-heavy prompts with noticeably better coherence across that window — particularly in multi-file codebases and long document analysis tasks.

The code execution improvements are the part worth testing immediately. The updated model performs better on multi-step reasoning tasks where earlier 2.5 versions would lose track of intermediate state. If you've been using the model for automated code review or test generation, rerun your eval suite against the new checkpoint before assuming behavior is stable.

Pricing stayed roughly comparable to the previous tier, which makes the swap low-risk. You can evaluate it directly in Google AI Studio or swap the model identifier in your existing Gemini API calls:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-2.5-pro-latest")

response = model.generate_content(
    "Review the following Python function for edge cases and suggest fixes."
    + your_code_string
)
print(response.text)

If you're already comparing frontier models for code tasks, the head-to-head between OpenAI o3 and Gemini 2.5 Pro on coding benchmarks is worth reading alongside these I/O updates to calibrate your expectations.

Google AI Studio: Faster Iteration Without Leaving the Browser

Google AI Studio shipped several quality-of-life upgrades that matter for prototyping speed. The most useful is persistent system instructions per project, which means you stop re-pasting your prompt scaffolding every session. Projects now save API call history with the exact model parameters used, which makes regression testing between model versions far less tedious.

The new "Compare" mode lets you run the same prompt against two model configurations side by side in one view. This is genuinely useful when you're deciding between Gemini 2.5 Flash and 2.5 Pro for a latency-sensitive endpoint. For a deeper look at what Flash brings to cost-sensitive workloads, the practical guide to Gemini 2.5 Flash covers token pricing and throughput tradeoffs in detail.

Grounding with Google Search is now available in AI Studio without a separate configuration step. For agents that need current information without fine-tuning on recent data, this is the fastest path to a working prototype.

Jules: Google's Async Coding Agent

Jules is Google's answer to the async coding agent category — it runs in the background, picks up GitHub issues, writes code, and opens a pull request for your review. The positioning is similar to what you may have seen from other AI coding tools, but Jules runs inside Google's infrastructure and integrates directly with the Gemini code execution environment.

The practical workflow looks like this: you assign Jules to an open GitHub issue, it clones the relevant branch, reasons through the codebase, makes targeted changes, and posts a PR with an explanation of what it did and why. You review and merge, or push back with a comment and let it iterate.

Early access is rolling out through a waitlist, but the documented integration points are already public. Jules uses the same tool-use API conventions you may already have set up for other Gemini agent workflows, so the ramp-up is manageable if you've built agents before. It's worth understanding where async AI coding agents tend to fail before you hand Jules a large refactor task — the production failure patterns in AI coding agents covers the category-wide pitfalls that apply here too.

Project Astra and the Live API

Project Astra is Google's ongoing multimodal agent research, and this year it got a developer-facing surface: the Live API. The Live API lets your application maintain a persistent, low-latency connection to Gemini, streaming audio and video frames in real time and getting responses back in kind.

This is what enables the "look at this and explain it" interaction pattern — your app sends a camera frame, the model responds, and the conversation continues with full context of the visual stream. The API uses WebSockets for the persistent connection and returns streamed token output or audio, depending on configuration.

A minimal connection in Python looks like this:

import asyncio
from google import genai

client = genai.Client(api_key="YOUR_API_KEY")
MODEL = "gemini-2.0-flash-live-001"

CONFIG = {"response_modalities": ["TEXT"]}

async def main():
    async with client.aio.live.connect(model=MODEL, config=CONFIG) as session:
        await session.send(input="Describe what you see.", end_of_turn=True)
        async for response in session.receive():
            if response.text:
                print(response.text)

asyncio.run(main())

The Live API is available in the Gemini API today on a usage-limited basis. Rate limits are tighter than the standard generate endpoint, so plan for backoff logic from the start rather than retrofitting it when you hit production load. If you've been following the real-time voice API space, the architecture choices here overlap with what the OpenAI Realtime API rollout established as baseline expectations for latency and session management.

Android 16 and the New Adaptive UI System

Android 16 moves the adaptive layout system from recommended practice to a harder requirement for apps targeting the new SDK. If your app uses a fixed-orientation manifest flag or hard-codes pixel breakpoints, you will see layout breakage on the new foldable and large-screen form factors that are increasingly common on Pixel devices.

The key change is the promotion of WindowSizeClass from a Jetpack library convenience to the primary layout decision point the platform expects you to use. Apps that ignore it won't be blocked from publishing immediately, but the Play Store has started surfacing form-factor compatibility ratings to users, which affects install conversion on tablet and fold hardware.

The adaptive UI migration checklist is short but non-trivial:

1. Remove any screenOrientation locks in your AndroidManifest.xml unless there is a hard device-sensor reason for them.
2. Replace hardcoded dp breakpoints with WindowWidthSizeClass checks in your composables or fragment transactions.
3. Test on the resizable emulator at Compact, Medium, and Expanded width classes before submitting to the Play Store.
4. Audit any dialogs or bottom sheets that use fixed match_parent widths — they often clip on foldable inner screens.

Android 16 also ships updated predictive back gesture APIs and a refreshed notification permission flow. Neither requires urgent code changes, but both affect UX quality enough to be worth scheduling before your next minor release.

Veo 3 and Imagen 4: When Generative Media Becomes an API Call

Veo 3 is Google's latest video generation model, and unlike its predecessors it ships with a documented API endpoint rather than a demo-only interface. You send a text prompt (and optionally a reference image), set duration and aspect ratio parameters, and get back a video file URI when the job completes. The generation is asynchronous — you poll a job ID rather than waiting on a synchronous response.

Imagen 4 follows the same pattern for images but with substantially better text rendering inside generated images and improved photorealism on hands and faces — historically weak points in diffusion models. The API surface is nearly identical to Imagen 3, so migration is mostly a model-name swap in existing integrations.

Both models sit behind the Vertex AI API as well as the Gemini Developer API, so your existing auth and quota setup applies. Use Vertex AI if you need enterprise SLAs and VPC controls; use the Gemini Developer API if you're prototyping and want faster iteration without configuring a GCP project.

A practical use case that's immediately buildable: a content pipeline that takes a product brief, generates a thumbnail image with Imagen 4, and produces a short promotional video clip with Veo 3 — fully automated, triggered by a webhook from your CMS.

Common Pitfalls to Avoid This Week

Don't treat preview announcements as shipping features. Several I/O demos — including some of the more dramatic Project Mariner and Deep Research API segments — are research previews with no public endpoint. Build on what has a documented API and a stable model identifier today.

Don't skip rate limit planning on the Live API. The persistent WebSocket connection pattern is new territory for most teams. Session timeouts, reconnect handling, and per-minute token budgets all need to be explicit in your architecture before you go to production.

Don't assume Gemini 2.5 Pro behavior is stable across checkpoints. Google updates model weights behind the same identifier periodically. Pin a specific checkpoint in your eval harness so you can detect regressions, and don't rely on informal behavior observations as a substitute for a formal eval suite.

Don't skip the Android 16 resizable emulator test. It's tempting to test only on a physical device you have on hand. The resizable emulator lets you snap between size classes in seconds and is the fastest way to catch adaptive layout bugs before they reach users.

Don't conflate Jules with a fully autonomous deployment pipeline. Jules writes code and opens PRs — your review and merge step is still essential. Treat it as a fast junior contributor, not a replacement for code review.

Next Steps

Here are the concrete actions worth taking in the next few days:

• Swap your Gemini API calls to gemini-2.5-pro-latest in a staging environment and run your existing eval suite to measure accuracy changes before promoting to production.
• Open the Live API quickstart in Google AI Studio and build a single-turn audio or video interaction end to end — even a toy prototype will surface the latency and reconnect edge cases you'll need to handle.
• Run your Android app through the resizable emulator at all three WindowWidthSizeClass values and file tickets for anything that breaks before Android 16 becomes the dominant target SDK.
• Sign up for the Jules waitlist and prepare one low-risk GitHub issue (a well-scoped bug with a clear acceptance criterion) as the first task to hand it when access arrives.
• Evaluate Imagen 4 for any existing Imagen 3 integration — the text rendering improvement alone is worth a benchmark run if your use case includes text overlays in generated images.