Monte sua própria equipe de agentes gerenciados — Jack Wotherspoon, Google DeepMind

Autoria: AI Engineer · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Build Your Own Team of Managed Agents - Jack Wotherspoon, Google DeepMind · Canal: AI Engineer · 19:17 · Assistir no YouTube

Tópicos: Agentes de IA, Ferramentas de desenvolvimento com IA, Segurança de IA

Resumo

Jack Wotherspoon apresenta os agentes gerenciados do Gemini, que executam agentes de programação em sandboxes na nuvem por meio de uma chamada de API. Ele explica os componentes do sistema, incluindo harness, ambientes, skills, credenciais e triggers, além de mostrar como interações e ambientes separados permitem criar fluxos de trabalho com vários agentes. A palestra também aborda controles de segurança para proteger secrets e demonstra casos de uso para pesquisa, análise financeira e geração de relatórios. Ao final, ele indica o AI Studio e a documentação como pontos de partida.

Pontos-chave

Agentes gerenciados executam tarefas em sandboxes na nuvem, sem usar diretamente a máquina local.
O Gemini API permite iniciar um agente gerenciado por meio de uma chamada de API e oferece infraestrutura e harness prontos.
O Interactions API registra as etapas das interações, enquanto os ambientes armazenam os arquivos criados ou usados pelos agentes.
Agentes diferentes podem reutilizar o mesmo ambiente e trabalhar em sequência, cada um com um contexto novo.
É possível configurar skills, conectar repositórios e usar ferramentas integradas ou serviços externos via MCP.
Um proxy injeta credenciais apenas quando necessário, sem expor os secrets diretamente à sandbox.
Triggers permitem executar agentes em horários definidos, por exemplo, para gerar briefings recorrentes.
A demonstração mostra agentes encadeados para pesquisar documentos financeiros, analisar dados e produzir relatórios.

Capítulos

Início	Capítulo	Resumo
00:01	O que são agentes gerenciados	Jack apresenta a ideia de executar agentes de programação em sandboxes na nuvem e explica por que isso pode ser útil.
02:03	A oferta do Gemini e sua infraestrutura	A palestra introduz os agentes gerenciados do Gemini, o Interactions API e os principais componentes da execução na nuvem.
05:12	Componentes e configuração dos agentes	Jack descreve harness, ambientes, skills, credenciais, triggers e opções de modelo para diferentes tarefas.
08:50	Interações, ambientes e fluxos multiagente	A distinção entre interações e ambientes permite que agentes com contextos novos reutilizem os mesmos arquivos.
11:58	Segurança, agendamento e divisão de tarefas	O apresentador explica a proteção de credenciais, os triggers e a coordenação de agentes especializados.
14:34	Demonstrações e como começar	As demonstrações mostram pesquisa e análise financeira com vários agentes, geração de relatórios e integração em aplicações.

Citações

Você pode executar esses agentes na nuvem, em uma sandbox. — 00:32

Agora tudo se resume a uma única chamada de API. — 02:34

Ele reutiliza o ambiente, mas tem um contexto e uma conversa novos. — 09:53

Os secrets nunca entram de fato na sandbox. — 12:28

Conceitos e entidades

Jack Wotherspoon (pessoa): Engenheiro de DevEx na Google DeepMind que apresenta os agentes gerenciados do Gemini.
Google DeepMind (empresa): Organização onde Jack Wotherspoon trabalha e responsável pela oferta de agentes gerenciados apresentada.
Gemini Managed Agents (ferramenta): Oferta do Gemini API para executar agentes em sandboxes na nuvem com infraestrutura gerenciada.
Interactions API (ferramenta): API voltada a interações de agentes com várias etapas, que mantém o estado das conversas.
AI Studio (ferramenta): Plataforma indicada na palestra para começar a experimentar agentes gerenciados e acessar exemplos.
Gemini 4 Argon (modelo): Modelo apresentado como opção para tarefas que exigem raciocínio profundo e análise.
sandbox (conceito): Ambiente isolado na nuvem onde os agentes podem executar código e trabalhar com arquivos.
environment (conceito): Estado do sistema de arquivos da sandbox, reutilizável por diferentes interações e agentes.
trigger (conceito): Agendamento que inicia um agente automaticamente em horários ou intervalos definidos.

Tradução completa (pt-BR)

