Kronumos 2 Kairos: Cost-Bounded Automated Program Repair via Dual-Brain Cybernetic Sub-Cortex on SWE-bench Verified

A manutenção de software é uma indústria silenciosa e massiva que consome mais de sessenta por cento do orçamento global de engenharia. É o trabalho de encontrar peças quebradas em sistemas digitais complexos e consertá-las sem quebrar as partes que ainda funcionam. Por décadas, esta tem sido uma tarefa humana, exigindo um conhecimento profundo de como diferentes arquivos de código conversam entre si. Recentemente, programas de computador treinados em vastas quantidades de código começaram a tentar realizar este trabalho por conta própria. Esses programas, conhecidos como modelos de linguagem de grande escala, podem ler uma descrição de um problema e sugerir uma correção. No entanto, quando esses modelos tentam consertar softwares do mundo real, eles frequentemente enfrentam dificuldades. Eles se perdem no volume colossal de informações, cometem erros sutis de formatação que fazem com que o computador rejeite seu trabalho e o fazem a um alto custo financeiro, muitas vezes exigindo caro poder de computação em nuvem para cada tentativa.

Um novo estudo introduz uma abordagem diferente para este problema, uma que prioriza a precisão e a eficiência de custos em vez da força bruta. Os pesquisadores construíram um sistema chamado Kronumos 2 Kairos, projetado para agir como uma ferramenta cirúrgica em vez de um mecanismo de busca amplo. Em vez de deixar um modelo de computador vagar por uma base de código, adivinhando e testando repetidamente, este sistema força o modelo a focar em uma tarefa muito específica e estreita. Ele combina um modelo de computador de tamanho moderado e de código aberto com um motor baseado em regras rígidas que atua como um inspetor de controle de qualidade rigoroso. O objetivo era ver se um modelo menor e mais barato poderia consertar bugs reais de software se fosse protegido de sua própria tendência a cometer erros descuidados e se fosse impedido de desperdiçar recursos em etapas desnecessárias. Os pesquisadores testaram este sistema em um benchmark de quinhentos problemas de software do mundo real, um conjunto padrão de desafios usado para medir a capacidade da inteligência artificial de reparar código.

O sistema opera dividindo o trabalho em duas partes distintas. A primeira parte é o "córtex cognitivo", que é o modelo de computador responsável por entender o problema e escrever a correção do código. A segunda parte é o "subcórtex", um motor determinístico escrito em uma linguagem que garante um comportamento exato e previsível. Este subcórtex atua como um filtro e um formatador. Antes mesmo de o modelo ver o problema, o subcórtex remove milhares de linhas de ruído técnico irrelevante que geralmente poluem as mensagens de erro. Ele remove informações sensíveis, como senhas e chaves de API, para garantir a privacidade. Em seguida, ele pega a saída do modelo e a verifica contra as regras estritas de como os patches de código devem ser escritos. Se o modelo cometer um erro nos números das linhas, na indentação ou na formatação da correção, o subcórtex o detecta imediatamente. Ele ou corrige o erro ou rejeita o patch inteiramente, garantindo que nenhum código quebrado ou malformado seja enviado para teste. Este processo evita que o sistema perca tempo com tentativas que estão fadadas ao fracasso devido a simples erros de formatação.

Os pesquisadores rodaram este sistema contra os quinhentos problemas de software do mundo real. Os resultados mostraram que o sistema conseguiu resolver oito desses bugs. Embora oito de quinhentos possa parecer um número pequeno, a significância reside em como o sistema alcançou isso. Os pesquisadores usaram um modelo com apenas sete bilhões de parâmetros, que é significativamente menor do que os modelos massivos usados por empresas comerciais que frequentemente custam milhares de dólares para rodar. Ao usar sua arquitetura de cérebro duplo, o sistema conseguiu resolver esses problemas com custo marginal zero para o poder de computação utilizado. A quantidade média de dados que o sistema processou para cada tarefa foi de pouco mais de dois mil tokens, um número noventa e três por cento menor do que os centenas de milhares de tokens tipicamente consumidos por outros sistemas de reparo automatizado. Essa redução drástica no uso de dados significa que o sistema é muito mais eficiente e escalável do que as alternativas atuais.

Uma descoberta crítica do estudo foi a importância do motor de controle de qualidade rigoroso. Quando os pesquisadores removeram a capacidade do subcórtex de corrigir erros de formatação após o modelo escrever o código, o número de reparos bem-sucedidos caiu de oito para seis. Isso demonstrou que uma parte significativa das falhas do modelo não se devia à falta de compreensão, mas sim a erros menores e corrigíveis na forma como o código era apresentado. O subcórtex atuou como uma rede de segurança, capturando esses erros e garantindo que as correções lógicas encontradas pelo modelo fossem de fato entregues em um formato utilizável. O sistema também provou que poderia operar sem executar os testes de software durante o processo de reparo. Em vez de tentar a correção e ver se ela funciona, o sistema baseou-se em suas regras internas para garantir que a correção fosse estruturalmente sólida antes mesmo de ser aplicada.

O estudo avaliou o sistema através de quatro ecossistemas de software diferentes, incluindo projetos importantes como Django e Scikit-Learn. Os oito reparos bem-sucedidos cobriram uma variedade de problemas, desde corrigir um erro de travamento em uma ferramenta de migração de banco de dados até corrigir um erro matemático em uma biblioteca de análise de dados. Em um caso, o sistema corrigiu um bug onde um programa travava se uma configuração específica estivesse ausente; o modelo identificou corretamente que o código precisava verificar a ausência dessa configuração antes de tentar usá-la. Em outro caso, ele corrigiu um problema onde um programa acidentalmente alterava dados que deveria manter intactos. Os pesquisadores inspecionaram manualmente cada correção bem-sucedida para confirmar que a lógica estava correta e que a solução não era apenas um palpite de sorte.

Os pesquisadores reconhecem que seu sistema não é uma solução completa para todos os bugs de software. O modelo ainda tem dificuldades com problemas muito complexos que exigem raciocínio profundo através de muitos arquivos diferentes ou que envolvem conceitos abstratos além de seu treinamento. No entanto, o estudo estabelece uma nova base para o que é possível com modelos menores e de código aberto. Ele mostra que, ao combinar um modelo de computador capaz, porém modesto, com um sistema baseado em regras rígidas que impõe padrões estritos, é possível alcançar resultados confiáveis sem os custos massivos associados aos sistemas de ponta atuais. O trabalho sugere que o futuro do reparo automatizado pode não depender de tornar os modelos infinitamente maiores, mas de construir melhores sistemas para guiá-los e capturar seus erros.

Esta pesquisa fornece um caminho claro para tornar o reparo de software automatizado acessível e econômico. Ao provar que um sistema pode consertar bugs reais com custo zero e alta eficiência, o estudo desafia a noção de que apenas os modelos mais caros e poderosos podem realizar este trabalho. O sucesso da abordagem de cérebro duplo destaca o valor de separar a tarefa criativa de escrever código da tarefa mecânica de garantir que ele siga as regras. À medida que o campo do reparo automatizado continua a evoluir, este trabalho oferece um exemplo prático de como equilibrar inteligência com disciplina, garantindo que as ferramentas que construímos para consertar nosso software sejam, elas mesmas, robustas, confiáveis e eficientes.