SAGE: A Self-Adaptive Agentic Framework for Execution-Guided Code Generation and Self-Repair
Este artigo apresenta o SAGE, um framework multiagente autoadaptável que melhora significativamente a confiabilidade da geração de projetos de múltiplos arquivos executáveis ao empregar um ciclo de controle MAPE-K de malha fechada para executar código iterativamente, analisar erros de tempo de execução e realizar autorreparo, alcançando assim um aumento estatisticamente significativo nas taxas de sucesso em comparação com a geração de passagem única.
Artigo original sob licença CC BY 4.0 (https://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 que você está tentando ensinar um robô brilhante, mas levemente distraído, a construir um castelo de LEGO complexo. Você dá ao robô uma instrução simples: "Construa um castelo com um fosso e uma ponte levadiça". O robô, treinado em milhões de imagens de castelos, pode instantaneamente montar uma estrutura que parece perfeita. Mas, se você tentar puxar a ponte levadiça, ela pode se soltar porque o robô usou uma peça que foi descontinuada anos atrás, ou porque ele esqueceu de colar a base ao chão. No mundo da ciência da computação, este é o desafio dos "Large Language Models" (LLMs - Modelos de Linguagem de Grande Escala). Estes são sistemas de IA que são incrivelmente bons em escrever pequenos pedaços de código, como uma única função, mas frequentemente têm dificuldade quando solicitados a construir um projeto de software completo e funcional do zero. Eles podem esquecer de instalar ferramentas necessárias, usar instruções obsoletas ou criar um programa que parece correto no papel, mas que trava no momento em que você tenta executá-lo.
Por muito tempo, a solução foi apenas pedir ao robô para tentar novamente, esperando que ele acerte de primeira. Mas este artigo introduz uma abordagem mais inteligente: em vez de apenas adivinhar, deixe o robô realmente construir o castelo, tente abrir a ponte levadiça e, se ela quebrar, conserte-a imediatamente. Esta é a ideia central da "autocorreção guiada por execução" (execution-guided self-repair). É como ter um inspetor de controle de qualidade que não olha apenas para as plantas, mas que realmente tenta usar o produto. Se o produto falha, o inspetor diz ao constrím ao construtor exatamente o que deu errado, e o construtor o conserta. Este ciclo de construir, testar e consertar continua até que o projeto funcione perfeitamente. A grande questão que os pesquisadores têm feito é: este loop de "tentar, falhar, consertar" realmente torna a IA muito melhor em construir softwares complexos, ou faz apenas o robô girar em círculos e se confundir?
O pesquisador por trás deste estudo, Harshil Lodhiya, criou um novo sistema chamado SAGE (Self-Adaptive Agentic Framework for Execution-Guided Code Generation and Self-Repair) para responder a essa pergunta. Pense no SAGE como uma pequena equipe de construção automatizada com quatro funções distintas trabalhando em um loop. Primeiro, um Planejador (Planner) decompõe seu grande objetivo em um checklist detalhado. Segundo, um Programador (Coder) constrói os arquivos com base nessa lista. Terceiro, um Validador (Validator) atua como o inspetor rigoroso: ele prepara uma oficina limpa e isolada, instala as ferramentas necessárias e tenta executar o programa. Se o programa travar ou falhar em fazer o que deveria fazer, o Validador não desiste; ele envia a mensagem de erro para um quarto membro, o Agente de Feedback (Feedback Agent). Este agente atua como um detetive, lendo o relatório de erro e dizendo ao Programador exatamente qual arquivo alterar e como consertá-lo. O Programador então faz o reparo, e toda a equipe tenta novamente. Este ciclo se repete até que o projeto seja executado com sucesso ou que eles esgotem as tentativas.
A equipe testou o SAGE em um conjunto especial de 15 tarefas complicadas que eles desenharam especificamente para enganar a IA, como usar comandos de bibliotecas antigas que não existem mais ou esquecer um arquivo de saída obrigatório. Eles compararam o loop de "conserto" do SAGE contra uma IA padrão que apenas tenta construir o projeto uma vez e espera pelo melhor. Os resultados foram claros: o loop de autocorreção fez uma enorme diferença. Ao usar um modelo de IA forte (gpt-4.1-mini), a abordagem padrão de "tentativa única" (one-shot) teve sucesso em cerca de 69,3% dos casos. Mas quando adicionaram o loop de reparo do SAGE, a taxa de sucesso saltou para 92,0%. Isso é um aumento de 22,7 pontos percentuais, o que o pesquisador afirma ser um ganho significativo e relevante. Essencialmente, o loop resgatou tarefas que a IA teria falhado completamente, como corrigir um código que tentava usar um apelido de frequência de "mês" que havia sido removido de uma biblioteca de dados popular.
No entanto, o artigo também testou uma versão mais agressiva da ideia. Eles se perguntaram: e se a IA não apenas corrigisse falhas, mas também verificasse se o programa está perfeitamente completo, mesmo que não apresente erros? Por exemplo, se um programa deveria gerar um arquivo de relatório, mas terminou sem erro, apenas sem criar o arquivo, a IA detectaria isso? Eles construíram um sistema "consciente da correção" (correctness-aware) para fazer isso. Surpreendentemente, esse rigor extra não ajudou muito. A taxa de sucesso subiu apenas um pouco, 2,7 pontos (para 94,7%), e o pesquisador descobriu que essa diferença não era estatisticamente significativa. Na verdade, a verificação extra às vezes causava o "super-conserto" (over-fix) de coisas, quebrando programas que já estavam funcionando bem. A lição aqui é que, embora dizer à IA exatamente o que o sucesso significa seja útil, forçá-la constantemente a re-verificar e re-consertar pode, na verdade, torná-la pior.
Em resumo, o artigo mostra que dar à IA um loop de "tentar, falhar, consertar" é uma maneira poderosa de construir softwares funcionais, transformando uma taxa de sucesso de cerca de 69,3% em 92,0%. Ele prova que permitir que a IA veja seus próprios erros em um ambiente real e isolado é a chave para desbloquear seu potencial para projetos complexos. Mas também nos alerta que ser perfeccionista demais pode ser contraproducente; às vezes, é melhor deixar a IA consertar os grandes erros e deixar o resto em paz. O pesquisador disponibilizou seu código e seu conjunto de testes para que qualquer pessoa possa usar, esperando ajudar outros a construir softwares que possam se curar sozinhos.
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.