Google Agent Smith Escreve 25% do Código Google: O Que Equipes de API Devem Saber

TL;DR

O agente interno de codificação de IA do Google, Agent Smith, agora gera mais de 25% do novo código de produção da empresa. Diferente de ferramentas como o Copilot, o Agent Smith opera assincronamente em segundo plano, escrevendo, testando e iterando código sem interação humana. Para equipes de API, isso traz desafios práticos: estabilidade de contratos, cobertura de testes, alinhamento da documentação e revisão de código quando um quarto da base é gerado por máquina.

Experimente o Apidog hoje

---

Introdução

Durante uma teleconferência de resultados em março de 2026, o CEO do Google, Sundar Pichai, revelou que mais de 25% do novo código produzido no Google é gerado por IA.

Isso não é preenchimento automático ou sugestões do Copilot aceitas manualmente. Trata-se de código enviado para produção após ser totalmente gerado por IA. O Agent Smith, ferramenta interna do Google, tornou-se tão popular entre os 180.000 funcionários que a empresa precisou limitar seu uso para evitar sobrecarga na infraestrutura.

O Agent Smith representa uma nova categoria de ferramenta de codificação de IA. Enquanto Copilot e Claude Code ajudam em tempo real, o Agent Smith executa tarefas em segundo plano: engenheiros delegam atividades, saem, e revisam o trabalho pronto mais tarde.

Equipes de API precisam se adaptar a essa mudança de “código assistido por IA” para “código gerado por IA”. Como manter contratos de API estáveis? Como garantir cobertura de testes adequada? Como impedir que a documentação fique desatualizada?

💡 Dica: A plataforma de ciclo de vida de API da Apidog mantém design, testes, mocks e documentação sincronizados, independentemente de quem faz a mudança — humano ou IA. Experimente o Apidog gratuitamente para criar fluxos de trabalho de API "à prova de agentes".

Este artigo detalha o funcionamento do Agent Smith, como ele difere de outras ferramentas de IA e o que equipes de API podem implementar agora.

O que o Agent Smith faz

Codificação Autônoma Assíncrona

O Agent Smith não é apenas um assistente na IDE. Ele executa tarefas completas em segundo plano. O fluxo de trabalho é:

1. Engenheiro descreve uma tarefa em linguagem natural
2. Agent Smith divide a tarefa em subtarefas
3. Ele escreve código em múltiplos arquivos
4. Roda testes e itera em caso de falhas
5. Engenheiro revisa o trabalho finalizado

Diferente do Copilot ou Claude Code, o Agent Smith se comporta como um desenvolvedor júnior: pega o ticket, some por algumas horas e retorna com um pull request.

A delegação de tarefas pode ser feita via chat interno do Google, inclusive por dispositivos móveis. O Agent Smith busca automaticamente perfis, contexto e documentação relevante da base interna do Google.

Construído sobre Gemini e Antigravity

O Agent Smith utiliza a família de modelos Gemini do Google, com sistemas de recuperação para acessar a base de código e documentação interna, construído sobre a plataforma Antigravity. O diferencial é a decomposição e execução autônoma de tarefas.

A recuperação aumentada garante que o Agent Smith não gere código isolado: ele referencia padrões existentes, implementações e convenções internas, o que viabiliza qualidade de produção em larga escala.

O que significa "25% do novo código"

O número divulgado refere-se a código:

• Gerado por IA (não apenas sugestões aceitas)
• Revisado por engenheiros humanos
• Enviado para sistemas de produção
• Medido sobre toda a produção de engenharia do Google

Ou seja, não são 25% de toda a base, mas 25% do novo código criado atualmente. A tendência é de crescimento.

Como o Agent Smith difere de outras ferramentas de IA

O espectro de ferramentas de codificação de IA

Ferramenta	Modo	Interação	Escopo	Código de produção?
GitHub Copilot	Preenchimento automático em tempo real	Inline na IDE	Nível de linha/função	Após aceitação humana
Claude Code	Sessão interativa	Conversacional	Alterações em múltiplos arquivos	Após revisão humana
Cursor Agent	Segundo plano + interativo	Embutido na IDE	Nível de projeto	Após revisão humana
Agent Smith	Autônomo assíncrono	Delegação de tarefas	Implementação de recurso completo	Após revisão humana
KAIROS (não lançado)	Daemon sempre ativo	Monitoramento em segundo plano	Em todo o repositório	A definir

O Agent Smith ocupa a ponta autônoma desse espectro. A próxima etapa seria a implantação sem revisão humana — o que ainda não ocorre (nem deveria).

Por que a assincronia importa para equipes de API

Ferramentas em tempo real (Copilot, Claude Code) atuam dentro do fluxo do desenvolvedor: o contexto está fresco, correções são instantâneas.

