Uma interação é tudo de que você precisa — Ivan Leo, Google DeepMind

Ver no idioma original →

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: An Interaction Is All You Need — Ivan Leo, Google DeepMind · Canal: AI Engineer · 16:42 · Assistir no YouTube

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

Resumo

Ivan Leo apresenta a Interactions API e o serviço Manage Agents, explicando como eles atendem a aplicações com modelos e agents que usam ferramentas, preservam contexto e executam tarefas longas. A API mantém o estado das interações por meio de IDs e organiza as respostas em etapas tipadas, facilitando a criação de aplicações multimodais e o uso combinado de ferramentas. O Manage Agents oferece sandboxes persistentes, carregamento de arquivos e configuração de agents nomeados, além de um proxy para proteger credenciais. A palestra também apresenta o Gemini API CLI e uma skill para ajudar na migração para a nova API.

Pontos-chave

• A evolução dos modelos, de respostas simples e function calling para agents capazes de usar ferramentas, refletir e interagir com ambientes.
• A Interactions API foi criada para dar suporte a diferentes modelos, agents e cargas de trabalho por meio de uma interface comum.
• O parâmetro previous interaction ID preserva o contexto entre chamadas e ajuda a manter as thought signatures necessárias ao desempenho dos modelos Gemini.
• O modelo de dados steps distingue os tipos de saída e as ações realizadas em cada etapa, facilitando o tratamento de conteúdo multimodal e tool calling.
• O Manage Agents fornece sandboxes remotas persistentes e permite retomar o trabalho usando o environment ID.
• É possível carregar fontes como repositórios do GitHub, buckets do Google Cloud Storage e arquivos inline nos ambientes dos agents.
• O agent pode usar as mesmas skills e configurações locais e na nuvem, facilitando a passagem de workflows para execução remota.
• Um proxy man-in-the-middle pode inserir credenciais em chamadas de rede sem expor os tokens ao agent.
• Agents nomeados podem ser configurados a partir de arquivos ou por interação iterativa; a palestra informa suporte a até mil agents nomeados.
• O Gemini API CLI permite testar modelos localmente e empacotar configurações de agents; uma skill também ajuda na migração para a Interactions API.

Capítulos

Início	Capítulo	Resumo
00:12	Da interação simples aos agents	Ivan apresenta a evolução do uso de modelos, de respostas diretas para sistemas que usam ferramentas, memória e ambientes de execução.
03:48	A Interactions API e a preservação de contexto	A palestra introduz a API, explica o uso de IDs para preservar contexto e mostra como combinar chamadas, modalidades e ferramentas.
09:26	Manage Agents e sandboxes persistentes	Ivan apresenta o agent remoto, o uso de ambientes persistentes e o carregamento de fontes, como repositórios e arquivos.
12:01	Skills, segurança e configuração de agents	A demonstração aborda tarefas complexas, a reutilização de skills, a proteção de credenciais por proxy e a criação de agents nomeados.
15:08	CLI, migração e encerramento	O apresentador descreve o Gemini API CLI e uma skill para apoiar a migração para a Interactions API, antes de encerrar a palestra.

Citações

Uma interação é tudo de que você precisa. — 00:12

Para a maioria dos casos, um agent é um modelo de linguagem rodando em um loop. — 02:13

Desde que você nos devolva o mesmo interaction ID, todo o contexto é preservado. — 05:51

O agent consegue pesquisar, raciocinar e lidar com tudo isso de forma autônoma. — 11:00

Conceitos e entidades

• Ivan Leo (pessoa): Apresentador da palestra e integrante da equipe de developer experience do Google DeepMind.
• Google DeepMind (empresa): Organização em que Ivan Leo diz trabalhar e responsável pelos produtos apresentados na palestra.
• Interactions API (ferramenta): API apresentada para atender chamadas de modelos e agents, preservar o contexto e organizar saídas em etapas.
• Manage Agents (ferramenta): Serviço apresentado para executar agents em sandboxes remotas persistentes e configuráveis.
• AI Studio (ferramenta): Interface citada como uma forma simples de experimentar os modelos e criar aplicações.
• Gemini (modelo): Família de modelos mencionada como compatível com a API e os recursos apresentados.
• thought signatures (conceito): Dados opacos associados às interações com modelos Gemini que, segundo o palestrante, devem ser preservados para evitar queda de desempenho.
• steps data model (conceito): Modelo de dados que identifica claramente as etapas, as saídas do modelo e as chamadas de funções.
• Antigravity (ferramenta): Harness de agents descrito na palestra como usado em produtos do Google e no serviço de agents remotos.
• Gemini API CLI (ferramenta): CLI apresentada para testar modelos Gemini localmente e empacotar configurações de agents.

Tradução completa (pt-BR)

