The Gemini Interactions API gives models and agents one interface with server-side state, background jobs, multimodal inputs, and tool use.
2
Managed sandboxes let agents run code, create files, install dependencies, use APIs, and share persistent environments without the developer managing cloud infrastructure.
3
Agents can be packaged from an AGENTS.md file, skills, and a prepared environment, then reused through the Agents API or called with one API request.
Summary
Philipp Schmid presents the Gemini Interactions API as an interface for both models and agents. It keeps state on the server, supports long-running asynchronous work, handles text, audio, and images, and combines built-in tools such as Google Search with custom functions. The API also replaces the old user/model turn pattern with a timeline of typed steps, which fits reasoning and tool calls more directly. The central demo uses the Antigravity agent in a managed cloud sandbox. The agent can run code, write files, install packages, use skills, read an AGENTS.md file, and continue work in the same environment. Schmid then shows how prepared environments can be turned into reusable agents and how the Gemini API CLI can help create them. The AI Talk Radio demo makes the design concrete: an agent researches a topic, writes scripts, generates speech and music, and combines the files into a show.
The Gemini API has moved from text completion toward goal-driven agents
Schmid describes a progression from models that continued text, to instruction-following models, to chat interfaces with user and model turns, and then to function calling. Agents now receive a goal, instructions for checking or deploying the result, and potentially hours or days to complete the work. The developer is no longer only asking for a response. The agent can think, call functions, and return a finished result after a longer process.
The Interactions API gives models and agents the same interface
The Interactions API uses the same basic pattern for calling a Gemini model or the Antigravity agent. An interaction has a model or agent, an input, and optional tools or an environment. Inputs can be strings or multimodal data. The API includes server-side state, so a follow-up can refer to the previous interaction by ID instead of the client rebuilding the whole history. It also supports asynchronous operations, which fits work such as video generation that should not keep an HTTP connection open.
Typed steps fit reasoning and tool calls better than user and model turns
Schmid says the traditional user/model pattern becomes awkward when a model exposes thoughts, emits a reasoning signature, or calls a function. A function result comes from the environment, not from the user, yet older APIs often put it into a user turn. Interactions instead use a synchronous timeline of steps, with each action or generation represented by its own type. A function-calling agent can return a function result directly, which also leaves room for new step types later.
A managed sandbox gives each agent a persistent working environment
When the environment is set to remote, the Gemini API starts a cloud sandbox for the request. The agent can run code, create and write files, install dependencies, install tools, and call the developer's APIs. Schmid says the environment persists across interactions, so an agent can continue from files created in an earlier turn. The developer sends API requests without managing the underlying infrastructure. Multiple agents can also share one environment and pass context through its file system.
Sources, skills, and AGENTS.md files provide the agent's working context
An environment can receive sources from GCS buckets, GitHub repositories, or inline files. Skills placed in the skills directory are picked up automatically and included in the system instruction. An AGENTS.md file is also loaded into the system instruction when the environment starts. In the talk radio demo, the file tells the agent to research the subject, write scripts, generate music and speech, and mix the resulting files. Skills contain the instructions and code needed for those tasks.
The Agents API packages a prepared environment for reuse
The Agents API lets a developer define the underlying model, instructions, and environment. One agent can first prepare an environment by installing tools such as the GitHub CLI, adding skills, and running checks. The developer receives an environment ID and can use it to create another agent that starts with the prepared files and configuration. Schmid presents this as a way to share agents with users or customers without separately managing Terraform, Kubernetes, microservices, or Firecracker.
The AI Talk Radio demo is assembled from files and skills
The talk radio app is a UI on top of managed agents. A single request asks it to make a show about a question such as whether cereal or milk should go into a bowl first. The agent starts an environment, installs Python dependencies, reads its skills, researches the subject, writes material for several speakers, and generates speech and music. The resulting show has people arguing different sides of the topic. Schmid says the applet's code can be remixed in AI Studio or copied into a backend.
The managed agent loop reduces orchestration to one API call
With ordinary agent applications, the client often receives a function call, runs it somewhere, and sends the function result back. Managed agents run that loop inside the remote sandbox instead. A request starts the sandbox, loads the files, and lets the agent perform its work on the server. The environment can also connect to remote MCP servers or run local MCP servers. The developer can later download files created by the agent through the interface or an API.
"Meaning if you send a request, our back end starts a cloud sandbox where the agent can run code, can create files, write files, install dependencies, install your own tools or maybe call your own APIs."09:11
Who should watch
You are building an agent that needs to run code, install tools, or continue work after the initial request.
Your current application stores conversation state and manually handles every tool call and function result.
You want to package an agent with skills, source files, and a prepared environment for other developers or users.
