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

Softwareonderhoud is een stille, enorme industrie die meer dan zestig procent van het wereldwijde engineeringbudget opslokt. Het is het werk van het vinden van kapotte onderdelen in complexe digitale systemen en het repareren ervan zonder de onderdelen die nog wel werken te breken. Decennialang was dit een menselijke taak, die diepgaande kennis vereiste van hoe verschillende codebestanden met elkaar communiceren. Onlangs zijn computerprogramma's die getraind zijn op enorme hoeveelheden code begonnen om dit werk zelf te proberen te doen. Deze programma's, bekend als large language models, kunnen een beschrijving van een probleem lezen en een oplossing voorstellen. Echter, wanneer deze modellen proberen echte software te repareren, hebben ze vaak moeite. Ze raken verdwaald in de enorme hoeveelheid informatie, ze maken subtiele vormfouten waardoor de computer hun werk afwijst, en ze doen dit tegen hoge financiële kosten, omdat er vaak dure cloud computing-kracht nodig is voor elke poging.

Een nieuwe studie introduceert een andere aanpak voor dit probleem, een die de voorkeur geeft aan precisie en kostenefficiëntie boven brute kracht. De onderzoekers bouwden een systeem genaamd Kronumos 2 Kairos, ontworpen om te fungeren als een chirurgisch instrument in plaats van een brede zoekmachine. In plaats van een computermodel door een codebase te laten dwalen, waarbij het herhaaldelijk gokt en controleert, dwingt dit systeem het model om zich te concentreren op een zeer specifieke, nauwe taak. Het koppelt een middelgroot, open-source computermodel aan een rigide, regelgebaseerde engine die fungeert als een strikte kwaliteitscontroleur. Het doel was om te zien of een kleiner, goedkoper model softwarebugs in echte software kon oplossen als het beschermd zou worden tegen zijn eigen neiging tot slordige fouten en als het voorkomen zou worden dat het middelen verspilt aan onnodige stappen. De onderzoekers testten dit systeem op een benchmark van vijfhonderd real-world softwareproblemen, een standaard set uitdagingen die wordt gebruikt om het vermogen van kunstmatige intelligentie om code te repareren te meten.

Het systeem werkt door de taken op te splitsen in twee duidelijke delen. Het eerste deel is de "cognitieve cortex", de computer die verantwoordelijk is voor het begrijpen van het probleem en het schrijven van de code-oplossing. Het tweede deel is de "sub-cortex", een deterministische engine geschreven in een taal die exacte, voorspelbare resultaten garandeert. Deze sub-cortex fungeert als een filter en een formatter. Voordat het model het probleem zelfs maar ziet, verwijdert de sub-cortex duizenden regels irrelevante technische ruis die de foutmeldingen meestal vervuilen. Het verwijdert gevoelige informatie zoals wachtwoorden en API-keys om de privacy te waarborgen. Vervolgens controleert het de output van het model aan de hand van de strikte regels voor hoe codepatches geschreven moeten worden. Als het model een fout maakt in de regelnummers, de inspringing of de formattering van de fix, vangt de sub-cortex dit onmiddellijk op. Het corrigeert de fout of wijst de patch volledig af, zodat er nooit gebroken of slecht geformatteerde code wordt ingediend voor testen. Dit proces voorkomt dat het systeem tijd verspilt aan pogingen die gedoemd zijn te mislukken door eenvoudige vormfouten.

De onderzoekers draaiden dit systeem tegen de vijfhonderd real-world softwareproblemen. De resultaten toonden aan dat het systeem acht van deze bugs succesvol kon oplossen. Hoewel acht van de vijfhonderd klein kan lijken, ligt de betekenis in de manier waarop het systeem dit bereikte. De onderzoekers gebruikten een model met slechts zeven miljard parameters, wat aanzienlijk kleiner is dan de enorme modellen die door commerciële bedrijven worden gebruikt en die vaak duizenden dollars aan kosten met zich meebrengen. Door hun dual-brain architectuur te gebruiken, slaagde het systeem erin deze problemen op te lossen met nul marginale kosten voor de gebruikte rekenkracht. De gemiddelde hoeveelheid data die het systeem per taak verwerkte, was net iets meer dan tweeduizend tokens, een cijfer dat drieënnegentig procent lager is dan de honderdduizenden tokens die door andere automatische reparatiesystemen gewoonlijk worden verbruikt. Deze drastische reductie in dataverbruik betekent dat het systeem veel efficiënter en schaalbaarder is dan de huidige alternatieven.