00:12 Olá, pessoal, meu nome é Ivan. Faço parte da equipe de experiência do desenvolvedor do Google DeepMind. Hoje vamos falar sobre a novíssima API de interações e nossa nova oferta, Manage Agents. Para citar um artigo muito famoso: uma interação é tudo de que você precisa. Antes de avançarmos para explicar o que é a API de interações e o que é a nova oferta Manage Agents, vamos fazer uma viagem pela memória e traçar como os modelos mudaram e como temos trabalhado com eles. Quando começamos a trabalhar com modelos, muitas vezes havia uma única interação: você enviava uma mensagem, como “Conte uma piada”, e então

00:42 podia receber uma resposta. Por exemplo: “Por que os cientistas não confiam nos átomos? Porque eles compõem tudo.” Depois de um tempo, à medida que os modelos ficaram cada vez mais capazes e passaram a entender melhor o mundo, as coisas ficaram um pouco mais complicadas. Queríamos colocar esses modelos em diferentes aplicações, mas, para isso, precisávamos que fossem confiáveis. Então inventamos o function calling, que permitia aos modelos criar objetos JSON individuais com estruturas previsíveis. Pense em como, quando você quer se cadastrar em um site, a página envia um payload JSON ao backend com um

01:12 nome de usuário e uma senha. Isso permite que o servidor do backend diga: “Certo, temos um novo usuário; agora podemos criar uma nova conta.” Isso tornou possível usar modelos em diferentes partes da aplicação, seja para extrair informações de usuários, analisar dados e muito mais. Mas agora estamos vendo um avanço incrível: os modelos estão ficando mais capazes. Eles conseguem raciocinar por períodos muito longos antes de responder às pessoas. Estamos passando de um cenário em que tínhamos completions, instruções e funções — em que podíamos perguntar, por exemplo: “Ei,

01:43 qual é a previsão do tempo em Nova York?” — e o modelo tinha uma ferramenta de previsão do tempo para obter esses dados, processá-los e gerar uma resposta, para um cenário em que os modelos têm várias ferramentas à disposição. Eles conseguem chamar ferramentas, pensar e refletir sobre o significado da resposta, interagir com o ambiente e, por fim, gerar uma resposta. E isso nos traz de volta à pergunta: o que é um agent? Fundamentalmente, se você observar o que é um agent, verá que boa parte dele é mesmo impulsionada por um modelo. Muitas pessoas reduzem isso a apenas um

02:13 modelo de linguagem executado em um loop. E, na maioria dos casos, isso é verdade. Se você tiver um modelo realmente capaz, vai perceber que, à medida que os modelos ficam cada vez mais capazes, muito da estrutura de apoio desaparece. Muitos modelos — por exemplo, os modelos Opus mais recentes ou os modelos Fable — agora usam diretamente uma ferramenta bash, em vez de ferramentas especializadas individuais, como as ferramentas de editar arquivo ou ler arquivo que usávamos antes. Portanto, o que temos, na verdade, é um modelo de linguagem usado para entender o contexto e a intenção do usuário, ao qual são fornecidos vários recursos diferentes

02:44 com os quais ele interage no ambiente. Ele tem alguma memória de curto prazo e memória de longo prazo para acompanhar o que encontrou, além de um ambiente no qual executar funções. Se você estiver criando um agent de programação, mas não lhe der um ambiente onde possa realmente executar código, por exemplo, ele não vai conseguir fazer nada. Se quiser experimentar algum dos nossos modelos, a maneira mais fácil é usar o AI Studio. Quero destacar que as anotações da minha apresentação de hoje foram programadas no AI Studio. Fiz vibe coding nelas dois minutos antes desta palestra. Você vai ver…

03:17 Você pode ver o histórico da conversa aqui. Eu literalmente disse: “Preciso de um site responsivo para dispositivos móveis onde eu possa inserir as anotações da apresentação”, porque descobri que não poderia usar o modo de apresentação. Então dei algumas instruções breves e, num instante, tinha uma aplicação simples que podia usar sem complicação, publicada em um site acessível a todos. Temos um plano gratuito bem generoso. Na maioria das minhas apresentações, tenho usado o plano gratuito. Felizmente, não tenho usado meus tokens ilimitados do Google. E acho que essa é a melhor maneira de vocês experimentarem

03:48 nossos modelos. Seja com nossos novos modelos de tradução de fala para fala, nos quais você fala, digamos, em inglês e o modelo traduz para qualquer idioma, seja experimentando nossos modelos mais recentes, como o Gemini 3.5 Flash e outros. É muito fácil fazer isso, com controles simplificados na interface que permitem ajustar todos os parâmetros. Vamos falar sobre a API de interações. Uma das coisas que observamos, especialmente ao passar dos modelos para uma dinâmica em que agora temos modelos e agents, é que os tipos de cargas de trabalho

