Build Your Own Team of Managed Agents - Jack Wotherspoon, Google DeepMind

Hi, everybody. Thank you so much for coming. My name is Jack Wotherspoon, and I am a DevX engineer at Google DeepMind, and today we're gonna talk about managed or cloud agents. Um, so raise of hands here, who all has heard of either cloud or managed agents or has used them? Okay. Well, we're, we're starting off on the right foot. Um, so you might have heard of them. If you-- For those who haven't, cloud or managed agents are essentially a way of instead of running a harness,

uh, and running coding agent on your own machine, you can actually just run them in the cloud on a sandbox. Um, so let's first start by why the heck would you even wanna do that? Well, sandboxes are really powerful for a number of reaso-reasons. Uh, number one, they're not running on your own machine, so you can, you know, spawn a cloud agent. It can go and write code, it can reason, it can do research, search the web. It can go ahead and write tests, run tests, uh,

verify, and actually come back with verified kind of answers. Um, and that's a really strong thing. If you've ever, like, tried to run verification either on your own laptop, you know, sometimes it steals the browser, um, it starts to run things for you, you start getting pop-ups and things like that. So running this all in the cloud, um, takes away that pain. And the other reason is that your laptop doesn't scale. Uh, you might start to have specific setups like agent skills, or you maybe have customized your

personal coding agent on your machine, but then how do you go and share that with a colleague? Or how do you integrate that into your app, right? You don't want your app that you're deploying to customers to be running, uh, with your own kind of subscription or things like that, right? So we want to be able to scale this up, um, in doing so. And managed agents or cloud agents are a great, great way to do that. So close. The sign almost stayed up. Don't worry about it.

So when it comes to kind of managed or cloud agents, you know, to do this yourself is quite a tedious process. Uh, you know, you have to actually spin up a container or a VM. You have to load things onto that, manage it. Um, and then you actually have to do harness engineering, you know, figure out ki-- build your own harness within the sandbox. Um, and then let's not even start to talk about networking or setting up firewall rules or all the security stuff. So that's where kind of managed agents come in, and, uh,

whether it's Gemini managed agents, Cloud managed agents, uh, we'll be talking about Gemini managed agents today, which is our offering, uh, in the Gemini API, uh, at DeepMind. And really now it boils down to just being a single API call. So that is really the beauty of managed agents. With a single API call, you're getting all the things we talked about. So you're getting the sandbox, you're getting the Antigravity harness built out of the box that is in the sandbox, and it can go ahead and do a lot of powerful things. Um,

you don't have to worry about managing any of the infrastructure or the scale as you need in your application. More agents, you can just be-- do more API calls.

Actually, we'll go back for a sec. So you can see here, this is our Interactions API. Um, it's our kind of new agent-first, uh, version of our SDKs and client libraries. So previously, we had kind of models. You would, you know, do an input, get an output, but that didn't really scale to agents in the new world we live in. So we launched a new kind of SDK, uh, covering interactions. So interactions are much more kind of mirroring what agents are doing. So it can be multiple

steps. You know, when a, when you do an agent call, it can go ahead and write files, call those files, call different MCP tools. Um, so really, this new Interactions API that we launched, uh, in one GA earlier this year, is now our kind of home for managed agents. So you just call the agent. Instead of having a model, you have an agent. So we have our base Antigravity agent, and then you set environment="remote". So that's that key thing that's now telling it, "Okay, we want a managed agent that runs in the

cloud." And then you give it kind of regular input as you're used to.

So here's kind of how the infrastructure actually looks under the hood. So when you call a managed agent, you kind of have that input that we saw, and then it calls the Gemini API, which has a bunch of, you know, built-in server-side tools like, um, searching the web through Google Search or file system tools to read and write files. Um, and you can also add your own custom functions or MCP tools as well. And then we have the sandbox. So that's actually running on kind of Google Cloud infrastructure. Um, so when you call the

Gemini API to get a managed agent, it goes ahead and actually sets up and spins up that sandbox for you, and you can go ahead and actually upload files to the sandbox. So if you have agent skills or AGENTS.md, or you want to load a GitHub repository on startup, uh, we allow you to do all that cool stuff.

So here are kind of the building blocks that make up a managed agent. These are kind of the different core pillars. Um, so you've got the harness itself, and that's the Antigravity harness. It's the exact same harness that's running, uh, in our Antigravity suite of products over at Google. So that's what's kind of figuring out the tool calls. It has the built-in tools. Um, and then we have the environment. And we'll talk a bit more about how the environment is kind of its own entity, um, which allows you to do really cool kind of multi-agent workflows by

having different agents pointed at the same sandbox, so they can write files. A different agent can pick that same environment up later and actually build upon those files. Um, and then we've got skills we talked about. So you can upload your skills to the sandbox, just as you would have potentially like playbooks or different ways of doing things at your company or on your personal agent. You can upload those to the managed agent as well. And then we have credentials. Credentials is a new piece of managed agent, which essentially lets us inject either kind of