Agentes assíncronos mudam esse paradigma. O Agent Smith pode modificar endpoints de API sem que o desenvolvedor entenda imediatamente as motivações, o que pode gerar:

• Dificuldade em compreender mudanças de formato de resposta
• Alterações no contrato da API não evidentes em revisões padrão
• Testes, documentação e mocks possivelmente desatualizados
• Mudanças disruptivas passando despercebidas

O que quebra quando a IA escreve o código da sua API

Desalinhamento do contrato da API

O contrato de API define endpoints, esquemas, códigos de status e formatos de erro. Humanamente, mudanças requerem atualização de OpenAPI, notificação de consumidores e versionamento.

Um agente autônomo pode modificar a API sem atualizar o contrato. Exemplo:

• Agent Smith recebe: "Adicionar preferências de usuário"
• Adiciona preferences à resposta de GET /api/users/{id}
• Testes existentes passam (não checam campos extras)
• Tipos do frontend não preveem preferences
• App móvel quebra ao receber campo inesperado

O código está correto, os testes passam, mas o contrato está quebrado.

Lacunas na cobertura de testes

Agentes de IA tendem a gerar testes que validam apenas o novo comportamento, não protegem contra regressões. Para APIs, isso pode deixar de fora:

• Benchmarks de latência
• Formatos de erro padronizados
• Validação de limites de autenticação
• Comportamento de paginação
• Respeito ao padrão de limitação de taxa

Desalinhamento da documentação

Se a documentação não é gerada automaticamente da especificação, alterações feitas pelo agente podem não ser propagadas. Mesmo com documentação automática, exemplos e contexto de uso dependem de input humano.

Fadiga de revisão

Com 25% do código gerado por IA, 25% das revisões são para esse output. O código parece bom, mas pode não estar alinhado com decisões arquitetônicas ou requisitos tácitos. O risco é a aprovação automática e bugs em produção.

Como construir fluxos de trabalho de API "à prova de agentes"

1. Torne os contratos de API a fonte da verdade

Use design-first: a especificação OpenAPI deve ser o ponto central. Isso permite detectar rapidamente qualquer quebra de contrato.

Sem design-first:

Alteração de código → Testes passam → Envio → Contrato quebrado

Com design-first:

Especificação define o contrato → Código deve corresponder à especificação → Validação detecta desalinhamento

O designer visual do Apidog permite definir endpoints e esquemas antes do código. Valide todo output do Agent Smith contra a especificação — nunca apenas contra testes.

2. Use testes de contrato, não só testes unitários

Testes unitários checam comportamento interno; testes de contrato validam o acordo entre serviços.

Exemplo de teste de contrato:

// Este teste falha se a estrutura da resposta mudar,
// mesmo que a nova estrutura seja "válida"
describe("GET /api/users/:id contract", () => {
  it("returns expected schema", async () => {
    const response = await request(app).get("/api/users/123");

    expect(response.body).toMatchSchema({
      type: "object",
      required: ["id", "name", "email", "created_at"],
      properties: {
        id: { type: "string" },
        name: { type: "string" },
        email: { type: "string", format: "email" },
        created_at: { type: "string", format: "date-time" }
      },
      additionalProperties: false  // Detecta campos inesperados
    });
  });
});

A linha additionalProperties: false é fundamental. Sem ela, campos extras adicionados pela IA passam despercebidos.

O Apidog automatiza testes de contrato: defina o esquema e valide todas as respostas.

3. Controle as implantações com validação de especificação

Adicione validação automática ao CI/CD. Antes de implantar, valide se o código está em conformidade com a especificação.

# Etapa do pipeline de CI/CD
- name: Validar contrato de API
  run: |
    apidog run --test-scenario-id CONTRACT_TESTS
    if [ $? -ne 0 ]; then
      echo "Violação de contrato de API detectada. Revise as alterações."
      exit 1
    fi

Isso bloqueia violações de contrato antes de chegar à produção.

4. Exija atualizações de especificação para alterações na API

Crie uma regra: todo PR que altera a API precisa atualizar a especificação OpenAPI. Para PRs gerados por IA, o agente deve atualizar a spec ou um humano deve garantir a atualização antes do merge.

No Apidog, alterações de spec se propagam automaticamente para:

• Documentação
• Respostas de mock
• Asserções de teste
• Tipos de SDK

5. Monitore o comportamento da API em produção

Mesmo com testes e validação, monitore produção para capturar problemas reais:

• Violações de esquema: logue respostas fora do padrão
• Novos campos: alerte sobre campos fora da especificação
• Taxa de erros: monitore endpoints de IA
• Latência: avalie desempenho dos endpoints alterados
• Tráfego: monitore padrões inesperados