04:18 que queremos oferecer mudaram bastante. Pela API do Gemini, você tem o Nano Banana e o Gemini 3.5 Flash, mas também tem agents muito capazes, como o agent de pesquisa profunda, que pode funcionar por três minutos ou mais. Você interage com ele, ele elabora algum tipo de plano de pesquisa, sai e faz o trabalho por conta própria e retorna com relatórios de pesquisa muito aprofundados e detalhados. Então, é bem difícil pensar em consumir modelos e agents por meio de um monte desses endpoints diferentes. Além disso, para muitos dos

04:49 endpoints de API mais antigos, muitos dados ficavam em objetos profundamente aninhados. Dá para imaginar as dificuldades que enfrentamos ao criar integrações próprias. Queríamos viabilizar casos de uso em que fosse possível gerar uma imagem com o Nano Banana, fazer uma pesquisa, gerar uma imagem no Veo a partir daí ou iniciar vários agents diferentes, que saíssem e fizessem o trabalho por conta própria. A API de interações é nossa solução para isso: estamos criando uma API que possa oferecer suporte a todos esses diferentes casos de uso e

05:20 a outros que possamos criar por conta própria. Queremos levar o Gemini a toda a superfície do ecossistema Google. A melhor maneira de começar é com o estado mantido no servidor. Uma das coisas que você vai perceber, especialmente ao usar a nova série de modelos Gemini, é que temos algo chamado assinaturas de pensamento. Quando você interage com o modelo, se ele chama uma função ou fornece uma resposta, ele retorna uma sequência bem opaca desses números. Para muitas pessoas, gerenciar isso manualmente era muito difícil e, às vezes, quando conversávamos com diferentes startups, descobríamos que

05:51 elas perdiam o cache por causa de um único espaço em branco que tinham adicionado por engano. Agora, com a API Responses, você pode ver o primeiro turno: “Oi, meu nome é Phil.” Na resposta, fornecemos um ID de interação. Se você nos enviar esse mesmo ID de interação no parâmetro previous interaction ID, como você verá no segundo turno, todo o contexto é preservado. Isso é muito importante com a nova série de modelos Gemini, porque, se você não nos enviar essas assinaturas de pensamento, vai notar uma queda no desempenho.

06:21 Mas o que mais isso possibilita? Aqui você vê uma demonstração criada por Vampsy, da nossa equipe, que fez um trabalho incrível: usando uma única foto, era possível gerar, com o Nano Banana, várias versões suas em diferentes países e locais. Cada uma dessas fotos é uma interação individual, mas você pode pensar nisso como uma chamada inicial à API que gera todas essas chamadas de interação. Usando essas interações e o mesmo ID de interação, geramos então um vídeo usando o ID de interação e o novo modelo Omni que acabamos de lançar. Algo assim não teria sido possível

06:52 sem a API de interações criada pelo Philip ali. Então, na verdade, é um trabalho realmente incrível, devo dizer. Para dar um exemplo, uma ideia do que seria necessário para criar algo parecido: é só isto. Primeiro, você passa no Gemini 3.1 Flashlight uma imagem, gera uma imagem minha em Veneza. Você pega o ID da interação, passa de volta para client.create e, desta vez, especifica que quer o modelo Omni Flash, que lançamos na quarta-feira. E isso permite

07:22 que você use agora o mesmo modelo Omni com as mesmas informações, o mesmo tipo de imagens e o mesmo contexto em todas essas chamadas. Isso possibilita criar aplicações agênticas mais complexas, ricas e realmente elaboradas. O mesmo acontece com a geração de áudio. Se você olhar na parte inferior, vai ver que agora temos output.type. Antes, você teria que lidar com esse objeto bem aninhado, como completions audio. E seria bem complicado aninhá-lo corretamente. Não consigo nem me lembrar de cabeça. Mas

07:52 agora, cada parte das saídas geradas está claramente demarcada por um tipo bem definido. Se for áudio, como você vê aqui, basta analisá-lo e tratá-lo de acordo. Certo? Mas o que acontece se eu quiser gerar uma imagem? É o mesmo método, client.interaction.create. Basta modificar a modalidade da resposta e a configuração de geração. E agora tenho um output.type de imagem. Isso facilita muito começar a criar e experimentar com o Gemini. O mesmo vale para o uso de ferramentas. Você

