BACE: LLM-based Code Generation through Bayesian Anchored Co-Evolution of Code and Test Populations

Het artikel introduceert BACE, een framework dat codegeneratie verbetert door code en tests te laten co-evolueren onder leiding van Bayesiaanse updates, waardoor het de valkuil van zelfversterkende fouten in eerdere methoden overwint en superieure prestaties behaalt op LiveCodeBench v6.

De kern

BACE: Hoe een AI-ontwikkelaar en een AI-tester samenwerken om foutloze code te maken

Stel je voor dat je een heel slimme, maar soms wat onzeker kunstenaar (de AI) hebt die gebouwen moet ontwerpen op basis van een beschrijving. Vroeger gaf deze kunstenaar gewoon één tekening af en hoopte dat het goed zat. Maar vaak waren er kleine foutjes in de constructie die niet direct zichtbaar waren.

Om dit op te lossen, probeerden mensen een tweede AI in te huren: een inspecteur. Deze inspecteur zou de tekeningen controleren en zeggen: "Dit raam zit verkeerd!" of "Deze muur is te zwak!" Het probleem? De inspecteur was ook een AI. Soms droomde hij dingen die niet bestonden, of hij keek naar de verkeerde details. Als de kunstenaar dan probeerde om aan de eisen van de inspecteur te voldoen, maakte hij soms juist meer fouten. Het was alsof je een spiegelbeeld van een spiegelbeeld bekijkt: de afbeelding wordt steeds vager en vervormd.

BACE (Bayesian Anchored Co-Evolution) is een nieuwe manier om dit probleem op te lossen. Het is alsof we een heel slim team hebben opgezet in plaats van één kunstenaar en één inspecteur. Hier is hoe het werkt, vertaald naar alledaagse termen:

1. Geen één kunstenaar, maar een heel team (Populaties)

In plaats van dat de AI maar één ontwerp maakt, laat BACE een heel team van kunstenaars (een populatie) tegelijkertijd werken.

• Het idee: Als één kunstenaar een fout maakt en de inspecteur zegt "Nee!", is dat niet het einde. Andere kunstenaars in het team hebben misschien een beter idee. Het team zorgt ervoor dat het goede idee niet direct verdwijnt, zelfs als de inspecteur even in de war is.

2. De "Noisy Sensor" (De onzekere meetinstrumenten)

BACE erkent dat de AI-inspecteur niet perfect is. Hij is als een onbetrouwbare meetinstrument in een storm.

• De slimme truc: BACE vertrouwt niet blind op "Ja" of "Nee". Het gebruikt een soort gok- en geloofssysteem (Bayesiaanse logica).
  • Als de inspecteur zegt: "Dit is goed!", denkt het systeem: "Oké, dat is waarschijnlijk waar, maar misschien is de inspecteur net een beetje slordig."
  • Als de inspecteur zegt: "Dit is fout!", denkt het systeem: "Misschien is de kunstenaar fout, maar misschien is de inspecteur ook wel gek."
  • Het systeem past zijn geloof in de kunstenaar en de inspecteur continu aan, gebaseerd op hoe vaak ze elkaar bevestigen. Als een kunstenaar vaak goed scoort, wordt zijn geloofswaarde hoger. Als een inspecteur vaak fouten maakt die later blijken onjuist, wordt zijn geloofswaarde lager.

3. Het Anker (De onwrikbare waarheid)

Dit is het belangrijkste deel. Om te voorkomen dat het hele team in een cirkel draait en steeds gekkere dingen gaat doen (wat "co-evolutionary drift" heet), heeft BACE een Anker.

• De analogie: Stel je voor dat de kunstenaars en inspecteurs in een bootje zitten op een woelige zee. Als ze alleen naar elkaar kijken, drijven ze weg. BACE gooit een anker uit dat vastzit aan de bodem.
• In de praktijk: Dit anker zijn de simpele, bekende voorbeelden uit de opdracht (bijvoorbeeld: "Als ik 2+2 invoer, moet het antwoord 4 zijn"). Deze voorbeelden zijn 100% waar.
  • Als een ontwerp dit anker niet haalt, is het direct fout. Geen discussie.
  • Als een ontwerp het anker wel haalt, krijgt het een boost in geloof.
  • Dit zorgt ervoor dat het team altijd in de buurt van de echte waarheid blijft, zelfs als de AI-inspecteur soms raart.

4. De dans van de evolutie

Het proces verloopt als een dans:

