O Novo Coder do Google Funciona Enquanto Você Dorme

A gravidade teve uma semana difícil. Wicked 2 estreou nos cinemas, e o Antigravity pousou silenciosamente do Google DeepMind ao lado do Gemini 3 Pro, anunciando não um novo assistente de codificação, mas uma revisão completa do que um IDE realmente é.

Antigravity chega como um "novo IDE da Google DeepMind", como disse o líder de produto Kevin Hou ao público presente no AI Engineer, e parece ser uma linha na areia. Não se trata de um plugin acoplado ao VS Code; é o primeiro IDE totalmente desenvolvido por um laboratório de IA fundamental, com os modelos e o editor co-projetados como um único sistema.

A procedência importa. Quando a DeepMind lança um IDE, isso sinaliza que os laboratórios de pesquisa em IA não se veem mais apenas como fornecedores de modelos, mas como criadores de ferramentas completas para desenvolvedores, controlando tudo, desde os pesos do transformador até os atalhos de teclado.

Antigravity foi lançado na mesma semana que o Gemini 3 Pro, e essa combinação é o ponto, não uma coincidência. Hou enquadrou cada mudança significativa nos ferramentas de codificação—autocompletar, chat, agentes—como “motivada por alguma mudança que acontece com as capacidades dos modelos,” e Antigravity é o primeiro IDE construído em torno dessas novas capacidades desde o dia zero.

Em vez de tratar o IDE como uma casca estática em torno de uma chamada de API, a Antigravity considera o Gemini 3 como o sistema operacional do seu fluxo de trabalho de desenvolvimento. O produto existe porque o modelo agora pode planejar, executar e verificar tarefas de longa duração, não apenas autocompletar a próxima linha.

Hou chama a Antigravity de “incondicionalmente focada no agente”, e essa expressão está cumprindo um papel real. Em sua visão, o IDE não é mais o centro de gravidade; o agente é, e o editor, o navegador e os terminais são apenas ferramentas que ele pega e coloca.

Essa postura centrada no agente diferencia a Antigravity do GitHub Copilot, Cursor ou da crescente lista de editores aprimorados por IA. Essas ferramentas incorporam a IA dentro do IDE; a Antigravity incorpora o IDE dentro da IA, e essa inversão pode ser a verdadeira história deste lançamento.

A Antigravity não é enviada como um complemento de autocomplete mais inteligente anexado ao seu editor; ela é enviada como um sistema de três superfícies que trata os agentes como cidadãos de primeira classe. O editor, o navegador e o Gerenciador de Agentes funcionam como pares, com agentes impulsionados pelo Gemini 3 pulando entre eles em menos de 100 ms, agindo mais como um processo de sistema operacional distribuído do que como um chatbot.

No nível do solo está o Editor de IA, um ambiente VS Code bifurcado que se comporta exatamente como sua memória muscular espera—abas, terminais, pontos de interrupção—até que não se comporta. O autocomplete ultrarrápido cuida do trabalho de "digitar e sugerir", enquanto uma barra lateral de agente reflete o contexto do Gerenciador de Agentes para que você possa transferir ou retomar tarefas sem perder o fio da meada.

Essa barra lateral transforma o editor em um cockpit para trabalhos detalhados. Você pode pedir a um agente para refatorar um componente React complicado, gerar testes para um serviço Go ou conectar uma nova rota de API, e então entrar nos últimos 20%: ajustando tipos, corrigindo casos extremos ou reescrevendo textos. O comando Command-E ou Control-E te leva diretamente para o Gerenciador de Agentes, de modo que a transição de um único arquivo para a visão global da missão parece instantânea.

Onde o Antigravity se destaca dos IDEs tradicionais é no navegador controlado pelo agente. Nos bastidores, é uma instância do Chrome que o agente pode controlar diretamente—clicar, rolar, preencher formulários, executar JavaScript e recarregar seu servidor de desenvolvimento local—usando sua autenticação existente, cookies e acesso ao Google Docs, painéis do GitHub ou ferramentas internas.

