Since Gemma 4 dropped in early April, working inside Antigravity feels noticeably different.
Running Gemma 4 locally while coding, I started noticing fewer moments where I could tell whether I was hitting a cloud model or something running on my own machine. "AI democratization" is a phrase I've heard for years — but this is the first time it's felt real in my actual workflow.
Google I/O 2026 is coming up in May. Before I share what I'm hoping to see announced, I want to walk through what's actually changed in the first half of 2026 — based on what I've been building day-to-day.
Gemma 4 Integration Changed What "Local Development" Means
The biggest surprise when I first set up Gemma 4 inside Antigravity was how well it maintained context across a long session.
Before Gemma 4, when I asked an agent to handle a multi-file refactor, it would often lose the thread somewhere in the middle and ask me to re-explain the goal. Gemma 4 handles those longer sessions noticeably better. The project's overall structure stays "in scope" even as you pile on incremental changes.
For projects where you'd rather not send code to the cloud — client work, sensitive repos, or anything under an NDA — local Gemma 4 is a practical option now. The basics of setting it up are covered in Gemma 4 × Antigravity Guide. As of April 2026, the 8B and 12B models run stably. The 27B+ models work but require significantly more RAM, so I'd start with 8B.
# Setting up local Gemma 4 via Ollama in Antigravity
# Add this to .antigravity/settings.json
{
"modelOverride": {
"provider": "local",
"model": "gemma4:8b",
"endpoint": "http://localhost:11434/v1",
"contextWindow": 32768,
"temperature": 0.2
}
}
# Start the model in Ollama first:
# ollama run gemma4:8b
#
# Expected result: Antigravity completions and chat
# now route through your local Gemma 4 instance.
# Latency goes up, but nothing leaves your machine.One setting worth noting: temperature at 0.2. For code generation, you want reproducibility over creativity. At 0.7 or above, the completions can get "interesting but unusable" — especially for boilerplate-heavy tasks.
AgentKit 2.0 Changed How I Delegate Work
AgentKit 2.0 made delegating to agents feel different. The most practical improvement for me has been how easy it became to define custom tools.
Previously, giving an agent a new capability meant writing a fair amount of scaffolding code. With AgentKit 2.0, TypeScript function definitions generate tool schemas automatically. That's reduced the friction of extending an agent's toolset considerably.
The feature I reach for most often is built-in error handling. When an agent fails at something — API timeout, parsing error, whatever — the retry logic runs automatically instead of requiring me to step in. Those moments of "oh, the agent stopped again" that used to pull me back to the terminal have gotten much rarer.
Full implementation patterns are in the AgentKit 2.0 Complete Guide. My suggestion: build a minimal custom tool before reading the docs too deeply. Getting something running first makes the documentation click much faster.
Manager Surface and the Feeling of Having a Team
Manager Surface lets a top-level agent coordinate multiple sub-agents, each handling a specific part of a task.
The first time I used it, I described it to a friend as "feeling like a director." I give the Manager a high-level goal — say, "read this API docs and give me three implementation approaches, compared" — and the Manager breaks it down, dispatches sub-agents, and aggregates their findings back to me.
For indie developers, the most useful pattern I've found is splitting "research → design → implementation" across sub-agents when adding a significant feature. The research agent reads the existing codebase, the design agent drafts approaches, the coding agent writes the actual implementation. The clarity that comes from that separation is surprisingly large even when you're the only human in the loop.
That said, Manager Surface has rough edges. If you give the sub-agents vague instructions, things go sideways. You still need to be precise about roles and boundaries — it's just that you're specifying them at a higher level of abstraction.
MCP Ecosystem and the Integrations I Actually Use
The MCP (Model Context Protocol) ecosystem around Antigravity has expanded significantly in 2026. While Antigravity's native MCP support is still evolving, there are enough bridges to make the key integrations work well.
Three I rely on daily:
-
Figma integration: Feeding component definitions from a Figma file into Antigravity meaningfully improves UI code generation. The generated components stay closer to the design intent when the agent can actually read the design.
-
GitHub Issues integration: I load open issues into Antigravity's context when working on bug fixes. Paired with error logs, it can sometimes connect a specific issue to the root cause without me having to spell it out.
-
Supabase schema loading: Passing the database schema before asking for SQL or API code dramatically reduces type mismatches. Without the schema, agents will occasionally reference columns that don't exist. A small thing that adds up.
Building your own MCP server to pipe in project-specific data is covered in the Custom MCP Server Guide. Once you have your own data sources wired up, the quality of agent output shifts noticeably.
What I'm Watching for at Google I/O 2026
About a month until Google I/O 2026. Based on where Antigravity and Google's AI tooling are heading, here's what I'm expecting — or at least hoping to see.
Gemma 4 optimization for coding tasks: The current 8B model is good, but a version specifically fine-tuned for Antigravity's Editor View would push completion quality meaningfully higher. Google has the data; it wouldn't be surprising to see an "Antigravity Edition" of Gemma 4 announced.
AgentKit stabilization: AgentKit 2.0 still has rough corners — some APIs feel beta-quality. A stable release at I/O, ideally paired with a community template library, would make multi-agent workflows accessible to a lot more developers.
Deeper Stitch integration: The Antigravity–Stitch integration got meaningfully tighter in early 2026. If I/O brings announcements that close the loop from UI generation through deployment inside Antigravity, that's going to matter a lot for solo builders.
Firebase Studio convergence: Firebase Studio and Antigravity currently exist as mostly separate products. An integration where Antigravity persistently understands the state of your Firebase project — realtime database, auth, functions — would make backend-aware frontend development much more fluid.
Two Things Worth Doing Before I/O
After I/O, there's always a flood of announcements to absorb. Having some foundation laid beforehand makes it easier to act on new features quickly.
Set up local Gemma 4 now: If a model update ships at I/O, having Ollama already configured means you can try it the same day. The setup takes maybe 20 minutes; the payoff is being ready to experiment immediately.
Build one thing with AgentKit 2.0: Concepts only sink in through implementation. Even a minimal agent with one custom tool is enough to calibrate how the framework actually behaves. That calibration will make any AgentKit announcements at I/O much easier to evaluate.
The Google I/O 2026 schedule and sessions are being updated at io.google as they're confirmed. I'm expecting more concrete implementation examples this year than last — the AI IDE market is competitive enough now that Google has reason to show real depth. Looking forward to seeing what they've built.
For those who want a deeper dive into any of the areas covered here, the Manager Surface Guide walks through multi-agent architecture patterns in detail. It's particularly useful if you're thinking about how to structure sub-agent roles before trying Manager Surface yourself.
The pace of change in 2026 has been fast. The tools that felt like experiments six months ago are now genuinely load-bearing parts of how I ship software. I'm curious to see whether I/O accelerates that further — or opens entirely new directions I'm not predicting at all.