Agentes criaram um kernel de sistema operacional que roda Doom — Kevin Hou, 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: Agents Built an OS Kernel That Runs Doom — Kevin Hou, Google DeepMind · Canal: AI Engineer · 18:53 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA, Modelos de IA

Resumo

Kevin Hou apresenta o Anti-gravity, produto de programação com agentes do Google, e explica como seu desenvolvimento acompanha os avanços dos modelos. Ele descreve a aposta em equipes de agents coordenadas por um agente principal, com subagents especializados que trabalham em paralelo. Entre os exemplos, estão a criação de um kernel de sistema operacional capaz de rodar Doom e a automação de análises de evals. Hou destaca três primitivas para essa nova etapa: subagents dinâmicos, sidecars e interfaces generativas.

Pontos-chave

O Anti-gravity foi concebido como um produto agent-first, e sua experiência deve evoluir conforme os modelos ficam mais capazes.
Na versão 2.0, o IDE e o agent manager passaram a ser aplicativos separados.
A equipe aposta que a orquestração de equipes de agents será uma forma importante de trabalhar com modelos.
As equipes de agents podem reunir subagents especializados, criados dinamicamente e capazes de usar modelos diferentes.
Uma execução demonstrativa criou um kernel de sistema operacional do zero e rodou Doom, usando 93 subagents ao longo de 12 horas.
Uma ferramenta interna automatizou 90% de um fluxo de comparação de evals, gerando hipóteses e um relatório interativo.
Sidecars são processos de longa duração que permitem conectar o modelo a eventos e gatilhos externos, como webhooks e tarefas agendadas.
A interface generativa cria elementos interativos sob demanda, em vez de depender apenas de interfaces fixas.

Capítulos

Início	Capítulo	Resumo
00:32	Anti-gravity e a ideia de escalar com inteligência	Kevin Hou apresenta o produto e defende que a experiência deve acompanhar as capacidades dos modelos.
04:18	Mudanças de paradigma e equipes de agents	O palestrante relembra resistências a mudanças anteriores e explica a aposta em separar o agent manager do IDE.
07:05	Como funcionam as equipes de agents	Um agent principal coordena subagents especializados, que podem trabalhar em paralelo e gerar interfaces sob demanda.
09:43	Construindo um kernel que roda Doom	Hou relata a criação de um kernel de sistema operacional do zero com 93 subagents, em 12 horas.
11:20	Automação de pesquisa e análise de evals	Uma ferramenta interna automatiza a comparação de resultados, investiga hipóteses e apresenta descobertas em uma interface interativa.
14:34	As primitivas de 2026: subagents e sidecars	O palestrante detalha subagents dinâmicos e sidecars, que conectam agents a eventos e gatilhos externos.
16:10	Interfaces generativas e encerramento	Hou explica como interfaces geradas sob demanda podem substituir elementos fixos e conclui com recomendações para quem cria produtos com agents.

Citações

Os LLMs não são mais apenas coadjuvantes. Podem ser a estrela do time se você criar o produto certo ao redor deles. — 00:32

À medida que o modelo melhora, o seu produto também deve melhorar. — 02:39

Criamos um kernel de sistema operacional completo do zero e jogamos Doom nele. — 10:15

Fizemos o possível para sair do caminho e deixar o modelo trabalhar. — 17:16

Conceitos e entidades

Antigravity (ferramenta): Produto de programação com agents do Google, apresentado por Kevin Hou como uma plataforma para trabalhar com agents e projetos.
Google DeepMind (empresa): Organização onde a equipe apresentada trabalha no desenvolvimento de modelos e do produto Anti-gravity.
Kevin Hou (pessoa): Integrante da equipe de engenharia do Anti-gravity que apresenta as ideias e os exemplos do vídeo.
Gemini 3.5 Flash (modelo): Modelo citado como capaz de executar tarefas e liderar equipes de agents com rapidez e menor custo.
agent manager (conceito): Componente para gerenciar e orquestrar vários agents, que no Anti-gravity 2.0 pode ser usado separadamente do IDE.
Agent teams (conceito): Equipes coordenadas por um agent principal, que distribui o trabalho entre subagents especializados.
subagents (conceito): Agents especializados que podem ser criados dinamicamente e trabalhar de forma independente ou em paralelo.
sidecars (conceito): Processos de longa duração que escutam eventos externos e permitem configurar gatilhos para os agents.
generative UI (conceito): Interface interativa criada sob demanda pelo modelo e exibida dentro da experiência de conversa.
DOOM (modelo): Jogo que a equipe executou como demonstração no kernel de sistema operacional criado pelos agents.

Tradução completa (pt-BR)

00:32 Certo. Olá a todos. Meu nome é Kevin. Vou falar sobre anti-gravity. Então, temos fãs da Copa do Mundo por aqui? Uhu! Imaginem que vocês estão treinando a Argentina, estão aos 89 minutos e têm Messi no time. Que jogada vão fazer? Ela se chama: deem a bola para o Messi e saiam da frente. Os LLMs não são mais apenas coadjuvantes. Eles podem ser a estrela do time, se vocês criarem o produto certo

