Technische Samenvatting: ExecuGraph – Executie-gegronde Multi-agent Systemen voor Betrouwbare Backend Code Generatie

Probleemstelling

Hoewel Large Language Models (LLMs) de standaard zijn geworden voor geautomatiseerde code generatie, blijft betrouwbaarheid een kritieke beperking, met name voor backend code die strikte invarianten van datastructuren en afhandeling van randgevallen vereist. Bestaande benaderingen vertrouwen vaak op single-agent, single-pass paradigma's of multi-agent pipelines die roldecompositie (het toewijzen van verschillende taken aan verschillende agenten) verwarren met executiefeedback (het gebruik van runtime testresultaten om verfijning te sturen).

De centrale onderzoeksleemte die is geïdentificeerd, is het gebrek aan gecontroleerde empirische studies die het marginale voordeel van multi-agent roledecompositie isoleren van het voordeel van executiefeedback. Veel eerdere systemen schrijven prestatiewinst toe aan complexe agent-architecturen, terwijl die winst simpelweg kan voortkomen uit de aanwezigheid van een executielus. Bovendien zijn tekstuele zelf-review mechanismen (bijv. "LLM-als-rechter") gevoelig voor instabiliteit en fout-negatieven, waarbij correcte code vaak wordt geblokkeerd op basis van parafrase-gevoelige verbale kritieken in plaats van runtime-uitkomsten.

Methodologie: Het ExecuGraph Framework

De auteurs presenteren ExecuGraph, een workflow framework dat expliciet is ontworpen als een instrument om executiefeedback te ontkoppelen van multi-agent roledecompositie.

Kernarchitectuur

ExecuGraph is geformaliseerd als een getypeerd transitiesysteem ($W = (S, A, \rho, D, T)$) over een gedeeld state-object $S$, georkestreerd via LangGraph. Het bevat:

1. Gedeelde State: Een getypeerd record (GraphState) dat de probleemstelling, het plan, de code, review-artefacten, evaluatieresultaten en retry-aantallen vasthoudt.
2. Agent Laag: Zes gespecialiseerde agenten:
   • Planner: Genereert algoritmische strategie en complexiteitsanalyse.
   • Code Generator: Produceert Python-code op basis van het plan.
   • Logical Reviewer: Biedt adviserend-alleen statische analyse (gestructureerde JSON) maar fungeert niet als poortwachter voor acceptatie.
   • Evaluator: De enige autoriteit voor acceptatie; voert code uit in een subprocess-sandbox en past hybride testen toe (deterministische tests of door LLM gegenereerde tests).
   • Optimizer: Refactort de code alleen na succesvolle executie.
   • Explainer: Genereert documentatie na acceptatie.
3. Executie Sandbox: Een subprocess-geïsoleerde omgeving met strikte import-policies (om sandbox-schendingen te voorkomen voor standaardbibliotheken zoals bisect of heapq), resource-limieten en gesaneerde omgevingen.
4. Beslissingspredicaat: Acceptatie wordt uitsluitend bepaald door executie-uitkomsten (s.evaluation.passed = True), niet door statische review of verbale zelfbeoordeling.

Experimenteel Ontwerp

De primaire innovatie van het framework is het vermogen om in te klappen naar verschillende baselines via configuratie-switches binnen dezelfde codebase:

• Single-Agent One-Shot (SO): Alleen generator, geen retries.
• Single-Agent Execution-Retry (SR): Generator + Evaluator met retries (Self-Debug stijl), zonder Planner/Reviewer.
• Multi-Full (MF): Alle agenten ingeschakeld met retries.
• Ablaties: Specifieke agenten (Planner, Reviewer, Optimizer) of de Retrieval-laag (RAG) kunnen worden uitgeschakeld om de marginale bijdrage te meten.

De studie maakt gebruik van drie datasets:

1. Internal-30: Een gecureerde suite van 30 problemen (DP, Graph, Datastructuren).
2. HumanEval: De volledige benchmark van 164 problemen.
3. APPS-Introductory: Een subset van 50 problemen.

Experimenten werden uitgevoerd met open-weight modellen (Qwen2.5-Coder-7B en DeepSeek-Coder-V2-Lite-16B) die lokaal werden gehost op een consumenten-GPU (RTX 4050) om reproduceerbaarheid met nul API-kosten te garanderen.

Belangrijkste Bijdragen

1. Isolatie van Mechanismen: ExecuGraph biedt de eerste gecontroleerde vergelijking die executiefeedback scheidt van multi-agent decompositie. Door het framework te laten inklappen naar de SO, SR en MF condities, tonen de auteurs aan dat de "multi-agent" winst vaak een confound is van executiefeedback.
2. Adviserende Reviewer: Het framework ontkoppelt de "critic" rol expliciet van de "acceptatie" autoriteit. De Logical Reviewer is slechts adviserend, wat het risico op "fout-negatieven" voorkomt waarbij een zelfverzekerde maar onjuiste LLM-rechter correcte code blokkeert.
3. Empirische Diagnostische Studie: Het paper presenteert een rigoureuze diagnostiek die aantoont dat executiefeedback de overgrote meerderheid van de prestatiewinst drijft, terwijl het toevoegen van multi-agent componenten vaak verwaarloosbare of zelfs negatieve rendementen oplevert ten opzken de kosten.
4. Reproduceerbaarheid en Artefact Correctie: De auteurs hebben alle code, logs en scripts vrijgegeven. Cruciaal is dat zij een defect in de sandbox import-policy in hun oorspronkelijke harness hebben geïdentificeerd en gecorrigeerd, die correcte programma's met standaardbibliotheken (bijv. bisect) onterecht had afgewezen. Alle gerapporteerde resultaten zijn opnieuw gescoord met de gecorrigeerde sandbox zonder de modellen opnieuw aan te roepen.
5. Kosten-Correctheid Analyse: Gedetailleerde kwantificering van de trade-offs tussen nauwkeurigheid, wall-clock tijd, tokengebruik en het aantal LLM-aanroepen over verschillende configuraties.