Isso faz com que o navegador seja mais do que apenas um painel de visualização. Os agentes podem iniciar seu aplicativo, percorrer um fluxo de inscrição, ajustar o CSS e, em seguida, lhe entregar uma gravação semelhante a um vídeo do Chrome com um cursor azul mostrando cada ação em vez de uma parede de diffs. A verificação se torna visual: o modal foi renderizado, o estado de erro foi acionado, a animação apresentou lentidão?

Pairado acima de tudo está o Gerente de Agentes, o centro de comando da Antigravity. Ele trata os agentes como tarefas, não como conversas, proporcionando uma única janela para iniciar trabalhos de longa duração, acompanhar o progresso e revisar artefatos—planos, diferenças, gravações, capturas de tela—sem precisar se fixar em um único arquivo.

Uma visualização de caixa de entrada destaca tudo o que requer uma decisão humana: comandos de terminal destrutivos, migrações de esquema, solicitações de permissão. Notificações do sistema operacional o puxam de volta apenas quando necessário, permitindo que você orquestre múltiplos agentes rodando entre o editor e o navegador, enquanto você, ironicamente, se afasta ainda mais do código.

Os agentes deixam de ser coadjuvantes em Antigravity; eles se tornam seus novos gerentes de projeto. O Gerente de Agentes está acima do código, proporcionando uma visão de cockpit de tudo o que seus trabalhadores autônomos estão fazendo no editor, navegador e terminal. Em vez de rolar por diffs, você observa as tarefas serem criadas, executadas e reportadas como um painel de operações ao vivo.

A Antigravity estabelece uma relação de um para muitos aqui: uma janela do Gerenciador de Agentes, muitos agentes se espalhando pelo seu stack. Você pode ter um agente refatorando um monólito em TypeScript, outro configurando uma nova rota de API e um terceiro executando testes de integração baseados em navegador. O Gerenciador mantém todos eles em um único feed priorizado, completo com status, artefatos e próximas ações.

O controle flui através de uma caixa de entrada de alto nível que captura qualquer coisa arriscada, destrutiva ou ambígua antes de chegar ao seu computador. Comandos de terminal, migrações de banco de dados e trabalhos de longa duração aguardam nesta fila até que você os aprove ou negue. Esse design previne o pesadelo de um agente excessivamente entusiasta `rm -rf`‑ando um diretório enquanto você dorme.

Os itens da caixa de entrada chegam como cartões compactos e legíveis: comando, justificativa, arquivos ou serviços afetados e resultado esperado. Um clique envia o agente para frente; outro cancela o ramo de trabalho e o orienta a se replanejar. Notificações em nível de sistema operacional significam que você não precisa ficar monitorando a janela—Antigravity te cutuca apenas quando algo realmente precisa de uma decisão humana.

A velocidade é a outra metade da história. Alternar entre Gerente de Agente e o editor usando Command+E ou Control+E leva menos de 100 ms, rápido o suficiente para parecer instantâneo. Você pode examinar uma lista de tarefas, aprovar uma ação no terminal e, em seguida, voltar a um arquivo específico para ajustar uma função antes que o agente continue.

Esse salto de menos de 100 ms é importante quando você está lidando com múltiplos processos: orquestração no Gerente, edições precisas no editor, verificação no navegador controlado pelo agente. Todo o sistema o encoraja a passar mais tempo no nível estratégico e menos tempo micromanipulando comandos. Para uma análise mais detalhada desse fluxo de trabalho centrado no agente, o Google mantém documentos e downloads no Antigravity - Site Oficial.

Os agentes não apenas leem seu código no Antigravity; eles acionam uma instância completa do Chrome como um engenheiro de QA que nunca dorme. O Google conecta o IDE a um navegador controlado por agente que roda com seu perfil normal do Chrome, cookies e autenticação, e então entrega o controle ao Gemini 3. O resultado se parece menos com uma autocompletação e mais com um trabalhador remoto vivendo dentro da aba do seu navegador.