08:23 pode combinar diferentes ferramentas integradas, algo que não era possível antes. Por exemplo, aqui estamos tentando fazer com que um agent pesquise na internet os relatórios de segurança mais recentes do aplicativo React. Demos a ele acesso ao mesmo índice que o Google tem, com o tipo Google search. Demos a ele a capacidade de, essencialmente, recuperar informações de páginas da web usando a ferramenta URL context que disponibilizamos. E demos a ele uma ferramenta personalizada chamada file incident. O modelo pode raciocinar de forma autônoma, descobrir de que informações precisa e, em seguida, gerar uma resposta para você, tudo em uma única chamada de API. Isso é muito

08:54 poderoso porque agora você tem modelos que conseguem trabalhar não só com informações disponíveis até a data de corte do treinamento, mas também com informações posteriores, pois agora têm acesso à internet inteira. E tudo isso se resume ao novo modelo de dados steps que temos: em vez de um mundo em que uma única mensagem é enviada a um modelo e ele responde, teremos coisas muito complexas, como chamadas assíncronas a ferramentas e modelos trabalhando juntos, certo? E queremos garantir que tenhamos uma estrutura de dados robusta para dar suporte a isso. Por isso, introduzimos o modelo de dados steps, que substitui o array outputs legado original

09:26 por um discriminador bem definido, que deixa muito claro, em cada etapa, qual foi a saída do modelo, quais foram as assinaturas das ferramentas, quais funções foram chamadas e, especialmente, qual conteúdo está sendo gerado. Antes, vocês viram content.type, com áudio e vídeo, e isso facilita criar esses pipelines multimodais de uma forma que só as famílias de modelos Gemini conseguem. A segunda novidade que lançamos é o anti-gravity como agent remoto, o que gostamos de chamar de manage agent. Padronizamos o uso do harness anti-gravity em todo o nosso conjunto de produtos do Google. No AI Studio,

09:57 que vocês acabaram de ver, os sites são criados com o agent anti-gravity. No aplicativo anti-gravity, vocês também usam o agent anti-gravity. Esse é um harness muito capaz, com o qual treinamos conjuntamente o Gemini. Daqui para a frente, acho que vocês terão muitos ganhos se usarem esse harness pronto para uso. Se quisesse criar um agent de programação antes, primeiro teria que ajustar o harness. Depois, teria que encontrar um provedor de sandbox, gerenciar a infraestrutura e descobrir como preservar o contexto, especialmente entre execuções. Mas, com o manage agent anti-gravity, você recebe um sandbox persistente pronto para uso.

10:29 Com uma única chamada de API, você recebe um sandbox ao qual pode continuar fazendo chamadas e que pode tratar como uma nuvem pessoal, sem precisar fazer nenhum tipo de modificação. Aqui você pode ver um exemplo em que queremos analisar o conteúdo de um repositório do GitHub. Em seguida, enviamos uma chamada de API para o agent anti-gravity, que inicia um sandbox remoto e começa a investigar do que se trata o repositório. Você pode ver que ele chama list file para descobrir o que há no espaço de trabalho. Depois, lê cada arquivo individualmente e, por fim, gera um relatório. Tudo isso acontece em um

11:00 sandbox remoto, sem nenhuma intervenção da nossa parte. O agent consegue pesquisar, raciocinar e lidar com tudo isso de forma autônoma. Também gerenciamos sandboxes persistentes com vários estados, como mencionamos antes: desde que você preserve o ID do ambiente que retornamos, pode direcioná-lo de volta ao sandbox original. Então, essas são duas primitivas que oferecemos: o ID da interação, que permite preservar e usar o contexto e garante que você não estoure o cache, e o ID do ambiente, que permite direcioná-lo exatamente para o mesmo contexto. Assim, você pode usar o mesmo

11:31 sandbox. Não precisa gerenciar nenhum tipo de persistência de estado; basta adicionar algumas linhas de código. Outra forma de facilitar isso é permitir que você carregue fontes. Muitas vezes, você pode ter dependências personalizadas, arquivos EMD e arquivos auxiliares que quer colocar nesse sandbox específico. Então, damos suporte a buckets do Google GCS, repositórios do GitHub e arquivos inline. O que vocês veem aqui é uma demonstração que continua a partir da chamada anterior. Estamos passando o

12:01 ID do ambiente, e o modelo tem exatamente os mesmos arquivos, no ponto em que paramos. Quaisquer pacotes que você instalar e quaisquer arquivos que você adicionar ou criar ficam acessíveis ao modelo em cada turno, desde que você passe de volta o ID da interação e o ID do ambiente. Isso não se limita a tarefas muito simples com o manage agent. O que vocês veem aqui é uma execução em que o modelo consumiu mais de dois milhões de tokens tentando analisar um repositório que recebemos para um hackathon, no qual alguém criou do zero uma linguagem de programação inteira para codificar ambientes de aprendizado por reforço. Se

