Terminal, Git e MCP: Antigravity 2.10 mostra para onde vão as IDEs com IA
Google Antigravity 2.10 não é uma versão espetacular porque agregou uma função inesperada. Importa porque leva várias ações normais do desenvolvimento ao mesmo espaço do agente: executar comandos, inspecionar diffs, preparar arquivos para commit, confirmar mudanças, revisar chamadas a ferramentas e anexar contexto mais rico.
Essa é a direção real do mercado.
A IDE com agentes se parece cada vez menos a “um chat ao lado do editor” e cada vez mais a uma sala de operações para entregar software.
O changelog oficial do Google para Antigravity 2.10.0, publicado em 24 de agosto de 2026, resume a manchete assim: “Embedded Terminals, Git Version Control, and Audio Attachments” (Terminais Embarcados, Controle de Versão Git e Anexos de Áudio). A versão resumida é que Antigravity agora incorpora um terminal embarcado na barra lateral, controles nativos de Git no painel de Review, visualizações mais ricas para execuções de MCP e ferramentas personalizadas, comentários sobre regiões de imagem, anexos de áudio e várias melhorias de desempenho.
Nenhuma dessas funcionalidades é conceitualmente exótica. Justamente por isso a versão é interessante.
A superfície do agente está absorvendo o ciclo do SDLC
Durante anos, as ferramentas de desenvolvimento estiveram organizadas em superfícies separadas:
- O editor para escrever código.
- O terminal para executar comandos.
- A interface de Git ou a CLI para revisar e confirmar mudanças.
- O navegador para documentação, issues e previews.
- O chat para assistência com IA.
- CI para validar.
Os agentes de código começaram se anexando a uma ou duas dessas superfícies. Primeiro viveram dentro do editor. Depois se mudaram para o terminal. Depois começaram a abrir arquivos, aplicar patches, ler documentação, rodar testes, chamar ferramentas e gerar artefatos.
Antigravity 2.10 é outro passo na fase de consolidação.
O terminal embarcado permite executar builds, suites de testes e scripts sem trocar de aplicação. Os controles de Git permitem inspecionar diffs da árvore de trabalho, fazer stage e unstage de arquivos e criar commits pelo painel de Review. As etapas de execução de MCP e ferramentas personalizadas agora mostram cabeçalhos estruturados, blocos de argumentos expansíveis e previews formatados de resultados.
Essa combinação importa mais que qualquer um dos pontos separadamente.
Quando o agente pode propor código, executar o comando que o valida, mostrar o diff, expor a evidência das chamadas a ferramentas e deixar que a pessoa faça commit da mesma interface, a IDE deixa de ser apenas o lugar onde se edita código. Se converte em um painel de controle para o trabalho de desenvolvimento.
Por que Git dentro da interface do agente importa
A integração com Git é especialmente importante porque define a passagem entre autonomia do agente e responsabilidade humana.
Um agente de código pode gerar um patch. Mas o desenvolvedor ainda precisa responder perguntas práticas:
- O que mudou?
- A mudança está bem delimitada?
- O agente tocou arquivos que não correspondiam?
- Posso preparar apenas uma parte do trabalho?
- Isso deveria virar commit agora ou precisa de outra volta de validação?
Ao colocar controles de revisão de Git diretamente dentro do fluxo do agente, Antigravity reduz a distância entre “o modelo fez algo” e “entendo o que está por entrar no repositório”.
Essa é a parte que importa para os times.
O gargalo na codificação agêntica não é apenas a qualidade da geração de código. É a revisabilidade. Se um agente consegue trabalhar rápido mas a pessoa não consegue inspecionar, separar, rejeitar ou confirmar mudanças com clareza, o fluxo ainda se sente inseguro. Os controles nativos de Git tornam o ciclo mais legível.
Isso também aproxima Antigravity do território de fluxo de trabalho que ocupam ferramentas como Cursor, Claude Code, agentes no estilo Codex e projetos terminal-first como OpenCode. A pergunta competitiva deixa de ser apenas “qual modelo escreveu a melhor função?” e passa a ser “qual superfície dá ao desenvolvedor melhor controle operativo sobre o trabalho do agente?”.
O terminal completa o ciclo build-test-review
O terminal embarcado é a outra peça grande.
Um fluxo sério com agentes de código precisa de execução de comandos. Não é possível avaliar a maioria das mudanças não triviais apenas lendo o patch. São necessários testes, type checks, linters, scripts de build, migrações, servidores de desenvolvimento, comandos de pacotes e, às vezes, pequenos comandos de diagnóstico.
Se o terminal vive fora do ambiente do agente, o fluxo se fragmenta. O desenvolvedor pede ao agente que mude o código, troca de aplicação, roda os testes, copia o resultado de volta, pede uma correção, revisa o diff em outro lugar e repete.
Funciona. Mas não é elegante.
Com execução de terminal e revisão de Git na mesma interface, o ciclo fica mais compacto:
- Pedir ao agente que faça uma mudança.
- Executar o comando relevante.
- Inspecionar a falha ou o sucesso.
- Revisar o diff.
- Preparar os arquivos corretos.
- Fazer commit ou pedir outra iteração.
Esse é o ciclo que todos os ambientes de codificação com IA estão tentando capturar.
Para os leitores de yoDEV, especialmente times que estão avaliando ferramentas de AI dev além da demo, a pergunta prática é esta: a ferramenta reduz mudanças de contexto ao mesmo tempo que preserva revisão humana, ou esconde complexidade atrás de uma caixa de chat?
Antigravity 2.10 se move claramente para a primeira resposta.
Os previews de MCP não são cosmética
As melhorias em previews de MCP e ferramentas personalizadas podem parecer polimento de interface, mas apontam para outra camada importante: observabilidade das chamadas a ferramentas.
A medida que os agentes chamam mais ferramentas externas, os desenvolvedores precisam ver o que aconteceu. Qual ferramenta foi invocada? Com quais argumentos? O que devolveu? O resultado veio estruturado, truncado, formatado ou ambíguo?
Antigravity 2.10 melhora essas etapas de execução com cabeçalhos estruturados, blocos de argumentos expansíveis e previews formatados de resultados. Isso importa porque MCP está se tornando parte da stack agêntica de desenvolvimento. Os agentes não estão mais limitados a editar arquivos e executar comandos em shell. Quando conectados, conseguem consultar issue trackers, documentação, bases de dados, ferramentas de observabilidade, arquivos de design e serviços internos.
Quantas mais ferramentas um agente consegue chamar, mais a interface precisa expor evidência.
Uma chamada a ferramenta oculta é difícil de confiar. Uma chamada visível e inspecionável se torna parte da rastreabilidade de revisão.
Por isso o marco de “IDE agêntica como painel de controle” é útil. O painel de controle não se trata apenas de dar ordens. Também se trata de observabilidade, revisão, permissões e recuperação.
Áudio e comentários sobre imagens expandem o contexto ao redor do código
Os anexos de áudio e os comentários sobre regiões de imagem são menos centrais para o ciclo de entrega de software, mas fazem parte da mesma história.
Antigravity agora permite anexar arquivos de áudio como MP3, WAV, M4A, AAC, OGG, FLAC e OPUS de até 20 MB. Também permite selecionar regiões e deixar comentários diretamente sobre imagens no visualizador de arquivos.
Isso significa que o workspace do agente está absorvendo mais formas de entrada: notas de voz, capturas de UI, referências de design, registros visuais de bugs, diagramas e feedback visual. Para times de produto e engenharia, isso importa porque muitas tarefas de código não começam como tickets perfeitamente redigidos. Começam como “esta parte da UI não se sente bem”, “isso foi o que gravou o usuário” ou “compara esta captura com o estado esperado”.Quanto mais naturalmente esses insumos entrarem no workspace do agente, menos trabalho de tradução recai sobre o desenvolvedor.
Mesmo assim, esta é a zona onde os times devem ter cuidado. Os inputs mais ricos são úteis, mas também aumentam a quantidade de contexto que pode conter informações privadas de produto, clientes ou processos internos. Os fluxos com áudio e imagens precisam da mesma atenção de governança que o acesso a código e repositórios.
O aviso: a consolidação também pode se tornar lock-in
A vantagem estratégica dessa direção é clara: menos superfícies, ciclos mais ajustados, melhor revisão e menos trocas de contexto.
O risco também é claro.
Quando uma IDE agêntica controla execução de terminal, revisão de Git, chamadas a ferramentas, previews, anexos, comentários e fluxos de artefatos, ela se torna um ambiente padrão muito poderoso. Isso pode melhorar a produtividade, mas também aumenta os custos de mudança. Os times deveriam avaliar não só a experiência do modelo, mas também os limites operacionais:
- Os desenvolvedores conseguem revisar claramente cada mudança do agente?
- As chamadas a ferramentas são suficientemente visíveis para auditar e depurar?
- O time consegue manter sua disciplina existente de Git?
- O fluxo se degrada bem se o agente falhar?
- Os permissionários e ferramentas conectadas são compreensíveis?
- O trabalho pode ser reproduzido fora da IDE?
Essas perguntas importam cada vez mais conforme as IDEs agênticas se tornam centrais no desenvolvimento diário.
Uma superfície de agente muito polida que oculta demais não é uma ferramenta de produtividade. É um problema de governança esperando seu momento.
O sinal maior
Antigravity 2.10 é uma versão de produto, mas o sinal de fundo atravessa toda a indústria.
As ferramentas de coding com IA estão convergindo sobre a mesma tese: a interface futura para construir software não será apenas um editor, nem apenas um terminal, nem apenas um chat. Será um workspace onde o agente possa agir, o desenvolvedor possa inspecionar e o time possa manter controle sobre o processo de entrega.
Por isso terminal, Git e previews de MCP pertencem à mesma conversa.
O terminal dá execução.
Git dá responsabilidade.
MCP dá alcance.
A interface do agente os une.
Para desenvolvedores na Iberoamérica que estão escolhendo seu stack de coding com IA em 2026, eu usaria essa lente. Não perguntem só qual ferramenta escreve melhor código em um benchmark. Perguntem qual ferramenta dá ao seu time o ciclo mais limpo desde intenção até implementação, validação e revisão.
Antigravity 2.10 é a resposta mais recente do Google para essa pergunta.