Como o navegador compartilha sua autenticação, o agente pode obter contexto em tempo real dos mesmos lugares que você. Ele pode abrir especificações do Google Docs, revisar suas solicitações de pull no GitHub e navegar em rastreadores de bugs internos ou painéis que estão atrás de SSO. Em vez de você colar URLs e tokens em um prompt, o agente navega silenciosamente por esses sites, constrói um modelo mental funcional do seu sistema e incorpora isso em seus planos.

A segunda metade do truque é a atuação. O Antigravity expõe cliques, rolagens, teclado e primitivas de execução JavaScript ao modelo, para que ele possa: - Clicar em botões e menus - Preencher formulários e acionar fluxos - Executar trechos de JS no console - Capturar capturas de tela e gravações

Na demonstração de Kevin Hou, esse poder se manifesta em um aplicativo web de rastreamento de voos de aparência deceptivamente simples. Ele adiciona um novo cartão modal a um gerador de obras de arte no estilo de Thomas Cole e pede ao agente que o conecte. Em vez de retornar uma parede de diferenças, o agente abre o navegador, atualiza a página e movimenta um cursor em forma de círculo azul pela interface para provar que o recurso realmente funciona.

Essa gravação não é uma animação falsa; é um registro de eventos DOM reais e chamadas de rede. O agente clica no modal, verifica o layout, confere se os novos voos são exibidos corretamente e recarrega para garantir que o estado persista. Você recebe um pequeno artefato em vídeo anexado à tarefa, ao lado das mudanças de código que a produziram.

Isso fecha a lacuna da "última milha" que tem atormentado as ferramentas de codificação de IA por dois anos. Os geradores de código conseguem produzir componentes React e manipuladores de API, mas geralmente param bem antes de um navegador real, cookies reais e dados reais. O agente de navegador da Antigravity ultrapassa essa barreira, transformando "parece certo na diferença" em "funciona no aplicativo" por padrão.

Os artefatos estão no centro de como a Antigravity deseja que você julgue o trabalho de uma IA. Em vez de confiar em uma parede de saídas de modelo ou em um misterioso crachá de "tarefa concluída", você recebe objetos concretos e verificáveis que o agente deixa para trás enquanto trabalha.

Ferramentas de codificação de IA à moda antiga pediam que você revisasse diferenças de código e, talvez, uma transcrição de chat. O Antigravity inverte isso: o agente monta planos de implementação, descritivos de tarefas passo a passo, capturas de tela e gravações de navegador que mostram exatamente como ele executou a alteração.

Você ainda vê diferenças no editor, mas elas não são mais a interface principal. O Gerenciador de Agentes te leva um nível acima, onde os artefatos padrão são: - Um plano de ataque em linguagem natural - Alterações de código vinculadas - Evidências visuais do navegador controlado pelo agente

A gravação do navegador é a peça central. Quando o agente termina de configurar um recurso ou corrigir um bug, ele pode anexar um vídeo de si mesmo operando uma instância completa do Chrome: ponto azul se movendo, cliques acontecendo, rolagens, preenchimentos de formulário e JavaScript sendo executado na sua aplicação real.

Em vez de ler 20 arquivos alterados para ver se um modal funciona, você clica em reproduzir. Você observa o agente atualizar seu gerador de obras de arte aleatórias, disparar o novo cartão modal e verificar se a interface do usuário se comporta corretamente sob condições reais de DOM e rede.

Essas gravações se acumulam junto a capturas de tela e artefatos textuais. Para uma tarefa complexa, você pode ver uma sequência: documento de design inicial, plano de implementação, edições de código, logs do terminal e um vídeo final do navegador provando que o fluxo de ponta a ponta funciona.