12:32 você já usou a linguagem de programação Scratch, sabe que é uma linguagem de arrastar e soltar em que dá para fazer personagens simples se moverem. Mas, aqui, com uma única chamada de API, conseguimos analisar um repositório inteiro que tem uma DSL personalizada, uma página da web, vários esquemas e um loop de treinamento de RL rodando dentro do HUD. Isso realmente abre oportunidades para você criar agents altamente personalizados e eficientes sem precisar lidar com a infraestrutura subjacente nem ajustar o harness. O melhor de usar o agent anti-gravity é que, fundamentalmente, é o mesmo agent que roda no seu

13:03 IDE anti-gravity, o que significa que, se você tiver determinados workflows ajustados localmente e tiver skills que garantiu serem excelentes, quando estiver satisfeito com elas, basta empacotá-las em uma única pasta. Permitimos que você as envie da mesma forma, usando as fontes, para a pasta de agents, e isso dá ao seu agent exatamente as mesmas skills, com o mesmo agent harness e o mesmo prompt, tanto localmente quanto na nuvem. Quando estiver pronto ou satisfeito com o que seu agent está fazendo localmente, você pode enviá-lo, e tudo funcionará como esperado. A próxima pergunta que costumamos receber

13:34 As empresas dizem: “Ei, preciso que meu agent seja seguro. O que vou fazer se meu agent vazar uma credencial de rede?” Para isso, implementamos um proxy man-in-the-middle. O que isso significa? Muitas vezes, você precisa fazer chamadas de API para diferentes provedores, como a Gemini API. Talvez precise baixar repositórios privados do GitHub etc. Temos um proxy que fica no meio e, assim, para qualquer chamada feita pelo seu modelo, analisamos o cabeçalho e podemos substituir itens conforme necessário. O que você está vendo aqui é um caso em que transformamos cada chamada de saída para o GitHub

14:06 API, injetando o token dinamicamente. Assim, mesmo que o modelo sofra uma injeção de prompt de alguma forma e vaze seu token da API do GitHub, ele nunca vai realmente ver o token. Ele só vai executar código que será executado na API do GitHub, e seu token nunca será exposto. Quando você estiver confortável com o desempenho do agent e tiver configurado tudo direito, oferecemos duas maneiras diferentes de configurar e definir um agent com nome, bem parecido com o agent de prévia do anti-gravity que você vem usando. A primeira é congelá-lo com um conjunto específico de arquivos configurados e

14:38 fontes de rede. É isso que você está vendo à esquerda. Estou criando um agent de análise de dados a partir do agent base de prévia do anti-gravity, com algumas configurações básicas de ambiente aqui, apenas uma skill do GCS. A outra maneira que oferecemos é conversar iterativamente com um agent para configurar o ambiente como você quiser. Por exemplo, talvez você queira certas dependências ou certos pacotes, e pode congelar um ambiente como um agent específico; todas as chamadas subsequentes passam por ele. Quando estiver satisfeito com isso, fica muito fácil escalar

15:08 suas cargas de trabalho. Neste momento, oferecemos suporte a até mil agents com nome, o que significa que você pode ter todas essas configurações diferentes sem pagar pelo armazenamento. Você não paga pelo sandbox. Só paga pelo modelo. Otimizamos nossa infraestrutura para ter um desempenho muito bom e dar conta de uma carga de trabalho como essa. Estamos muito animados para ver o que as pessoas vão criar. Recentemente, também disponibilizamos como open source uma nova Gemini API CLI. É uma CLI simples que você pode usar para começar a trabalhar com os modelos Gemini e testá-los localmente usando comandos simples de CLI

15:40 . O outro benefício é que você poderá iterar localmente no seu código, usando seu agent de programação ou seu agent do anti-gravity. Quando estiver tudo pronto, ele empacota o código em uma única pasta, faz o upload diretamente e cria um agent para você. Por fim, se estiver pensando em migrar para a Interactions API, que é onde estarão todos os nossos novos modelos, também criamos uma nova skill da Interactions API que você pode fornecer ao seu agent de programação favorito. Ela permitirá que você faça a migração sem problemas. Tenho certeza de que vocês

16:11 já passaram por situações em que pediram ao Gemini para implementar algo de um jeito específico, mas ele continua usando Gemini 2.5 Flash ou Gemini 2.0. Então, o que fazemos é manter atualizada a lista de todos os modelos e de todos os métodos. Oferecemos um bom conjunto de skills e, como Philip mencionou ontem, avaliamos isso regularmente para garantir que estejam realmente fazendo o que queremos: permitir que vocês usem Gemini e desenvolvam com Gemini da melhor forma. Esse é o fim da minha palestra. Muito obrigado por virem e por ficarem até o fim da conferência. E

16:42 sim, espero que vocês comecem a usar. Vou ficar por aqui caso tenham alguma dúvida sobre a nova API. [música]