6. Separe revisão da API da revisão do código

Revisão de código verifica funcionamento; revisão de API verifica impacto em consumidores.

Lista de verificação para revisão de API:

• Algum consumidor será quebrado?
• Especificação OpenAPI está atualizada?
• Mudanças incompatíveis estão versionadas?
• Respostas de erro seguem o padrão?
• Novos endpoints estão documentados?
• Equipes downstream foram notificadas?

A trajetória: para onde a codificação autônoma está indo

Agent Smith hoje vs. amanhã

Agent Smith em 25% é só o começo. Sergey Brin destacou IA agentica como "grande foco" em 2026. O percentual tende a crescer com melhorias de ferramenta e adaptação de workflow.

Outras empresas já seguem o mesmo caminho:

• KAIROS (Claude Code): daemon com webhooks GitHub e workers em segundo plano
• Copilot Agent Mode: tarefas multi-etapa e edição autônoma
• CodeWhisperer (Amazon): expansão para workflows agent

A tendência é clara: de "assistente" para "colaborador autônomo" e "infraestrutura". Em breve, a pergunta não será se a IA escreve sua API, mas quanto dela.

O que equipes de API devem preparar agora

• Design-first é obrigatório: A especificação é o único artefato estável quando agentes entram no fluxo.
• Invista em testes de contrato: Unitários não bastam se o autor não entende convenções não escritas.
• Escolha ferramentas integradas: Plataformas fragmentadas favorecem desalinhamento. O Apidog mantém tudo sincronizado.
• Revisão customizada para IA: Checklists e validação automatizada específicas para mudanças em API são essenciais.

Experimente o Apidog gratuitamente para criar fluxos de trabalho de API consistentes, independente de quem (ou o quê) gere o código.

FAQ

O que é o Google Agent Smith?

Agent Smith é o agente de IA do Google, baseado nos modelos Gemini e na plataforma Antigravity. Ele opera em segundo plano: engenheiros delegam tarefas, e o Agent Smith gera, testa e itera o código sem interação humana em tempo real. Em março de 2026, ele foi responsável por mais de 25% do novo código de produção do Google.

O Agent Smith está disponível fora do Google?

Não. É uma ferramenta restrita a funcionários do Google, sem planos para lançamento público. Sua tecnologia é similar ao Copilot Agent Mode e Claude Code, mas mais integrada ao ecossistema interno do Google.

Código gerado por IA quebra contratos de API?

Pode quebrar. Agentes de IA escrevem código que passa nos testes, mas testes nem sempre cobrem todo o contrato de API. Testes de contrato e design-first são essenciais para evitar surpresas.

Equipes de API devem se preocupar com o Agent Smith?

Não com o Agent Smith em si, mas com a tendência que ele representa. Ferramentas semelhantes (Copilot Agent Mode, KAIROS, etc.) devem chegar ao mercado. Prepare seu fluxo de trabalho com design-first, testes de contrato e ferramentas integradas.

Como impedir que agentes de IA quebrem minhas APIs?

• Use desenvolvimento design-first com OpenAPI como fonte da verdade
• Adicione testes de contrato com additionalProperties: false para detectar mudanças inesperadas
• Controle implantações com validação automática de especificação
• Use plataformas integradas como o Apidog

Diferença entre código assistido por IA e código gerado por IA?

Código assistido por IA (Copilot, Claude Code) é criado em tempo real com supervisão humana. Código gerado por IA (Agent Smith) é produzido sem envolvimento humano em tempo real — a revisão acontece depois, aumentando o risco de violações não detectadas.

Agentes de IA vão substituir desenvolvedores de API?

Não. O Agent Smith ainda depende de definição de tarefas, revisão de código e aprovação humanas. IA aumenta produtividade, mas não substitui julgamento e contexto humanos. O papel do desenvolvedor passa a ser definir tarefas, revisar resultados e manter a coerência do sistema.

Principais conclusões

• O Agent Smith gera 25% do novo código de produção do Google de forma autônoma e assíncrona
• Isso representa uma migração de código assistido para código gerado por IA, mudando o workflow de revisão em APIs
• O desalinhamento de contrato é o principal risco quando agentes autônomos alteram endpoints e esquemas
• Design-first com OpenAPI como fonte da verdade previne quebras de contrato
• Testes de contrato com validação rigorosa capturam mudanças que unitários não pegam
• Plataformas como Apidog sincronizam especificação, testes, mocks e documentação para evitar desalinhamento
• A automação de codificação está acelerando; prepare seus fluxos de trabalho de API agora

O Agent Smith em 25% é só o começo. Equipes que construírem fluxos de API "à prova de agentes" hoje estarão prontas para adotar ferramentas autônomas com segurança amanhã.