A validação torna-se visual e temporal em vez de puramente textual. Você confirma que um teste de regressão é executado, que a autenticação é bem-sucedida com seus cookies reais, que um clique em um botão realmente atualiza o estado, tudo isso sem reconstruir a lógica apenas a partir das diferenças.

A confiança cresce porque os artefatos correspondem à maneira como os humanos já depuram e revisam o trabalho. Os engenheiros naturalmente recorrem a compartilhamentos de tela, vídeos no Loom e URLs de staging; a Antigravity incorpora esse instinto no produto e faz com que o agente produza esses ativos automaticamente.

À medida que modelos como o Gemini 3 Pro se tornam mais eficientes em tarefas de longo prazo, esses artefatos se tornam as barreiras de segurança. Você deixa o agente trabalhar durante a noite e, em seguida, retorna a uma caixa de entrada organizada com planos, ajustes e gravações que você pode auditar em minutos em vez de horas.

A antigravidade existe porque os modelos subjacentes finalmente cruzaram um limiar. O Gemini 3 Pro não é um aprimoramento marginal em relação ao Gemini 1.5 ou Gemini 2; dentro da DeepMind, as equipes o descrevem como uma mudança de patamar em poder de raciocínio e confiabilidade. O mantra de Kevin Hou—“o produto é tão bom quanto os modelos que o sustentam”—aparece em quase todas as decisões de design.

Os copilotos de codificação anteriores passaram por melhorias limitadas: primeiro com a autocompletar de forma curta, depois com chat usando RLHF, e por fim com “agentes” frágeis que desmoronavam em tarefas longas. O Gemini 3 Pro vai além disso ao manter planos maiores em sua mente, coordenar ferramentas por horas em vez de minutos e se recuperar de seus próprios erros. Essa mudança torna um IDE centrado em agentes, como o Antigravity, não apenas possível, mas necessário.

Quatro atualizações de modelo são as mais importantes. Primeiro, inteligência avançada: o Gemini 3 Pro pode decompor um pedido de funcionalidade em dezenas de subtarefas, rastrear dependências e atualizar o plano à medida que os testes falham ou as APIs mudam. Segundo, uso sutil de ferramentas: o modelo pode decidir quando acessar o sistema de arquivos, quando abrir um navegador, quando executar um comando no terminal e quando perguntar a você antes de fazer qualquer uma dessas ações.

Em terceiro lugar, o Gemini 3 Pro lida com tarefas mais longas sem perder o foco. Em vez de expirar após algumas chamadas de ferramenta, ele pode orquestrar refatorações de várias horas, execuções de CI e testes de ponta a ponta, destacando apenas os passos que precisam de revisão humana. Em quarto lugar, a multimodalidade nativa significa que ele pode ler capturas de tela de UI, mocks de design, logs e documentação diretamente, integrando tudo isso em código e testes.

Essas capacidades quebram a metáfora da janela de chat. Uma única conversa rolável não pode representar 15 agentes operando em um editor, um navegador e um terminal, todos com seus próprios estados e artefatos. Você precisa de um plano de controle assíncrono que trate o chat como apenas uma das muitas visões de um sistema em tempo real.

É por isso que a Antigravity oferece um Gerente de Agentes com caixas de entrada, notificações e artefatos, em vez de uma caixa de texto glorificada. A interface do usuário se adapta ao que o Gemini 3 Pro realmente pode fazer: gerenciar o trabalho enquanto você dorme e, em seguida, apresentar resultados verificáveis—diferenças, gravações, planos—quando você retorna. Para uma análise mais aprofundada dessa arquitetura, o Google detalha a pilha em Construa com Antigravity - Blog dos Desenvolvedores do Google.

O Multimodal Gemini transforma o Antigravity de um autocompletar mais inteligente em um colaborador de design completo. Como o Gemini 3 Pro entende nativamente texto, código, imagens e layouts de UI em uma única janela de contexto, o agente pode raciocinar sobre seus componentes React, sua exportação do Figma e suas variáveis CSS como um único artefato coerente, em vez de arquivos separados.

