Technische Samenvatting: Autonome LLM-agenten en CTF's: Een Tweede Blik

Probleemstelling

Ondanks de proliferatie van Large Language Model (LLM)-agenten die beloven offensieve beveiligingstaken te automatiseren, verdienen recente claims van bijna-menselijke succespercentages bij Capture-the-Flag (CTF)-uitdagingen nader onderzoek. De cybersecurity-industrie kampt met een aanzienlijk tekort aan personeel, terwijl aanvallen nieuwe kwetsbaarheden razendsnel exploiteren. Hoewel LLM's kennis bezitten van kwetsbaarheidsklassen en tools, vereist offensieve beveiliging meerstapsplanning, adaptief toolgebruik en coherent contextbeheer over lange interactiehorizonten – vaardigheden die huidige agenten moeite hebben om betrouwbaar te demonstreren. Bovendien vertrouwen veel eerdere studies op gesloten systemen of proxy-taken (bijvoorbeeld kwetsbaarheidsdetectie) in plaats van volledige exploit-uitvoering, waardoor er een gat blijft bestaan in het begrijpen van de ware capaciteiten en beperkingen van autonome agenten bij penetration testing.

Methodologie

De auteurs voeren een rigoureuze evaluatie uit van LLM-gebaseerde agenten op een gecureerde set van 30 webgebaseerde CTF-uitdagingen die 14 kwetsbaarheidsklassen bestrijken (bijvoorbeeld SQL-injectie, XSS, zakelijke logische fouten, race-voorwaarden). Alle uitdagingen werden handmatig opgelost door de auteurs om grondwaarheidsreferentieoplossingen te bieden voor fijnmazige analyse.

Agent-architecturen

De studie vergelijkt drie domeinspecifieke, modulaire architecturen met een algemeen doel basismodel:

1. Executor (E): Een monolithische agent verantwoordelijk voor ontdekking, planning en uitvoering.
2. Executor + Evaluator (E+E): Een multi-agent systeem waarbij een Evaluator de voorgestelde acties van de Executor beoordeelt voordat ze worden uitgevoerd, en feedback geeft voor verfijning.
3. Planner + Executor + Evaluator (P+E+E): Een gestructureerde pijplijn waarbij een Planner (ondersteund door een Recon Node) een hoogwaardig aanvalsplan formuleert, dat vervolgens wordt uitgevoerd door de Executor en bewaakt door de Evaluator. Dit ontwerp ontkoppelt planning van uitvoering.
4. Basislijn (claude-code): Een productie-georiënteerde, algemeen doel agentic assistent (Opus 4.5) die autonoom zijn interne architectuur bepaalt, inclusief het vermogen om sub-agenten te spawnen.

Experimentele Opstelling

• Modellen: De modulaire architecturen werden getest met GPT-4.1 en GPT-5. De basislijn gebruikte claude-code (Opus 4.5).
• Uitvoering: Elke architectuur werd drie keer per uitdaging uitgevoerd (90 totale runs per architectuur) om consistentie te meten, terwijl de basislijn één keer per uitdaging werd uitgevoerd vanwege token-beperkingen.
• Omgeving: Agenten interacteerden met geïsoleerde gedockerde webapplicaties via SSH-terminals, met behulp van run_command en run_python tools.
• Metrieken: Succespercentage (maximaal over runs), gemiddeld aantal interactiestappen, kosten (USD) en wall-clock duur.

Belangrijkste Bijdragen en Resultaten

1. Prestatieplafond en Vergelijking met Basislijn

De studie onthult dat huidige agenten nog steeds onder het menselijke prestatieniveau zitten.

• Succespercentage: Zowel de best ontworpen architectuur (P+E+E met GPT-5) als de algemeen doel claude-code losten exact 19 van de 30 uitdagingen op (63%).
• Model-afhankelijkheid: De LLM-ruggengraat is doorslaggevend; GPT-4.1 loste slechts 9/30 taken op, terwijl GPT-5 19/30 bereikte, wat aangeeft dat complexe meerstapsredenering de nieuwste generatiemodellen vereist.
• Architectuur versus Algemeen Doel: Hoewel claude-code hetzelfde pieksuccespercentage behaalde als de meest complexe ontworpen oplossing zonder domeinspecifieke engineering, boden de ontworpen oplossingen superieure efficiëntie.