1. Het team van kunstenaars maakt ontwerpen.
2. Het team van inspecteurs maakt tests.
3. Ze testen elkaar.
4. Het systeem past hun geloof aan: "Deze kunstenaar is waarschijnlijk slim, deze inspecteur is misschien een beetje doof."
5. De beste kunstenaars en de slimste inspecteurs krijgen een kans om hun "kinderen" (nieuwe versies) te maken, terwijl de slechtste worden weggegooid.
6. Maar wacht! Als twee kunstenaars precies hetzelfde doen, houden we er maar één van over (om ruimte te maken voor nieuwe ideeën). Als twee inspecteurs precies hetzelfde zien, houden we de beste van hen over. Dit zorgt voor diversiteit: het team blijft creatief en zoekt naar nieuwe oplossingen.

Waarom is dit zo goed?

Vroeger gaven AI-systemen vaak op als de tests niet betrouwbaar leken. Ze dachten: "Laten we maar niet testen, maar gewoon nadenken." BACE zegt: "Nee, laten we testen, maar we doen het slim."

Door te werken met een team, door te twijfelen aan de tests (maar ze toch te gebruiken), en door vast te houden aan de simpele waarheid (het anker), slaagt BACE erin om beter te zijn dan de beste systemen die we tot nu toe hadden. Het werkt zelfs met kleinere, goedkopere AI-modellen, wat betekent dat we in de toekomst sneller en goedkoper perfecte software kunnen maken.

Kortom: BACE is als een slimme werkplaats waar een groep kunstenaars en een groep inspecteurs elkaar helpen, elkaar corrigeren, maar altijd vasthouden aan de basisregels, zodat ze uiteindelijk een perfect gebouw neerzetten, zonder dat ze in de war raken door hun eigen twijfels.

Technische samenvatting

Probleemstelling