00:01 [música] >> Oi, pessoal. Muito obrigado por virem. Meu nome é Jack Witherspoon e sou engenheiro de DevEx na Google DeepMind. Hoje vamos falar sobre agents gerenciados ou na nuvem. Então, levantem a mão: quem já ouviu falar de agents na nuvem ou gerenciados, ou já usou algum? Certo. Estou começando com o pé direito.

00:32 Então, talvez você já tenha ouvido falar deles. Para quem ainda não ouviu, agents na nuvem ou gerenciados são basicamente uma forma de, em vez de executar um harness e um agent de programação na sua própria máquina, você poder executá-los na nuvem, em um sandbox. Vamos começar pelo motivo de alguém querer fazer isso. Bem, sandboxes são muito poderosos por vários motivos. Primeiro, eles não estão sendo executados na sua própria máquina. Assim, você pode, sabe, iniciar um agent na nuvem. Ele pode escrever código, raciocinar, fazer pesquisas, pesquisar na web. Pode escrever testes, executá-los, verificar os resultados e voltar com respostas que foram efetivamente verificadas. Isso é algo muito útil. Se você já tentou executar uma verificação no seu próprio laptop, sabe que às vezes ela toma conta do navegador. Começa a executar coisas por você. Aparecem janelas pop-up e coisas assim. Executar tudo isso na nuvem elimina esse incômodo.

01:02 E o outro motivo é que seu laptop não escala. Talvez você comece a usar configurações específicas, como skills de agent, ou personalize seu agent de programação pessoal na sua máquina. Mas como você compartilha isso com um colega ou integra isso ao seu aplicativo, certo? Você não quer que o aplicativo que está disponibilizando para os clientes seja executado com a sua própria assinatura ou coisas assim, certo? Então, queremos poder escalar isso, e é aí que entram os agents gerenciados ou na nuvem. São uma

01:32 ótima, ótima maneira de fazer isso. Quase deu, a placa quase ficou levantada. Não se preocupem com isso. >> [risos] >> Quando se trata de agents gerenciados ou na nuvem, fazer isso por conta própria é um processo bem trabalhoso. Você precisa iniciar um contêiner ou uma VM. Precisa carregar coisas nela e gerenciá-la. E depois precisa fazer engenharia de harness, descobrir como criar seu próprio harness dentro do sandbox. E nem vamos começar a falar

02:03 de rede, configuração de regras de firewall ou de toda a parte de segurança. É aí que entram os agents gerenciados. Seja o Gemini Managed Agents ou o Cloud Managed Agents, hoje vamos falar sobre o Gemini Managed Agents, nossa oferta na Gemini API da DeepMind. E, na prática, tudo se resume a uma única chamada de API. Essa é a grande vantagem dos agents gerenciados. Com uma única chamada de API, você tem tudo o que mencionamos. Então, você tem o sandbox, está

02:34 com o harness anti-gravity pronto para uso dentro do sandbox, e ele pode fazer muitas coisas poderosas. Você não precisa se preocupar em gerenciar a infraestrutura nem em escalar. Se o seu aplicativo precisar de mais agents, basta fazer mais chamadas de API. Na verdade, vamos voltar um instante. Aqui você pode ver nossa Interactions API. É a nossa versão mais recente dos SDKs e bibliotecas cliente, pensada primeiro para agents. Antes, tínhamos modelos: você fornecia uma entrada e recebia uma saída. Mas isso não se adaptava bem aos agents no novo mundo em que vivemos. Então, lançamos um novo SDK que abrange as interactions. As interactions refletem muito melhor o que os agents fazem. Podem envolver várias etapas. Quando você faz uma chamada de agent, ele pode escrever arquivos, chamar esses arquivos e chamar diferentes ferramentas MCP. Então, essa nova Interactions API que lançamos e que ficou disponível em geral no início deste ano é agora

03:05 o nosso espaço para os agents gerenciados. Você simplesmente chama o agent: em vez de ter um modelo, você tem um agent. Temos o nosso agent anti-gravity básico. Depois, você define environment = remote. Esse é o ponto-chave que indica: “Certo, queremos um agent gerenciado que seja executado na nuvem”. Em seguida, você fornece uma entrada normal, como está acostumado. Então, é assim que a infraestrutura funciona nos bastidores. Quando você chama um agent gerenciado, fornece aquela entrada que vimos. Em seguida, ele chama a Gemini API, que