2. Efficiëntie en Consistentie

Hoewel de piekoplosbaarheid identiek was bij sterke systemen, had architecturale complexiteit een aanzienlijke impact op efficiëntie en betrouwbaarheid:

• Kosten en Stappen: De P+E+E-architectuur was het meest kostenefficiënt, met een vermindering van het gemiddelde aantal stappen van 31,56 (alleen Executor) naar 24,09 en een kostenverlaging van 34% ten opzichte van de monolithische aanpak.
• Consistentie: Multi-agent architecturen toonden een hogere robuustheid. De P+E+E-opstelling loste dezelfde uitdaging op in alle drie de onafhankelijke runs voor 16/30 taken, vergeleken met 12/30 voor de monolithische Executor.
• Runtime Overhead: Ondanks stap-efficiëntie, hadden gestructureerde architecturen hogere wall-clock tijden vanwege de overhead van het instantiëren van meerdere agenten, terwijl claude-code snel bleef door zelden sub-agenten te spawnen.

3. Foutanalyse en Bottlenecks

De studie identificeert dat fouten consequent clusteren rond specifieke categorieën, ongeacht de gebruikte agent-architectuur of het model.

• Primaire Bottleneck: Kwetsbaarheidsdetectie is het belangrijkste faalpunt. De Planner identificeerde de doelkwetsbaarheid correct in 23/30 gevallen; in de overige 7 konden noch de agenten noch claude-code een plan formuleren. Zodra een kwetsbaarheid werd herkend, slaagde exploitatie in het overgrote merendeel van de gevallen.
• Systematische Faalmodi:
  • Cross-Site Scripting (XSS): Fouten waren te wijten aan omgevingsbeperkingen (geen browser-rendering voor JavaScript-uitvoering) in plaats van redeneerfouten.
  • Blind SQL/Command Injectie: Fouten voortvloeiden uit contextvenster-beperkingen. Lange, iteratieve payload-verfijning degradeerde de redeneerkwaliteit en consistentie.
  • Zakelijke Logische Fouten: Agenten faalden consequent om te redeneren over applicatiewerkstromen, en verkeerden naar het zoeken naar standaard technische exploits (bijvoorbeeld injecties) in plaats van de beoogde logica te begrijpen.
  • Race-voorwaarden: Beide systemen faalden om aanvallen uit te voeren die gelijktijdige of gesynchroniseerde acties vereisten, aangezien de architecturen sequentieel opereerden en de noodzaak voor parallelisme niet afleidden.

Betekenis en Claims

Het paper biedt een "realiteitscheck" op claims van bijna-menselijke prestaties in autonome offensieve beveiliging. De primaire betekenis ligt in:

1. Het Vaststellen van Sterke Basislijnen: Aantonen dat algemeen doel agenten zoals claude-code sterke basislijnen zijn die de piekprestaties van handgemaakte, domeinspecifieke multi-agent systemen evenaren.
2. Het Identificeren van Architecturale Waarde: Aantonen dat architectuur weliswaar het plafond van oplosbare taken niet verhoogt, maar gestructureerde orchestration (specifiek het Planner-Executor-Evaluator-model) de consistentie, kostenefficiëntie en stapreductie binnen de oplosbare subset significant verbetert.
3. Het Definieren van Beperkingen: Verduidelijken dat huidige beperkingen niet louter architecturaal zijn, maar voortvloeien uit fundamentele gaten in LLM-capaciteiten:
   • Technisch: Gebrek aan omgevingscapaciteiten (browser-rendering, concurrentie).
   • Cognitief: Onvermogen om te redeneren over zakelijke logica en coherentie te behouden over lange, stateful interactieketens.

De auteurs concluderen dat toekomstige vooruitgang vereist dat deze specifieke omgevings- en cognitieve barrières worden aangepakt, met name het verbeteren van kwetsbaarheidsdetectie en langetermijncontextbeheer, in plaats van simpelweg de architecturale complexiteit te verhogen.