Don't Blame the Large Language Model: How Agent Harness Evolution Shapes Coding Agent Quality
Este artigo apresenta o primeiro estudo longitudinal controlado demonstrando que a rápida evolução dos sistemas de controle (harnesses) dos agentes, em vez dos modelos de linguagem de grande escala subjacentes, é o principal motor das flutuações de qualidade em agentes de codificação, conforme evidenciado por uma análise profunda de 35 lançamentos sequenciais do Qwen Code CLI.
Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo
Imagine um mundo onde o seu computador não apenas espera que você digite comandos, mas realmente faz o trabalho por você. Esta é a era dos "agentes de codificação" — programas inteligentes e autônomos que podem ler código, corrigir bugs e até escrever novos softwares por conta própria. Mas aqui está o ingrediente secreto: esses agentes não são apenas o cérebro (o modelo de IA gigante); eles também precisam de um corpo e de um sistema nervoso para funcionar. Esse corpo é chamado de "harness do agente" (ou estrutura do agente). Pense no modelo de IA como um gênio brilhante, mas preguiçoso, que precisa de um gerente para lhe entregar as ferramentas certas, lembrá-lo das regras e organizar seus pensamentos. O harness é esse gerente. Ele decide quais ferramentas a IA pode usar, quanta informação mostrar a ela e como retornar e tentar novamente se a primeira tentativa falhar. Todos assumem que, se continuarem contratando melhores gerentes e atualizando o escritório, o gênio ficará mais inteligente e trabalhará mais rápido. Mas e se o gerente estiver, na verdade, piorando as coisas ao adicionar regras demais ou instruções confusas? Essa é a grande pergunta que este artigo faz: à medida que esses sistemas "gerentes" são atualizados constantemente, eles estão realmente ajudando a IA a fazer um trabalho melhor ou estão apenas tornando-a mais lenta e cara?
Os autores deste artigo decidiram brincar de detetive para resolver um mistério do qual os desenvolvedores de software têm se queixado. Eles notaram que, sempre que esses agentes de codificação recebiam uma atualização, eles frequentemente começavam a cometer mais erros ou levavam muito mais tempo para concluir as tarefas. As pessoas geralmente culpavam o próprio cére-IA, pensando que o modelo havia ficado mais burro. Os pesquisadores suspeitavam que o verdadeiro culpado era o "gerente" (o harness) mudando de ideia com muita frequência. Para provar isso, eles montaram um experimento muito rigoroso. Eles escolheram um modelo de IA específico e o trancaram em uma gaiola para que ele não pudesse mudar nada. Então, pegaram o software "gerente" (especificamente o Qwen Code CLI) e o rodaram através de 35 versões diferentes, desde o primeiro lançamento até o mais recente. Para cada versão, deram ao agente 50 enigmas de codificação do mundo real para resolver, usando exatamente o mesmo cérebro de IA todas as vezes.
Os resultados foram surpreendentes e um pouco engraçados. Apesar de o software "gerente" ser atualizado constantemente — às vezes lançando novas versões mais de duas vezes por dia — a capacidade da IA de realmente resolver os enigmas não melhorou nada. Na verdade, a taxa de sucesso permaneceu praticamente a mesma, pairando em torno de 30%, não importa quantas vezes eles atualizassem o software. As primeiras versões eram tão boas para corrigir bugs quanto as versões novas e complicadas. No entanto, havia um grande porém: as versões mais recentes eram incrivelmente dispendiosas. As versões mais recentes do gerente faziam a IA usar quase o dobro de "tokens" (que são como o combustível ou a moeda que a IA queima para pensar) e faziam o dobro de chamadas de ferramentas em relação às versões antigas. Era como atualizar o motor de um carro para uma versão supercomplexa que usa o dobro de gasolina, mas não faz o carro andar mais rápido.
Os pesquisadores investigaram mais a fundo para descobrir por que isso estava acontecendo. Eles analisaram as mudanças no código do software gerente e descobriram que, quando os desenvolvedores adicionavam muitos novos recursos ou tentavam corrigir muitos pequenos bugs ao mesmo tempo, a IA ficava confusa e desperdiçava mais energia. Eles também descobriram que certas partes do "corpo" do gerente eram perigosas de tocar. Alterar a forma como a IA fala com seu céreão (a camada "LLM Provider") ou como ela se lembra das coisas (a camada "Context Management") frequentemente fazia o agente tropeçar e falhar. Por outro lado, corrigir brechas de segurança ou adicionar extensões simples parecia seguro. O maior choque? A equipe de software não tinha como saber que esses problemas estavam ocorrendo. Seus testes automáticos verificavam apenas se o software travava, não se a IA estava realmente fazendo um bom trabalho ou desperdiçando dinheiro. Era como uma fábrica que só verifica se a linha de montagem está se movendo, mas nunca verifica se os carros que saem dela realmente têm rodas.
No fim, o artigo sugere que precisamos parar de culpar o cérebro da IA por esses erros. O problema real é que o software "gerente" está evoluindo rápido demais sem uma verificação de qualidade adequada. Os desenvolvedores estão adicionando tantos recursos e mudanças que a IA fica sobrecarregada, usando mais recursos para alcançar exatamente os mesmos resultados de antes. Os autores pedem um novo tipo de "garantia de qualidade" que verifique especificamente se o agente ainda é eficiente e eficaz após cada atualização, em vez de apenas verificar se ele ainda liga. Até lá, atualizar esses agentes de codificação pode ser apenas pagar mais pelo mesmo desempenho.
Afogado em artigos na sua área?
Receba digests diários dos artigos mais recentes que correspondam às suas palavras-chave de pesquisa — com resumos técnicos, no seu idioma.