A demonstração do mockup da Antigravity mostra como isso realmente se sente. Você pede ao agente para "criar uma página de destino para uma startup de autenticação sem senha", e ele não apenas gera HTML — ele produz uma imagem de alta fidelidade da página diretamente dentro do IDE, ao lado do código que poderia renderizá-la.

A parte interessante vem a seguir: você anota esse mockup como em um Google Docs. Você pode adicionar comentários diretamente na imagem principal, circundar o botão de CTA ou destacar a tabela de preços e escrever: “Faça isso parecer mais corporativo, menos de startup”, e o agente alimentado por Gemini interpreta essas pistas espaciais e anotações em linguagem natural juntos.

Em vez de tratar esses comentários como sugestões vagas, a Antigravity os considera como entradas estruturadas. O agente lê a imagem, entende onde cada comentário está localizado na tela, mapeia essas regiões de volta ao código de layout e aos tokens de design, e então gera um novo artefato de mockup além de um dif na sua base de código.

Esse loop — imagem → comentários → nova imagem mais código — roda inteiramente dentro do IDE. Você nunca troca para o Figma, nunca exporta PNGs, nunca copia CSS manualmente. O Gerenciador de Agentes acompanha cada iteração como um artefato separado, para que você possa voltar para "Versão 2 com CTA azul" ou comparar layouts como você compararia commits.

O desenvolvimento de software silenciosamente se tornou multimodal há anos. As equipes modernas já equilibram: - Código e arquivos de configuração - Diagramas de arquitetura e gráficos de sequência - Mockups de UI, sistemas de design e capturas de tela - Registros de log, painéis e gravações de navegador

A maioria das ferramentas ainda mantém esses elementos em aplicativos separados; o Antigravity é a primeira IDE convencional que os trata como um espaço de trabalho contínuo. Ao ser construído em torno do Gemini multimodal desde o primeiro dia, permite que o mesmo agente raciocine sobre diagramas, UIs e caminhos de código, fazendo com que "projetar com IA" pareça menos uma conversa com um bot e mais uma colaboração com um designer de produto full-stack que nunca dorme.

O design centrado no agente significa que a Antigravity trata a IA como a operadora principal do seu ambiente de desenvolvimento, e não como uma assistente que vive em uma barra lateral. O produto pressupõe que os agentes lerão, escreverão, clicarão e testarão em toda a sua pilha enquanto você estiver ausente, e depois trarão à tona apenas as decisões e os pontos de verificação que exigem seu julgamento. Os humanos se tornam revisores, e não executores manuais de cada etapa.

A maioria das ferramentas "assistidas por IA" ainda orbita um fluxo de trabalho centrado no humano. Você escreve o código, depois pressiona uma tecla de atalho para autocompletar, uma resposta de chat ou uma sugestão de refatoração; o modelo apenas reage ao seu cursor. Mesmo quando as funcionalidades são apresentadas como "agentes", esses sistemas costumam ficar presos dentro de uma única aba do IDE, controlados pelo seu próximo comando.

Os flips antigravitacionais invertem essa hierarquia. O Gerente de Agentes fica acima do editor e do navegador, funcionando como uma espécie de centro de controle, projetado para rastrear metas, ramificações de trabalho e tarefas que exigem várias horas, em vez de diferenças individuais. A qualquer momento, há exatamente uma janela do Gerente de Agentes coordenando muitos agentes e muitas superfícies.

As decisões de UI e UX decorrem dessa suposição de autonomia. O editor, a instância do Chrome controlada pelo agente e o terminal são todos enquadrados como ferramentas para o agente, não ferramentas para você. Um atalho de teclado (Command-E ou Control-E) alterna entre o Gerenciador e o editor em menos de 100 ms, reforçando que sua visualização principal é o progresso do agente, não suas próprias digitações.

