Google Antigravity May 2026 Updates: New Features and What Changed

Every time I open Antigravity's release notes, the workflow notes I wrote the month before are already a little out of date. New features are welcome, but sorting out which ones actually matter for day-to-day work takes longer than trying them.

So instead of transcribing the changelog, this roundup reorders the May 2026 changes around a single question: when I actually used each one, where did it help and where did it trip me up? Read it as decision material for folding these into your own workflow, not as a feature list.

AgentKit 2.0 Integration — the win is the debug output

The change with the biggest felt difference in May was the AgentKit 2.0 integration.

AgentKit 2.0 is Google's major revision of its agent-building framework, and the Antigravity coupling is tighter than before. The feature table lists "better tool-call accuracy" and "improved multi-agent context sharing," but the part I leaned on most was the unglamorous one: richer debug output in the agent loop. You can now trace which tool ran, with what arguments, how many times, and where the agent's reasoning branched. That alone made diagnosing a "why is it behaving unexpectedly" agent dramatically faster.

Here's the minimal agent definition:

from google.aistudio.agentkit import Agent, Tool, AgentConfig
 
config = AgentConfig(
    model="antigravity-2.5-pro",
    max_iterations=10,
    enable_thinking=True
)
 
@Tool(name="search_docs", description="Search technical documentation")
def search_documentation(query: str) -> str:
    return f"Search results for: {query}"
 
agent = Agent(config=config, tools=[search_documentation])
 
result = agent.run("Research React Native SwiftUI integration patterns")
print(result.output)
print(f"Completed in {result.iterations} steps")

One caution: if you leave max_iterations high while handing the agent a tool that calls an external API, the loop can run far more times than you expect and quietly rack up cost. When I add a new tool, I drop max_iterations to 3–4 to watch the behavior first, then raise it once things are stable.

An iteration cap is not enough — watch tool calls too

This one cost me.

max_iterations caps how many times the agent thinks, not how many tools it fires within a single pass. Models that support parallel tool calls will dispatch several at once inside one step. My documentation-search agent normally settled at 2 steps and 5 tool calls. Then I loosened one prompt, and a single run ballooned to 9 steps and 23 calls. Watching step count alone would never have surfaced that.

So I wrap every agent in a thin budget guard.

import time
from collections import Counter
 
def run_with_budget(agent, prompt, *, max_steps=4, max_tool_calls=8):
    """Run an agent under both an iteration cap and a tool-call cap."""
    agent.config.max_iterations = max_steps
    started = time.perf_counter()
 
    result = agent.run(prompt)
 
    calls = Counter(step.tool_name for step in result.steps if step.tool_name)
    total_calls = sum(calls.values())
    elapsed = time.perf_counter() - started
 
    print(f"{elapsed:.1f}s / {result.iterations} steps / breakdown {dict(calls)}")
 
    if total_calls > max_tool_calls:
        raise RuntimeError(
            f"Tool-call budget exceeded: {total_calls} calls (limit {max_tool_calls})"
        )
    return result

It raises rather than returning, because once the budget is blown there is nothing worth continuing for. A run that overshoots its budget has failed operationally, even when the answer happens to be right. Passing result.steps through a Counter shows at a glance which tool is misbehaving. In my case a single external search tool accounted for 15 of the calls, and the root cause was a vague tool description. The broader question of how to keep an agent inside its lane is what making an AI agent a dependable partner is built around.

A2A Protocol Support — turn your own agents into parts

Agent-to-Agent (A2A) protocol support was strengthened this cycle.

A2A is Google's proposed standard for letting agents built on different frameworks talk to each other. With Antigravity now supporting it, agents you build here can interoperate with ones built in LangChain or AutoGen.

The practical change comes down to one thing: an Antigravity-built agent can be called as a "tool" by an agent in another framework. Before, you tended to face an all-or-nothing choice — build everything in Antigravity, or build everything elsewhere. That boundary is gone. You can build just the part Antigravity is good at and leave the overall orchestration to a framework you already know. Not having to draw a large multi-agent design up front, and instead adding small parts one at a time, was especially helpful. As an indie developer running several apps and a few tech blogs alone, being able to swap in just the part I need — without building out the whole system — is what makes this practical.

Splitting work between local and cloud

Ollama and LM Studio connectivity got steadier, and model switching is smoother.

import antigravity
 
client = antigravity.Client(
    backend="ollama",
    model="gemma3:latest",
    base_url="http://localhost:11434"
)
 
