A Systematic Study of LLM-Based Architectures for Automated Patching

Probleemstelling

Softwarekwetsbaarheden hebben een steeds grotere impact door de complexiteit van moderne software-ecosystemen (bijv. Log4Shell). Hoewel detectie van kwetsbaarheden steeds geautomatiseerd wordt, blijft het repareren (patchen) een grote bottleneck. Een patch moet niet alleen de kwetsbaarheid elimineren, maar ook de bestaande programmasemantiek behouden en naadloos integreren in grote, evoluerende codebases.

Recente vooruitgang in Large Language Models (LLM's) toont aan dat ze kwetsbaarheden kunnen repareren, maar er is een gebrek aan inzicht in hoe verschillende architecturale integratiestrategieën de effectiviteit, efficiëntie en robuustheid beïnvloeden. Bestaande werken behandelen de systeemarchitectuur vaak als een implementatiedetail in plaats van een ontwerpparameter, en leidende productiesystemen zijn vaak gesloten (propriëtaire), waardoor het moeilijk is om te beoordelen of hun ontwerpkeuzes generaliseerbaar zijn.

Methodologie

De auteurs voeren een gecontroleerde evaluatie uit van vier verschillende LLM-gebaseerde architecturale paradigma's voor het automatisch patchen van kwetsbaarheden. Ze gebruiken een uniek benchmark- en evaluatieframework gebaseerd op de DARPA AI Cyber Challenge (AIxCC) dataset, specifiek gericht op 19 Java-kwetsbaarheden uit grote, real-world projecten (zoals Apache Commons, ZooKeeper, Log4j).

De vier onderzochte architecturen zijn:

1. Fixed Workflow: Een deterministische, regelgedreven pijplijn waarbij elke stap (statische analyse, patchgeneratie, validatie) strikt is vastgelegd. Er is geen dynamische planning; het systeem volgt een vooraf gedefinieerde volgorde.
2. Single-Agent System: Een autonoom LLM-agent dat planning en toolgebruik integreert. Het agent redeneert over de taak, kiest zelf welke tools (zoals zoeken, bewerken, valideren) het moet gebruiken, en gebruikt feedback van mislukte tests om zijn volgende actie te plannen.
3. Multi-Agent System: De reparatiewerkflow wordt opgesplitst in gespecialiseerde agenten (bijv. Context Retriever, Root-Cause Analyst, Patch Generator, Validator, Reflection Agent). Deze agenten communiceren via een gedeelde staat (shared state) om de cognitieve last te verdelen en contextvensters te beheren.
4. General-Purpose Code Agents: Representatief vertegenwoordigd door Claude Code. Dit zijn algemene coderingsassistenten die niet specifiek voor patching zijn ontworpen, maar wel over rijke tool-interfaces en dynamische planning beschikken om complexe coderingstaken uit te voeren.

De evaluatie omvatte het meten van:

• Correctheid: Percentage succesvol gepatchte kwetsbaarheden (gebaseerd op crash-tests en functionele tests).
• Tool Usage: Hoe agenten interacteren met de code en validatietools.
• Kosten: Token-gebruik en uitvoeringstijd.
• Robuustheid: Omgaan met fouten, oneindige lussen en complexe foutlocaties.

Belangrijkste Bijdragen

1. Architecturale Taxonomie: De auteurs formaliseren en implementeren voor het eerst vier architecturale paradigma's voor LLM-gebaseerde patching onder één experimentele setting.
2. Unificatie van Evaluatie: Ze bieden een eerlijke vergelijking tussen domeinspecifieke systemen en algemene coderingsagenten op de AIxCC-dataset.
3. Diepgaande Gedragsanalyse: Door middel van log-analyse onthullen ze de trade-offs tussen kosten, iteratiediepte en succes, en tonen ze aan dat architectuur net zo belangrijk is als het model zelf.

Resultaten

De resultaten tonen duidelijke trade-offs tussen de verschillende architecturen:

• Algemene Prestaties: General-Purpose Code Agents (Claude Code) presteerden het beste overall, met succesvolle patches voor 16/19 kwetsbaarheden. Dit is hoger dan de beste domeinspecifieke agenten (Multi-Agent op GPT-5 haalde 13/19).
  • Reden: Algemene agents profiteren van flexibele, adaptieve planningsloops en rijke tool-interfaces die beter omgaan met onvoorspelbare codebases.
• Kosten en Efficiëntie:
  • Fixed Workflows en Single-Agent systemen zijn aanzienlijk token-efficiënter en sneller. Ze zijn echter kwetsbaarder voor "brittle" zoekgedrag als de redeneringsomvang groeit.
  • Multi-Agent systemen leiden tot aanzienlijk hogere kosten (token-gebruik) en latente overhead door coördinatie tussen agenten.
• Trade-offs:
  • Fixed Workflow: Efficiënt maar broos; faalt vaak bij complexe kwetsbaarheden die afwijken van het vaste schema.
  • Single-Agent: Een goede balans tussen flexibiliteit en kosten, maar kan vastlopen in lokale optima.
  • Multi-Agent: Verbeterde generalisatie door specialisatie, maar de coördinatiekosten en het risico op "reasoning drift" (afwijken van de oorspronkelijke taak) nemen toe bij complexe taken.
  • General Agents: Hoewel duurder in tokens, tonen ze de grootste robuustheid tegen oneindige lussen en lange uitvoeringen. Ze falen echter soms in specifieke gevallen waar gespecialiseerde systemen wel slagen (complementair effect).

Een opmerkelijke bevinding is dat Multi-Agent ontwerpen niet consistent beter presteren dan goed ontworpen Single-Agent systemen; de coördinatie-overhead kan de voordelen van specialisatie tenietdoen.

Betekenis en Conclusie

Dit paper concludeert dat de betrouwbaarheid en het kostenplaatje van geautomatiseerde kwetsbaarheidsreparatie niet alleen afhangen van de capaciteit van het LLM-model, maar kritisch worden bepaald door het architecturale ontwerp en de diepte van de iteratie.

• Er is geen "one-size-fits-all" oplossing. Algemene coderingsagenten bieden de beste dekking en robuustheid voor complexe, real-world scenario's, maar tegen een hoge prijs.
• Gespecialiseerde, domeinspecifieke architecturen blijven essentieel voor situaties waar kosten, snelheid en controle cruciaal zijn.
• De studie benadrukt dat architectuur een "first-class design variable" moet zijn bij het bouwen van autonome beveiligingssystemen, in plaats van alleen te vertrouwen op het trainen van betere modellen.

De bevindingen bieden een blauwdruk voor toekomstige systemen die een balans moeten vinden tussen de flexibiliteit van algemene agents en de efficiëntie van gespecialiseerde workflows.