03:37 tem várias ferramentas integradas do lado do servidor, como pesquisar na web usando o Google Search ou usar ferramentas do sistema de arquivos para ler e gravar arquivos. Você também pode adicionar suas próprias funções personalizadas ou ferramentas MCP. E então temos o sandbox. Ele é executado na infraestrutura do Google Cloud. Quando você chama a Gemini API para obter um agent gerenciado, ela configura e inicia o sandbox para você. Você também pode enviar arquivos para o sandbox. Então, se você tiver skills de agent ou um agents.md, ou quiser carregar um repositório do GitHub na inicialização, permitimos que você faça tudo isso. Então, aqui estão os blocos de construção de um agent gerenciado. Esses são os diferentes pilares principais. Temos o próprio harness, que é o harness anti-gravity. É exatamente o mesmo harness executado no nosso conjunto de produtos anti-gravity na Google. É ele que determina as chamadas de ferramentas. Ele tem ferramentas integradas. E então temos o ambiente. Vamos falar um pouco mais sobre como o ambiente é uma entidade própria, o que permite criar workflows multi-agent bem interessantes: você pode direcionar diferentes agents para o mesmo sandbox, para que eles gravem arquivos. Depois, outro agent pode usar esse mesmo ambiente e continuar o trabalho a partir desses arquivos. Também temos as skills que mencionamos. Você pode enviar suas skills para o sandbox, assim como talvez usasse playbooks ou diferentes formas de trabalhar na sua empresa ou no seu agent pessoal. Você

04:10 também pode enviá-las para o agent gerenciado. E então temos as credenciais. As credenciais são um novo componente dos agents gerenciados que nos permite inserir tokens ou seu OAuth do MCP no sandbox do agent gerenciado, para que você possa acessar seus diferentes serviços. Também temos triggers, que permitem agendar a execução de um agent gerenciado. Digamos que você queira fazer uma análise financeira às 8h30 todas as manhãs, antes da abertura do mercado. Você poderia

04:41 configurar um trigger. O agent gerenciado seria iniciado, executaria a tarefa ou processaria a entrada e geraria um resultado. Você pode usar webhooks para enviar uma mensagem no Slack. Talvez ele consulte o quadro do Jira da sua equipe todas as manhãs e envie algo como: “Aqui está o que todo mundo está fazendo”, e coisas assim. Falamos um pouco sobre o harness. É o harness anti-gravity que é executado nos bastidores, e você pode alterar os modelos usados por ele. Ontem, lançamos o Gemini 4 Argon, nosso novo modelo de ponta.

05:12 Então, recomendo muito que você o experimente. É um ótimo modelo. Mas vamos mostrá-lo mais adiante nesta demonstração. Você pode definir o modelo no arquivo de configuração do agent gerenciado, na configuração do agent, como podem ver aí. Temos um parâmetro de uma linha para definir o modelo. É assim que você pode ajustar o agent gerenciado de acordo com o workflow. Se quiser fazer algo que precise ser rápido e eficiente, pode usar o Gemini Flash. Se quiser fazer algo que exija raciocínio profundo ou talvez envolva muita análise, pode usar outro modelo, como

05:42 ferramentas. E então temos o ambiente. Vamos falar um pouco mais sobre como o ambiente é uma entidade própria, o que permite criar workflows multiagente muito interessantes, colocando diferentes agents no mesmo sandbox para que possam gravar arquivos. Depois, outro agent pode acessar esse mesmo ambiente e realmente trabalhar a partir desses arquivos. E também temos as skills de que falamos, então você pode enviar suas skills para o sandbox, assim como faria com possíveis playbooks ou diferentes maneiras de trabalhar na sua empresa ou no seu agent pessoal. Você

06:12 também pode enviá-las para o managed agent. E então temos as credenciais. As credenciais são um novo recurso do managed agent que basicamente nos permite injetar tokens ou o OAuth do seu MCP no sandbox do managed agent, para que você possa acessar seus diferentes serviços. E também temos os triggers, que permitem agendar a execução de um managed agent. Digamos que, às 8h30 da manhã, todas as manhãs, antes da abertura do mercado, você queira fazer algum tipo de análise financeira. Você poderia