01:03 para eles. E, para deixar sua estrela brilhar, vocês precisam sair do caminho do modelo. Talvez precisemos mostrar os slides. Os slides estão aparecendo? Ah, estão. Ótimo. Então, Anti-gravity é o produto de programação com agent do Google para usuários técnicos e não técnicos. Nós o lançamos em novembro de 2025 e, desde então, temos ajudado desenvolvedores a avançar, tanto dentro do Google quanto fora dele. Meu nome é Kevin Hou e lidero parte da equipe de engenharia do anti-gravity.

01:36 Então, vamos falar um pouco mais sobre o que é o anti-gravity. Sempre fomos, e sempre seremos, assumidamente centrados em agents. No ano passado, lançamos a IDE do anti-gravity com um conceito totalmente novo de gerenciador de agents: uma plataforma para gerenciar e orquestrar muitos agents. Desde então, extraímos nosso agent e lançamos nossa própria CLI do anti-gravity. E, no mês passado, no Google IO, tivemos o prazer de lançar o anti-gravity 2.0. Seguindo a ideia de tirar o modelo do

02:07 caminho, separamos a IDE do gerenciador de agents. Agora, são dois aplicativos distintos. E você pode usar o gerenciador de agents como um aplicativo independente. Como uma imagem vale mais que mil palavras, aqui está uma captura de tela do anti-gravity 2.0 em ação. Como podem ver, ele não é apenas um centro de controle dedicado para seus agents e projetos: você tem subagents, todos os modelos novos, work trees, tarefas agendadas e modo de voz. Há muitas coisas para explorar no produto. Mas não quero passar o dia falando sobre o produto. Quero

02:39 contar um pouco mais sobre os bastidores, alguns dos princípios que o orientaram e, em especial, algumas das coisas que levaram ao seu roteiro de desenvolvimento. Então, para alguns de vocês que são fãs de longa data do AIG, esta é, na verdade, minha quinta vez falando no AIG. E trabalho com ferramentas para desenvolvedores desde 2022. A lição que se destacou acima de todas as outras que mencionei é a ideia de crescer junto com a inteligência. Isso significa que, conforme o modelo melhora, seu produto também deve melhorar. E a fronteira do modelo que você disponibiliza deve ficar

03:13 evidente na experiência que os usuários têm com o produto. Vamos ver exemplos mais concretos do que isso significa. Quem me acompanha no X ou me ouve falar sem parar há uns quatro anos sabe que venho trabalhando em várias transformações desse tipo, ano após ano. Em 2022, eu trabalhava com preenchimento automático e barras laterais de chat. Isso se baseava em embeddings, regras, arquivos e análise de árvore sintática; basicamente, tudo dentro daquele aplicativo era determinístico, porque era só isso que o

03:44 modelo realmente conseguia fazer. E, em 2024, quando os agents entraram em cena, isso mudou completamente a forma como os desenvolvedores trabalhariam. Surgiram novos elementos básicos, como MCP, ferramentas personalizadas e sistemas de permissões. Em 2025, lançamos o gerenciador de agents do anti-gravity, e muitos outros produtos seguiram o mesmo formato, com usuários gerenciando vários agents em paralelo ao mesmo tempo. Isso levou a coisas como skills, hooks, artifacts e alguns outros elementos básicos. E isso definiu, de certa forma, a era de 2025. Então, vamos falar um

04:18 pouco sobre 2026 e quais poderiam ser esses elementos básicos. Antes de responder a essa pergunta, quero levá-los de volta a algumas dessas cicatrizes de guerra, que são um pouco mais próximas de casa. Crescer junto com a inteligência não é nada fácil. É muito difícil tirar dos usuários algo de que gostam e com que estão acostumados para conduzi-los a um caminho potencialmente melhor — e essa palavra é importante. Nem sempre estamos certos, mas duas coisas me vieram à mente enquanto preparava os slides desta palestra. A primeira é dar um terminal à IA. Todos nos lembramos dos temores de que o Sonnet apagasse toda a sua

04:52 base de código e causasse coisas catastróficas tanto para sua startup quanto para sua empresa, e assim por diante. Mas, à medida que os modelos melhoraram e as pessoas investiram em elementos básicos, como sistemas de permissões, os usuários passaram a construir mais rápido, lançar mais coisas e fazer isso com segurança. Então, conseguimos superar esse desafio. E, à medida que os modelos ficaram mais inteligentes, passaram a tomar decisões melhores sobre o que deveriam ou não executar no seu terminal. O segundo caso é este tweet, que representa muito bem os gritos que ouvi quando removemos o chat do Windsurf. Muitos

