Build Your Own Team of Managed Agents - Jack Wotherspoon, Google DeepMind
Loading slides…
Read the talk
Build Your Own Team of Managed Agents
Jack Wotherspoon explains how Gemini Managed Agents combine a cloud sandbox, the Antigravity harness, reusable instructions, and separate conversation and filesystem state. The demos follow company filings through quantitative analysis and into reports built inside an application.
From a talk by Jack Wotherspoon
At a glance
Ideas worth remembering
A managed agent packages a cloud sandbox and an agent harness behind an API call, removing local execution interference and much of the infrastructure setup.
Interaction IDs continue conversations; environment IDs reuse workspaces. Keeping those separate lets a fresh agent build on saved files without inheriting the earlier conversation.
Skills and AGENTS.md supply working instructions, repositories supply code, and MCP servers supply service connectivity. A saved agent configuration makes the refined setup callable again by agent ID.
The credential proxy keeps the real token outside the sandbox and injects it into destination-matched requests. This isolates the secret rather than proving that every authenticated action is safe.
The NVIDIA demonstration makes specialization concrete: filing research produces metrics.json, a quant agent reads it and runs Python analysis, and a third agent can turn the research into a report.
An application can expose the final artifact rather than the agent's execution stream. The VOO example returns a PDF with analysis, charts, and links to the documents used.
Move the work off your laptop
A coding agent running verification can take over your browser, launch processes, and leave you dealing with pop-ups while you try to work. Jack Wotherspoon, a developer experience engineer at Google DeepMind, starts with this ordinary nuisance before introducing managed agents: run the coding-agent harness in a cloud sandbox rather than on your own machine. The agent can still write code, search the web, run tests, and inspect results; its working environment moves elsewhere.
The second problem is sharing that setup. A personal coding agent may have useful skills and carefully chosen instructions, but a colleague cannot automatically reuse them, and a customer-facing application should not depend on your laptop and personal subscription. As Wotherspoon puts it, “your laptop doesn't scale.” Moving execution to an API-accessible service makes the agent something an application can invoke rather than a workstation someone must keep running.
Doing this yourself means provisioning a container or virtual machine, loading its dependencies, building or installing the agent harness, and handling networking, firewall rules, and security. Gemini Managed Agents packages the sandbox and the Antigravity harness behind one API call. Additional calls request additional agent runs, leaving the service to manage the underlying infrastructure. The simplification is operational: the application still has to decide what work to request and how to use the result.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
An interaction can contain a whole agent run
The Interactions API gives that run a different shape from a simple model request. An input need not lead straight to a final text response. The agent may write a file, execute it, call an external tool, inspect the result, and continue. An interaction represents this multi-step work rather than treating the entire operation as an opaque input/output exchange.
What makes the demonstrated call a cloud-agent request? It selects the base Antigravity agent and sets environment="remote", then supplies the task as input. That environment setting requests remote execution. The useful distinction in the example is between choosing an agent, which includes a harness for doing work, and choosing only a model to generate a response.
Underneath the call, the Gemini API provisions a sandbox on Google Cloud infrastructure. The service provides tools such as Google Search and filesystem access, while custom functions and MCP tools can extend what the agent can reach. Startup material can include a GitHub repository, an AGENTS.md file, and skills. This lets a remote run begin with actual working material instead of asking the model to reconstruct a project from the prompt.
The building blocks have different jobs:
- Harness: Antigravity manages tool use and supplies built-in tools. Wotherspoon describes it as the same harness used in Google's Antigravity product suite.
- Environment: The sandbox filesystem holds the work. Another agent can reuse it and build on files already written there.
- Skills: Uploaded playbooks describe how the company or individual wants a task performed.
- Credentials: Authentication connects the agent to services; the later proxy example explains how the real secret stays outside the sandbox.
- Triggers: A schedule starts a run without waiting for a person to submit a task.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose the model for the job—and budget for its output
The harness does not fix the model choice. A model parameter in the agent configuration lets the same managed-agent setup serve different workloads. Wotherspoon proposes Gemini Flash for fast, efficient work and Gemini 4 Argon for deeper reasoning or extensive analysis. This separates the execution machinery from the reasoning capability selected for a particular task.
A second capability concerns how much the model can produce. Wotherspoon describes Gemini 4's “long decode”: instead of an output ceiling of around 64K tokens, it shares a one-million-token budget among input, thinking, and output. Those are competing uses of the same allowance, not three separate million-token capacities. The intended use is work such as mathematical reasoning or financial modeling whose answer may run for many pages.
The claimed benefit is room to finish an unusually long analysis without hitting a smaller output cap. Wotherspoon also reports improvements on mathematical and financial benchmarks, but supplies no named benchmark or score here. That supports understanding the proposed capacity change, not a quantified prediction of better financial analysis.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep the files without inheriting the conversation
The key to handing work between agents is that conversation state and workspace state are separate server-side objects. An interaction records the conversation. Passing an interaction's ID into the next interaction continues that conversation into another turn. An environment represents the sandbox filesystem: documents, generated images, code, and other files. APIs can upload material into it or download the results.
What survives when the next agent starts fresh? Reusing an environment ID preserves access to the workspace without requiring the next agent to inherit the earlier conversation. The two paths below distinguish conversation continuation from file-based handoff. Continuing the conversation carries forward conversational state; reusing the environment gives a fresh interaction access to the work already saved.
The example begins with one agent collecting filings or annual reports, doing some work, and saving files. A later agent receives the same environment ID and starts with a fresh context window. It can read those saved materials and continue the analysis. The handoff therefore depends on what the first agent writes down: files preserve the selected work product, while the fresh conversation does not automatically contain every earlier exchange.
Two ways to carry state into the next interaction
Read the diagram as text
- Previous interaction. conversation-continuation — Holds server-side conversation state.
- Next conversational turn. conversation-continuation — Continues the conversation using the previous interaction's ID.
- Existing environment. workspace-handoff — Contains files saved by an earlier agent.
- Fresh agent interaction. workspace-handoff — Starts a new conversation while accessing the existing workspace.
- Previous interaction → Next conversational turn: Pass interaction ID to continue conversation.
- Existing environment → Fresh agent interaction: Reuse environment ID to access saved files.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Bring tools, instructions, and a repository
Customization comes through both connectivity and working material. Built-in code execution, file reading and writing, and Google Search cover common operations. Remote MCP servers connect other services. Uploaded skills and AGENTS.md files bring the playbooks used by a personal agent into the cloud environment. The code and generated files stay in the sandbox rather than modifying the developer's local workspace.
The code example gives the agent its instructions through an inline AGENTS.md file and mounts a GitHub repository of financial skills. Wotherspoon also describes how a developer could mount a project repository for a different task, such as checking its code for bugs.
Once the setup behaves as intended, agents.create saves a reusable agent configuration. Subsequent calls invoke that agent by its agent ID. This is a different kind of reuse from the shared environment: the saved agent makes a refined setup callable again, while an environment holds the files produced during work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep secrets outside; make runs scheduled and specific
The credential mechanism refines the earlier description of giving agents authenticated access. The sandbox receives a dummy token, not the real GitHub secret. When the agent sends a request to the GitHub API, an intervening proxy matches the destination and injects the actual token. The agent can make an authenticated request without possessing the credential itself.
Where does the real token enter the request? The diagram places that change at the proxy, after the request leaves the sandbox. This addresses the specific risk of an agent finding a reusable secret in its environment. It does not, by itself, establish that every action available through the authenticated service is appropriate; the described protection is credential isolation and destination-matched injection.
Triggers make a saved agent useful without an interactive session. Examples include an 8:30 AM financial-analysis run, a daily briefing, email scanning that suggests replies, and checking a team's Jira board before sending a Slack update through a webhook. These are separate possible jobs. A schedule starts the chosen task; the task produces a result, which can then be delivered through a connected service.
Delegation uses the same API-based access. A managed agent can be configured to call other managed agents and fan out work. Wotherspoon favors narrow responsibilities—research a subject, draft notes, save the result—over one enormous assignment whose progress is difficult to measure. Writing an intermediate file gives the next specialist a concrete input and gives the builder an output to inspect. Scheduling decides when work starts; decomposition decides who does which part.
Authentication changes at the proxy
Read the diagram as text
- Agent sandbox. sandbox — Contains a placeholder token rather than the real GitHub secret.
- Credential proxy. outside-sandbox — Matches the API destination and injects the real token.
- GitHub API. external-service — Receives the request with the injected credential.
- Agent sandbox → Credential proxy: Outbound request uses placeholder token.
- Credential proxy → GitHub API: Matched request carries injected real token.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
NVIDIA filings become a quant agent's input
The first end-to-end demonstration assigns an SEC filing researcher to NVIDIA. An API call starts the company-research task. Step traces record individual operations, including file writes and code execution, so the builder can inspect the run at a finer level than the final response. The traces are useful for finding out what the agent actually did and where its workflow might need adjustment.
The researcher produces metrics in the shared filesystem. The next call starts a quant agent with the same environment ID, giving it access to metrics.json. This is the earlier state distinction doing real work: the quant agent receives its own task, but it does not need to repeat the filing research to get the saved metrics.
The quant agent reads metrics.json and runs a five-year discounted-cash-flow model in Python. Its Markdown report uses NVIDIA’s Q2 FY2027 filing to estimate an implied value per share and compares that estimate with the share price quoted in the report. The five years are the model’s cash-flow projection period. The demo shows how the agent arrived at a valuation, but provides no market outcome against which to test it.
A third agent can turn the accumulated research into a report. That separates gathering information, analyzing it, and presenting it into inspectable assignments rather than asking a single conversation to do everything. Google Docs and Slack are proposed delivery extensions: with the appropriate MCP servers connected, the workflow could write a document or send a message. Those integrations are possibilities described here, not completed steps in this demonstration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From connected documents to an application report
The next example puts the managed agent behind an application. A connected Google Drive holds receipts and annual company data. The agent researches that material and creates a visualization, using a skill that describes how to build an interactive report. The service connection supplies the input; the skill supplies the procedure for turning it into the intended output.
This expands the role of the coding agent beyond editing a repository. The same remote execution setup can research documents, build a report, or generate application content. Wotherspoon points to AI Studio and its managed-agent gallery as a starting point, then opens a stock-research example to show what the API can look like behind a purpose-built front end.
After correcting the entry, he submits VOO. The ticker application uses several managed agents for specific research tasks. Its interface streams the execution steps exposed through the Interactions API, making the activity visible during the demo. Wotherspoon explicitly treats that stream as an illustrative interface choice: an application can use managed agents without showing customers the same running display.
The requested deliverable is a report based on the findings produced in the sandbox. Opening the result reveals a PDF containing research, analysis, key takeaways, and charts. The agent has moved from a short ticker input to a file the application can present, rather than stopping at a chat response.
The VOO report plots the fund’s closing price on the last trading day of each of the past four months. A separate bar chart shows distributions per share for the past four completed quarters. The report also links back to its research material. Wotherspoon describes the agent finding and reading documents on Vanguard’s site, then opens the Vanguard S&P 500 ETF prospectus from the report.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
Related talks
- Why AI Agents Should Have Their Own Sandbox — Philipp Schmid, Google DeepMind
A closer look at the same execution model, including typed interaction steps, persistent filesystems, reusable agent configurations, and inspecting a running sandbox.
- Stop Telling Agents How — Dan Barrett, Raymond Weitekamp & Jose Montes de Oca, OpenProse
Compares the managed execution layer with a harness-agnostic approach to reusable workflows, explicit inputs and outputs, triggers, and dependency-aware multi-agent work.
- Backtest Your Agent Against Yesterday's Web — Ryan Ahern, Exa
Extends the financial-research example into evaluation: historical web cutoffs help test predictions without leaking information that became available after the outcome.
Full transcript
Loading transcript…