# Build Your Own Team of Managed Agents

Jack Wotherspoon, Google DeepMind | AI Engineer NYC 2026 | 19:44

Source: https://www.youtube.com/watch?v=Y_p3y6zP5QE
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/build-your-own-team-of-managed-agents
Published: 2026-10-26
Tags: agents, deployment, multi-agent, security, workflows

## TL;DR
- Managed agents run coding and research agents in cloud sandboxes through a single API call.
- The Interactions API separates conversation state from sandbox files, allowing fresh agents to continue work in the same environment.
- A proxy keeps credentials outside the sandbox, while triggers and shared environments support scheduled and multi-agent workflows.

## Summary
Jack Wotherspoon introduces Gemini Managed Agents, which run the Antigravity harness inside cloud sandboxes instead of on a developer's laptop. The managed service creates the sandbox, provides built-in tools such as code execution, file operations, and Google Search, and supports custom functions and MCP servers. The Interactions API handles multi-step agent work, while environments hold files that later agents can reuse with a fresh context window. Wotherspoon also covers uploaded skills, AGENTS.md files, GitHub repositories, saved agent configurations, scheduled triggers, and credential injection through a proxy. In the main demo, an SEC filing researcher passes metrics to a quant agent, which produces analysis for a reporting agent. A second demo embeds several managed agents in a stock research application. The talk is practical and product-focused, with security and workflow composition receiving more attention than model evaluation.

## Key ideas
### Cloud sandboxes remove laptop interference and make agent work easier to share
[00:54](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=54s)
Wotherspoon says a cloud sandbox lets an agent write code, search the web, write and run tests, and return verified answers without taking over a developer's laptop. Local agents can steal the browser, create pop-ups, or depend on a personal setup that is hard to share with colleagues. A cloud service also gives an application a way to run agents under its own infrastructure instead of using a developer's subscription. This makes the same workflow easier to reuse inside a product or across a team.

### Managed agents replace infrastructure and harness setup with one API call
[02:13](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=133s)
Running an agent yourself requires a container or virtual machine, installed dependencies, a harness, networking, firewall rules, and other security work. Gemini Managed Agents packages those pieces behind a single API call. The service creates the sandbox and provides the Antigravity harness, so developers can make more calls when an application needs more agents. Wotherspoon presents this as the main difference between assembling an agent platform yourself and using a managed service.

### The Interactions API models agents as multi-step work rather than one prompt and one answer
[03:26](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=206s)
The Interactions API is the agent-focused part of the Gemini SDK. Instead of treating a request as one input followed by one output, it supports work across several steps. An agent can write files, call those files later, and use MCP tools during the same task. A managed agent is selected in the configuration, with the environment set to remote. The API becomes the place where agent calls and their multi-step activity are represented.

### A managed agent combines a harness, environment, skills, credentials, and triggers
[05:22](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=322s)
Wotherspoon describes several parts that developers configure. The Antigravity harness decides how to make tool calls and includes built-in tools. An environment is the sandbox file system that different agents can share. Skills let developers upload company playbooks or personal procedures. Credentials provide access to tokens or MCP OAuth. Triggers wake an agent on a schedule, such as running financial analysis before the market opens or checking a Jira board and sending a Slack message.

### Model choice can match the agent to speed or analysis needs
[07:02](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=422s)
The managed agent configuration allows developers to choose the model. Wotherspoon recommends a faster Gemini Flash model for work that needs speed and a different model such as Gemini 4 Argon for deeper reasoning or analysis. He describes Gemini 4 Argon as suited to financial tasks and analysis across many documents. He also says its million-token limit is shared across input, thinking, and output, allowing longer outputs for tasks such as mathematical reasoning or financial modeling.

### Interactions and environments keep conversation state separate from reusable files
[08:51](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=531s)
An interaction records the conversation turn and can be passed to a later interaction. An environment records files created in the cloud sandbox, including documents, images, and analysis results. Developers can download or upload those files through the API. This separation lets a later agent reuse the same environment while starting with a fresh context window. Wotherspoon's example has one agent save filings and analysis, then a second agent continue from those files without inheriting the first agent's conversation.

### The proxy keeps real credentials outside the sandbox
[12:21](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=741s)
Managed agents do not receive the actual secrets they need to call external services. The sandbox gets a placeholder token instead. When the agent calls a service such as GitHub, the proxy identifies the target API and injects the real credential at that point. Wotherspoon says this prevents an agent from finding a GitHub token in the sandbox and using it for unrelated actions. Credentials can also support MCP OAuth connections.

### Small specialist agents can pass files through a controlled workflow
[13:37](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=817s)
Wotherspoon says one managed agent can call other managed agents, allowing work to fan out across narrowly defined tasks. In the demo, an SEC filing researcher investigates Nvidia and writes metrics to the shared file system. A quant agent reads metrics.json, runs Python analysis, and produces a forecast. A third agent turns the research into a report. The agents share an environment, while each can have a specific purpose that is easier to inspect and measure than one broad task.

### Managed agents can be embedded in applications and scheduled services
[16:34](https://www.youtube.com/watch?v=Y_p3y6zP5QE&t=994s)
The demos show managed agents inside applications rather than only as developer tools. One application reads company receipts from Google Drive and creates an interactive visualization using an uploaded skill. Another stock research application coordinates agents that investigate a ticker, create analysis, and produce a PDF with charts, sources, and takeaways. Wotherspoon says developers can use the SDK to add these workflows to their own services, or start from examples in AI Studio.

## Notable quotes
- "With a single API call, you're getting all the things we talked about." (02:56)
- "So, environments are what's actually kind of in the file system on the sandbox." (09:21)
- "Secrets never actually enter the sandbox." (12:15)
- "You can actually set it up so that one managed agent knows how to, because it's just an API call, actually call other managed agents." (13:38)

## Tools & references mentioned
- Google DeepMind
- Gemini Managed Agents
- Interactions API
- Antigravity harness
- Gemini API
- Gemini 4 Argon
- Gemini Flash
- Google Cloud
- Google Search
- MCP
- AI Studio
- GitHub
- Google Drive
- Slack
- Jira

## Who should watch
- You are building coding or research agents and do not want to manage containers, sandboxes, networking, and agent harnesses yourself.
- Your team needs agents to reuse files, skills, and repositories across separate runs or pass work between specialist agents.
- You want to put agent workflows inside an application or run them on a schedule while keeping service credentials outside the sandbox.

## Related talks

- [Why AI Agents Should Have Their Own Sandbox](https://aietalks.com/talks/why-ai-agents-should-have-their-own-sandbox) (Philipp Schmid, Google DeepMind, 20:42)
- [Multiplayer agentic engineering](https://aietalks.com/talks/multiplayer-agentic-engineering) (Arjun Singh, Superconductor, 18:44)
- [Realtime multiplayer, automation, and you!](https://aietalks.com/talks/realtime-multiplayer-automation-and-you) (Idan Gazit, GitHub, 21:41)
- [Building Agents at Cloud Scale](https://aietalks.com/talks/building-agents-at-cloud-scale) (Antje Barth, AWS, 19:00)
- [How Google DeepMind Runs Agents at Scale](https://aietalks.com/talks/how-google-deepmind-runs-agents-at-scale) (KP Sawhney & Ian Ballantyne, Google DeepMind, 25:13)