response = client.generate(
    prompt="Find the bug in this code",
    context="# Code\n[code here]"
)
print(response.text)

Since this update I've settled into "draft locally, finish in the cloud." Here are the rough timings from my own machine (M2 Pro, 32 GB, gemma3:latest). Hardware moves these numbers a lot, so read the ratios rather than the absolutes.

Just moving the high-repetition work to local noticeably calms the monthly API bill. But switching by hand means forgetting to switch, so I route on the task name and fall back to the cloud whenever local is unreachable.

import antigravity
import requests
 
LOCAL = antigravity.Client(
    backend="ollama", model="gemma3:latest",
    base_url="http://localhost:11434",
)
CLOUD = antigravity.Client(backend="google", model="antigravity-2.5-pro")
 
DRAFT_TASKS = {"commit_message", "log_summary", "rename_suggestion"}
 
def generate(task: str, prompt: str, context: str = "") -> str:
    """Drafts go local; everything else goes to the cloud. Fall back if local is down."""
    if task in DRAFT_TASKS:
        try:
            return LOCAL.generate(prompt=prompt, context=context, timeout=20).text
        except (requests.Timeout, requests.ConnectionError):
            pass  # ollama serve is down, or the model is still loading
    return CLOUD.generate(prompt=prompt, context=context).text

The timeout=20 matters more than it looks. A local model can spend several seconds loading, and if the call hangs there, the whole automation pipeline stalls behind it. For the connection steps themselves, see running Gemma 4 on Antigravity.

Gemma 4 Deepening — from image to code

The Gemma 4 × Antigravity integration matured further, with multimodal (text + image) quality as the headline. Turning a code screenshot into an implementation, or a UI design image into a component skeleton, both got more reliable.

The trick in practice is not to stop at handing over the image: state the constraints on the output in words too. Adding "render this screen in SwiftUI, no state management, layout only" meaningfully changes the granularity of what comes back. Gemma 4 × Antigravity is also the most-read topic on Antigravity Lab, and the pairing genuinely works well.

Context Window Expansion — cross-file refactors get easier

The usable context window expanded, making it comfortable to work while holding a large codebase or a long conversation history. You feel it most in multi-file refactoring and in design reviews that need project context. Reading several related files together no longer loses the thread, so the "forgot the premise of a file it just edited and returned a mismatched fix" failure happens less.

Three things that actually tripped me up

The features were fine. The time went elsewhere. If this spares you one of these, it was worth writing down.

A trailing slash in base_url. Write http://localhost:11434/ and the connection comes back 404, because the path join produces //. The error text only ever says the model can't be found. Dropping the slash fixes it.

Slow first call after the model unloads. Ollama drops a model from memory after five idle minutes by default. My first request each morning took close to 10 seconds, and I nearly wrote off local models as "just slow." Starting the server with OLLAMA_KEEP_ALIVE=30m ollama serve makes it feel like a different machine.

Argument schema mismatches over A2A. When caller and callee disagree on types, the tool call is swallowed silently rather than raising, and the agent quietly falls back to answering without the tool. Keeping @Tool annotations on plain str / int types, and avoiding Optional and composite types, was the reliable path. If an agent goes quiet on you, diagnosing an unresponsive AI agent covers the isolation steps.

Pricing Changes

Spring 2026 pricing revisions relaxed limits on several plans, particularly the Pro tier's context limit, which makes it easier to handle for individual developers. The current numbers are in the Antigravity pricing and usage breakdown.

Two months on, what stayed

Having run these through May and June, exactly two of them stuck.

AgentKit 2.0's debug output, paired with the tool-call budget above. Together they turned my agents from "somehow works" into "I can explain what it did." The local/cloud split stayed too — and less for the bill than for a side effect I didn't anticipate: drafting keeps working on a train with flaky reception.

A2A is the one I dropped. I still think the idea is sound, but working alone, I never once needed to cross a framework boundary. A capability you can use and a capability you should use are different things. It took me two months to confirm something I already knew.

If you only try a few, in this order

You don't need to chase every change. Start by using AgentKit 2.0's debug output to make your existing agents' behavior visible, and put a ceiling on tool calls. Then move your high-repetition work onto a local LLM. Those two steps alone change the day-to-day feel. A2A and Gemma 4 multimodal can wait until you have a concrete need.

When the next update lands, I'll sort it the same way: does it help my actual work?