06:44 configurar um trigger. O managed agent basicamente seria ativado, executaria a tarefa ou processaria a entrada e produziria um resultado. Você pode, por exemplo, usar webhooks para enviar uma mensagem no Slack. Talvez ele consulte o quadro do Jira da sua equipe todas as manhãs e envie algo como “aqui está o que todos estão fazendo”, e coisas assim. Então, falamos um pouco sobre o harness. É o harness do Anti-Gravity, que é executado nos bastidores, e você pode alterar os diferentes modelos com que ele funciona. Ontem, acabamos de lançar o Gemini 4 Argon, nosso novo modelo de fronteira.

07:14 Então, recomendo muito que você o teste. É um ótimo modelo. Mas vamos mostrá-lo mais tarde, nesta demonstração. E você pode definir um modelo diferente na configuração do managed agent, na configuração do agent, como você pode ver aí. Temos aquele parâmetro de uma linha para definir o modelo. É assim que você pode ajustar o managed agent de acordo com o workflow. Se quiser fazer algo que precise ser rápido e eficiente, pode usar o Gemini Flash. Se quiser fazer algo que exija raciocínio profundo ou talvez envolva muita análise, pode usar outro modelo, como

07:45 Gemini 4 Argon. Como dissemos, Gemini 4 Argon foi lançado ontem. É um modelo realmente ótimo. Ele é especialmente bom em tarefas financeiras, o que é ótimo, esperamos, para o público aqui. Também é muito bom em fazer análise de dados em uma ampla variedade de documentos. E, como sempre, os modelos Gemini também são muito, muito bons em multimodalidade. Outro recurso muito legal e interessante que temos com o modelo Gemini 4 é a geração longa. Normalmente, os modelos têm um máximo de tokens de saída de

08:17 cerca de 64 mil tokens. Mas, com Gemini 4, aumentamos esse limite para que agora o limite de 1 milhão de tokens da context window seja compartilhado entre entrada, raciocínio e saída. Assim, se você precisar aumentar a saída para fazer raciocínios matemáticos extremos ou modelagem financeira, em que a saída talvez tenha páginas e mais páginas, o modelo pode fazer isso. E isso está mostrando avanços em alguns dos benchmarks matemáticos e financeiros disponíveis.

08:50 Então, falamos um pouco sobre a API de interações e os ambientes, e eles são um dos pilares principais. São duas primitivas essenciais dos managed agents que oferecem bastante flexibilidade e permitem personalizar as configurações dos agents. São duas coisas com estado diferentes no nosso backend, no lado do servidor. As interações são o que gerencia a conversa. Assim, quando você envia uma entrada e recebe uma saída, em uma rodada diferente com o modelo, elas são salvas como o que chamamos de

09:21 interações. Você pode pegar uma interação, passar o ID dela para a próxima interação e, assim, ter a segunda rodada. Também temos ambientes. Os ambientes são o que está de fato no sistema de arquivos do sandbox. Quando o agent grava arquivos, cria imagens ou realiza diferentes tarefas com arquivos no próprio sandbox na nuvem, isso representa o ambiente. E você pode usar nossas APIs para

09:53 baixar arquivos desse ambiente ou fazer upload deles. Mas separar essas duas coisas permite fazer coisas muito legais. Como você pode ver aqui, estamos criando uma interação com o agent usando nosso primeiro bloco de código. Ele vai realizar algum trabalho e salvar um arquivo. Depois, podemos passar o ID do ambiente para o próximo agent. Assim, ele retoma o trabalho. Ele tem uma context window e uma conversa totalmente novas, mas reutiliza o ambiente. Então, pode, por exemplo, salvar os relatórios do terceiro trimestre no nosso

10:24 workspace. Talvez vamos buscar os relatórios anuais, os documentos regulatórios. Depois, vamos fazer uma análise e salvá-la em um arquivo. Em seguida, podemos inserir um novo agent, reutilizando exatamente o mesmo ambiente, mas desta vez com uma context window nova. É um workflow multi-agent, o que é muito legal. Há várias ferramentas integradas ao sandbox, como execução de código, leitura e gravação de arquivos, além do Google Search. Também oferecemos suporte a servidores SMTP remotos,

