A Guerra dos Assistentes de Código: O Que a Infraestrutura Realmente Precisa Suportar

A corrida dos assistentes de AI para programação entrou numa fase nova. Com Claude Code, Codex e Gemini CLI já testados por desenvolvedores ao redor do mundo, a pergunta já não é se essas ferramentas funcionam — é como把它们规模化 sem estourar o orçamento ou criar uma latência que faça o desenvolvedor querer arremessar o teclado pela janela.

Um estudo interessante do laboratório SyFI da Universidade de Washington traz números concretos sobre como as cargas de trabalho reais dos agentes de programação funcionam. E os resultados podem te surpreender: spoiler, sua infraestrutura de inference provavelmente não está otimizada para isso.

A Revolução Autônoma que Ninguém Previu

Aqui está algo que parece óbvio depois que alguém fala: agentes de código não apenas respondem perguntas. Eles executam planos. Quando você pede para um assistente criar uma funcionalidade ou corrigir um bug, não está iniciando uma simples transação pergunta-resposta — está desencadeando um fluxo autônomo onde o modelo vai raciocinar, executar comandos shell, ler e modificar arquivos, rodar testes e iterar até ficar satisfeito (ou até você interromper).

Os pesquisadores capturaram mais de 4.300 sessões reais totalizando aproximadamente 55 bilhões de tokens. Os padrões são marcantes. Cada solicitação do usuário dispara em média 8,8 ciclos de ferramentas LLM antes de completar. Pense nisso: para cada pergunta que um desenvolvedor faz, são quase nove rodadas de geração do modelo seguida de execução de ferramenta. O modelo não está apenas falando — está agindo. E 88% de todas as rodadas de inference acontecem não em resposta à entrada do usuário, mas em resposta aos resultados das ferramentas.

Isso tem implicações enormes para planejamento de throughput. Chatbots tradicionais são essencialmente sistemas request-response com eventuais complementos. Agentes de código são mais parecido com processos autônomos de longa duração com alternância frequente entre fases de geração e execução. Suas políticas de autoscaling, sua fila de requests, suas estratégias de caching — tudo isso precisa ser repensado através da lente de fluxos de trabalho autônomos de múltiplas etapas.

A Assimetria de Input-Output que Está Quebrando Seu Cache

Aqui está um número que deveria fazer qualquer engenheiro de infraestrutura pensar duas vezes: inputs superam outputs numa proporção de 294 para 1. Nas traces analisadas, modelos leram 52,56 bilhões de tokens de input em cache e preencheu 2,34 bilhões de novos, porém geraram apenas 186,9 milhões de tokens de output. Uma rodada típica trabalha com um prefixo de 32K a 256K tokens e adiciona apenas algumas centenas a alguns milhares antes de decodificar algumas centenas de saída.

Isso cria um perfil de performance fundamentalmente diferente do que a maioria dos sistemas de serving de LLM está otimizada. Inference tradicional de modelos de linguagem foca heavily em throughput de geração — quantos tokens por segundo conseguimos produzir? Mas para agentes de código, o gargalo frequentemente não é a velocidade de decoding; é o time-to-first-token (TTFT) depois que a execução da ferramenta retorna. A equipe descobriu que o TTFT do Codex para cada passo fica em torno de 3,1 segundos, o que representa aproximadamente 25% do tempo total de geração de uma rodada. Quando você está fazendo nove rodadas por request, essa overhead se compõe rápido.

A história do caching também é mais nuanced do que parece à primeira vista. Sim, input caching (prefill caching) ajuda com o contexto massivo que agentes de código carregam. Mas a workload de prefill é dividida entre tokens em cache e tokens novos que precisam de computação real. Prefills curtos e incrementais após execução de ferramentas têm características de performance diferentes do carregamento inicial de long-context. Sistemas de serving precisam lidar com ambos de forma eficiente, e as estratégias ótimas podem diferir entre esses casos.

Comandos Shell Continuam Dominando