05:26 usuários gritavam com nossa equipe porque tiramos algo muito importante para eles — a barra lateral de chat — e a substituímos por apenas um agent. Na época, isso era algo conhecido e bastante difícil de aceitar. Mas, olhando para trás, os modelos avançaram. Pesquisa em várias etapas, pesquisa agentic e execução se tornaram o novo paradigma. E aqui estamos hoje, usando e adorando todos esses produtos agentic. E assim chegamos à batalha de hoje. O que está acontecendo agora? Separamos o gerenciador de agents da IDE. E, com o anti-gravity 2.0, dividimos

05:59 os dois em aplicativos distintos. Acreditamos que a relação entre a IDE e o gerenciador de agents é como a relação entre o depurador e a IDE. Você nem sempre precisa de um depurador, mas é definitivamente útil ter um se precisar descer um nível e avançar mais um passo nessa pilha de abstrações. E nossa previsão é que essa ideia de orquestração de agents — que vocês podem chamar de equipes de agents, enxames ou fábricas de software — é o futuro. E estamos dispostos a apostar nesse futuro. Estes são os elementos básicos do que estamos chamando de era das equipes de agents de 2026. São coisas como subagents,

06:33 UI generativa e sidecars. Vamos falar com mais detalhes sobre o que são essas coisas e mostrar alguns exemplos de como aparecem no produto. Mas é muito importante entender primeiro o porquê. O que motivou essas mudanças? E quais mudanças e propriedades dos modelos levaram de fato ao desenvolvimento dessas novidades? Como equipe de produto, vocês impõem essa nova era de elementos básicos ou ela surge quando usam o modelo e vivenciam o que ele pode fazer? A resposta é: um pouco dos dois, certo? E o privilégio

07:05 de estar no Google DeepMind é termos essa relação entre o produto e o modelo. Vocês se lembram de que o ponto central do anti-gravity 1.0 era gerenciar agents em paralelo e colocar o ser humano no comando. E, se lembram da minha última palestra, falei bastante sobre esse ciclo virtuoso entre pesquisa e produto. E agora, como prometido, graças ao produto anti-gravity, o Gemini aprendeu algumas coisas sobre como gerenciar uma equipe de agents. Ainda há muito espaço para tornar os sistemas multiagent melhores, mais colaborativos,

07:37 e melhores em decompor tarefas em tarefas menores. Mas o Gemini já tem uma ótima vantagem inicial, e os fundamentos foram incorporados ao modelo para que possamos criar um produto como o anti-gravity 2.0. O Gemini 3.5 Flash — sim, o Gemini 3.5 Flash — foi lançado em abril e trouxe ao mercado muitos daqueles recursos com que vínhamos trabalhando nos bastidores com o anti-gravity. E o Flash agora não é apenas bom em executar tarefas. Ele também é muito bom em liderar equipes. É mais rápido e mais barato, ampliando a curva de Pareto entre inteligência e a velocidade e o custo com que essas coisas são executadas.

08:08 Juntando tudo isso, ficamos muito animados em anunciar a prévia pública das equipes de agents no anti-gravity. Basta digitar o comando de barra /teamwork para ver um novo modo, no qual você pode entrar e lançar um enxame de agents para trabalhar na tarefa em questão. Vamos falar um pouco sobre como isso funciona. Você, como usuário, especifica a tarefa. Quanto mais específico, melhor. Mas a natureza desses estilos de comunicação agentic é que, se precisar de mais alguma coisa, o agent pode, na verdade,

08:41 pedir mais informações até que tudo esteja basicamente claro. Você trabalhará com esse agent líder, que gerenciará uma equipe de tamanho arbitrário para realizar o trabalho. E eu gosto de dizer que é como os Vingadores, certo? Ele reunirá várias funções especializadas. Pode haver engenheiros de frontend, engenheiros de backend, especialistas em infraestrutura, QA, design; a lista continua sem parar. E há infinitas possibilidades para o que cada um desses subagents pode assumir. Cada subagent é gerado dinamicamente e pode operar de forma independente.

09:11 E ele pode até selecionar um modelo diferente daquele que o agent principal está usando. E quem faz isso é esse agent principal. Mais uma vez, estamos escalando com inteligência. E um dos aspectos mais legais disso é que ele pode usar UI generativa. Com um modelo tão rápido quanto o Flash, as coisas podem acontecer quase instantaneamente. Se você perguntar: “Ei, qual é o status da minha tarefa? Mostre um quadro Kanban do que está acontecendo.” Ou talvez, sabe, você prefira algo um pouco mais parecido com a ferramenta de depuração do Chrome. Ele pode mostrar uma linha do tempo assim. E todas essas coisas são geradas na hora porque

09:43 ele consegue gerar UI sob demanda. Então, alguns dos projetos que o sistema implementou: criamos um editor de fotos. Você pode até editar fotos raw diretamente no navegador. Também criamos um app de mensagens que talvez pareça um pouco familiar para quem está aqui. E cada um deles exigiu centenas de subagents e levou quase meio dia para ser executado. Mas, para realmente testá-lo ao máximo, uma das grandes execuções que fizemos foi construir um kernel de sistema operacional inteiro. Isso é algo que pudemos mostrar