10:56 para que você possa trazer seus próprios servidores. Pode se conectar aos seus serviços favoritos. Isso realmente leva o agent um passo adiante e permite que ele realize tarefas do dia a dia ou tarefas que você pode integrar aos seus apps. Falamos um pouco sobre isso, mas você também pode montar arquivos no sistema de arquivos. Assim, pode fazer upload dos seus diferentes arquivos agents.md e das suas skills, e executar os playbooks que seus agents executam na sua máquina pessoal, mas em um ambiente onde você pode reproduzir o processo e ter esse trabalho feito

11:27 para você na nuvem. Assim, não precisa se preocupar em substituir arquivos ou bagunçar as coisas na sua máquina. Tudo é executado na nuvem como um processo e retorna o resultado. Aqui está um exemplo de código em que vamos fazer upload de um exemplo de agents.md para o nosso sandbox e também conectar um repositório do GitHub. Agora, o agent pode analisar seu código, procurar bugs e coisas do tipo. Você também pode salvar os agents.

11:58 Também temos uma API de agents, então você pode usar agents.create. Depois de refinar seu workflow e encontrar um agent que funcione para você, pode salvá-lo para chamá-lo facilmente várias vezes. Você pode iterar nele e salvá-lo para usar depois. Então, pode invocar facilmente seu agent pessoal chamando-o pelo ID do agent. Outro aspecto importante da segurança dos managed agents é que os segredos nunca entram no sandbox. Então,

12:28 nossos managed agents têm um proxy, uma camada entre o sandbox e nossa API. O que ele faz é colocar no sandbox um token fictício de substituição, para que o agent nunca possa sair do controle e dizer: “Ah, vejo que tem um token do GitHub aqui. Deixa eu ver o que mais tem por aí”. Ele nunca pode fazer isso, porque na verdade nunca tem seu token do GitHub. Quando chama a API do GitHub, nosso proxy insere o token. Ele identifica que

12:59 é a API do GitHub e insere esse segredo. Assim, o agent nunca pode fazer algo que não deveria. Falamos rapidamente sobre os triggers, que também são muito poderosos. Você pode configurá-los para gerar um resumo diário todas as manhãs, como dissemos: analisar seus e-mails e talvez sugerir quais responder, ou verificar o mercado de ações antes da abertura. Essa é uma maneira de executar um dos seus agents em um

13:32 cronograma. Falamos um pouco sobre workflows multi-agent, e os managed agents podem funcionar muito bem neles. Você pode configurá-los para que um managed agent saiba chamar outros managed agents — já que basta uma chamada de API —, delegar trabalho e distribuí-lo. Assim, você pode ter agents bem especializados e direcionados, cada um com uma função principal, que executam muito bem.

14:03 Talvez seja redigir anotações ou fazer pesquisas. Ele grava o resultado em um arquivo e salva essas informações; então, o próximo agent pode assumir a partir dessa entrada diferente. Isso divide o trabalho para que tudo fique bem controlável e para garantir que as tarefas específicas sejam bem executadas, em vez de simplesmente dar uma tarefa muito, muito ampla a um agent, sem ter como avaliar o que ele está fazendo. Agora, vamos testar isso rapidamente.

14:34 Podemos executar os agents aqui e ver como é na prática. Temos um pesquisador de documentos regulatórios da SEC, que pesquisa empresas. Aqui, configuramos o Nvidia. Podemos fazer a chamada à API. Como dissemos, é apenas uma chamada à API. É muito fácil integrá-la aos seus próprios workflows internos ou publicar isso nos seus serviços ou apps para pessoas externas. Aqui, podemos ver os rastros das etapas. Cada coisa

15:06 que o agent faz é salva como um rastro de etapa. Assim, você pode ver os resultados das funções para gravar no arquivo e executar o código, acompanhar o que o agent está fazendo e otimizar o processo para garantir que o workflow seja simples. E estamos usando o mesmo ID de ambiente de que falamos? Como estamos usando o mesmo ID de ambiente neste cenário, nossos agents conseguem retomar o trabalho. Então, tínhamos um pesquisador de documentos regulatórios da SEC que pesquisou a Nvidia e nos forneceu várias métricas.

