This is a submission for the Google I/O 2026 Challenge: Explore Google I/O 2026

Google shipped a lot of developer tooling at I/O 2026. The thing I want to actually build with is Managed Agents in the Gemini API.

Here's the pitch: one API call provisions a fully-functional agent with a remote execution sandbox. No infrastructure setup. No managing cloud VMs. No configuring the Antigravity agent harness manually. You write the agent logic. Google handles the environment.

This guide walks through what Managed Agents actually are, how they differ from the existing Gemini API, and how to get something running.

The Problem Managed Agents Solve

Building with the Gemini API before I/O 2026 meant one of two things:

Option A — Stateless calls: Send a prompt, get a response. Fine for Q&A. Useless for anything that requires multiple steps, state between calls, or executing code.

Option B — DIY infrastructure: Spin up a VM, configure the Antigravity harness (Google's agent runtime, announced at I/O 2025 as an alpha), manage sandboxing and credential isolation yourself, deploy the whole thing. Capable, but not a 30-minute getting-started experience.

Managed Agents collapse this to a single API call. The agent harness runs on Google's infrastructure. You get a remote sandbox, tool execution, and persistent state without provisioning anything.

What You Actually Get

A Managed Agent gives you:

  • Remote execution sandbox — code runs in Google's infrastructure, not your machine
  • Persistent state — the agent maintains context between tool calls and across a session
  • Tool use — the agent can call functions you define, fetch URLs, run code
  • Parallel subagents — via Antigravity's dynamic subagent system, agents can spin up specialized sub-agents for parallelized work
  • Scheduled tasks — background tasks that run on a schedule without a persistent connection

This is essentially the Antigravity 2.0 stack (Google's agent-first development platform, also announced at I/O 2026) delivered as an API.

Getting Started

1. Enable Managed Agents in AI Studio

Go to Google AI Studio, create a new project, and enable the Managed Agents feature under the Experimental section. You'll need a Gemini API key.

2. Install the SDK 

pip install google-generativeai>=0.8.0
Enter fullscreen mode Exit fullscreen mode

3. Your First Managed Agent 

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# Define the tools your agent can use
def search_documentation(query: str) -> str:
    """Search technical documentation for a given query."""
    # Your implementation here
    return f"Documentation results for: {query}"

def run_code(code: str, language: str = "python") -> dict:
    """Execute a code snippet and return the result."""
    # The Managed Agent sandbox handles actual execution
    return {"stdout": "...", "stderr": "", "exit_code": 0}

# Create the agent — Managed Agents handles the rest
agent = genai.ManagedAgent(
    model="gemini-3.5-flash",
    tools=[search_documentation, run_code],
    system_instruction=(
        "You are a technical assistant. When asked about code, "
        "search the docs first, then write and test code to verify your answer."
    ),
)

# Run the agent — it will use tools, iterate, and return a complete answer
result = agent.run(
    "Show me how to implement rate limiting in FastAPI with Redis"
)
print(result.text)
Enter fullscreen mode Exit fullscreen mode

The agent call is blocking — it runs until the agent decides it has a complete answer. Under the hood, Gemini 3.5 Flash is orchestrating tool calls, synthesizing results, and iterating automatically.

Async and Streaming

For production use, you'll want async and streaming so your application stays responsive:

import asyncio

async def run_agent_async():
    agent = genai.ManagedAgent(
        model="gemini-3.5-flash",
        tools=[search_documentation, run_code],
        system_instruction="You are a technical assistant.",
    )

    # Stream the agent's output as it works
    async for event in agent.run_stream("Explain and demonstrate async context managers"):
        if event.type == "text":
            print(event.text, end="", flush=True)
        elif event.type == "tool_call":
            print(f"\n[Calling tool: {event.tool_name}]")
        elif event.type == "tool_result":
            print(f"[Tool returned: {event.result[:100]}...]")

asyncio.run(run_agent_async())
Enter fullscreen mode Exit fullscreen mode

The event stream lets you show users what the agent is doing as it works — which matters for long-running tasks where a blank spinner kills perceived responsiveness.

Scheduled Tasks

One of the capabilities that separates Managed Agents from standard API calls is scheduled background tasks:

# Register a task that runs every day at 9am
agent.schedule_task(
    prompt=(
        "Check the GitHub repository for new issues labeled 'bug'. "
        "For each new issue, search the codebase for the relevant component "
        "and add a comment with likely root causes and affected files."
    ),
    schedule="0 9 * * *",  # cron syntax
    name="daily-issue-triage",
)
Enter fullscreen mode Exit fullscreen mode

This runs without a persistent connection. The Managed Agent runtime handles the scheduling, execution, and logging. You can check task status and results via the API or in AI Studio.

Parallel Subagents

For tasks that decompose naturally into parallel work, Managed Agents supports dynamic subagent spawning via the Antigravity integration:

agent = genai.ManagedAgent(
    model="gemini-3.5-flash",
    tools=[...],
    system_instruction=(
        "You orchestrate research tasks. When given a broad topic, "
        "break it into parallel sub-tasks and spawn subagents to handle each. "
        "Synthesize their results into a unified response."
    ),
    enable_subagents=True,  # enables dynamic subagent spawning
)

result = agent.run(
    "Research the current state of WebAssembly runtimes: "
    "performance benchmarks, language support, production adoption, "
    "and future roadmap. Cover all angles in parallel."
)
Enter fullscreen mode Exit fullscreen mode

The orchestrating agent decomposes the task, spawns specialized subagents for each sub-problem, and synthesizes the results — handling the parallelism automatically.

Deploy to Cloud Run in One Click

If you've built your agent in AI Studio, the I/O 2026 update adds a one-click Deploy to Cloud Run option. First two apps are free, no payment setup required. This is the fastest path from prototype to a publicly accessible endpoint.

For programmatic deployment:

# From the Antigravity CLI (also new at I/O 2026)
antigravity deploy my-agent \
  --runtime managed \
  --region us-central1 \
  --model gemini-3.5-flash
Enter fullscreen mode Exit fullscreen mode

What Antigravity 2.0 Adds on Top

If you want more control than the Managed Agents API gives you, Antigravity 2.0 is the full platform:

  • Antigravity CLI for spinning up specialized subagents from the command line
  • Cross-platform terminal sandboxing with credential masking and hardened Git policies
  • Firebase integration for full-stack apps with auth and storage
  • Exports to Netlify from Google Stitch (the new UI design tool)

Managed Agents is Antigravity for developers who don't want to manage infrastructure. Antigravity 2.0 is for developers who want full control.

The Honest Assessment

What's genuinely good: The abstractions are right. Infrastructure should be invisible for most agent use cases. Managed Agents makes the 80% case — a stateful, tool-using agent that runs in the cloud — genuinely easy.

What to watch: The sandbox is Google's infrastructure. For agents that need access to internal systems, private databases, or custom toolchains, the Managed Agents sandbox has limits. The Antigravity CLI path gives you more flexibility there, but it's also more setup.

The pricing model matters: Scheduled tasks and long-running agents accumulate costs differently than stateless API calls. Test thoroughly before deploying agents that run on cron schedules against production data.

Bottom Line

Managed Agents is the "batteries included" path to building production agents on Gemini. One API call, a list of tools, and a system prompt is all you need to go from idea to a deployed, stateful, tool-using agent.

The scheduling and subagent features are where it stops being a demo feature and starts being infrastructure worth building on. The combination of Gemini 3.5 Flash's speed with Managed Agents' infrastructure is what makes the "agentic era" theme from Google's I/O keynote feel grounded rather than aspirational.

Build something with it this week. The time between "I wonder if this is possible" and a deployed endpoint is now measured in minutes, not days.

Links: Google AI Studio · Gemini API Docs · Antigravity 2.0 — Google I/O Developer Highlights · Google I/O 2026