A supervisão substitui a microgerência. A caixa de entrada do Gerente de Agentes agrega eventos que requerem atenção—executar um comando terminal arriscado, mesclar uma grande refatoração, atualizar a configuração de produção—para que você possa aprovar ou rejeitar com um único clique. Notificações a nível de sistema o trazem de volta apenas quando algo ultrapassa uma limite de segurança que a equipe não quer que o agente ultrapasse sozinho.

Os artefatos tornam essa confiança auditável. Em vez de expor chamadas de ferramenta brutas, os agentes produzem Artefatos como planos de implementação, revisões de código, capturas de tela e gravações completas do Chrome com um cursor visível. Você revisa o que o agente fez no editor e no navegador como se estivesse assistindo a um colega compartilhar sua tela.

Essa arquitetura centrada em agentes separa a Antigravity de concorrentes que ainda acoplam IA a IDEs centradas no humano. À medida que modelos como Gemini 3 Pro escalam em comprimento de contexto, confiabilidade e uso de ferramentas, a hierarquia da Antigravity já assume que os agentes executarão a maior parte do fluxo de trabalho enquanto os humanos supervisionam as partes que realmente importam.

Cursor, Replit e GitHub Copilot Workspace prometeram um programador par, alimentado por IA, vivendo dentro do seu editor. A Antigravity inverte essa narrativa, propondo um espaço de trabalho agente onde o IDE é apenas uma superfície e o agente é o sistema operacional do seu trabalho. Em vez de autocompletar com chat, o Google está vendendo um ambiente de automação completo que abrange editor, navegador e camada de orquestração.

Os concorrentes têm partes disso. O Cursor se concentra fortemente em refatorações no editor e contexto em escala de repositório; o Copilot Workspace protótipos “especificações para PRs” que rodam na nuvem. O Antigravity funde essas ideias em um plano de controle local e multicamada que pode abrir o Chrome, navegar por dashboards e enviar artefatos enquanto você dorme.

A verdadeira vantagem do Google está acima da interface do usuário. Ao incorporar a equipe de produtos Antigravity dentro da DeepMind, o grupo de Kevin Hou testou o Gemini 3 meses antes do lançamento, moldando tanto as APIs de chamada de ferramentas do modelo quanto o comportamento dos agentes do produto. Esse ciclo fechado significa que a pesquisa pode corrigir modos de falha—como o planejamento de longo prazo instável—diretamente no modelo em vez de mascará-los com soluções improvisadas no produto.

O pacote da DeepMind também permite que o Google ajuste especificamente para cargas de trabalho de agentes, e não apenas para benchmarks de chat. O contexto longo, o uso mais forte de ferramentas e o raciocínio multimodal do Gemini 3 Pro foram calibrados para a arquitetura de três superfícies da Antigravity, e não adicionados posteriormente. Concorrentes que dependem de APIs públicas não têm esse tipo de privilégio de co-design.

Então veio o erro da “escassez global de chips”. Quando a Antigravity atingiu listas de espera esta semana, uma barreira de capacidade acionou um banner de indisponibilidade em tom de brincadeira que se espalhou pelo X e pelo Hacker News em poucas horas. A mensagem serviu como um gráfico de crescimento: a demanda por agentes sempre ativos que compilam, navegam e testam em segundo plano já está sobrecarregando os aceleradores do Google.

Esse momento viral também expôs o custo computacional por trás desse paradigma. Um agente que executa testes de navegador, gerencia terminais e mantém artefatos por horas se comporta mais como um pequeno serviço de backend do que como uma conclusão pontual. A disposição do Google em arcar com esse custo sinaliza o quão central ele vê os agentes em sua estratégia de nuvem.

Antigravity, enquadrado dessa forma, é menos um IDE e mais o modelo do Google para a próxima geração de desktops para desenvolvedores. Introdução ao Antigravity - Google Codelabs parece menos um processo de integração para um plugin e mais um treinamento para um novo modelo operacional: seu código, seu navegador e seus agentes compartilhando o mesmo espaço de trabalho.