Transcrição original

[00:12] Hey guys, my name is Ivan. I’m on the developer experience team at Google Demine. And today we’re covering the brand new interactions API and our new offering manage agents. And so to take a quote from a very famous paper, an interaction is all you need. Before we move on to what the interactions API is and what the new manage agents offering is let’s take a trip down memory lane and let’s kind of trace how models have changed and how we’ve worked with models. So when we first started working with models a lot of times you would have a single interaction you would send a message tell me a joke and then you

[00:42] might get a response for example why don’t scientists trust atoms because they make up everything. After a while as models got more and more capable and they understood more about the world this became a bit more complicated. We wanted to take these models, put them in different applications, but to do so, we needed them to be reliable. And so to do so, we invented function calling, where models could create individual JSON objects with predictable structures. Think like how when you want to register for a website, your web page sends a JSON payload to the back end with a

[01:12] username and a password. And that enables the backend server to say, okay, we have a new user and now we can actually create a new account. that made it possible for us to actually use models in different parts of this application whether it’s extracting user information, parsing data and more. But right now we’re seeing this incredible cups where models are getting more capable. We’re seeing models being able to reason go for very extended periods of time before they come back to people. And so you’re moving from a place where we went from completions instruction and functions where we might ask, hey,

[01:43] what’s the weather in New York City? and the model has a call weather tool that it can get that data, ingest it, and generate a response to now a case where models have multiple tools under their belt. They’re able to call tools, think and reflect on what the response meant, interact with the environment, and ultimately generate a response. And so this just brings us back to what is an agent. Fundamentally, if you look at what an agent is, it’s really a model that powers a huge chunk of it. A lot of people have reduced this to just a

[02:13] language model running in a loop. And for most cases, this is true. If you have a really capable model, you’ll find that as we’ve got models that become more and more capable, a lot of the scaffolding has fallen away. A lot of models, for example, the latest Opus models or fable models are now just immediately just using a bash tool instead of individually specialized tools like a edit file or a read file tool like we used to do. And so really what we have is a language model that’s used to understand the context, the user’s intent that’s given a bunch of different functions, all different

[02:44] resources that it then interacts with its environment in. It has some short-term memory and some long-term memory to keep track of what it’s encountered and then an environment to execute functions in. If you’re building a coding agent, but you don’t give it an environment where it can actually execute code, for example, it’s not going to be able to do anything. And so if you’d like to try any of our models, the easiest way to do so is actually with AI Studio. And so I actually like to point out that my speaker notes today were actually coded on AI Studio. I vived it out 2 minutes before this talk. Uh you’ll see the um

[03:17] you can see the conversation history over here. Um I literally said I need a mobile responsive website that I can pass in speaker notes because I found out I wasn’t going to be able to use presenter view. And so what I did, I just gave it some brief instructions and before you know it, you have a simple application that you can use without any hassle deployed on a website that’s accessible to all. So we have a really generous uh free tier for most of my presentations. I’ve just been using the free tier. I haven’t been using my Google unlimited tokens thankfully. And I think it’s the best way for you to try

[03:48] our models. Whether it’s our new speechtospech translation models where you take in some you speak in let’s say English and it can translate to any language or you know you want to try our latest models like the Gemini 3.5 flash etc. It makes it very easy for you to do so with simplified UI toggles to just be able to tune all of the different parameters. So let’s talk about the interactions API. Now one of the things that we’ve seen especially as we’ve moved from models to a dynamic where now we have models and agents is that the kind of workloads

[04:18] that we want to support have changed significantly right through the Gemini API you have nano banana you have you know Gemini 3.5 flash but you also have very capable agents like the deep research agent that’s going to run for anywhere from three minutes and more you interact with it you have some sort of research plan it’s going to go out and do its own thing and it comes like a very deep and detailed research reports. Now, it’s pretty difficult then to think about consuming models and agents through a whole bunch of these different endpoints. Additionally, for a lot of

[04:49] the older kind of API endpoints, a lot of the data was in in very deeply nested objects. And so you can imagine the kind of difficulties that we had ourselves when we were building in first-party integrations. And we wanted these use cases where you might be able to generate a nanobanana image, do some research, generate a vo image from there or spawn out all these different agentic kind of like agents that go out and do their own thing. And so the interactions API is our sort of solution to this as we look to build an API that can support all of these different use cases and

[05:20] ones that we can build on ourselves. you look to bring Gemini across the entire surface of the Google ecosystem. So the best place to get started is just with serverside state. One of the things that you’ll realize especially as you use the new Gemini series of models is that we essentially have this thing called thought signatures where if you interact with the model, if it calls a function, if it gives a response, it’s going to pass back a very opaque series of these numbers. For a lot of people, manually managing this was very difficult and sometimes when we talked to different startups, we found that

