Google I/O 2026 just shipped the thing I've wanted for two years: a fully sandboxed, cloud-hosted agent I can spin up with a single function call. No Docker. No orchestration boilerplate. No "provision a VM and wire up tools" weekend project. Just an import and three lines of Python.

This is my hands-on walkthrough of the new Gemini API Managed Agents, announced at Google I/O 2026 — what it is, what it actually does, and how to build something real with it in under 15 minutes.

What Are Managed Agents?

Before Managed Agents, building an AI agent from scratch meant:

• Provisioning your own compute environment
• Wiring up tools (web search, code execution, file I/O) manually
• Writing an agent loop to handle multi-step reasoning
• Managing state across turns yourself

That's half a day of setup before your agent does anything useful.

Managed Agents collapse all of that into one API call.

You call client.interactions.create(...), and Google's infrastructure:

1. Spins up an ephemeral Linux sandbox
2. Loads Gemini 3.5 Flash as the underlying model (the new frontier-speed model announced at I/O)
3. Equips it with web search, code execution, and file management out of the box
4. Runs the full agent loop autonomously until the task is done
5. Returns the result — and tears down nothing you need to clean up

The sandbox is real. The agent actually writes files, runs scripts, browses the web, and installs packages inside it.

Prerequisites

You'll need:

• A Gemini API key (get one free at https://aistudio.google.com/apikey)
• Python 3.9+ or Node.js 18+
• The Google GenAI SDK

Install the SDK:

pip install google-genai
# or
npm install @google/genai

Export your key:

export GEMINI_API_KEY="your_key_here"

Step 1: Your First Agent Call

Let's start with something dead simple to prove it works — ask the agent to write a script, run it, and return the output.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Write a Python script that fetches the current Bitcoin price from a public API and prints it with a timestamp.",
    environment="remote",
)

print(interaction.output_text)

That's it. Three parameters:

• agent: The agent version to use. antigravity-preview-05-2026 is the current general-purpose managed agent.
• input: Plain English description of the task.
• environment="remote": Provision a fresh cloud sandbox for this run.

The response object gives you:

• interaction.output_text — the agent's final answer
• interaction.id — needed to continue the conversation
• interaction.environment_id — the sandbox ID (needed to reuse state)
• interaction.steps — every step the agent took: reasoning, tool calls, code it ran

That last one is underrated. You can see exactly what the agent did, which is great for debugging.

Step 2: Build Something Actually Useful — A Research Digest Agent

Let's build something I'd actually want to use: give the agent a URL, have it read the page, summarize the key points, and save a formatted PDF report.

from google import genai

client = genai.Client()

url = "https://blog.google/innovation-and-ai/technology/developers-tools/google-io-2026-developer-highlights/"

interaction = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input=f"""
    Read the article at {url}.
    Extract the 5 most important announcements for developers.
    For each announcement, write:
      - A one-line summary
      - Why it matters
      - A concrete thing a developer could do with it today
    Save the result as a nicely formatted PDF called 'io26_digest.pdf'.
    """,
    environment="remote",
)

print(interaction.output_text)
print(f"\nEnvironment ID (save this): {interaction.environment_id}")

The agent will browse the URL, read it, reason about the content, write the formatting code, run it, and produce a PDF — all without you managing any of that pipeline.

Step 3: Multi-Turn Conversations (State Persists!)

Here's where it gets genuinely useful: you can continue a conversation in the same sandbox. Files from the previous turn are still there.

# Continue from the previous interaction — same sandbox, same chat history
interaction_2 = client.interactions.create(
    agent="antigravity-preview-05-2026",
    previous_interaction_id=interaction.id,      # resume conversation
    environment=interaction.environment_id,      # reuse the same sandbox
    input="Now add a bar chart comparing the number of new tools announced per product area (Agents, Android, Web, AI Studio). Append it to the PDF.",
)

print(interaction_2.output_text)

Two things are being persisted independently here, which is worth understanding:

• previous_interaction_id — carries over the conversation history and reasoning context
• environment — carries over the sandbox state (files, installed packages, everything on disk)

You can mix and match. Pass only the environment ID to get a fresh conversation in the same workspace. Pass only previous_interaction_id to keep the chat history but start with a clean sandbox. This flexibility is genuinely thoughtful API design.

Step 4: Stream the Response for Long-Running Tasks

Some agent tasks take a while — browsing, installing packages, writing and running code. Streaming lets you watch the agent work in real time instead of staring at a blank screen.

from google import genai

client = genai.Client()

