Why AI Agents Should Have Their Own Sandbox — Philipp Schmid, Google DeepMind
Philipp Schmid of Google DeepMind introduces the Gemini Interactions API, a unified interface for models and agents with server-side state and long-running jobs. He then shows managed cloud sandboxes for Antigravity agents that persist, can be shared, and automatically pick up skills and AGENTS.md files, closing with a live AI talk radio demo built from a single prompt.
Philipp Schmid from Google DeepMind, who works on Google AI Studio and the Gemini API, opens with a reflection on how LLM usage has evolved. He then argues that agents should not run on your laptop but in their own cloud sandbox, created with a single API call.
Where things are headed
Schmid frames the shift in stages. Early GPT-style models (around 2018 and 2019) could only continue text, such as completing a poem from its first few words. Instruction tuning made models answer questions. ChatGPT then popularized the user/model turn-based conversation, and function calling added the ability to take actions. We are now moving into a phase where the user gives a goal rather than a prompt, describes how success is verified, and expects the agent to run for hours or days before returning results.
He also notes that his opening slide was already outdated. The day before the talk, Google shipped Nano Banana Lite, a fast and cheap image model at roughly 4 cents per image, and Omni Flash on the Interactions API for programmatic video creation and editing.
The Interactions API
The Interactions API is Google’s answer to OpenAI’s Responses API, positioned as more developer-focused and friendlier to web developers. Its central property is a single interface: calling a Gemini model and calling an agent such as the Antigravity agent look nearly identical. Inputs can be plain strings or multimodal data, and tools or environments are configured alongside them. Four capabilities stand out:
- Server-side state: instead of managing conversation history on the client, you pass the previous interaction ID, and the server concatenates prior inputs so the model sees everything that has happened.
- Long-running operations: async requests return an ID, with streaming or polling to retrieve results. This matters for Omni video generation, which takes a long time and should not hold an HTTP connection open.
- Multimodal outputs: audio via Gemini TTS requires setting the response modality to audio and adding generation config. Image generation with Nano Banana follows the same pattern.
- Tool composition: built-in tools like Google Search and URL context can be combined with custom function calling, and the model decides on its own whether to search, visit URLs, or call a function.
He demonstrates this with a small CVE agent that searches for React vulnerabilities, uses URL context to read the pages, and uses function calling to return structured output that can be stored in a database.
From turns to steps
Schmid makes a conceptual argument that the user/model turn abstraction no longer fits agentic applications. Reasoning models expose thoughts or only signatures, and function results are awkward to return as a user turn because they come from the environment, not from the user. Google replaces the turn model with a synchronous timeline of typed steps. Each action or generation is its own step type, which makes it easier to add capabilities later while keeping the API explicit about what was done. A function-calling agent returns a function result as a step rather than as a fake user message.
The Antigravity agent and managed sandboxes
Shipped at Google I/O, the Antigravity agent in the Gemini API runs the same agent harness as the Antigravity IDE, the 2.0 version, and the CLI. Schmid clarifies that the harness is the backend of the agent. Products can differ in their tools and system instructions, since the IDE is a coding agent, but improvements to Gemini within the harness benefit all of them.
Setting the environment field to remote gives each request a managed cloud sandbox where the agent can run code, create and write files, install dependencies and tools, and call APIs. Environments persist across turns, so a follow-up interaction can reuse the previous environment. Environments can also be shared among agents, which can coordinate through the file system or through sub-agents that pick up each other’s work.
Context reaches the sandbox through sources such as GCS buckets, GitHub repositories, or inline files. Skills stored in a skills directory are picked up automatically and included in the system instruction. An AGENTS.md file from a coding agent or an existing agent is appended to the system instruction as well.
Agents API and the CLI
To share and reuse configurations, the Agents API lets you define a base agent, meaning the underlying instructions plus an environment. That environment can be a raw environment built from sources or an existing one. Schmid’s example: an agent sets up a sandbox with the GitHub CLI, adds skills, and runs sanity checks. You get back an environment ID and create a new agent that always starts from that preconfigured environment. He stresses that this removes the need for Terraform, Kubernetes, microservices, or Firecracker.
He also introduced a Gemini API CLI. It is not a coding agent and not Gemini CLI. It is a tool that agents can use to call the Gemini API, including image and video models, and to create, iterate on, and improve managed agents. Dedicated skills for the Interactions and Agents APIs are available.
Demo: AI Talk Radio
The demo is an AI Talk Radio app in AI Studio, previously shown at the Google I/O developer keynote. It is a simple UI over a managed agent with access to all Gemini models. From one prompt, it generates a thumbnail, speech, and music, does research, and produces a short radio show. Schmid requested a show on whether pineapple belongs on pizza, and played a pre-recorded show on whether cereal or milk goes in first. The output is multi-voice dialogue with a host and callers who reason and share opinions, not a monologue. In the clip, a host takes calls from listeners in Boston and Sydney, who argue opposing sides.
The applet is open in terms of code, and users can remix it from the gallery under the build section. Its agent is just files: an AGENTS.md loaded at environment startup, plus skills. One skill runs TTS generation through a Python script that calls Gemini models via the Interactions API. Moving from the UI to a backend is a matter of copying that file and creating an agent. The Antigravity agent in the playground also offers six templates.
Exploring the sandbox
To show the environment, Schmid prompts the agent to inspect where it runs. The first request takes about 7 to 10 seconds to start the sandbox. The agent then runs bash commands and reports that it is on Ubuntu with 8 vCPUs, 16 GB of memory, and Python and pip installed. Follow-up prompts continue in the same environment, and files can be downloaded from the sandbox through the UI or an API.
How the managed loop works
The main architectural point is that, with managed agents, the agent loop runs entirely on Google’s servers. Normally, developers handle function calls on the client, passing them to a runtime and returning results. With managed agents this collapses into a single API call: the sandbox loads the files, and the loop runs remotely. Remote MCP servers can be connected, and local MCP servers can run inside the environment.
Schmid points developers to the Gemini API agents documentation and its quick start. He also suggests installing the coding skills for tools like Claude Code or Codex to get started.