10:15 no Google IO: criamos um kernel de sistema operacional completo do zero e até jogamos Doom nele. Meu colega Verun conseguiu demonstrá-lo no Google IO. Ficamos muito orgulhosos desse marco específico porque ele realmente mostrou que, se você acrescentar mais inteligência e mais subagents a esse tipo de problema, um modelo como o Gemini 3.5 Flash consegue fazê-lo de uma maneira não só muito, muito poderosa, mas também escalável e, sabe, relativamente acessível. Obviamente, não vamos gastar milhares e milhares de dólares para construir um kernel de sistema operacional todos os dias, embora isso seja possível. E algumas das estatísticas

10:47 desse projeto: foram necessários 93 subagents ao longo de 12 horas, feitas 15.000 solicitações e usados dois bilhões de tokens, tudo por menos de US$ 1.000 — um dos aspectos realmente legais desse projeto. E, como você pode ver neste exemplo específico, as primitivas de subagent são um dos elementos definidores da construção de equipes de agents na era de 2026. Então, equipes de agents são apenas o primeiro exemplo. Quero mostrar outro exemplo que nossa equipe usa internamente e que demonstra algumas dessas novas primitivas. O segundo é sobre automatizar tarefas de pesquisa. Então, trabalhamos dentro do

11:20 Gemini. Ajudamos a tornar o Gemini melhor em tarefas relacionadas a programação e a agents. E é aí que a verdadeira magia do produto começa a acontecer. Temos uma versão interna do anti-gravity que pesquisadores, engenheiros e pessoas sem conhecimentos técnicos podem usar. E, quando entendem as primitivas oferecidas pelo anti-gravity, ele se torna uma maneira muito, muito poderosa de automatizar os próprios workflows. Vamos usar como exemplo a avaliação lado a lado. Esse é um workflow muito comum, não só na DeepMind, mas também, de modo geral, no setor. Basicamente, você executa várias rodadas, 1, 2, 3, 4 etc. E

11:54 quer compará-las. Então, você seleciona um conjunto de tarefas, executa algumas rodadas, obtém resultados e eles ficam, essencialmente, em duas tabelas diferentes. Aí você analisa o controle, analisa o experimento e precisa descobrir não só qual foi a diferença, mas também quais talvez sejam os motivos dessas diferenças e como podemos iterar a partir daí para criar uma versão melhor para o próximo experimento. Tradicionalmente, isso exigia muito trabalho manual em notebooks Jupyter. Mas, quando você começa a trabalhar com as novas primitivas de 2026, acaba com um workflow muito mais limpo.

12:25 Assim, pesquisadores conseguiram automatizar 90% desse workflow simplesmente perguntando ao agent, em linguagem natural, sobre a avaliação em questão. Então, o agent, agora preparado com skills e conhecimento da enorme base de código do monorepo do Google, consegue processar os números e retornar a diferença. O que é realmente legal aqui é que, em vez de simplesmente pegar essa diferença e devolvê-la ao usuário, ele foi além. Ele iniciou um agent de pesquisa especializado que propõe cem hipóteses diferentes para explicar por que essas diferenças podem ocorrer. Depois, usa subagents para iniciar um subagent para

12:58 cada hipótese e, basicamente, investigar aquele caso específico em paralelo, reunindo tudo em uma única resposta e então dizendo ao pesquisador: “Ei, aqui estão algumas áreas que encontrei. E aqui está um relatório para você analisar.” E o mais legal é que ele não para no relatório. Ele também monta uma UI generativa para você explorar, interagir, selecionar menus suspensos, filtrar, segmentar, dividir e interagir de forma rica com esses dados. E, internamente, nos importamos muito com esse tipo de workflow. Melhorar o modelo,

13:30 melhorar o produto e entender as maneiras como os usuários têm sucesso e fracassam internamente no Google. Então, o que antes era um processo muito manual agora leva minutos. O que antes exigia engenharia manual — você precisava criar seu próprio conjunto assíncrono de agents, configurar seus avaliadores e juntar com fita os pipelines de dados — tudo isso agora começa a se apoiar nessas novas primitivas que estabelecemos anteriormente na apresentação. Você tem um grafo de subagents totalmente dinâmico. A UI generativa aparece no final para apresentar os resultados de forma rica, da maneira que o usuário melhor

14:01 compreenda ou talvez de acordo com seu estilo de aprendizagem. E tudo isso pode ser gerado novamente e refeito na hora. Tudo o que o usuário precisava fazer era carregar um arquivo de skills e fazer perguntas. Então, com o trabalho em equipe e esse exemplo de avaliação, começamos a chegar às primitivas de 2026 de que venho falando. E essas características dos modelos realmente mudam a forma como temos de pensar no produto e desenvolvê-lo. Nos três exemplos que discutimos, o primeiro é o subagent dinâmico. E, para dar um pouco mais de contexto, basicamente não há dois subagents iguais.