Een cruciale bevinding van de studie was het belang van de strikte kwaliteitscontrole-engine. Wanneer de onderzoekers de mogelijkheid van de sub-cortex om formatteringsfouten te herstellen na het schrijven van de code wegnamen, daalde het aantal succesvolle reparaties van acht naar zes. Dit toonde aan dat een aanzienlijk deel van de mislukkingen van het model niet te wijten was aan een gebrek aan begrip, maar aan kleine, corrigeerbare fouten in de presentatie van de code. De sub-cortex fungeerde als een vangnet, dat deze fouten opving en ervoor zorgde dat de logische oplossingen die het model vond, daadwerkelijk in een bruikbaar formaat werden geleverd. Het systeem bewees ook dat het kon opereren zonder de softwaretests zelf uit te voeren tijdens het reparatieproces. In plaats van de fix uit te proberen om te zien of het werkt, vertrouwde het systeem op zijn interne regels om te garanderen dat de fix structureel solide was voordat deze werd toegepast.

De onderzoekers evalueerden het systeem binnen vier verschillende software-ecosystemen, waaronder grote projecten zoals Django en Scikit-Learn. De acht succesvolle reparaties bestreken een verscheidenheid aan problemen, van het oplossen van een crash in een database-migratietool tot het corrigeren van een wiskundige fout in een bibliotheek voor data-analyse. In één instantie loste het systeem een bug op waarbij een programma zou crashen als een specifieke instelling ontbrak; het model identificeerde correct dat de code moest controleren op de afwezigheid van de instelling voordat deze probeerde deze te gebruiken. In een ander geval loste het een probleem op waarbij een programma per ongeluk gegevens zou wijzigen die het juist ongemoeid had moeten laten. De onderzoekers inspecteerden elke succesvolle fix handmatig om te bevestigen dat de logica correct was en dat de oplossing niet slechts een gelukkige gok was.

De onderzoekers erkennen dat hun systeem geen volledige oplossing is voor alle softwarebugs. Het model worstelt nog steeds met zeer complexe problemen die diep redeneren over veel verschillende bestanden vereisen of die abstracte concepten bevatten die buiten de trainingsomvang vallen. Echter, de studie vestigt een nieuwe baseline voor wat mogelijk is met kleinere, open-source modellen. Het laat zien dat het, door een capabel maar bescheiden computermodel te combineren met een rigide, regelgebaseerd systeem dat strikte standaarden afdwingt, mogelijk is om betrouwbare resultaten te behalen zonder de enorme kosten die gepaard gaan met de huidige state-of-the-art systemen. Het werk suggereert dat de toekomst van automatische reparatie niet afhangt van het maken van modellen oneindig groter, maar van het bouwen van betere systemen om hen te begeleiden en hun fouten te corrigeren.

Dit onderzoek biedt een duidelijk pad vooruit om automatische softwarereparatie toegankelijk en betaalbaar te maken. Door te bewijzen dat een systeem echte bugs kan oplossen met nul kosten en hoge efficiëntie, daagt de studie de opvatting uit dat alleen de duurste, krachtigste modellen dit werk kunnen doen. Het succes van de dual-brain aanpak benadrukt de waarde van het scheiden van de creatieve taak van het schrijven van code van de mechanische taak van het waarborgen dat het aan de regels voldoet. Naarmate het veld van automatische reparatie zich blijft ontwikkelen, biedt dit werk een praktisch voorbeeld van hoe men intelligentie met discipline kan balanceren, zodat de tools die we bouwen om onze software te repareren zelf ook robuust, betrouwbaar en efficiënt zijn.