15:36 como saída. E então, agora podemos iniciar esse tipo de quant agent, que vai dar uma olhada nas métricas, porque elas estão no sistema de arquivos. Ele está reutilizando o mesmo ambiente, o mesmo sandbox. E agora pode pegar sua tarefa e seu trabalho daquele metrics.json, executá-lo e rodar vários arquivos de código Python para examinar os dados e, de fato, avaliá-los para a Nvidia. E, se viermos aqui e olharmos o arquivo MD, podemos ver que o managed agent fez uma pesquisa com base nas métricas que recebeu e agora está meio que

16:07 fazendo uma previsão do preço das ações. E então podemos iniciar um terceiro agent só para pegar essa pesquisa e esse despejo de conhecimento e transformá-los em um relatório. E, se tivéssemos conectado diferentes servidores MCP, poderíamos, por exemplo, conectar o Google Docs, fazer com que ele gerasse e escrevesse o resultado em um Google Doc, ou enviasse uma mensagem no Slack, para que você pudesse realmente criar workflows personalizados com managed agents. E então também é muito fácil criar managed agents com o SDK e integrá-los à

16:38 sua própria aplicação. Então, esta é apenas uma demonstração em que temos um managed agent conectado ao nosso serviço. Ele está conectado ao nosso Google Drive, onde colocamos vários recibos dos dados anuais da nossa empresa, e ele vai criar esta visualização com base nos dados. E é o managed agent que está fazendo toda a pesquisa. Ele tem, sabe, uma espécie de skill que explica como criar este relatório interativo. E então ele

17:08 simplesmente vai raciocinando e montando tudo isso para nós. Então, ele é muito personalizável. Praticamente qualquer coisa que você consiga fazer com seu próprio agent de programação pessoal, pode transformar facilmente em um managed agent, que você pode executar diariamente na empresa ou configurar nos seus próprios apps. Também temos outros no nosso Gemini API no AI Studio, em que você pode criar jogos na hora. Pode pesquisar documentos e fazer todo tipo de coisa.

17:44 Então, a maneira mais fácil de começar hoje é acessar o AI Studio e começar por lá gratuitamente. Também temos a documentação dos managed agents, mas vou fazer rapidamente outra demonstração, já que temos alguns minutos. Este é um dos exemplos de managed agents que temos na galeria do AI Studio. E este exemplo tenta mostrar como você pode integrar managed agents às suas próprias aplicações. Então, você cria uma interface agradável e insere uma ação.

18:15 Ah, sem a barra. Então, podemos usar VOO. E este ticker agent é composto por vários managed agents diferentes, que vão executar tarefas específicas e buscar diferentes análises sobre uma ação. E, novamente, isto é mais uma ilustração: quando você está integrando managed agents aos seus próprios apps, talvez não queira ter este tipo de fluxo

18:45 mas é só para visualizar o que o agent está fazendo de fato. Ele está raciocinando sobre todas as diferentes etapas na API de interações. E então este managed agent recebe a instrução de gerar um relatório com base em todas as descobertas e no raciocínio que fez no sandbox. Então, se clicarmos no relatório, veremos que o managed agent gerou este arquivo PDF para nós, onde podemos ver toda a pesquisa que ele fez, conferir a análise e os principais pontos, além de ver estes gráficos para visualizar os dados. Ele também vai incluir links para

19:17 todos os recursos que realmente usou para isso. Ele acessou o site da Vanguard, encontrou os diferentes documentos, leu-os e depois fez uma análise. E é isso sobre managed agents. Muito obrigado.

Transcrição original

[00:01] [music] >> Hi everybody. Thank you so much for coming. My name is Jack Witherspoon and I am a DevEx engineer at Google DeepMind and today we’re going to talk about managed or cloud agents. So raise your hands here, who all has heard of either cloud or managed agents or has used them? Okay. I’m starting off on the right

[00:32] foot. 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 and running coding agent on your own machine, you can actually just run them in the cloud on a sandbox. So let’s first start by why the heck would you even want to do that? Well, sandboxes are really powerful for a number of reasons. Number one, they’re not running on your own machine. So you can, you know, spawn

[01:02] 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, verify and actually come back with verified kind of answers. 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. It starts to run things for you. You start getting pop-ups and things like that. So running this all in the cloud takes away that pain.

[01:32] And the other reason is that your laptop doesn’t scale. 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 with your own kind of subscription or things like that, right? So, we want to be able to scale this up and doing so. And managed agents or cloud agents are a

