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

La maintenance logicielle est une industrie discrète et massive qui consomme plus de soixante pour cent du budget mondial de l'ingénierie. C'est le travail consistant à trouver les pièces brisées dans des systèmes numériques complexes et à les réparer sans casser les parties qui fonctionnent encore. Pendant des décennies, il s'est agi d'une tâche humaine, exigeant une connaissance approfondie de la manière dont différents fichiers de code communiquent entre eux. Récemment, des programmes informatiques entraînés sur de vastes quantités de code ont commencé à tenter ce travail par eux-mêmes. Ces programmes, connus sous le nom de grands modèles de langage, peuvent lire la description d'un problème et suggérer une correction. Cependant, lorsque ces modèles tentent de réparer des logiciels réels, ils éprouvent souvent des difficultés. Ils se perdent dans le volume colossal d'informations, commettent des erreurs de formatage subtiles qui poussent l'ordinateur à rejeter leur travail, et ce, à un coût financier élevé, nécessitant souvent une puissance de calcul infonuagique coûteuse pour chaque tentative.

Une nouvelle étude introduit une approche différente à ce problème, une approche qui privilégie la précision et l'efficacité des coûts plutôt que la force brute. Les chercheurs ont construit un système appelé Kronumos 2 Kairos, conçu pour agir comme un outil chirurgical plutôt que comme un moteur de recherche large. Au lieu de laisser un modèle informatique errer à travers une base de code, en devinant et en vérifiant de manière répétée, ce système force le modèle à se concentrer sur une tâche très spécifique et étroite. Il associe un modèle informatique open-source de taille modérée à un moteur rigide, basé sur des règles, qui agit comme un inspecteur de contrôle de qualité strict. L'objectif était de voir si un modèle plus petit et moins coûteux pouvait réparer de véritables bugs logiciels si on le protégeait de sa propre tendance à commettre des erreurs de négligence et si on l'empêchait de gaspiller des ressources dans des étapes inutiles. Les chercheurs ont testé ce système sur un benchmark de cinq cents problèmes logiciels réels, un ensemble de défis standard utilisé pour mesurer la capacité de l'intelligence artificielle à réparer du code.

Le système fonctionne en divisant le travail en deux parties distinctes. La première partie est le « cortex cognitif », qui est le modèle informatique responsable de la compréhension du problème et de l'écriture de la correction du code. La seconde partie est le « sous-cortex », un moteur déterministe écrit dans un langage qui garantit un comportement exact et prévisible. Ce sous-cortex agit comme un filtre et un formateur. Avant même que le modèle ne voie le problème, le sous-cortex élimine des milliers de lignes de bruit technique non pertinent qui encombrent habituellement les messages d'erreur. Il supprime les informations sensibles telles que les mots de passe et les clés API pour garantir la confidentialité. Il prend ensuite la sortie du modèle et la vérifie par rapport aux règles strictes de la rédaction des correctifs de code. Si le modèle commet une erreur dans les numéros de ligne, l'indentation ou le formatage du correctif, le sous-cortex le détecte immédiatement. Il corrige l'erreur ou rejette entièrement le correctif, garantissant qu'aucun code brisé ou mal formé n'est jamais soumis pour test. Ce processus empêche le système de perdre du temps sur des tentatives vouées à l'échec en raison de simples erreurs de formatage.

Les chercheurs ont confronté ce système aux cinq cents problèmes logiciels réels. Les résultats ont montré que le système pouvait résoudre avec succès huit de ces bugs. Bien que huit sur cinq cents puisse paraître être un chiffre faible, la signification réside dans la manière dont le système y est parvenu. Les chercheurs ont utilisé un modèle de seulement sept milliards de paramètres, ce qui est nettement plus petit que les modèles massifs utilisés par les entreprises commerciales qui coûtent souvent des milliers de dollars à faire fonctionner. En utilisant leur architecture à double cerveau, le système a réussi à résoudre ces problèmes avec un coût marginal nul pour la puissance de calcul utilisée. La quantité moyenne de données traitées par le système pour chaque tâche était d'un peu plus de deux mille tokens, un chiffre quatre-vingt-treize pour cent inférieur aux centaines de milliers de tokens typiquement consommés par les autres systèmes de réparation automatisés. Cette réduction drastique de l'utilisation des données signifie que le système est bien plus efficace et évolutif que les alternatives actuelles.

Une conclusion critique de l'étude fut l'importance du moteur de contrôle de qualité strict. Lorsque les chercheurs ont supprimé la capacité du sous-cortex à corriger les erreurs de formatage après que le modèle a écrit le code, le nombre de réparations réussies est passé de huit à six. Cela a démontré qu'une part significative des échecs du modèle n'était pas due à un manque de compréhension, mais plutôt à des erreurs mineures et corrigeables dans la présentation du code. Le sous-cortex a agi comme un filet de sécurité, capturant ces erreurs et garantissant que les correctifs logiques trouvés par le modèle étaient réellement livrés dans un format utilisable. Le système a également prouvé qu'il pouvait fonctionner sans exécuter les tests logiciels lui-même pendant le processus de réparation. Au lieu d'essayer le correctif et de voir s'il fonctionne, le système s'est appuyé sur ses règles internes pour s'assurer que le correctif était structurellement sain avant même d'être appliqué.

L'étude a évalué le système à travers quatre écosystèmes logiciels différents, incluant des projets majeurs comme Django et Scikit-Learn. Les huit réparations réussies couvraient une variété de problèmes, allant de la correction d'un crash dans un outil de migration de base de données à la correction d'une erreur mathématique dans une bibliothèque d'analyse de données. Dans un cas, le système a corrigé un bug où un programme plantait si un paramètre spécifique manquait ; le modèle a correctement identifié que le code devait vérifier l'absence de ce paramètre avant de tenter de l'utiliser. Dans un autre cas, il a corrigé un problème où un programme modifiait accidentellement des données qu'il était censé laisser intactes. Les chercheurs ont inspecté manuellement chaque correctif réussi pour confirmer que la logique était correcte et que la solution n'était pas seulement un coup de chance.

Les chercheurs reconnaissent que leur système n'est pas une solution complète à tous les bugs logiciels. Le modèle éprouve toujours des difficultés avec des problèmes très complexes qui nécessitent un raisonnement profond à travers de nombreux fichiers différents ou qui impliquent des concepts abstraits dépassant son entraînement. Cependant, l'étude établit une nouvelle référence pour ce qui est possible avec des modèles open-source plus modestes. Elle montre qu'en combinant un modèle informatique capable mais modeste avec un système rigide basé sur des règles qui impose des normes strictes, il est possible d'obtenir des résultats fiables sans les coûts massifs associés aux systèmes de pointe actuels. Le travail suggère que l'avenir de la réparation automatisée ne dépendra peut-être pas de la création de modèles infiniment plus grands, mais de la construction de meilleurs systèmes pour les guider et corriger leurs erreurs.

Cette recherche offre une voie claire pour rendre la réparation logicielle automatisée accessible et abordable. En prouvant qu'un système peut réparer de vrais bugs avec un coût nul et une grande efficacité, l'étude remet en question l'idée que seuls les modèles les plus coûteux et les plus puissants peuvent accomplir ce travail. Le succès de l'approche à double cerveau souligne la valeur de la séparation entre la tâche créative de l'écriture de code et la tâche mécanique de s'assurer qu'elle respecte les règles. Alors que le domaine de la réparation automatisée continue d'évoluer, ce travail offre un exemple pratique de la façon de équilibrer l'intelligence et la discipline, garantissant que les outils que nous construisons pour réparer nos logiciels sont eux-mêmes robustes, fiables et efficaces.