Os desenvolvedores agora enfrentam uma pergunta direta: se um agente pode refatorar um código, configurar OAuth, acessar sua API de testes e navegar pela interface enquanto você dorme, qual é exatamente o seu trabalho? A Antigravity responde redefinindo-o silenciosamente. Você deixa de atuar como um implementador linha por linha e passa a ser a pessoa que decide o que deve ser construído, por que e com qual padrão.

Em vez de temer a substituição, os desenvolvedores que se adaptam se tornam arquitetos e orquestradores. O Gerente de Agentes transforma o trabalho em um portfólio de missões delegadas: “Implementar um sistema de controle de recursos,” “Migrar este serviço para gRPC,” “Projetar uma matriz de testes para dispositivos móveis.” Seu valor se desloca para escolher as missões certas, sequenciá-las e avaliar se os artefatos resultantes são realmente bons o suficiente para serem lançados.

Essa mudança exige novas habilidades. A decomposição de problemas em alto nível torna-se inegociável: você precisa dividir um pedido de produto vago em tarefas concretas, adaptáveis ao agente, com critérios de sucesso claros, dependências e limites. Se você não conseguir descrever o sistema de forma clara em inglês e diagramas, não vai gostar do que o agente produzir em código.

A solicitação deixa de ser um meme e se torna engenharia de requisitos. Boas solicitações em Antigravity se assemelham a mini documentos de design: entradas e saídas explícitas, casos extremos, não-obtivos, restrições de desempenho e como verificar o resultado. Você escreverá menos loops e mais especificações que leem como: "Dadas essas SLOs de latência e este esquema, projete um plano de implementação com canários e rollback automatizado."

A validação se torna a outra metade do trabalho. Os artefatos da Antigravity—gravações de navegador, planos, diferenças, execuções de teste—se transformam na sua superfície de revisão. Você aprenderá a: - Ler o plano de um agente e identificar modos de falha ausentes - Usar o navegador controlado pelo agente para investigar estados UI estranhos - Anotar artefatos com feedback direcionado que o agente pode iterar de forma autônoma

Ferramentas como o Antigravity não farão com que haja menos desenvolvedores; elas gerarão desenvolvedores mais ambiciosos. Quando um único engenheiro pode coordenar agentes para implementar serviços, realizar testes de ponta a ponta e iterar sobre a experiência do usuário durante a noite, o gargalo deixa de ser “Quão rápido posso programar?” e passa a ser “Quão audacioso posso ser sobre o que construiremos a seguir?”.

O que é o Google Antigravidade?

O Google Antigravity é um novo Ambiente de Desenvolvimento Integrado (IDE) 'focado em agentes' da Google DeepMind. Ele utiliza agentes de IA autônomos para gerenciar, escrever e verificar código em várias superfícies, incluindo um editor, um navegador e um gerenciador central de agentes.

Como o Antigravity é diferente do GitHub Copilot ou do Cursor?

Enquanto ferramentas como o Copilot se concentram na conclusão de código assistida por IA e em bate-papos dentro do editor, o Antigravity é projetado para agentes autônomos que executam tarefas complexas e de longa duração. Ele eleva o desenvolvedor a um papel de orquestração, gerenciando agentes que podem trabalhar simultaneamente em um editor de código e em um navegador web.

O Google Antigravidade é gratuito?

Sim, de acordo com os detalhes do lançamento inicial, o Google Antigravity é oferecido gratuitamente para desenvolvedores individuais em macOS, Linux e Windows.

Quais modelos de IA a Antigravity utiliza?

O Antigravity foi lançado em conjunto com o Gemini 3 Pro e está profundamente integrado com suas capacidades. A plataforma também suporta a opcionalidade de modelos, permitindo que os desenvolvedores utilizem outros modelos como Claude Sonnet 4.5 e GPT-4.