Grote Taalmodellen (LLM's) hebben indrukwekkende prestaties geleverd in het genereren van code, maar ze maken vaak subtiele logische fouten die niet worden opgepikt door traditionele, open-loop generatie. Om dit op te lossen, zijn gesloten-lus benaderingen (zoals AgentCoder) ontwikkeld, waarbij een agent code genereert en een andere agent tests schrijft om feedback te geven.

De kern van het probleem ligt echter in de onbetrouwbaarheid van gegenereerde tests:

1. Fragiele feedback: Als de test-agent een foutieve test genereert, kan deze onjuiste code "laten slagen" (false positives) of juist correcte code laten falen (false negatives).
2. Co-evolutionaire drift: Bestaande methoden behandelen gegenereerde tests vaak als absolute "ground truth". Dit leidt tot een vicieuze cirkel waar de populatie van code en tests zich gezamenlijk aanpast aan fouten in plaats van naar de juiste oplossing convergeert.
3. Afwijkende trends: De nieuwste state-of-the-art methoden (zoals MapCoder en CodeSIM) hebben de testgeneratie volledig verlaten en vertrouwen puur op redenering, omdat ze gegenereerde tests als te onbetrouwbaar beschouwen.

Het paper stelt de vraag: Hoe kan een synthese-systeem convergeren naar een correcte oplossing als het meetinstrument (de testsuite) zelf een onbetrouwbare bron van waarheid is?

Methodologie: BACE (Bayesian Anchored Co-Evolution)

BACE lost dit op door code-synthese te herformuleren als een Bayesiaanse co-evolutionaire proces. In plaats van één enkele code en één enkele test te gebruiken, onderhoudt BACE populaties van beide, die wederzijds evolueren op basis van geloofswaarschijnlijkheden (belief distributions) in plaats van deterministische uitkomsten.

De kerncomponenten zijn:

1. Populatie-benadering:

   • Er wordt een populatie van code-candidaten ($C$) en een populatie van tests ($T$) onderhouden.
   • Dit vermindert het risico dat een enkele foutieve test een geldige oplossing vernietigt; andere lijnen in de populatie kunnen overleven.

2. Bayesiaanse Modelleren van Tests als "Noisy Sensors":

   • BACE behandelt uitvoeringsresultaten (Pass/Fail) niet als absolute waarheid, maar als ruisbeperkende signalen.
   • Er wordt een Bayesiaans update-model gebruikt waarbij de "geloofswaarde" ($b$) van een code-candidaat of een test wordt bijgewerkt op basis van interacties.
   • Drie ruisparameters worden gemodelleerd:
     • $\alpha$: Kans dat correcte code een gebroken test slaagt.
     • $\beta$: Kans dat foutieve code een geldige test slaagt.
     • $\gamma$: Kans dat foutieve code een gebroken test slaagt.
   • Door deze ruis te modelleren, kan het systeem onderscheid maken tussen waarheid en toeval.

3. Anchoring (Verankering):

   • Om te voorkomen dat het systeem in een zelf-verificerende lus terechtkomt (co-evolutionaire drift), worden de zoekprocessen verankerd op een minimaal setje publieke input/output voorbeelden uit de probleemspecificatie.
   • Deze "Anchors" hebben een hoge, onveranderlijke prior-geloofswaarde. Code die deze anchors faalt, krijgt een onbeperkte straf. Dit fungeert als een kompas dat de populatie bij de echte specificatie houdt.

4. Wederzijdse Evolutie en Diversiteit:

   • Alternierende evolutie: In even generaties evolueert de testpopulatie (terwijl code vaststaat), en in oneven generaties evolueert de codepopulatie. Dit stabiliseert het leersignaal.
   • Behavioral Diversity: In plaats van alleen te kijken naar de beste score, behoudt BACE diversiteit door individuen te groeperen op basis van hun gedragsvectoren (welke tests slagen of falen).
     • Code: Behoudt unieke strategieën zelfs als ze tijdelijk een lagere score hebben.
     • Tests: Verwijdert redundante tests die geen nieuwe informatie toevoegen.
   • Divergentie Ontdekking: Een speciale operator genereert tests die specifiek bedoeld zijn om verschillen te vinden tussen code-candidaten die op de huidige tests identiek presteren.

Belangrijkste Bijdragen

1. Bayesiaans Co-Evolutionair Framework: Een nieuwe formulering van code-synthese waarbij code en tests populaties wederzijds evolueren op basis van bijgewerkte geloofswaarschijnlijkheden, in plaats van deterministische validatie.
2. Belief Anchoring Mechanisme: Een innovatie die de zoektocht verankert op publieke voorbeelden, waardoor co-evolutionaire drift wordt voorkomen en het systeem veilig gebruik kan maken van gegenereerde tests.
3. Behoud van Gedragsdiversiteit: Implementatie van een elitisme-beleid dat gebaseerd is op gedragsvectoren en het gebruik van differentieel testen om de populatie divers te houden en te voorkomen dat het systeem vastloopt in triviale oplossingen.
4. State-of-the-Art Prestaties: BACE presteert beter dan bestaande methoden op zowel gesloten (proprietary) als open-source modellen.

Resultaten

De methode is geëvalueerd op LiveCodeBench v6 (problemen gepubliceerd na maart 2025), wat zorgt voor een schone dataset zonder data-contaminatie. De tests zijn uitgevoerd met drie modellen: GPT-5-Mini, Qwen2.5-Coder-7b en GPT-OSS-120b.

• Algemene Prestaties: BACE behaalde de state-of-the-art resultaten op alle moeilijkheidsgraden (Easy, Medium, Hard).
• Verbetering ten opzichte van concurrenten:
  • Tegenover CodeSIM (de huidige leider) boekte BACE een absolute verbetering van 2,5% (GPT-5-Mini), 5,4% (Qwen2.5-Coder-7b) en 5,0% (GPT-OSS-120b).
  • Opmerkelijk is dat AgentCoder met GPT-OSS-120b zelfs onder de directe prompting baseline uitkwam (52,1% vs 57,5%), terwijl BACE dit probleem oploste.
• Ablatie-studie: De studie toonde aan dat de combinatie van populatie-benadering, code-evolutie en co-evolutie van tests stapsgewijs de prestaties verbetert, waarbij de volledige BACE-architectuur de hoogste scores behaalde.

Betekenis en Conclusie

Dit paper is significant omdat het de huidige consensus uitdaagt dat gegenereerde tests te onbetrouwbaar zijn om te gebruiken. BACE bewijst dat gegenereerde tests waardevolle signalen blijven, mits ze worden gemodelleerd als ruisbeperkende sensoren binnen een Bayesiaans raamwerk en worden verankerd aan ground-truth voorbeelden.

De methode combineert de kracht van LLM's voor creatieve oplossing en testgeneratie met de wiskundige stabiliteit van Bayesiaanse inferentie en evolutionaire algoritmen. Dit opent de deur voor robuustere, geautomatiseerde softwareontwikkelingssystemen die niet afhankelijk zijn van menselijke test suites, maar wel in staat zijn om fouten in hun eigen feedbacklus te detecteren en corrigeren.