[05:51] they would lose their cache just with a single whites space that they mistakenly added in. So now with the responses API, you can see on the first turn, hi, my name is Phil. And in the response, we give you a interaction ID. And as long as you give us back that same interaction ID under the parameter previous interaction ID that you’ll see in the second turn, all that context is preserved. And this is really important with the new Gemini series of models because if you don’t give us back those thought signatures, you’re going to see a decrease in performance.

[06:21] But what else does this unlock? Here you see a demo built by Vampsy from our team that did an incredible demo where using a single photo, you could generate with Nanovana all these different variations of yourself in different countries and different locations. Each of these individual photos are a single interaction, but you can think of it from an initial API call. It spawns all these different interaction calls. Using those interactions, the same interaction ID, we then generate a video using the interaction ID and the new Omni model that we just launched. Something like this would not have been possible

[06:52] without the interactions API built by Philip over there. So, actually, it’s a really incredible piece of work, I will say. So, to give you an example, an idea of what it would take to build something similar, this is all it would take. First, you pass in Gemini 3.1 flashlight image, generate an image of me in Venice. You take the interaction ID, you chunk it back into the client.create, and this time you specify that you want the Omni flash model instead that we launched on Wednesday. And that allows

[07:22] you to now use the same Omni model with the same information, the same kind of images, and the same context throughout all these calls. It’s making it possible to build more complex, rich, and just these really complex agentic applications. The same thing occurs with audio generation. If you look at the bottom, you see that now we have output.type. In the past, you would have to take this very nested object like completions audio. And it would be very tricky for you to nest it out. I can’t even remember it off the top of my head. But

[07:52] now, every single bit of the outputs that come out are clearly demarcated by a strong type. If it’s an audio, as you see over here, all you got to do is just parse it and handle it accordingly. Right? But what happens if now I want to generate an image? It’s the same method over there, client.interaction.create. All I got to do is just modify the response modality and the generation config. And now I have an output.type of image. And this makes it very easy for me to start building and experimenting with Gemini. The same thing comes with tool use. You

[08:23] can mix and match different inbuilt tools that wasn’t possible before. For example, over here we’re trying to get an agent to look up the internet to find the latest security reports for the React application. We’ve given it access to the same index that Google has with type Google search. We’ve given it the ability to be essentially retrieve information from web pages using the URL context tool that we ship with. And we’ve given it a custom tool here called file incident. The model can reason autonomously on its own, figure out what information it needs, and then actually generate a response for you all in a single API call. This makes it very

[08:54] powerful because now you have models that not only can work with information at their training cut of date but beyond because now they have access to the entirety of the internet. And all this boils down to the new steps data model that we have where instead of a world where we have a single message sent to a model and a response, we’re going to have very complex things like async tool calls models working together, right? And we want to make sure we have a strong kind of data structure to support this. And so we’ve introduced the steps data model which replaces the original legacy outputs

[09:26] array with a tight discriminator that makes it very clear at each step what the model output what the dot signatures were what the functions called were and especially when it comes to the content is being generated. Earlier you saw content.type where it was audio and video and these makes it easy to build these multimodal pipelines in a way that only the Gemini model families can. The second thing that we’ve launched is anti-gravity as a remote agent as what we like to call manage agent. So we’ve standardized around using the anti-gravity harness across all of our Google suite of products. In AI studio,

[09:57] which you saw just now, websites are built with the anti-gravity agent. In the anti-gravity application, you’re also using the anti-gravity agent. Now, this is a very capable harness that we’ve co-rained Gemini on. And moving forward, I think you’re going to see many gains if you use this harness out of the box. If you wanted to build a coding agent in the past, you would first have to tune the harness. Then you had to find a sandbox provider, manage the infrastructure, and then kind of figure out way how to preserve the context, especially in between runs. But with the anti-gravity manage agent, you get a persistent sandbox out of the box.

[10:29] With a single API call, you get a sandbox that you can keep hitting and treat as a personal claw without any sort of modifications. You can see an example over here where we want to analyze what’s in a GitHub repository. We then pass it over in an API call over to the anti-gravity agent and it then boots up a remote sandbox and then starts investigating what the repository is about. You can see it calls a list file to get what’s in the workspace. It then reads each individual file and then it generates a final report. All of this is happening in a

[11:00] remote sandbox without any sort of intervention from our site. The agent’s able to research, reason and handle all of this autonomously. We also handle multi-state persistent sandboxes like what we mentioned earlier where as long as you preserve the environment ID that we returned to you, you’re able to route it right back to the original sandbox that you had. So these are two primitives that we given you. The interaction ID where you’re able to preserve and work with context and ensure you’re not busting your cache and the environment ID that enables you to route it to the exact same context. And so this way you can use the same