Resultaten

1. Executiefeedback vs. Multi-Agent Decompositie

Op de HumanEval benchmark (164 problemen) vond de studie:

• Executiefeedback is Cruciaal: Single-agent execution-retry (SR) presteerde beter dan single-shot (SO) met +25,6 procentpunt (81,7% vs. 56,1%, $p < 0,0001$).
• Multi-Agent Decompositie Voegt Geen Meetbare Waarde Toe: Het toevoegen van vijf agenten bovenop de retry-loop (MF) resulteerde in -1,2 procentpunt vergeleken met SR (80,5% vs. 81,7%, $p = 0,76$).
• Sampling Controle: Een "best-of-5" sampling controle (vijf onafhankelijke one-shot pogingen gefilterd door de sandbox) met een vergelijkbaar compute-budget als MF, won slechts +0,4 pp van one-shot. Dit bevestigt dat de winsten van SR voortkomen uit feedback, en niet louter uit verhoogde sampling diversiteit.

2. Kostenanalyse

• Single-Retry (SR): Bereikte een hoge nauwkeurigheid (81,7%) met ~1,5 LLM-aanroepen en ~13,3s wall-clock tijd.
• Multi-Full (MF): Vereiste ~5,3 LLM-aanroepen en ~59,8s wall-clock tijd (3,6x meer aanroepen, 7,3x meer tokens) voor statistisch ononderscheidbare nauwkeurigheid.
• Conclusie: Voor 7B-schaal modellen is de single-retry configuratie de meest kosteneffectieve route.

3. Cross-Model en Categorie Effecten

• DeepSeek-Coder-V2-Lite (16B MoE): Multi-agent decompositie vertoonde een +20,0 pp winst specifiek op Graph problemen (90,0% vs. 70,0%), maar veroorzaakte een -10,0 pp daling in Dynamic Programming en Datastructuren. Het netto resultaat was geen verandering in algemene nauwkeurigheid (83,3%). Dit suggereert een herverdeling van capaciteit in plaats van een universele schaalvergroting.
• Planner Distractor Effect: In kwalitatieve analyse werd gevonden dat de Planner agent op 7B modellen soms als een "distractor" fungeert. Als de Planner een gebrekkige structurele beperking emitteert (bijv. een onjuiste base-case initialisatie), houdt de Generator zich hier getrouw aan, en falen daaropvolgende retries om de fout te corrigeren omdat de gebrekkige planning in de context behouden blijft. Het verwijderen van de Planner in ablatiestudies verbeterde de nauwkeurigheid zelfs met 8,0 pp.

4. Retrieval (RAG)

Het inschakelen van de retrieval-laag (het voeden van de Planner met algoritmische snippets) leverde geen meetbare winst op (78,7% vs. 82,0% baseline). De auteurs schrijven dit toe aan de kleine schaal van de vector store en het feit dat 7B code modellen al beschikken over sterke parametrische kennis van standaard algoritmen.

Betekenis en Claims

Het paper claimt bescheiden dat executiefeedback de primaire drijfveer is van betrouwbaarheid in LLM code synthese, en niet multi-agent roledecompositie.

• Het "Negatieve" Resultaat is Robuust: De bevinding dat multi-agent decompositie geen waarde toevoegt bovenop single-agent retry is de meest robuuste claim in het paper, omdat beide condities executiefeedback ontvangen, waardoor de confound van testzichtbaarheid wordt geëlimineerd.
• Praktische Implementatie: De auteurs bevelen Single-Retry (SR) aan als de standaard deployment configuratie voor backend code generatie bij 7B parameter schalen. Het bereikt een equivalente nauwkeurigheid als Multi-Full met ongeveer 28% van de model-aanroepen en 14% van de token-kosten.
• Artefact Waarde: De auteurs erkennen dat Multi-Full nog steeds waardevol kan zijn voor het genereren van artefacten (bijv. invariant lijsten, verklaringen) die nuttig zijn voor software governance, maar niet voor het verbeteren van de ruwe correctheid.
• Gevaar van Executie-Gronding: Het paper benadrukt een cruciale les: executie-gegronde evaluatie is slechts zo betrouwbaar als de implementatie ervan. Een bug in de sandbox (het import-policy defect) kan resultaten stilletjes corrumperen, waardoor correcte programma's in fouten worden omgezet. De auteurs pleiten voor reference-solution controles in elk systeem waar het acceptatiecriterium code-executie is.

Samenvattend demonstreert ExecuGraph dat voor betrouwbare backend code generatie, een eenvoudige executie-retry loop superieur is aan complexe multi-agent orchestratie in termen van kostenefficiëntie en nauwkeurigheid, mits de executie sandbox correct is geïmplementeerd.