tokens or your MCP OAuth into the managed agent sandbox, so you can access your different services. And then we also have triggers, which allow you to actually schedule a managed agent to run. So let's say at eight thirty-- e-eight thirty AM every morning before the market opens, you wanna go and, you know, do some kind of financial analysis before the market opens up. You could set a trigger. The managed agent would essentially wake up, um, run its task or run its input, output a result. You can l-- like, do webhooks so

that you could send a Slack message. Maybe it queries your team's Jira board every morning and sends, you know, here's what everyone's working on, um, and things like that. So we talked a little bit about the harness. Um, it's the Antigravity harness that runs under the hood, and you can change the different models that it runs with. Uh, yesterday we just launched, uh, Gemini 4 Argon, which is our new frontier model. Um, so I definitely recommend testing it out. It's a great model. Um, but we'll show it later on in this-- in demo.

And you can set the different model in the config for the managed agent in the agent config. As you see there, we have that kind of one-line parameter to set the model. So that's how you can kind of tune the managed agent based on the workflow. If you're wanting to do something that needs to be fast and efficient, you can use Gemini Flash. If you want to do something that's deep reasoning or potentially doing a lot of analysis, then you can use a different model like Gemini 4 Argon.

Like we said, Gemini 4 Argon was released yesterday. Um, it's a really great model. It's especially good at financial tasks, which is great for, hopefully for the audience here. Um, and really good also at doing data analysis across a wide range of documents. Um, and as always, the Gemini models are also super, super good at multimodal. Another really cool interesting, um, feature that we have with the Gemini 4 model is long decode. So normally models have an output token max of around sixty-four K tokens.

Um, but with Gemini 4, we actually have upped this so that now the one million kind of context window or token limit is now shared between input, thinking, and output. So output, as you need to kinda scale up, if you need to do extreme kind of math reasoning or financial modeling where the output might be pages and pages and pages long, the model can actually go and do that. And this is showing to actually advance some of the more mathematical and financial benchmarks out there.

So we talked a bit about the interactions API and environments, and this is kind of one of the key pillars. These are kinda two core primitives in managed agents that allow you to get a lot of flexibility and be able to customize kind of the agent configurations that you do. So these are kind of two different, um, stateful things on our back end in our server side. So interactions is what manages your conversation. So when you put an input and get an output and kind of a different turn with the model, um, those are

saved as kind of what we call interactions. So you can take one interaction, pass that ID to the next interaction, and that kind of, you know, is the second turn. Um, and then we also have environments. So environments are what's actually kind of in the file system on the sandbox. So when the agent goes and writes files or creates images or does, um, different file tasks on the actual sandbox in the cloud, that's kind of representative of the environment. Um, and you

can go ahead and use our APIs to download files from that environment or upload them. But having these two things kind of split out allows you to do some really cool things where you can actually see here that we are creating one agent interaction with our first code block, and it's gonna go ahead and do some work and save a file. And then we can pass that environment ID to our next agent. So it actually picks up. It has a very fresh, like, kinda context window and conversation, but it's reusing

the environment. So it can go and, you know, say save the Q3 filings in our workspace. Maybe we're gonna go, you know, fetch the, fetch the annual reports, the filings, and then we're gonna go and do some analysis, save that as a file, and then we can have a new agent come in, reuse that same exact environment, but this time have a fresh context window, um, kind of a multi-agent workflow, which is really cool.

So there are a bunch of built-in tools already in the sandbox, like code execution, reading and writing files, as well as Google Search. But we also support, you know, remote MCP servers, so you can bring your own servers, you can hook up to your favorite services, and really that takes the agent a step further and be able to actually do kind of daily tasks or things that you can build into your apps.

And we talked a little bit about it, but you can also kind of mount files to the file system. So you can upload your different AGENTS.md files, your skills, and kind of run through the playbooks that you have your agents doing on your personal machine, but doing it in an environment where you can kind of reproduce and have that work done for you, uh, in the cloud. So you don't have to worry about, you know, overwriting any files or messing up things on your machine. Everything runs in the cloud, um, and can just run as a process and get you back that output.

So here's a, here's a code sample where we are actually going to upload an AGENTS.md example into our, um, sandbox, and then we're also connecting a GitHub repository. So now you can actually have the agent look at your code, check for bugs and things like that. And then you can also save the agents. We also have an agents API, so you can do agents.create. So once you've kind of refined your workflow and found an agent that works for you, you can save it, so they can easily call it, you know, in multiple different times. You can iterate on

it and then save it for later.

And then you can just easily invoke your personal agent by calling it with its, uh, agent ID.

So another big part of the security aspect of managed agents is that secrets never actually enter the sandbox. So our managed agents have a proxy that sits, uh, as kind of a layer between the sandbox and our API. And it actually, what it does is it puts a placeholder kind of dummy token into the sandbox so that the agent can never kind of go rogue and say, "Oh, I see that I have this GitHub token laying around. Let me just see what else is on there." Um, so it can actually never do that because it never actually