[11:31] sandbox. You don’t need to manage any sort of persistence of state and all you need to do is just add a few lines of code. The other way we’ve tried to make it easy is for you to be able to load in sources. A lot of times you might have custom dependencies. You might have EMD files, helper files that you want to throw on the on this specific sandbox. So we support Google GCS buckets. We support GitHub repositories and inline files. And so what you see over here is a demo whereby it continues off the previous call that we did. We’re passing in the

[12:01] environment ID and the model has the exact same files right where we left it. any sort of packages you install, any sort of files you throw and create, the model has access to it through each and every turn as long as you passes back the interaction ID and the environment ID. This isn’t just the sort of constraint to very simple task with the manage agent. What you’re seeing over here is a run where the model burnt over two million tokens trying to analyze a repository that we got for a hackathon where someone built from scratch an entire programming language to code reinforcement learning environments. If

[12:32] you’ve ever used the Scratch programming language, it’s a drag and drop language where you can kind of get simple characters to move. But over here with a single API call, we’re able to analyze an entire repository that has a custom DSL, a web page, a whole bunch of like schemas, and an RL training loop running inside HUD. And so it really opens up this kind of opportunities for you to build these very custom and performant agents without you having to handle the underlying infrastructure or tune the harness. The best part about using the anti-gravity agent is that fundamentally it’s the same agent running in your

[13:03] anti-gravity IDE, which means that if you have certain workflows that are you’ve tuned locally, you have skills that you’ve made sure are great, you can once you’re happy with those skills, you just package it into a single folder. We allow you to upload the same way using the sources into into agents folder and that gives your agent the exact same skills with the same agent harness and the same prompt running locally and in the cloud. When you’re ready or when you’re comfortable with what your agent is doing locally, you can then push it up and everything works as intended. The next question we often get from

[13:34] companies are, “Hey, I need my agent to be secure. What am I going to do if my agent leaks a network credential?” And to do so, we’ve implemented a man-in-the-middle proxy. So, what does this mean? A lot of times, you need to make API calls to different providers, say the Gemini API. You might need to download private GitHub repositories, etc. We have a proxy that stands in the middle and so any call your model makes we will look at the header and we can replace items at will. What you see over here is a case where we’ll transform every single outbound call to the GitHub

[14:06] API with an inject in the token dynamically. And so even if the model is somehow prompt injected and leaks your GitHub API token, it’s never actually going to see the token. It’s only going to execute code that will run against the GitHub API and your token is never exposed. Once you’re comfortable with how the agent is performing, you’ve set it up well, we give you two different ways for you to basically configure and set it up as a named agent, much like you’ve been using the anti-gravity preview agent. The first one is to freeze it with a certain set of configured files and

[14:38] network sources. That’s what you’re seeing on the left here. I have a data analyst agent that I’m creating from the anti-gravity preview base agent with some base environment configurations here, just a GCS skill. The other way that we allow you to do so is by chatting iteratively with an agent to set up an environment as you like. For example, you might want certain dependencies, you might want certain packages, and you can freeze an environment as a specific agent and all your subsequent calls kind of go through that. Once you’re happy with that, it makes it very easy for you to scale up

[15:08] your workloads. At this point, we support up to a thousand named agents, which means that you can have all these different configurations and you don’t pay for any of the storage. You don’t pay for you don’t pay for the sandbox. you only pay for the model. We’ve optimized our infrastructure to be very performant to be able to handle a workload like this. And we’re pretty excited to see what people are going to build. Recently, we’ve also out open sourced a new Gemini API CLI. This is a simple CLI that you can use to get started working with the Gemini models to test out the models locally using simple CLI

[15:40] commands. The other benefit of this is that you’re going to be able to iterate on your code on your coding agent or your anti-gravity agent locally. And once you’re ready, it packages it as a single folder and uploads it straight and creates an agent for you. Lastly, if you’re thinking of switching over to the interactions API, which is where all of our new models will be on, we’ve also created a new interactions API skill that you can feed to your favorite coding agent and that will then basically allow you to do the migration without any issues. I’m sure you guys

[16:11] have faced issues where you’ve asked Gemini to implement a specific kind of uh implementation and it keeps using Gemini 2.5 flash or Gemini 2.0. And so we what we do is we make sure we keep up to date the list of all the different models. We keep up to date all the different methods. We provide a good bunch of skills and like Philip mentioned yesterday, we regularly evaluate these and make sure make sure that they’re actually doing what we want them to do, which is allowing you to use Gemini and build on Gemini well. So that’s the end of my talk. Uh, thank you so much for coming by and staying around for the round of the conference. And

[16:42] yeah, I hope you guys get started. I’ll be on the side if you guys have any questions about the new API. [music]