Jack Wotherspoon on Building a Team of Managed Agents

I’m Jack Wotherspoon, a developer experience engineer at Google DeepMind, and I’m going to talk about managed, or cloud, agents. Instead of running a coding-agent harness on your own machine, you can run the agent in a sandbox in the cloud.

A cloud agent can write code, reason, research, search the web, write and run tests, and return with verified results. That work stays away from your local machine, so it does not take over your browser or trigger pop-ups while you are trying to work.

A laptop also does not scale well. You may have customized an agent or built useful skills, but sharing that setup with a colleague or integrating it into an application is harder when everything depends on your machine or personal subscription. Managed agents make it easier to scale the work.

Building a cloud agent yourself is tedious. You need to start a container or VM, load the right files, manage it, engineer a harness, and configure networking, firewall rules, and security. Gemini Managed Agents package those pieces in the Gemini API so the workflow can begin with a single call.

With that call, you get a sandbox and the Antigravity harness already set up. As an application needs more agents, you can make more API calls instead of managing the underlying infrastructure and scaling it yourself.

The Interactions API is Google’s agent-focused SDK and client interface. Earlier model APIs centered on giving a model input and receiving output; agents need to take multiple steps, write files, and call files or MCP tools. The Interactions API is designed to represent that work.

To run an agent in the cloud, the call uses the Antigravity agent and sets the environment to remote. That setting tells the system to create a managed agent rather than run the work locally.

Under the hood, a request goes through the Gemini API, which provides server-side tools such as Google Search and filesystem operations. Developers can add their own functions or MCP tools, while a sandbox runs on Google Cloud infrastructure.

When the managed-agent call arrives, the service spins up the sandbox. You can upload files into it, including agent skills, an AGENTS.md file, or a GitHub repository to load when the environment starts.

The first building block is the Antigravity harness, which decides how to plan work and call tools. The environment is a separate persistent workspace: one agent can create files there, and another can later pick up that same environment and continue.

Skills let a team upload its playbooks or repeatable instructions. Credentials let the service provide tokens or MCP OAuth access to services. Triggers add scheduled runs, such as an agent that analyzes information before the market opens or checks a team’s Jira board each morning.

You can choose which model the harness uses. A faster, more efficient model may suit a simple workflow, while deeper reasoning or financial analysis may call for a different model. Wotherspoon points to Gemini 4 Argon, which he says launched the previous day, and recommends testing it for financial and document-analysis tasks.

He also highlights long decode for Gemini 4. Rather than treating the output limit as a fixed 64K tokens, the one-million-token context budget can be shared among input, thinking, and output. That can support long outputs such as extensive mathematical reasoning or financial models.

Interactions and environments are two separate stateful resources. Interactions preserve the conversation history and reasoning turns; an environment preserves the files, data, and packages in the sandbox. Passing an interaction ID continues a conversation, while passing an environment ID reuses the workspace.

That separation enables a handoff: one agent can collect quarterly filings and save them, then a second agent can start with a fresh context window but reuse the same workspace. It can fetch annual reports, analyze the files, and save its own results for the next agent.

Managed agents come with tools for code execution, reading and writing files, and Google Search. They can also connect remote MCP servers, bringing in services that support daily tasks or features inside an application.

You can mount files in the workspace, such as AGENTS.md, skills, and a GitHub repository. That lets an agent follow the same playbooks you use on a personal machine, while keeping its work in a reproducible cloud environment.

After refining an agent workflow, you can save it through the Agents API and call it again by its agent ID. That makes a tested setup reusable across multiple runs.

Secrets never enter the sandbox. A proxy sits between the sandbox and external services; the agent sees a placeholder token, not the real GitHub or API credential. When it calls an allowlisted service, the proxy injects the secret into the outbound request, so the agent cannot inspect or exfiltrate the key.

Triggers can schedule an agent to run, for example, to prepare a daily market briefing or scan email before the day begins. Managed agents can also call other managed agents, letting specialized agents handle a narrow task and hand files to the next step.

In the first demo, an SEC filing researcher gathers information about Nvidia and saves metrics to a shared environment. Step traces show its function calls and file operations, so a team can inspect what the agent did and improve the workflow.

A quant agent then reuses that environment, reads the saved metrics, runs Python analysis, and prepares a forecast. A third agent can take the research and analysis and turn them into a report; with the right MCP servers, the final step could also write to Google Docs or send a Slack message.

Wotherspoon next shows how a managed agent can be built into an application. In the demo, an agent connects to company receipts in Google Drive and uses a skill to turn the data into an interactive financial summary.

The same approach can turn a personal coding-agent workflow into a managed agent that runs for a company or inside an app. Google’s Gemini API and AI Studio gallery already include examples for creating games, researching documents, and other tasks.

He opens a financial research example in AI Studio. The app takes a stock ticker and uses several managed agents to gather and analyze information, while the interface can show the steps as the agents work.

The agents synthesize their findings into a report with analysis, takeaways, charts, and links to source documents. Wotherspoon points viewers to AI Studio and the managed-agent documentation as places to get started, then thanks the audience.