SAGE: A Self-Adaptive Agentic Framework for Execution-Guided Code Generation and Self-Repair
Dit artikel introduceert SAGE, een zelfadaptief multi-agent framework dat de betrouwbaarheid van het genereren van uitvoerbare projecten met meerdere bestanden aanzienlijk verbetert door een gesloten MAPE-K controlecyclus te hanteren om iteratief code uit te voeren, runtimefouten te analyseren en zelfherstel uit te voeren, waardoor een statistisch significante toename in succespercentages wordt bereikt vergeleken met single-pass generatie.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Stel je voor dat je een briljante maar ietwat afwezige robot probeert te leren hoe hij een complex LEGO-kasteel moet bouwen. Je geeft de robot een eenvoudige instructie: "Bouw een kasteel met een gracht en een ophaalbrug." Een robot die getraind is op miljoenen foto's van kastelen, kan direct een structuur in elkaar klikken die er perfect uitziet. Maar als je probeat de ophaalbrug op te trekken, kan hij eraf breken omdat de robot een stuk heeft gebruikt dat jaren geleden uit productie is gegaan, of omdat hij vergeten is de basis aan de grond te lijmen. In de wereld van de informatica is dit de uitdaging van "Large Language Models" (LLM's). Dit zijn AI-systemen die ongelooflijk goed zijn in het schrijven van kleine stukjes code, zoals een enkele functie, maar ze worstelen vaak wanneer ze wordt gevraagd om vanaf nul een heel, werkend softwareproject te bouwen. Ze kunnen vergeten de benodigde tools te installeren, verouderde instructies gebruiken, of een programma maken dat er op papier correct uitziet, maar crasht op het moment dat je het probeert uit te voeren.
Lange tijd was de oplossing om de robot gewoon opnieuw te laten proberen, in de hoop dat hij het de eerste keer goed zou doen. Maar dit artikel introduceert een slimmere aanpak: in plaats van alleen maar te gokken, laat je de robot het kasteel daadwerkelijk bouwen, probeer de ophaalbrug te openen, en als hij breekt, herstel hem dan onmiddellijk. Dit is de kern van "execution-guided self-repair" (op uitvoering gebaseerde zelfreparatie). Het is als het hebben van een kwaliteitscontroleur die niet alleen naar de blauwdrukken kijkt, maar ook daadwerkelijk probeert het product te gebruiken. Als het product faalt, vertelt de inspecteur de bouwer precies wat er misging, en de bouwer repareert het. Deze cyclus van bouwen, testen en repareren gaat door totdat het project perfect werkt. De grote vraag die onderzoekers zich hebben gesteld is: maakt deze "probeer, faal, herstel"-loop de AI echt veel beter in het bouwen van complexe software, of zorgt het er alleen maar voor dat de robot met zijn wielen in de modder blijft draaien en in de war raakt?
De onderzoeker achter deze studie, Harshil Lodhiya, creëerde een nieuw systeem genaamd SAGE (Self-Adaptive Agentic Framework for Execution-Guided Code Generation and Self-Repair) om die vraag te beantwoorden. Denk aan SAGE als een kleine, geautomatiseerde bouwploeg met vier verschillende rollen die in een lus werken. Ten eerste breekt een Planner je grote doel af in een gedetailleerde checklist. Ten tweede bouwt een Coder de bestanden op basis van die lijst. Ten derde fungeert een Validator als de strenge inspecteur: het zet een schone, geïsoleerde werkplaats op, installeert de benodigde tools en probeert het programma uit te voeren. Als het programma crasht of niet doet wat het had moeten doen, geeft de Validator niet zomaar op; het stuurt de foutmelding naar een vierde lid, de Feedback Agent. Deze agent werkt als een detective, leest het foutrapport en vertelt de Coder precies welk bestand hij moet aanpassen en hoe hij het moet repareren. De Coder voert vervolgens de reparatie uit, en het hele team probeert het opnieuw. Deze cyclus herhaalt zich totdat het project succesvol wordt uitgevoerd of ze een aantal pogingen hebben verbruikt.
Het team heeft SAGE getest op een speciale set van 15 lastige taken die ze specif으로 hebben ontworpen om AI in de val te lokken, zoals het gebruik van oude bibliotheekcommando's die niet meer bestaan of het missen van een vereist uitvoerbestand. Ze vergeleken SAGE's "fix-it"-lus met een standaard AI die gewoon probeert het project één keer te bouwen en het beste ermee hoopt. De resultaten waren duidelijk: de zelfreparatie-lus maakte een enorm verschil. Wanneer een sterk AI-model (gpt-4.1-mini) werd gebruikt, slaagde de standaard "one-shot"-aanpak in ongeveer 69,3% van de gevallen. Maar wanneer ze de SAGE-reparatielus toevoegden, sprong het succespercentage naar 92,0%. Dat is een verbetering van 22,7 procentpunt, wat de onderzoeker een significante en betekenisvolle winst noemt. In essentie redde de lus taken die de AI anders volledig zou hebben laten falen, zoals het repareren van code die probeerde een "month" frequentie alias te gebruiken die uit een populaire datalibrary was verwijderd.
Echter, het paper testte ook een agressievere versie van het idee. Ze vroegen zich af: wat als de AI niet alleen crashes herstelt, maar ook controleert of het programma perfect compleet is, zelfs als het niet crasht? Bijvoorbeeld, als een programma bedoeld is om een rapportbestand te genereren, maar klaar is zonder een foutmelding te geven, maar simpelweg zonder het bestand te maken, zou de AI dat dan opmerken? Ze bouwden een "correctheid-bewust" systeem om dit te doen. Verrassend genoeg hielp deze extra strengheid niet veel. Het succespercentage steeg slechts met een kleine 2,7 punten (naar 94,7%), en de onderzoeker vond dat dit verschil niet statistisch significant was. Sterker nog, de extra controle zorgde er soms voor dat de AI dingen "over-repareerde", waardoor programma's die al werkten, juist kapot gingen. De les hier is dat hoewel het vertellen van de AI precies wat succes betekent nuttig is, het constant dwingen om opnieuw te controleren en te herstellen, het proces eigenlijk slechter kan maken.
Kortom, het paper laat zien dat het geven van een "probeer, faal, herstel"-lus een krachtige manier is om werkende software te bouwen, waarbij een succespercentage van ongeveer 69,3% wordt omgezet naar 92,0%. Het bewijst dat het laten zien van de eigen fouten in een echte, geïsoleerde omgeving de sleutel is tot het ontsluiten van het potentieel voor complexe projecten. Maar het waarschuwt ons ook dat te perfectionistisch zijn in de weg kan vallen; soms is het beter om de AI de grote fouten te laten herstellen en de rest met rust te laten. De onderzoeker heeft zijn code en testsuite openbaar gemaakt, in de hoop anderen te helpen software te bouwen die zichzelf kan genezen.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.