AgentForge: Execution-Grounded Multi-Agent LLM Framework for Autonomous Software Engineering

1. O Problema

Os Grandes Modelos de Linguagem (LLMs) demonstram alta proficiência na geração de código, mas falham consistentemente em tarefas de engenharia de software do mundo real devido à incapacidade de verificar a correção funcional.

• Limitações Atuais: A maioria dos sistemas trata a geração de código como um problema de previsão de um único passo (prompt para conclusão), sem mecanismos robustos de verificação.
• Falta de Execução Real: Sistemas multi-agente existentes frequentemente simulam a execução ou deixam a verificação como opcional. Isso introduz erros sistemáticos e impede a detecção de regressões, pois os modelos não recebem feedback baseado no comportamento real do programa.
• Necessidade: É necessário um ciclo de feedback onde a correção seja definida pela execução real do programa em um ambiente isolado, e não apenas pela probabilidade de tokens gerados pelo modelo.

2. Metodologia: O Framework AgentForge

O AgentForge é um framework multi-agente que formaliza a engenharia de software assistida por LLMs como um processo iterativo de refinamento baseado em execução. O sistema opera sob o princípio de que toda alteração de código deve sobreviver a uma execução em um "sandbox" (ambiente isolado) antes de ser propagada.

Arquitetura e Agentes

O sistema decompõe o processo de correção de bugs em cinco agentes especializados, coordenados por um orquestrador central:

1. Planner (Planejador): Gera um plano de execução estruturado, recuperando contexto de memória episódica (tarefas anteriores) e do índice do repositório atual.
2. Coder (Codificador): Produz patches mínimos (usando unified diffs) ou implementações completas, preservando linhas não alteradas para reduzir a superfície de erro.
3. Tester (Testador): Sintetiza casos de teste executáveis (pytest) cobrindo casos de uso, bordas e exceções.
4. Debugger (Depurador): Recebe o código e o feedback de execução (erros, stdout, stderr) e itera para corrigir falhas. Este ciclo repete-se até um limite de tentativas (padrão: 3).
5. Critic (Crítico): Avalia o resultado final e decide se o patch é válido, armazenando o sucesso na memória episódica para futuras recuperações.

Mecanismos Chave

• Execução em Sandbox (Docker): Todo código gerado é executado dentro de um container Docker descartável, com restrições rigorosas (512 MB de RAM, 0.5 CPU, sem rede). Isso fornece feedback de execução "grounded" (baseado na realidade), eliminando alucinações de simulação.
• Recuperação Dupla (Dual Retrieval): O sistema utiliza duas fontes de contexto:
  1. Memória Episódica: Tarefas e patches bem-sucedidos anteriores (armazenados em ChromaDB).
  2. Índice do Repositório: Arquivos relevantes do repositório atual, recuperados semanticamente para garantir que o planejamento seja fundamentado no código existente.
• Formulação MDP: O processo é modelado como um Processo de Decisão de Markov (MDP), onde o estado é o repositório e a recompensa é baseada nos resultados dos testes (passar/falhar).

3. Contribuições Principais

1. Verificação Baseada em Execução: Introduz a execução em sandbox como um princípio de primeira classe, onde a correção é definida por testes externos e não por sinais internos de probabilidade do modelo.
2. Decomposição de Papéis: Demonstra que separar as funções de geração, teste e depuração em agentes distintos reduz a acumulação de erros em comparação com a auto-correção monolítica.
3. Formalização Teórica: Estabelece proposições teóricas provando que o sinal de execução tem menor variância e maior fidelidade do que a probabilidade de likelihood do modelo, e que a decomposição melhora a taxa de sucesso se a redução de erro por agente superar o risco de falha em cadeia.
4. Framework Open-Source: Disponibiliza o código completo e os resultados reprodutíveis.

4. Resultados Experimentais

Os experimentos foram conduzidos no benchmark SWE-bench Lite (300 problemas reais do GitHub em repositórios Python como Django, Flask, NumPy).

• Desempenho Geral:
  • O AgentForge alcançou uma taxa de resolução de 40,0%.
  • Superou a linha de base de agente único (GPT-4o) em 26 pontos percentuais (14,0%).
  • Superou o framework ReAct (GPT-4o) em 28 pontos percentuais (12,0%).
  • Superou o SWE-agent (18,1%) em mais de 20 pontos.
• Estudo de Ablação:
  • A remoção de qualquer agente reduz o desempenho.
  • A remoção do Planner causou a maior queda (caindo para 19,0%), confirmando que a estrutura e o planejamento são essenciais.
  • O loop Tester-Debugger foi identificado como o principal motor de ganhos de desempenho.
• Análise de Erros:
  • A principal causa de falha (40%) foi a localização incorreta (identificar o arquivo ou linha errada), indicando que a compreensão da estrutura de dependências do repositório é o próximo gargalo a ser superado.
  • O sistema mostrou retornos decrescentes após 2 tentativas de depuração.
• Custo:
  • O pipeline completo custa aproximadamente 2,7x mais que um agente único, mas oferece uma eficiência de amostragem muito superior, resolvendo mais problemas por tarefa.

5. Significado e Implicações

O trabalho demonstra que, para engenharia de software autônoma, o design do pipeline estruturado e o feedback de execução verificada são mais importantes do que apenas escalar o tamanho do modelo.

• Mudança de Paradigma: Move a pesquisa de "gerar código perfeito de primeira" para "iterar até a correção baseada em evidências reais".
• Segurança e Confiabilidade: O uso obrigatório de sandbox mitiga riscos de execução de código malicioso ou inseguro durante o processo de desenvolvimento.
• Futuro: O trabalho aponta para a necessidade de melhor raciocínio sobre dependências multi-arquivo e síntese de testes mais robusta para superar os atuais limites de localização de bugs.

Em resumo, o AgentForge estabelece um novo padrão para sistemas multi-agentes em engenharia de software, provando que a integração rigorosa de execução real e especialização de papéis é a chave para resolver problemas complexos de código.