14:34 O agent principal é quem orquestra tudo isso por conta própria. Ele configura, prepara os prompts e inicia esses subagents na hora. Eles podem operar em paralelo. Podem operar em diferentes tipos de ambientes seguros, seja um sandbox ou um sistema de execução remota, e podem assumir infinitas funções especializadas. Então, a possibilidade de escalar aqui é bastante óbvia e, pelos dois últimos exemplos, provavelmente dá para perceber que, à medida que o modelo fica mais inteligente, sua equipe se torna mais especializada e colaborativa e, em última análise, capaz de realizar trabalhos mais

15:06 complexos para você. E o segundo é esse novo conceito, que já mencionamos um pouco antes: os sidecars. Esse é um novo protocolo de plug-in que estamos trazendo para o anti-gravity. Um processo sidecar é, essencialmente, um processo sidecar. O nome reflete, mais ou menos, o que acontece nos bastidores, mas é um utilitário de longa duração, responsável por ficar escutando. Ele permite que o modelo escute o mundo externo e configure seus próprios gatilhos para coisas que podem acontecer. Por exemplo, podem ser mensagens SMS. Podem ser webhooks, tarefas cron ou integração com PRs do GitHub. A

15:39 lista continua sem parar. Mas essa é uma primitiva genérica de plug-in. O anti-gravity já usa sidecars para coisas baseadas em tempo. É daí que vem o conceito de tarefas agendadas com cron. Mas, nos bastidores, tudo isso é essa nova primitiva de sidecar. Vamos publicar a especificação para que todos vocês possam desenvolver com base nessa nova primitiva mais para o fim deste verão. Mas há maneiras realmente, realmente legais de as pessoas estarem usando esse conceito internamente. E a terceira e última primitiva é a UI generativa. Nossa hipótese é que UIs especializadas, escritas por humanos, são meio

16:10 de mortos. O Gemini Flash no anti-gravity chega a quase 900 tokens por segundo. Isso é 10 vezes mais rápido do que muitas das experiências com outros modelos de ponta. E, em questão de segundos, você consegue transformar o que quer que esteja pensando em um prompt e em um caso de uso que é projetado e incorporado perfeitamente à visualização da conversa. E, em vez de depender de templates ou até mesmo de arquivos HTML, o anti-gravity pode renderizar sua interface gerada diretamente na conversa. Então você pode fazer coisas como esta e jogar Doom. Mas isso também se estende a coisas como gráficos de barras, gráficos, tabelas, qualquer coisa com que você

16:44 queira interagir e talvez examinar um pouco mais a fundo do que apenas um arquivo Markdown ou uma conversa. E a UI generativa, em muitos aspectos, me lembra a frase que o falecido Steve Jobs disse ao apresentar o iPhone. Ele justifica a remoção do teclado e diz: todos eles têm esses teclados. Eles estão lá, quer você precise deles ou não. E todos têm esses botões de controle fixos no plástico, iguais para todos os aplicativos. De forma análoga, criamos nosso produto para se adaptar dinamicamente às necessidades do agent. Deixamos de lado a infraestrutura pesada

17:16 e as interfaces mecânicas em favor de sidecars e UI generativa. Isso cria uma experiência de produto que não é fixa no plástico. Então, subagents, acionadores de sidecar e UI generativa são os primitivos mais recentes que estão impulsionando o anti-gravity. Fizemos o possível para não atrapalhar e deixar o modelo trabalhar. E, se você está criando um produto em torno de um agent, deve considerar quais são os primitivos do seu produto e como eles podem se adaptar à inteligência do modelo. Todos nós conhecemos a situação de

17:47 lançar funcionalidades agora ser algo bem fácil com todas essas novas ferramentas. E a questão é decidir quais funcionalidades de fato adicionar para que o modelo, para que seu produto, possa se adaptar à próxima versão do próximo modelo, que inevitavelmente será mais rápido, melhor e mais barato. E, com os primitivos certos, você, como criador ou responsável pelo produto, talvez se surpreenda com o que os modelos conseguem fazer. E, no estilo clássico, vou continuar usando o slide até finalmente superarmos a escassez de TPU. Então, você pode me encontrar no Twitter. Pode me mandar uma mensagem direta com seu feedback. Estamos sempre procurando

18:17 novas ideias sobre como criar o que há de mais avançado. Obrigado por assistir. Obrigado, Swix e Ben, por me receberem. É sempre um prazer estar aqui. E vou estar no estande do anti-gravity, caso queiram conversar mais. Se quiserem conhecer um pouco melhor o produto, alguns membros da equipe estarão lá. Então, muito obrigado pelo seu tempo. Estou animado para conhecer todos vocês. É.

18:53 Calor.

Transcrição original