Se você achava que agentes de código estariam fazendo raciocínio sofisticado e refatoração complexa, não estava errado — mas a realidade é mais bagunçada. Dos 433.000 chiamadas de ferramentas capturadas nas traces, 76% eram execuções de shell ou comandos. Rodar builds, testes, operações git, manipulação de arquivos através de ferramentas CLI — o trabalho ingrato que compõe o fluxo diário real do desenvolvimento de software.

Edições de arquivos ficaram em 11%, leituras de arquivos e buscas em 9%, com planejamento, delegação para sub-agentes e pesquisas web formando o restante. Essa concentração em comandos shell importa por várias razões. Primeiro, estas são operações de cauda longa: um simples ls é rápido, mas rodar uma suíte completa de testes ou compilar uma base de código grande pode levar minutos. A distribuição de latência se estende por quatro ordens de magnitude, o que faz planejamento de capacidade virar um pesadelo.

Segundo, o vocabulário de ferramentas varia significativamente entre agentes. Claude Code usou 54 ferramentas diferentes enquanto Codex usou 31, mas ambos concentraram a vasta maioria do volume no mesmo conjunto principal — shell, edições de arquivo, leituras de arquivo. Isso sugere que otimizar para essas ferramentas de alta frequência poderia gerar melhorias desproporcionais, mesmo sem abordar todo o ecossistema de ferramentas.

O Que Isso Significa Para Sua Infraestrutura

Se você está construindo ou operando ferramentas de desenvolvimento alimentadas por AI, essa pesquisa aponta para várias conclusões concretas.

Pense em fluxos de trabalho, não em requests. Sua infraestrutura de serving precisa considerar a natureza autônoma e de múltiplas etapas dos agentes de código. Isso significa contextos de request mais longos, gerenciamento de estado mais sofisticado e oportunidades de batch scheduling que agrupam chamadas de ferramentas relacionadas.

Otimize para os gaps de ociosidade. Usuários passam em média 46,7 minutos entre requests, apesar de um tempo de reflexão mediano de apenas 1,4 minutos. A distribuição é extremamente de cauda pesada — alguns desenvolvedores iteram rapidamente enquanto outros iniciam um request e voltam horas depois. Prefetching inteligente e estratégias de re-prefill durante esses períodos de ociosidade poderiam reduzir dramaticamente a latência percebida sem aumentar custos de compute.

Separe seus caminhos de prefill e decode. A proporção de 294:1 entre input e output significa que sua computação de prefill provavelmente é seu custo dominante. Prefills incrementais após execução de ferramentas precisam de otimização diferente do carregamento inicial de contexto. Considere pools de recursos separados ou políticas de scheduling para esses tipos diferentes de workload.

Não esqueça da infraestrutura de execução de ferramentas. Quando 76% da atividade do agente são comandos shell, sua orquestração de containers, padrões de acesso a filesystem e caching de ferramentas de build se tornam preocupações de primeira classe para serving de agentes AI. A inference do modelo é apenas parte do pipeline.

O Caminho à Frente

A equipe do TraceLab open sourceou seu pipeline de coleta e análise de traces, tornando possível para equipes de infraestrutura gerar suas próprias traces e otimizar para padrões de uso reais ao invés de benchmarks sintéticos. Esse tipo de dado do mundo real é exatamente o que o espaço de infraestrutura AI precisa enquanto amadurece de "fazer funcionar" para "fazer funcionar em escala."

Para a comunidade NameOcean Vibe Hosting, esses insights destacam por que estamos investindo em infraestrutura que vai além da simples alocação de GPU. Servir agentes de código AI não é apenas sobre compute bruto — é sobre entender as características únicas de workloads agentic e construir sistemas que possam lidar com a realidade autônoma, multi-step e intensiva em ferramentas de como desenvolvedores realmente usam essas ferramentas.

A era do agente de código está apenas começando, e as decisões de infraestrutura que tomamos hoje vão moldar quão eficientemente essas ferramentas servem desenvolvedores nos anos que vêm.