has your GitHub token. So what it does is when it goes and calls the GitHub API, our proxy will then inject that token. It will match it to say, you know, it's API-- GitHub API. Um, we're gonna go ahead and inject this secret, um, so that way the agent can never do anything that it shouldn't be able to.

And we talked quickly about triggers, but triggers are also really powerful because you can have them set to kind of a daily briefing every morning, like we said, scan your emails, maybe suggest ones to reply to, or if you want to check on the stock market before it opens, um, you can do that. And this is a way to run one of your agents on a set schedule.

And we talked a little bit about multi-agent workflows, but managed agents can actually work really well, um, in multi-agent workflows. So 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, um, and do work and fan out work. And then you can have very kind of niche and specific targeted agents that have one core purpose. They do that purpose really well. Um, you know, maybe it's drafting notes or doing research,

um, writes it to a file, gets that information saved, and the next agent can then take over from that different input. And this kind of breaks it up so that you can have things really controllable and really make sure that you're doing specific tasks well instead of just giving a super, super broad, you know, task to an agent and having it have no way of kind of measuring what it's actually doing.

So now we'll just quickly put this to the test. Um, so we can actually run the agents here and see what this actually looks like when you run one. So we have an S-- kind of an SEC filing researcher that just researches companies. We have it set to NVIDIA here, and we can go ahead and make call the a-API. So, like, again, this is just an API call. It's really easy to build into your own either internal workflows or to actually publish in your services or apps to external folks. So we can go see here.

There are step traces, so each thing the agent does, um, is saved as a step trace. So you can see we're having function result for the write to file, code execution, and you can kind of trace the-- what the agent is doing and optimize as you go to kind of make sure that the workflow is straightforward. And then we're reusing the same environment ID that we talked about. So because we're reusing the same environment ID in this scenario, we're actually having our agents pick up. So we can have-- We have this SEC filing researcher that went and did research on NVIDIA,

gave us a bunch of metrics as the output, and then we can now kick off this kind of quant agent, which will go take a look at the metrics because it's in the file system. It's reusing the same environment, the same sandbox, and now it can pick up its task and its job from that, um, metrics.json, take it, run a bunch of Python code files to see and actually look at it, make evaluation for NVIDIA. And if we go here and look at the MD file, we can see the managed agent went and actually

did research based on the metrics it got, and it's now kind of doing a forecast for the share price and the stock.

And then we can kick off a third agent just to kind of take that research and knowledge dump and turn it into a report. And if we had connected different MCP servers, like we could connect to Google Docs, have it actually output and write to a Google Doc or send a message in Slack so that you can really kind of create these customized workflows from managed agents.

And then you can also build managed agents super easily with the SDK into your own application. So this is just a demo here where we have a managed agent that is actually, um, connected to our service. Um, it's connected to our Google Drive, where we dumped in a bunch of receipts of our annual kind of, um, company data, and it's gonna go ahead and actually create this visualization, um, by-- from, from the, the data. And the managed agent is the one that's actually doing all the research. It has, you know, kind of a skill that will go out

and tells it kind of how to do this interactive report. Um, and then it's just kind of reasoning through it and building this out for us.

So it's really customizable. You can really kind of anything you can do on your own personal coding agent, you can kind of turn it easily into a managed agent that you can either run as a company daily or set up in your own app so that we have other ones on our, on our Gemini API on AI Studio where you can kind of create games on the fly, um, you can research documents and do all kinds of things.

So the easiest way to get started today is to go over to AI Studio and, uh, get started for free over there. And we also have our documentation for managed agents, but I'll quickly just do another demo here since we have a few minutes. This is one of our kind of managed agents examples that is on, uh, AI Studio in our gallery. Um, and this one's kind of just trying to showcase how you can actually build these managed agents into your own applications. Um, so this is, you know, create a nice front end and put in the stock.

Oh, not slash. So we can go ahead and do VOO. And this ticker agent is a bunch of our different managed agents that will go out and do specific tasks, um, and look for different analysis on a stock.

And again, this is kind of more of an illustration, illustration. As like, as you're building managed agents into your own apps, you might not wanna have this kind of stream. Um, but just to kind of visualize what the actual agent is doing, um, it's reasoning through all the different steps in the interactions API. And then this managed agent is told to kind of generate a report based on all of the findings and reasoning it did in its sandbox. So now if we go ahead and click on the report, we can see the managed agent outputted this kind of PDF, um, file for us

where we can see all of the research it did, see its analysis and key takeaways, as well as doing these charts so we can visualize. And it's also gonna go and link out to kind of all of the, um, resources, um, that it went and is actually using for this. So it actually went to the Vanguard, Vanguard site, found the different documents, read them in, and then did analysis on it.

And that is it on managed agents. Thank you very much.