[00:32] All right. Hello everyone. Um, my name is Kevin. I’m going to be talking about anti-gravity. So, are there any World Cup fans out there? Woo! Imagine you are coaching Argentina and you’re in the 89th minute and you have Messi on your team. What play are you running? It’s called Give Messi the ball and get the heck out of the way. LLMs aren’t just role players anymore. They can be your star player if you build the right

[01:03] product around them. And to let your star player cook, you have to get out of the model’s way. We might want to get the slide. Are the slides up? Oh, they are. Great. Um, so Anti-gravity is Google’s agent coding product for technical and non-technical users. Uh we launched back in November of 2025 and have been accelerating devs both within Google and externally ever since. My name is Kevin How and I lead part of the engineering team on anti-gravity.

[01:36] So let’s talk a little bit more about what anti-gravity is. We have and always will be unapologetically agent first. So, we debuted the anti-gravity IDE last year with a brand new agent manager concept and it was a platform to manage and orchestrate many agents. Since then, we’ve actually extracted our agent and launched our own anti-gravity CLI. And last month at Google IO, we had the pleasure of launching anti-gravity 2.0. In the theme of getting the model out of

[02:07] the way, we actually decoupled the IDE from the agent manager. So, now you have two separate applications. Um, and now you can use the agent manager in a standalone app. And since pictures are worth a thousand words, here’s a screenshot of anti-gravity 2.0 in action. As you can see, not only is it your own dedicated mission control for your agents and projects, you have sub agents, you have all the new models, you have work trees, scheduled tasks, voice mode. There are so many things to unpack with the product. But I don’t want to spend today telling you about the product. I want to

[02:39] tell you a little bit more about the behind the scenes, some of the principles that went into it and notably some of the things that led to its roadmap. So, as some of you for the longtime AIG fans, uh this is actually my fifth time speaking at AIG. Um and I’ve been building developers tools since 2022. And the one thing that has stood above all other lessons that I’ve tal talked about is the idea of scaling with intelligence. This means that as the model gets better, so should your product. And the frontier edge of whatever model you are serving should be

[03:13] apparent inside of your users’s product experience. So let’s get into more concrete examples of what this means. So for those of you that follow me on X or hear me just yap generally for the last four years, you’ll know that I’ve been working on a number of these sort of transformations year over year over year. In 2022, I was working on autocomplete and chat sidebars. This was based on embeddings, rules, files, a syntax tree parsing, basically everything inside of that app is deterministic because that’s all that

[03:44] the model could really handle. And in 2024, when agents came onto the scene, it completely changed how developers were going to do work. With it came new primitives like MCPs, custom tools, and permission systems. And with 2025, we introduced anti-gravity’s agent manager with many other products following suit in that similar form factor with users managing many agents at once in parallel. And this led to things like skills, hooks, artifacts, and a couple other primitives. Um, and that sort of defined the 2025 era. So, let’s talk a

[04:18] little bit about 2026 and what those primitives might be. Before we answer this question, I want to take you back to some of these battle scars that are a little bit closer to home. Scaling with intelligence really is not easy. It’s really hard to take away something that users love and are familiar with to lead them down potentially, and that’s a big keyword, a better path. We aren’t right 100% of the time, but there are two that jump to mind when I was putting together the slides for this talk. The first one is giving AI a terminal. We all remember fears about son of Anton deleting your

[04:52] entire codebase and doing catastrophic things to both, you know, your startup, your company, etc., etc. But as models got better and people invested in primitives such as permission systems, users ended up building faster, they ended up shipping more, and they did so safely. So, we were able to overcome this. And as models got smarter, they were able to make better decisions about what they should and should not run in your terminal. The second instance is um this tweet which is very representative of sort of the yelling that I got uh when we removed chat from windsurf. So a lot of

[05:26] users were yelling at our team because we took away something that was very dear to them the chat sidebar and replaced it with only an agent. Now at the time this is something that was familiar and rather difficult to swallow. But when we look back, models have advanced. Multistep research, agentic research and execution became the new paradigm. And here we are today using and loving all these agentic products. And so now I bring you to today’s battle. What is going on today? So we decoupled the agent manager from the IDE. And with anti-gravity 2.0, we split

[05:59] them into separate applications. We believe that the IDE is to the agent manager what the debugger was to the IDE. You don’t always need a debugger, but it definitely is helpful to have it if you need to go a layer beneath and go one step deeper into that abstraction stack. And our prediction is that this idea of agent orchestration, you can call it agent teams, you can call it swarms, you could call it software factories, is the future. And we’re willing to bet on that future. So here are the primitives for what we’re calling the agent teams 2026 era. These are things like sub aents,

[06:33] generative UI, and sidecars. And we’ll talk more concretely about what those things are and some examples of how they manifest inside of the product. But it’s really important to first understand the why. What brought about these changes and what model changes, what model properties actually led to the development of these new things? And as a product team, do you force the new era of primitives or is it something that comes to you by using the model and experiencing the model? The answer is kind of both, right? And the privilege