stream = client.interactions.create(
    agent="antigravity-preview-05-2026",
    input="Search for the top 5 Python libraries released in the last 3 months for building AI agents. For each, write a paragraph on what it does and install it to verify it works. Save a summary report as agent_libs.md.",
    environment="remote",
    stream=True,
)

for event in stream:
    print(event)

Streaming returns incremental step deltas — reasoning tokens, tool call updates, code output — as they happen. In practice, this transforms a 90-second wait into a live view of your agent actually working, which makes it dramatically easier to understand what's happening and catch problems early.

Step 5: Download the Files Your Agent Created

The agent creates files inside the sandbox. Here's how to pull them out:

import os
import requests
import tarfile

env_id = interaction.environment_id
api_key = os.environ["GEMINI_API_KEY"]

response = requests.get(
    f"https://generativelanguage.googleapis.com/v1beta/files/environment-{env_id}:download",
    params={"alt": "media"},
    headers={"x-goog-api-key": api_key},
    allow_redirects=True,
)

with open("sandbox_snapshot.tar", "wb") as f:
    f.write(response.content)

with tarfile.open("sandbox_snapshot.tar") as tar:
    tar.extractall(path="./agent_output")

print("Files saved to ./agent_output")

This downloads a .tar snapshot of the entire sandbox workspace. Your io26_digest.pdf, your charts, your scripts — all of it comes back.

Step 6: Register a Custom Agent

Once you've dialed in a useful agent configuration, you can save it as a named agent so you don't repeat the setup every time.

agent = client.agents.create(
    id="research-digest-agent",
    base_agent="antigravity-preview-05-2026",
    system_instruction="""
    You are a technical research assistant for developers.
    When given a URL or topic, you:
    1. Read and synthesize the source material
    2. Extract actionable insights for software developers
    3. Always include concrete code examples or next steps where relevant
    4. Save your output as a well-formatted PDF with a title, sections, and summary
    """,
    base_environment={
        "type": "remote",
        "sources": [
            {
                "type": "inline",
                "target": ".agents/AGENTS.md",
                "content": "Always cite your sources. Use markdown headings in reports. Include a TL;DR section at the top.",
            }
        ],
    },
)

print(f"Agent registered: {agent.id}")

Now invoke it by name — no config needed on each call:

result = client.interactions.create(
    agent="research-digest-agent",
    input="Summarize the key developer announcements from Google I/O 2026 and save a PDF.",
    environment="remote",
)

print(result.output_text)

Each invocation forks the base_environment, so every run starts clean but with your custom instructions and skills baked in.

What's Included in the Sandbox (Out of the Box)

No configuration required for any of this:

During preview, Google is not charging for sandbox compute — CPU, memory, and execution time are free. You're billed only for token usage and tool calls at standard Gemini 3.5 Flash rates.

My Honest Take

After spending a few hours with this, a few things stand out.

What's genuinely new: The friction reduction is real, not marketing copy. The comparable DIY setup — container, tool wiring, agent loop, state management — is hours of work. Managed Agents compress that to an import and a function call. For prototyping and internal tooling, the ROI is immediate.

What's still in preview: The API is marked preview, and it shows in places. Only one base agent is supported (antigravity-preview-05-2026). Agent versioning and rollback aren't available yet. Subagent delegation (one agent spawning another) isn't supported. These are real limitations if you're thinking about production use today.

The AGENTS.md pattern: Defining agent behavior in a markdown file mounted into the sandbox is a great design choice. If you've used Claude Code, this pattern is identical — and that convergence is probably intentional. It's slowly becoming a cross-platform standard, and I'm here for it.

The state model: The separation of conversation context and environment state into two independently controllable dimensions (previous_interaction_id vs environment) is subtle but well thought out. Once you grok it, you can build genuinely flexible multi-turn workflows.

Next Steps

• Managed Agents Quickstart: https://ai.google.dev/gemini-api/docs/managed-agents-quickstart
• Building Custom Agents: https://ai.google.dev/gemini-api/docs/custom-agents
• Antigravity Agent capabilities: https://ai.google.dev/gemini-api/docs/antigravity-agent
• Agent Environments: https://ai.google.dev/gemini-api/docs/agent-environment

The most interesting next step, in my opinion, is building a custom agent backed by a GitHub skills repository — you define reusable capabilities in SKILL.md files, commit them to a repo, and mount the whole repo into the agent's environment on every run. That's a proper engineering workflow for agent development, and I'll be covering it in a follow-up post.

Written for the Google I/O 2026 Writing Challenge on DEV.