[02:03] great great way to do that. So close, the sign almost stayed up. Don’t worry about it. >> [laughter] >> So, when it comes to kind of managed or cloud agents, you know, to do this yourself is quite a tedious process. You know, you have to actually spin up a container or a VM. You have to load things onto that, manage it. And then you actually have to do harness engineering, you know, figure out kind of build your own harness within the sandbox. And then let’s not even start to talk

[02:34] about networking or setting up firewall rules or all the security stuff. So, that’s where kind of managed agents come in and whether it’s Gemini managed agents, cloud managed agents, we’ll be talking about Gemini managed agents today, which is our offering in the Gemini API 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

[03:05] getting the anti-gravity harness built out of the box that is in the sandbox, and it can go ahead and do a lot of powerful things. 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 do more API calls. Actually, we’ll go back for a sec. So, you can see here, this is our interactions API. It’s our kind of new agent first version of our SDKs and client libraries. So,

[03:37] 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, and went GA earlier this year, is now

[04:10] 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 anti-gravity agent. And then you set environment equals 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

[04:41] 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

[05:12] skills or agents.md, or you want to load a GitHub repository on startup, uh, we allow you to do all of 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 anti-gravity harness. It’s the exact same harness that’s running, uh, in our anti-gravity suite of products over at Google. So, that’s what’s kind of figuring out the tool calls. It has the built-in

[05:42] tools. Um, and then we have the environment. 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. 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

[06:12] 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 8:30 8:30 a.m. every morning before the market opens you want to go and you know do some kind of financial analysis before the market opens up. You could

[06:44] set a trigger. The managed agent would essentially wake up, run its task or run its input, output a result. You can 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 and things like that. So we talked a little bit about the harness. It’s the anti-gravity harness that runs under the hood and you can change the different models that it runs with. Yesterday we just launched Gemini 4 Argon which is our new frontier model.

[07:14] So I definitely recommend testing it out. It’s a great model. 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 do that’s deep reasoning or potentially doing a lot of analysis, then you can use a different model like

[07:45] 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

[08:17] around 64K tokens. Um but with Gemini 4, we actually have up this so that now the 1 million kind of context window or token limit is now shared between input, thinking, and output. So, output, as you need to kind of 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.

[08:50] So, we talked a bit about the interactions API and environments, and this is kind of one of the key pillars. These are kind of 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

[09:21] call interactions. So, you can take one interaction, pass that ID to the next interaction, and that kind of, you know, it’s 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 different file tasks on the actual sandbox in the cloud, that’s kind of representative of the environment. And you can go ahead and use our APIs to

[09:53] 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 going to 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 kind of context window and conversation, but it’s reusing the environment. So, it can go and, you know, say save the Q3 filings in our

[10:24] workspace. Maybe we’re going to go, you know, fetch the fetch the annual reports, the filings. And then we’re going to 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. 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 SMTP servers,

[10:56] 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

[11:27] you in the cloud. So, you don’t have to worry about, you know, overriding 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’re 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.

[11:58] 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 you 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,

[12:28] our managed agents have a proxy that sits uh it’s a 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

[12:59] to say, you know, it’s API uh GitHub API. Um we’re going to go ahead and inject this secret. Um so, that way the agent can never do anything that it shouldn’t be able to. 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

[13:32] 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.

[14:03] 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

[14:34] 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 SEC 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 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

[15:06] the agent does um is saved as a step trace. So, you can see we’re having function result for the right 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 were we using the same environment ID that we talked about? So, because we’re using the same environment ID in this scenario, we’re actually having our agents pick up. So, we can have We had this SEC filing researcher that went and did research on Nvidia, gave us a bunch of metrics

[15:36] 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

[16:07] doing a forecast for the share price in 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 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

[16:38] 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 going to 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

[17:08] 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 apps 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. You can research documents and do all kinds of things.

[17:44] So, the easiest way to get started today is to go over to AI Studio and 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 AI Studio in our gallery. And this one’s kind of just trying to showcase how you can actually build these managed agents into your own applications. So, this is you know, create a nice front end and put in a stock.

[18:15] 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 and look for different analysis on a stock. And again, this is kind of more of an illustration illustration that’s like as you’re building managed agents into your own apps, you might not want to have this kind of stream

[18:45] but just to kind of visualize what the actual agent is doing. 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 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 going to go and link out to kind of

[19:17] all of the resources um that it went ends 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.