[07:05] of being inside of Google DeepMind is that we do have that relationship between the product and the model. So you remember the crux of anti-gravity 1.0 is to manage agents in parallel, to put the human in the driver’s seat. And if you remember my last talk, I talked a lot more about this research product flywheel. And now, as promised, because of the anti-gravity product, Gemini has now learned a thing or two about how to manage a team of agents. There’s still a lot of headroom to make multi- aent systems better, more collaborative,

[07:37] better at deconstructing tasks into smaller tasks. But we’ve got a really good head start with Gemini. and all the basics have been imbued to the model so that we can build a product like anti-gravity 2.0. Gemini 3.5 FL yeah Gemini 3.5 flash was launched back in April and this brought to market a lot of those capabilities that we had been working on in the background with anti-gravity and flash now isn’t just good at executing tasks. It’s actually really good at leading teams. It’s faster and cheaper, pushing

[08:08] the paro curve of what is intelligent versus the speed and the cost at which you run those things. And putting this all together, we were really excited to announce agent teams in public preview inside of anti-gravity. All you have to do is simply type the slash command/teamwork and you’ll see a new mode where you can enter and unleash a swarm of agents onto the task at hand. So we’ll talk a little bit about how this works. You as a user will specify your task. The more specific you are, the better. Though the nature of these agentic communication styles is that if it needs something more, it can actually

[08:41] ask you for more until everything is basically clear. You’ll work with that lead agent and it will manage a team of arbitrary size to get that work done. And what I like to say, it’s kind of like the Avengers, right? It’ll take a bunch of specialized roles. It may front-end engineers, backend engineers, infrastructure specialists, QA, design, the list goes on and on and on. And there are infinite possibilities for what each of those sub aents could take on. Each sub aent is dynamically generated and can operate independently.

[09:11] Um, and it can even actually select a different model from what the main agent is using. And this is done so by that main agent. Again, we are scaling with intelligence. And one of the coolest aspects of this is that it can use generative UI. With a model that is as fast as Flash, things can happen nearly instantaneously. If you ask, hey, what is the status of my task? show me a canban of what’s going on. Or maybe, you know, you prefer something a little bit more like uh the the Chrome debugger tool. It can show you a timeline like that. And all these things are generated on the fly because

[09:43] it’s able to generate UI on demand. So, some of the projects that the system has implemented, um we’ve built a photo editor. You can actually edit raw photos directly inside of your browser. Um we’ve also built a messaging app that might look a little bit familiar to those in the room. Um, and each of these took hundreds of sub aents uh, and took almost half a day to run. But to really put it through its paces, one of the hero runs that we did was actually building an entire OS kernel. This is something that, uh, we got to show off

[10:15] at Google IO, but we built a complete OS kernel from scratch and actually played Doom on it. And my colleague Verun was able to demo this at Google IO. We were super proud of this particular milestone because it really demonstrated that if you throw more intelligence, you throw more sub aents um at this sort of problem, a model like Gemini 3.5 Flash could do this in a way that was not only very very powerful, but also scalable and you know, mildly affordable. Obviously, we’re not going to spend thousands and thousands of dollars to build an OS kernel every day, though it is possible. And some of the stats out

[10:47] of this, it took 93 sub aents over the course of 12 hours, made 15,000 requests, two billion tokens, and it was under $1,000, which was one of the really cool aspects of this project. And so, as you can see with this particular example, sub agent primitives are one of the defining parts about building a 2026 era of agent teams. So, agent teams are just that first example. And I want to show you another example that our team uses internally that sort of demonstrates some of these new primitives. Um the second one is about automating research tasks. So we work inside of

[11:20] Gemini. We help sort of make Gemini better at coding related tasks, agentic related tasks. And this is where the real magic starts happening with the product. We have an internal version of anti-gravity that researchers, engineers, nontechnical folks can use. And when they understand the primitives that anti-gravity offers, it becomes a very very powerful way to automate your own workflows. So we’ll take the example of sideby-side eval. So this is a very common workflow not only at DeepMind but just generally in the industry. You essentially will take multiple rollouts 1 2 3 4 etc. Um and

[11:54] you want to compare them. So you’ll take a set of tasks, you’ll do some rollouts, you’ll get some results and they’ll essentially be in two different tables. Now you’ll look at the control, you’ll look at the experiment, and then you’ll have to figure out not only what the difference was, but perhaps what are the reasons for those differences and how can we actually iterate from there and make a better version of for the next experiment. Now, traditionally, this was a lot of Jupyter notebook elbow grease essentially. But when you start working with the new primitives in 2026, you end up with a lot cleaner of a workflow.

[12:25] So researchers were able to automate 90% of this workflow by simply asking the agent about the eval in question using natural language. Then the agent that is now primed with skills and an understanding of Google’s massive monor repo codebase is able to crunch the numbers and get back to you with a delta. Now what’s really cool here is instead of just taking that delta then handing it back to the user, it went the extra step. It spun up for a research agent specialist that proposes a hundred different hypotheses over why those deltas might occur. And then it uses sub aents to then spit up one sub aent for

[12:58] each hypothesis and basically drills into that particular case in parallel mapping back to a single response and then telling the researcher, hey here are some areas that I found. Now uh here’s a report that you can review. And what’s really cool is that it doesn’t stop at just the report. It actually puts together a generative UI for you to look through, interact, select dropdowns, filter, segment, slice, and actually interact richly with that data. And internally, we care a lot about this sort of workflow. Improving the model,

[13:30] improving the product, and understanding the ways that users find success and failure internally at Google. So, what used to be a very manual process now takes minutes. So, what used to be handineering, you’d have to build your own async pool of agents, you’d have to set up your judges, uh you’d have to tape together data pipelines, all of this now starts becoming grounded in these new primitives that we’ve established earlier in the slideshow. You have a sub aent graph that is completely dynamic. The generative UI comes in at the end to richly convey the findings in a way that the user best

[14:01] understands or maybe caters to their learning style. And all of these things can be regenerated and redone on the fly. All the user had to do was load up a skills file and ask away. So with teamwork and this eval example, we start arriving at these 2026 primitives that I keep talking about. And these model characteristics really change the way that we have to think about the product and how we have to develop the product. So the three examples that we’ve talked about, first we have the dynamic sub agent. And to provide a little bit more color here, basically no two sub aents are the same.

[14:34] The main agent is the one that is orchestrating this entirely on its own. It’s configuring and prompting and seeding these sub aents on the fly. They can operate in parallel. They can operate in different types of secure environments be it a sandbox be it a remote execution system and they can all take on infinitely an infinite number of specialized roles. So the scaling story here is quite obvious and from the last two examples you can probably tell as the model gets smarter your team will become more specialized it will become more collaborative and ultimately that means it’ll be capable of getting more

[15:06] complex work done for you. And now the second is this new concept and we’ve alluded to it slightly in the past, but it’s called sidecars. This is a new plug-in protocol that we’re bringing to anti-gravity. A sidecar process is essentially it is a sidecar process. The naming sort of reflects what’s going on under the hood, but it’s a longived utility and it’s responsible for listening. It allows the model to listen to the outside world and set up its own triggers for things that might happen. For example, this could be SMS messages. This could be web hooks, cron jobs, hooking it up to GitHub PRs, the the

[15:39] list goes on and on. But this is a generic plug-in primitive. Anti-gravity already uses sidecars for things that are timebased. This is where the the scheduled task cron concept comes from. Um, but under the hood, this is all this new sidecar primitive. So, we’ll be releasing the spec for this so that you all can build on top of this new primitive um later this summer. But there are some really, really cool ways that people internally have been using this sort of concept. And the third and final primitive is generative UI. So we hypothesize that human written specialized UIs are kind

[16:10] of dead. Gemini Flash on anti-gravity clocks in at almost 900 tokens a second. This is 10x faster than a lot of the other frontier model experiences. And in a matter of seconds, you’re able to go from whatever you thinking inside of your head into a prompt into a use case that is designed and embedded inside of your conversation view perfectly. And rather than rely on templates or even HTML files, anti-gravity can render your generated UI in line. So you can do things like this and play Doom. But this also extends to things like bar charts, graphs, um, tables, anything that you

[16:44] would want to interact with and maybe inspect a little bit further than just a markdown file or just a conversation. And generative UI in many ways reminds me of the quote that the late Steve Jobs said when unveiling the iPhone. He justifies the removal of the keyboard and says they all have these keyboards. They are there whether you need them or not. And they all have these control buttons that are fixed in plastic and are the same for every application. In an analogous way, we built our product to dynamically scale with the needs of the agent. We skipped the heavy

[17:16] infrastructure and mechanical UIs in favor of sidecars and generative UI. And that creates a product experience that is not fixed in plastic. So, sub aents, sidecar triggers, and generative UI are the latest primitives that are powering anti-gravity. We’ve tried our best to stay out of the way and let the model cook. And if you’re building a product around an agent, you should consider what are the primitives that are in my product and how might they scale with the model’s intelligence. We all are familiar with

[17:47] shipping features is now quite easy with all of these new tools. And it’s about deciding what features to actually add um so that the model so that your product can scale with the next release of the next model which will inevitably be faster, better, and cheaper. And so with the right primitives, you as a builder or you as a product owner, you might be surprised at what the models can do. And in classic fashion, I’m going to keep using the slide until we’ve actually conquered the TPU crunch. So you can find me on Twitter. Uh you can DM me for feedback. We’re always looking

[18:17] for new ideas on how to build the latest and greatest. Thank you for watching. Thank you Swix and Ben for having me. It’s always a joy to be here. And I’ll be at the anti-gravity booth if you want to talk further. If you want to get to know the product a bit more, some team members will be there. So, thank you so much for your time. Excited to meet you all. Yeah.

[18:53] Heat.