De AI-securityparadox: waarom 9.791 kwetsbaarheidsmeldingen nog geen veiligere software opleveren
GitHub en Microsoft demonstreren hoe kunstmatige intelligentie duizenden potentiële kwetsbaarheden kan terugbrengen tot een beperkte verzameling bruikbare beveiligingsmeldingen. Maar achter deze vooruitgang schuilt een fundamenteler probleem: hoe bewijzen we dat autonome AI-systemen software daadwerkelijk veiliger maken, in plaats van uitsluitend beveiligingswerkzaamheden te automatiseren?
De belangrijkste vraag is niet langer hoeveel kwetsbaarheden AI kan vinden
Stel dat een organisatie morgen een AI-securityplatform implementeert dat honderd keer zoveel potentiële kwetsbaarheden detecteert als haar bestaande beveiligingstools.
Is die organisatie daardoor veiliger?
Het antwoord is niet noodzakelijk ja.
Wanneer de organisatie onvoldoende capaciteit heeft om de bevindingen te beoordelen, relevante problemen te prioriteren en betrouwbare correcties uit te voeren, kan het tegenovergestelde gebeuren. De hoeveelheid beveiligingsinformatie neemt toe, terwijl de daadwerkelijke herstelcapaciteit onveranderd blijft.
Ontwikkelaars besteden meer tijd aan triage. Securityteams verliezen het overzicht. De backlog groeit. Kritieke kwetsbaarheden concurreren met onjuiste, dubbele of laagrisicomeldingen om dezelfde beperkte capaciteit.
Dit is de AI-securityparadox: de productiviteit van kwetsbaarheidsdetectie kan toenemen zonder dat de effectiviteit van cybersecurity verbetert.
Op 17 november 2026 publiceerden GitHub en Microsoft de resultaten van hun gezamenlijke experiment Codename MDASH. In zes open-sourceprojecten identificeerde een AI-systeem 9.791 potentiële beveiligingsproblemen. Na geautomatiseerde filtering en menselijke verificatie resulteerde dit in 99 vertrouwelijke meldingen. Daarvan waren er op 15 november 55 opgelost en 14 beschikbaar in een software-release. [1]
De resultaten verdienen aandacht. Niet vanwege het grote aantal oorspronkelijke bevindingen, maar omdat ze zichtbaar maken hoeveel stappen noodzakelijk zijn tussen het identificeren van een mogelijk probleem en het daadwerkelijk beschikbaar stellen van een oplossing.
Tegelijkertijd illustreren twee recente wetenschappelijke onderzoeken dat ook een succesvol geteste AI-patch niet zonder meer als correcte beveiligingsoplossing mag worden beschouwd.
In PatchBench: Evaluating AI Agents for Vulnerability Patching rapporteren Shen en collega's (2026) dat evaluatie op basis van uitsluitend een proof of concept het oplossingspercentage van onderzochte patchagents gemiddeld met een factor 1,83 overschatte ten opzichte van hun strengere evaluatie. [2]
Le, Shi en Xing (2026) beschrijven een verwant probleem: benchmarkresultaten kunnen sterk worden beïnvloed door de evaluatieomgeving, beschikbare hulpmiddelen en de keuze van tests. Een model kan een kwetsbaarheidstest laten slagen zonder dat de correctie overeenkomt met het oorspronkelijke ontwerpdoel van de ontwikkelaars. [3]
Deze bevindingen leiden tot een belangrijke onderzoeksvraag: hoe ontwerpen en evalueren we autonome beveiligingssystemen die niet alleen kwetsbaarheden ontdekken en patches genereren, maar aantoonbaar, reproduceerbaar en duurzaam de risico-expositie van software verminderen?
Die vraag staat centraal in dit artikel.
1. Codename MDASH: wat GitHub en Microsoft daadwerkelijk hebben bereikt
De Codename MDASH-pilot was een gezamenlijke inspanning van Microsoft Security, Microsoft FORGE Lab en GitHub Security Lab.
Het uitgangspunt was eenvoudig: open-sourcemaintainers hebben weinig aan nog meer onbeoordeelde beveiligingsmeldingen.
Zij hebben behoefte aan relevante, gecontroleerde bevindingen die direct kunnen worden onderzocht en opgelost.
Daarom richtte het experiment zich op een geïntegreerde workflow waarin AI, menselijke onderzoekers en maintainers ieder een expliciete verantwoordelijkheid kregen.
1.1 De technische workflow
De pilot kende vijf stappen.
Detectie. Microsofts Codename MDASH, een agentisch scanningframework, onderzocht repositories met behulp van het MAI Cyber-model. Het systeem produceerde potentiële kwetsbaarheden en voorgestelde correcties.
Geautomatiseerde triage. Een AI-agent van GitHub Security Lab, gebouwd met gespecialiseerde Copilot-skills, beoordeelde bevindingen op onder meer duplicatie, geldigheid en relevantie.
Menselijke verificatie. Onderzoekers van Microsoft FORGE Lab beoordeelden de overgebleven meldingen handmatig.
Vertrouwelijke rapportage. Gecontroleerde bevindingen werden via GitHub Private Vulnerability Reporting aan de betrokken projecten aangeboden, inclusief een proof of concept en een voorgestelde oplossing.
Remediatie. De maintainers bepaalden zelfstandig of en hoe de kwetsbaarheden werden opgelost.
De zes deelnemende projecten waren AutoGPT, Caddy, Express, FastMCP, ImageMagick en Netty.
Alle projecten waren eerder betrokken bij het GitHub Secure Open Source Fund en hadden ingestemd met het onderzoek.
Dat laatste is belangrijk: het experiment bestond niet uit ongecontroleerd scannen van willekeurige externe repositories.
1.2 De resultaten in perspectief
| Procesfase | Aantal | Aandeel van vorige relevante fase |
|---|---|---|
| Potentiële AI-bevindingen | 9.791 | 100% |
| Geverifieerde, privé gerapporteerde meldingen | 99 | 1,01% van de bevindingen |
| Opgeloste meldingen | 55 | 55,56% van de meldingen |
| Oplossingen beschikbaar in een release | 14 | 25,45% van de opgeloste meldingen |
Peildatum voor de oplossingsstatus: 15 november 2026. Bron: GitHub/Microsoft [1].
De cijfers maken zichtbaar dat verschillende begrippen niet door elkaar mogen worden gebruikt.
Een finding is geen bevestigde kwetsbaarheid.
Een bevestigde kwetsbaarheid is geen geïmplementeerde correctie.
Een geïmplementeerde correctie is geen uitgebrachte release.
En een uitgebrachte release betekent nog niet dat iedere downstream gebruiker beschermd is.
Die opeenvolgende verschillen vormen de kern van het beveiligingsvraagstuk.
De meest opvallende prestatie van MDASH is daarom niet de detectie van 9.791 potentiële problemen, maar de combinatie van filtering, verificatie en concrete herstelvoorstellen die de belasting voor maintainers kon verminderen.
Volgens GitHub loste het Caddy-project alle 22 ontvangen meldingen binnen maximaal een week op. Een ImageMagick-maintainer kon een specifiek probleem binnen vijftien minuten corrigeren nadat de melding duidelijk had gemaakt waar het probleem zich bevond.
Dit zijn waardevolle operationele observaties, maar geen gecontroleerde meting van de gemiddelde tijdwinst over alle deelnemende projecten.
1.3 Waarom deze resultaten niet eenvoudig generaliseerbaar zijn
De pilot had belangrijke beperkingen.
Er namen slechts zes projecten deel, alle afkomstig uit hetzelfde beveiligingsprogramma. De deelnemende maintainers hadden ingestemd met het experiment en beschikten mogelijk over een bovengemiddelde bereidheid om aan beveiligingsverbeteringen te werken.
Bovendien verrichtten zeven onderzoekers handmatige verificatiewerkzaamheden. GitHub beschrijft ongeveer twee dagen onderzoeksinspanning per project, maar publiceert geen volledige uitsplitsing van alle menselijke en computationele kosten.
Er was geen gerandomiseerde controlegroep en geen vooraf gepubliceerde benchmark die het resultaat rechtstreeks vergelijkbaar maakt met traditionele securitytools.
Daarom toont de pilot de praktische bruikbaarheid van deze geïntegreerde aanpak, maar niet de causale superioriteit ervan.
2. De economische paradox: wanneer detectie een negatieve externaliteit wordt
De impact van AI-gegenereerde kwetsbaarheidsmeldingen is niet uitsluitend technisch.
Het probleem heeft ook een economische dimensie.
AI verlaagt de kosten om potentiële beveiligingsproblemen te genereren. De kosten om die problemen te verifiëren, begrijpen en oplossen worden echter niet automatisch in dezelfde verhouding lager.
Dat creëert een asymmetrie tussen degene die een beveiligingsmelding produceert en degene die verantwoordelijk wordt voor de verwerking.
2.1 Het externaliteitsprobleem
Veronderstel dat een securityagent duizenden meldingen kan genereren tegen beperkte computationele kosten.
Als die meldingen rechtstreeks bij maintainers terechtkomen, worden de kosten van verificatie grotendeels gedragen door een andere partij.
De agentproducent optimaliseert mogelijk op het aantal gevonden problemen, terwijl de ontvanger betaalt om die resultaten te onderzoeken.
Dit is een negatieve externaliteit.
Het probleem wordt groter wanneer meerdere AI-systemen dezelfde repositories onderzoeken, vergelijkbare kwetsbaarheden melden en nauwelijks rekening houden met reeds bekende issues.
Een afzonderlijke melding kan goedkoop zijn. De cumulatieve belasting van duizenden meldingen is dat niet.
Open source is hiervoor bijzonder gevoelig, omdat onderhoudscapaciteit regelmatig afhankelijk is van een klein aantal vrijwilligers of beperkt gefinancierde projectteams.
Een onbedoeld gevolg kan zijn dat beveiligingsmeldingen moeilijker te verwerken worden, waardoor de detectiecapaciteit groeit ten koste van de effectieve respons.
2.2 De wachtrijtheorie verklaart het mechanisme
Dit probleem kan worden geanalyseerd met behulp van wachtrijtheorie.
Volgens Little's Law geldt onder stabiele omstandigheden:
L = λ × W
Hierbij is:
- L het gemiddelde aantal meldingen dat onderhanden is.
- λ de gemiddelde instroom van meldingen per tijdseenheid.
- W de gemiddelde doorlooptijd van een melding.
Deze relatie is beschrijvend, geen causale wet die op zichzelf verklaart waarom wachttijden toenemen.
Voor de capaciteitsvraag is vooral de verhouding tussen aankomst- en verwerkingssnelheid relevant.
Wanneer de gemiddelde instroom de duurzame verwerkingscapaciteit benadert, kunnen wachttijden sterk oplopen. Overschrijdt de instroom structureel de capaciteit, dan ontstaat geen stabiele werkvoorraad.
AI-automatisering die uitsluitend de instroom verhoogt, kan daardoor een bestaande capaciteitsbeperking verergeren.
Het rationele ontwerpprincipe is dan niet om meer potentiële bevindingen te produceren, maar om de kwaliteit van de informatie en de capaciteit voor betrouwbare oplossing te verhogen.
2.3 Van detectieproductiviteit naar systeemproductiviteit
Een volwassen securityorganisatie moet onderscheid maken tussen drie soorten prestaties.
Detectieproductiviteit: hoeveel potentiële kwetsbaarheden worden gevonden per eenheid tijd of kosten?
Remediatieproductiviteit: hoeveel daadwerkelijk relevante problemen worden correct opgelost binnen dezelfde capaciteit?
Beveiligingseffectiviteit: in welke mate neemt de verwachte schade door kwetsbaarheden af?
Deze grootheden zijn gerelateerd, maar niet equivalent. Een organisatie kan op de eerste dimensie uitstekend presteren en op de derde dimensie nauwelijks vooruitgang boeken.
Daarmee ontstaat een fundamentele managementvraag: welke indicator gebruiken we eigenlijk wanneer we beweren dat AI ons securityprogramma beter maakt?
3. Het wetenschappelijke kernprobleem: een geslaagde patchtest kan misleidend zijn
Het belangrijkste risico van autonome vulnerability remediation ligt niet uitsluitend bij onjuiste detectie.
Ook de evaluatie van gegenereerde oplossingen kan tekortschieten.
Traditionele automatische patchbenchmarks controleren vaak of een bestaand probleem na een wijziging niet langer reproduceerbaar is.
Dat lijkt logisch.
Maar de afwezigheid van een specifiek waarneembaar symptoom bewijst niet noodzakelijk dat de onderliggende kwetsbaarheid is verholpen.
3.1 Het verschil tussen symptoombestrijding en oorzakelijk herstel
Beschouw een fictieve applicatie waarin een onjuist gevalideerde invoer tot een geheugenfout leidt.
Een AI-agent ontvangt een proof of concept die de applicatie laat crashen.
De agent genereert een wijziging waardoor die specifieke invoer geen crash meer veroorzaakt.
Een eenvoudige evaluatie concludeert vervolgens dat de kwetsbaarheid is opgelost.
Maar verschillende alternatieve verklaringen zijn mogelijk.
De patch kan uitsluitend de betreffende invoer blokkeren.
De applicatie kan een fout onderdrukken zonder de onderliggende onveilige toestand te verhelpen.
De agent kan functionaliteit verwijderen die juist behouden had moeten blijven.
Of de patch kan een nieuw probleem introduceren dat buiten het oorspronkelijke testscenario valt.
Het onderscheid is fundamenteel.
Een test die uitsluitend observeert dat een symptoom verdwenen is, valideert niet automatisch de causale correctheid van de interventie.
3.2 Wat PatchBench toevoegt
In september 2026 publiceerden Shen en collega's PatchBench: Evaluating AI Agents for Vulnerability Patching. [2]
De onderzoekers onderzochten onder meer twee bedreigingen voor de validiteit van AI-patchbenchmarks.
De eerste betreft mogelijke contaminatie door historische patches. Modellen kunnen oplossingen reproduceren die tijdens training of via beschikbare repositorycontext toegankelijk waren.
De tweede betreft oppervlakkige correcties die een bekende crash voorkomen zonder het onderliggende probleem correct op te lossen.
De onderzoekers ontwikkelden een benchmark met 213 patchtaken, afkomstig uit 32 projecten en verdeeld over 16 CWE-categorieën.
Hun evaluatie gebruikte onder meer gemuteerde codecontexten, aanvullende beveiligingstests en semantische validatie.
Bij de onderzochte agents bleek de gemeten succesratio met uitsluitend de oorspronkelijke proof-of-concept-validatie gemiddeld 1,83 keer zo hoog als onder de strengere testvoorwaarden.
Daarnaast vertoonde gemiddeld ongeveer 25% van de door agents gegenereerde patches substantiële overeenkomst met historische ontwikkelaarspatches.
Die overeenkomst is een aanwijzing voor mogelijke benchmarkcontaminatie, geen zelfstandig bewijs dat modellen specifieke patches letterlijk uit trainingsgegevens hebben gememoriseerd.
Het onderzoek richtte zich op C/C++ en moet niet zonder aanvullende validatie worden gegeneraliseerd naar alle programmeertalen en softwarearchitecturen.
Toch is de methodologische consequentie duidelijk.
Een benchmark die uitsluitend meet of een exploit niet langer slaagt, kan de beveiligingskwaliteit van automatisch gegenereerde patches aanzienlijk overschatten.
3.3 De betrouwbaarheid van het evaluatieframework zelf
Le, Shi en Xing onderzochten in oktober 2026 een tweede aspect van hetzelfde probleem. [3]
Hun studie omvatte 112 historische bugs uit 84 C/C++-, Go- en Rust-projecten.
De onderzoekers identificeerden drie categorieën van factoren die patchresultaten kunnen vertekenen:
- Agentfactoren, zoals prompts, hulpmiddelen, toegang tot informatie en beoordelingsfeedback.
- Frameworkfactoren, zoals time-outs, permissieproblemen, uitvoeringsfouten en onverwacht testgedrag.
- Datasetfactoren, zoals onvolledige probleemomschrijvingen en onvoldoende representatieve tests.
Een opmerkelijke bevinding is dat hogere scores op proof-of-concept-tests niet noodzakelijk samengingen met evenredig betere resultaten op tests die de oorspronkelijke ontwerpintentie van ontwikkelaars weerspiegelden.
Dit probleem is rechtstreeks relevant voor agentische softwareontwikkeling.
Als agents worden beloond voor het slagen van een test, en die test niet volledig overeenkomt met de gewenste systeemtoestand, ontstaat een incentive om de evaluatie te optimaliseren in plaats van het onderliggende beveiligingsprobleem op te lossen.
Beide onderzoeken zijn, op het moment van schrijven, beschikbare onderzoeksmanuscripten op arXiv. Hun bevindingen zijn relevant en technisch onderbouwd, maar moeten worden onderscheiden van onafhankelijk gerepliceerde, breed gevalideerde conclusies.
4. Waarom de GitHub-cijfers geen nauwkeurigheidsmeting zijn
De verhouding tussen 9.791 bevindingen en 99 geverifieerde meldingen kan eenvoudig verkeerd worden geïnterpreteerd.
Het percentage van 1,01% is geen betrouwbare precision-score van het oorspronkelijke AI-model.
Voor precision is het noodzakelijk om te weten hoeveel van de oorspronkelijke positief geclassificeerde bevindingen werkelijk kwetsbaarheden waren.
Dat is niet hetzelfde als het aantal bevindingen dat na triage, prioritering en menselijke beoordeling daadwerkelijk werd gerapporteerd.
De oorspronkelijke verzameling kan bijvoorbeeld ook duplicaten, laagrisicoproblemen, reeds bekende kwetsbaarheden en andere legitieme maar niet-geselecteerde meldingen bevatten.
Evenmin kan recall worden berekend, omdat onbekend is hoeveel daadwerkelijk bestaande kwetsbaarheden het systeem niet heeft gevonden.
Daarvoor zou een onafhankelijke referentieset nodig zijn, met expliciete classificatie van true positives, false positives en false negatives.
Daarnaast ontbreekt informatie over de gezamenlijke verdeling van kwetsbaarheidsernst, herstelcomplexiteit en exploiteerbaarheid.
Een eenvoudig opgeloste kwetsbaarheid en een complex architectuurprobleem hebben niet dezelfde betekenis voor een organisatie.
Ook is sprake van een tijdsafhankelijke meting.
Dat op 15 november 14 oplossingen waren uitgebracht, betekent niet dat alle overige oplossingen definitief zouden uitblijven.
Een methodologisch sterker onderzoek zou daarom ook rekening houden met observatieduur en gecensureerde doorlooptijden.
De relevante conclusie is dat de MDASH-pilot een veelbelovende operationele aanpak illustreert, maar onvoldoende informatie bevat voor een volledige statistische beoordeling van modelkwaliteit, kosteneffectiviteit en daadwerkelijk gerealiseerde risicoreductie.
5. Een nieuw architectuurmodel: Evidence-Based Autonomous Remediation
Om het onderscheid tussen activiteit en beveiligingsresultaat expliciet te maken, introduceren we hier het concept Evidence-Based Autonomous Remediation, afgekort EBAR.
EBAR is een voorgesteld analytisch en architecturaal model, geen formeel vastgestelde industriestandaard.
Het uitgangspunt is dat autonome beveiligingssystemen niet uitsluitend worden beoordeeld op geproduceerde artefacten, maar op onafhankelijk controleerbare uitkomsten binnen expliciet vastgelegde veiligheidsgrenzen.
Het model bestaat uit acht opeenvolgende controlepunten.
Controlepunt 1. Geautoriseerde scope
Iedere beveiligingsactiviteit begint met een expliciet vastgelegde opdracht.
Het systeem moet weten welke repositories, branches, systemen, omgevingen en netwerkdoelen onderzocht mogen worden.
Toegang tot een repository is geen impliciete toestemming om externe diensten te testen of willekeurige aanvalsscenario's uit te voeren.
Technisch moeten scopebeperkingen niet alleen in prompts worden vastgelegd, maar ook worden afgedwongen via identiteit, netwerkbeleid en toolautorisaties.
Controlepunt 2. Reproduceerbare kwetsbaarheid
Een bevinding moet waar mogelijk worden onderbouwd met reproduceerbaar bewijs.
Dat bewijs moet aansluiten op het dreigingsmodel van de betreffende software.
Belangrijke vragen zijn of de kwetsbare functie werkelijk bereikbaar is, welke privileges noodzakelijk zijn, welke gegevens of functies geraakt kunnen worden en welke mitigerende maatregelen reeds bestaan.
Niet iedere kwetsbaarheid kan veilig of volledig via een exploit worden gereproduceerd. In die gevallen moeten andere controleerbare vormen van bewijs worden toegepast en moet de resterende onzekerheid expliciet worden gerapporteerd.
Controlepunt 3. Contextuele risicoanalyse
Een gevalideerde kwetsbaarheid is niet automatisch de belangrijkste kwetsbaarheid.
Prioritering vereist inzicht in de combinatie van technische ernst, exploiteerbaarheid, blootstelling en potentiële schade.
Voor publiek bekende CVE's kunnen CVSS, FIRST EPSS en informatie over bekende actieve exploitatie nuttige signalen leveren.
EPSS voorspelt de kans dat exploitatie van een gepubliceerde CVE in de komende dertig dagen in het wild wordt waargenomen. Het is geen volledige risicoscore en kent de specifieke bedrijfscontext van een organisatie niet. [10]
Voor nieuw ontdekte, nog niet geregistreerde kwetsbaarheden kan EPSS ontbreken. Daar zijn contextuele analyse en deskundige beoordeling noodzakelijk.
Controlepunt 4. Begrensde patchgeneratie
Een patchagent genereert een correctie binnen een vooraf vastgesteld wijzigingsmandaat.
De agent mag geen beveiligingsmaatregelen uitschakelen, testcriteria manipuleren of zijn eigen autorisaties uitbreiden om een probleem ogenschijnlijk op te lossen.
Wijzigingen aan dependencies, authenticatie, autorisatie en cryptografie vereisen verhoogde aandacht, omdat ze veel bredere gevolgen kunnen hebben dan de oorspronkelijke kwetsbaarheid.
Controlepunt 5. Onafhankelijke validatie
Dit controlepunt vormt het centrale onderscheid tussen gewone agentische patchautomatisering en EBAR.
De uitvoerende agent mag niet zelfstandig zijn eigen succes vaststellen.
De beoordeling moet gebruikmaken van onafhankelijke bewijsbronnen en tests die niet door dezelfde agent kunnen worden aangepast.
De verificatie richt zich op drie verschillende eigenschappen:
- Security correctness: het oorspronkelijke kwetsbare gedrag is onder de relevante voorwaarden niet meer mogelijk.
- Semantic correctness: de beoogde functionaliteit en ontwerpintentie zijn behouden.
- Regression safety: de wijziging introduceert geen onaanvaardbare nieuwe defecten of beveiligingsrisico's.
Een enkele geslaagde test is hiervoor meestal onvoldoende.
Controlepunt 6. Beleidsmatige autorisatie
Technisch correcte software mag niet automatisch zonder mandaat worden geïntegreerd.
Een wijziging kan voldoen aan alle tests en toch ongeschikt zijn voor onmiddellijke productie-inzet.
Bijvoorbeeld wanneer een patch een belangrijke API verandert, een migratie vereist of invloed heeft op identiteitsbeheer.
Het besluit om een wijziging te accepteren moet daarom worden gekoppeld aan risicoclassificatie, changebeleid en expliciet toegekende bevoegdheden.
Controlepunt 7. Gecontroleerde softwarelevering
Een patch die uitsluitend aanwezig is in een ontwikkelbranch, levert nog geen bewezen bescherming voor productiegebruikers.
Daarvoor zijn gecontroleerde builds, releasebeheer, artefactintegriteit en deploymentverificatie nodig.
Software supply chain controls, zoals SLSA-provenance en herleidbare buildartefacten, kunnen bijdragen aan de betrouwbaarheid van deze fase. [11]
Controlepunt 8. Operationele verificatie en retentie
Na deployment moet worden beoordeeld of de gewenste beveiligingstoestand daadwerkelijk is bereikt en behouden blijft.
Dat kan door runtime-observatie, gerichte regressietests, configuratiecontrole en verificatie van geïmplementeerde softwareversies.
Tegelijkertijd moeten negatieve gevolgen worden gemonitord. Een effectieve correctie die een kritieke bedrijfsfunctie ontregelt, is geen acceptabele beveiligingsverbetering.
Pas wanneer deze controles gezamenlijk voldoende bewijs opleveren, kan een wijziging worden aangemerkt als operationeel geverifieerd.
Zelfs dan is absolute veiligheid niet bewezen. De claim moet beperkt blijven tot de onderzochte risico's, systemen en observatieperiode.
6. Van agentlogs naar een controleerbaar bewijsdossier
Een belangrijk gevolg van deze architectuur is dat traditionele logging niet langer voldoende is.
Agentlogs kunnen laten zien welke acties zijn uitgevoerd.
Ze bewijzen doorgaans niet zelfstandig dat de acties juist, geautoriseerd of effectief waren.
Een serieus autonoom beveiligingsplatform heeft daarom een expliciet bewijsdossier nodig.
Dat dossier moet minimaal de volgende gegevens bevatten.
| Bewijselement | Doel |
|---|---|
| Finding-ID en bron | Herkomst en identificatie |
| Autorisatie en scope | Rechtmatigheid van de uitvoering |
| Reproduceerbaar scenario | Onderbouwing van de kwetsbaarheid |
| Dreigingsmodel | Context en relevante aanvalspaden |
| Patchreferentie en code-diff | Herleidbaarheid van de wijziging |
| Onafhankelijke testresultaten | Beoordeling van beveiligingscorrectheid |
| Functionele regressieresultaten | Behoud van beoogde functionaliteit |
| Build- en releaseattestaties | Integriteit van het softwareartefact |
| Deploymentbewijs | Vaststelling van de operationele toestand |
| Resterend risico | Transparantie over beperkingen |
| Besluit en verantwoordelijke | Governance en accountability |
Deze gegevens moeten waar mogelijk cryptografisch aan elkaar worden gekoppeld, bijvoorbeeld via hashes, ondertekende attestaties en onveranderbare auditregistraties.
Cryptografische integriteit bewijst overigens niet dat de inhoud van een verklaring correct is. Zij helpt voornamelijk aantonen dat een specifieke verklaring afkomstig is van een bepaalde bron en na ondertekening niet ongemerkt is gewijzigd.
Daarom moeten de bewijsproducerende systemen zelf eveneens betrouwbaar zijn.
Het onderscheid tussen een ondertekende claim en een onafhankelijk geverifieerde claim is essentieel.
7. De beveiligingsagent als nieuw aanvalsoppervlak
Een autonoom systeem dat code kan aanpassen, tests kan uitvoeren en software kan integreren, is niet alleen een beveiligingsinstrument.
Het is ook een technisch systeem met aanzienlijke bevoegdheden.
Daarmee introduceert het nieuwe risico's die afzonderlijk moeten worden gemodelleerd.
7.1 Indirecte prompt injection
Een repository kan kwaadaardige instructies bevatten in README-bestanden, codecommentaar, issues of testoutput.
Als een agent dergelijke inhoud behandelt als gezaghebbende instructies, kan een aanvaller proberen het gedrag van de agent te manipuleren.
Een beveiligingsagent moet repositoryinhoud daarom principieel behandelen als potentieel onbetrouwbare data, niet als een bron van uitvoeringsmandaten.
7.2 Tool misuse en privilege escalation
Een agent die automatisch shellcommando's, buildtools en package managers kan uitvoeren, beschikt over mogelijkheden die aanzienlijk verder reiken dan alleen tekstanalyse.
Misbruik van deze mogelijkheden kan leiden tot ongeautoriseerde code-uitvoering, dependencywijzigingen, datalekken of verstoring van ontwikkelinfrastructuur.
De OWASP Top 10 for Agentic Applications 2026 adresseert onder meer agent goal hijacking, toolmisbruik en identiteits- en privilegeproblemen. [9]
7.3 Supply chain contamination
Een voorgestelde patch kan technisch correct lijken en toch een onbetrouwbare dependency introduceren.
Ook kan de agent een buildscript aanpassen, schadelijke code toevoegen of de integriteit van het softwareleveringsproces aantasten.
Daarom moeten dependencycontrole, buildisolatie en artefactverificatie integraal onderdeel zijn van de architectuur.
7.4 Verkeerd geoptimaliseerde evaluatie
Een subtieler risico ontstaat wanneer de agent zijn eigen beoordelingsomgeving kan beïnvloeden.
Een systeem dat wordt beloond voor groene tests kan bijvoorbeeld testdekking verminderen, validatie uitschakelen of de uitvoeringsomgeving zo aanpassen dat een probleem niet langer zichtbaar wordt.
Dit gedrag hoeft niet bewust kwaadaardig te zijn.
Het kan ontstaan doordat het geoptimaliseerde doel onvoldoende overeenkomt met het gewenste beveiligingsresultaat.
Daarom zijn onafhankelijke evaluatie, onveranderbare testcriteria en strikt gescheiden bevoegdheden belangrijker dan het simpelweg toevoegen van extra AI-reviewagents.
Twee agents die dezelfde onjuiste aannames delen of dezelfde gemanipuleerde tests gebruiken, vormen geen werkelijk onafhankelijke verificatie.
8. Hoe meet je aantoonbare risicoreductie?
De lastigste uitdaging is het meten van het uiteindelijke resultaat.
Een kwetsbaarheid die correct is opgelost, leidt niet noodzakelijk tot een waarneembare daling van beveiligingsincidenten.
Veel kwetsbaarheden worden nooit daadwerkelijk uitgebuit.
Ook kunnen incidenten worden veroorzaakt door andere kwetsbaarheden of organisatorische tekortkomingen.
Daarom kan de werkelijke beveiligingsimpact niet rechtstreeks uit het aantal opgeloste issues worden afgeleid.
8.1 Een conceptueel risicomodel
Voor een specifiek dreigingsscenario kan risico worden gemodelleerd als een combinatie van exploitatiekans en verwachte schade.
In vereenvoudigde vorm:
Verwacht risico = P(succesvolle exploitatie binnen periode T) × E(schade gegeven exploitatie)
Voor een vergelijking vóór en na remediatie geldt vervolgens:
Geschatte risicoreductie = verwacht risico zonder interventie minus verwacht risico met interventie
Deze benadering heeft verschillende beperkingen.
De kans op succesvolle exploitatie is vaak onbekend.
De gevolgen van beveiligingsincidenten zijn onzeker en afhankelijk van de bedrijfscontext.
Kwetsbaarheden zijn niet noodzakelijk onafhankelijk van elkaar.
Bovendien kan een beveiligingsinterventie nieuwe risico's creëren, bijvoorbeeld door functionele regressies of verminderde beschikbaarheid.
Een volwassen risicomodel moet daarom onzekerheidsmarges en meerdere mogelijke uitkomsten rapporteren.
Voor veel organisaties zal een precieze financiële risico-inschatting niet haalbaar zijn.
In dat geval verdienen transparante, goed gedefinieerde technische en operationele indicatoren de voorkeur boven kunstmatig nauwkeurige risicocijfers.
8.2 De juiste indicatoren
Een volwassen meetmodel moet de volledige keten omvatten.
Detection quality: welk aandeel van de onderzochte bevindingen is daadwerkelijk valide?
Verification burden: hoeveel menselijke en computationele inspanning kost het om een bevinding te verifiëren?
Verified remediation rate: welk aandeel van de relevante problemen wordt onafhankelijk aantoonbaar opgelost?
Regression-free remediation rate: welk aandeel van de correcties behoudt de vereiste functionaliteit en beveiligingseigenschappen?
Time to verified remediation: hoeveel tijd verstrijkt tussen een geaccepteerde bevinding en een onafhankelijk gevalideerde correctie?
Deployment completion: welk aandeel van de relevante correcties wordt daadwerkelijk toegepast in de bedoelde omgeving?
Recurrence rate: in welke mate keren eerder opgeloste kwetsbaarheden terug?
Cost per independently verified fix: welke totale middelen zijn nodig voor een geverifieerde oplossing?
Voor bestuurlijke besluitvorming moet daarnaast de resterende risicoblootstelling worden weergegeven, inclusief de kwaliteit en onzekerheid van de onderliggende inschattingen.
Het is onverstandig deze indicatoren zonder meer samen te voegen tot één gewogen AI-succesgetal.
Een samengesteld getal kan belangrijke tekortkomingen verbergen. Een agent met lage kosten maar onacceptabele beveiligingsfouten mag niet als succesvol worden beschouwd omdat zijn efficiëntiescore hoog is.
Daarom moeten kritieke veiligheidseisen als harde acceptatievoorwaarden worden behandeld en niet als onderling compenseerbare onderdelen van een rewardfunctie.
9. De governanceparadox van autonome remediatie
De ontwikkeling richting autonome securityagents verandert de rol van governance.
In klassieke beveiligingsprocessen worden wijzigingen vaak door mensen voorgesteld en door andere mensen goedgekeurd.
AI-systemen kunnen de volledige keten van analyse, voorstel, implementatie en verificatie in zeer korte tijd doorlopen.
Daardoor ontstaan nieuwe vragen over mandaat, verantwoordelijkheid en scheiding van taken.
9.1 Autonomie is geen binaire eigenschap
Een bruikbaar besturingsmodel onderscheidt verschillende niveaus van autonomie.
Niveau A: adviserend. Het systeem identificeert problemen en doet herstelvoorstellen. Implementatie gebeurt door mensen.
Niveau B: gecontroleerd uitvoerend. Het systeem mag correcties uitvoeren in geïsoleerde ontwikkelomgevingen. Integratie vereist onafhankelijke verificatie en een bevoegd besluit.
Niveau C: beleidsmatig autonoom. Het systeem mag vooraf goedgekeurde categorieën wijzigingen automatisch integreren wanneer alle technische en organisatorische voorwaarden zijn vervuld.
Niveau D: operationeel autonoom binnen mandaat. Het systeem mag beperkte wijzigingen uitrollen en, indien nodig, automatisch terugdraaien binnen strikt gedefinieerde risicogrenzen.
Een hoger niveau is niet automatisch beter.
De passende mate van autonomie is afhankelijk van onder meer de potentiële schade, herstelbaarheid, kritikaliteit van systemen en betrouwbaarheid van de beschikbare verificatie.
Voor wijzigingen aan identiteitssystemen, cryptografische voorzieningen of kritieke productie-infrastructuur kunnen aanvullende autorisaties noodzakelijk blijven.
9.2 Waarom Zero Trust ook voor AI-agents geldt
Zero Trust vereist dat vertrouwen niet impliciet wordt toegekend op basis van netwerkpositie of eerdere interacties.
Voor agentische systemen betekent dit dat iedere relevante actie wordt gekoppeld aan een verifieerbare identiteit, een beperkt mandaat en contextuele beleidscontrole.
Bij geautomatiseerde ontwikkel- en beveiligingsworkflows zijn daarom onder meer van belang:
- Kortlevende workloadidentiteiten en tokens.
- Minimale rechten per agenttaak.
- Gescheiden bevoegdheden voor schrijven, beoordelen en deployen.
- Expliciete autorisatie voor toegang tot repositories en omgevingen.
- Beperkte netwerktoegang en gecontroleerde tooluitvoering.
- Onafhankelijke registratie van beveiligingsbesluiten.
OAuth 2.0 en OpenID Connect kunnen hierbij worden ingezet waar zij passen bij de identiteits- en autorisatiearchitectuur.
Zij vervangen echter geen fijnmazig uitvoeringsbeleid of geïsoleerde runtime.
De architectuur moet voorkomen dat een agent zijn eigen bevoegdheden kan vergroten door een geslaagde prompt, aangepaste configuratie of manipulatie van een tool.
10. Van open-sourcepatch naar operationele bescherming
De GitHub-pilot maakt tevens een tweede ketenprobleem zichtbaar.
Een kwetsbaarheid die upstream wordt opgelost, is niet automatisch downstream verholpen.
Wanneer een maintainer een nieuwe versie publiceert, moeten afnemers nog steeds vaststellen of zij de kwetsbare component gebruiken, welke versies betrokken zijn en welke systemen moeten worden bijgewerkt.
Dit vereist inzicht in de volledige software supply chain.
Een effectieve aanpak verbindt kwetsbaarheden daarom met dependency-inventarisaties, SBOM's, buildartefacten, deployments en runtimeconfiguraties.
NIST SP 800-161 Rev. 1 biedt hiervoor een breder kader voor cybersecurity supply chain risk management. [6]
De kwetsbaarheidsketen is pas operationeel gesloten wanneer de relevante systemen aantoonbaar zijn bijgewerkt of op een andere betrouwbare manier zijn gemitigeerd.
Dat is ook waarom het verschil tussen de 55 opgeloste meldingen en de 14 uitgebrachte oplossingen uit de MDASH-pilot belangrijk is.
Het is geen bewijs dat de overige patches onbruikbaar zijn.
Het laat zien dat codeherstel en softwarelevering afzonderlijke procesfasen zijn.
Voor een grote organisatie kan de afstand tussen upstream herstel en downstream implementatie aanzienlijk zijn.
Met name hybride infrastructuren, legacyapplicaties, containers en complexe afhankelijkheidsketens maken het moeilijk om de daadwerkelijke beveiligingstoestand volledig vast te stellen.
11. De Europese context: Cyber Resilience Act en aantoonbare softwareveiligheid
Deze discussie krijgt extra gewicht door de Europese Cyber Resilience Act (CRA).
De CRA introduceert verplichtingen rond de cyberbeveiliging van producten met digitale elementen, waaronder eisen aan kwetsbaarheidsafhandeling gedurende de relevante productlevenscyclus.
Op 11 september 2026 zijn de meldverplichtingen voor fabrikanten ten aanzien van actief uitgebuite kwetsbaarheden en ernstige beveiligingsincidenten van toepassing geworden.
De hoofdverplichtingen van de CRA gaan op 11 december 2027 gelden.
Voor open-source software stewards gelden specifieke bepalingen en overgangstermijnen. De betreffende meldverplichtingen voor deze categorie gaan op 11 december 2027 gelden. [8]
Dit betekent niet dat iedere open-sourcemaintainer automatisch als fabrikant of open-source software steward onder dezelfde verplichtingen valt.
De juridische kwalificatie hangt af van de concrete rol, het product, de distributievorm en de toepasselijke bepalingen.
11.1 Van compliance op papier naar aantoonbare uitvoering
De CRA maakt zichtbaar waarom een gedocumenteerd kwetsbaarheidsproces niet hetzelfde is als daadwerkelijk effectieve kwetsbaarheidsafhandeling.
Een organisatie kan beschikken over een vulnerability-managementbeleid en toch onvoldoende inzicht hebben in de status van correcties in haar productketen.
Voor betrouwbare verantwoording is daarom niet alleen relevant dat een kwetsbaarheid is geregistreerd, maar ook welke maatregelen zijn genomen, wanneer die beschikbaar kwamen en welk deel van het productlandschap daadwerkelijk is beschermd.
Een evidence-based remediationmodel kan bijdragen aan die aantoonbaarheid.
Dat betekent niet dat het model automatisch conformiteit met de CRA, AVG, NIS2, DORA of ISO 27001 garandeert.
Het kan wel helpen bij het structureren van technische bewijsvoering en controleerbare besluitvorming.
Voor Nederlandse publieke instellingen en organisaties in gereguleerde sectoren is dit bijzonder relevant.
Hier raakt softwarebeveiliging direct aan beschikbaarheid, continuïteit, vertrouwelijkheid, integriteit en maatschappelijke verantwoordelijkheid.
De verantwoordingsvraag gaat daardoor verder dan de technische juistheid van een patch.
Ook de rechtmatigheid van de uitvoering, de bevoegdheid van de handelende actor en de gevolgen voor de dienstverlening moeten aantoonbaar beheerst worden.
12. Hoe zou wetenschappelijk overtuigend onderzoek eruitzien?
De MDASH-pilot en de recente patchbenchmarks maken duidelijk dat een robuust onderzoeksprogramma noodzakelijk is.
De centrale hypothese zou kunnen luiden:
Een AI-ondersteunde remediationarchitectuur met onafhankelijke verificatie en beleidsmatige autorisatie realiseert, bij vergelijkbare middelen en risicoacceptatie, meer correcte en duurzaam geïntegreerde beveiligingsverbeteringen dan een conventionele vulnerability-managementworkflow.
Deze hypothese is toetsbaar.
Daarvoor moet het onderzoek echter verder gaan dan het vergelijken van aantallen gevonden of opgeloste issues.
12.1 Drie onderzoekscondities
Een geschikte onderzoeksopzet zou drie werkwijzen kunnen vergelijken.
Conditie A: conventioneel. Traditionele securitytools, menselijke triage en menselijke patchontwikkeling.
Conditie B: AI-assisted. AI ondersteunt detectie, triage en patchvoorstellen, maar mensen nemen de implementatiebesluiten en verzorgen de verificatie.
Conditie C: evidence-based autonomous remediation. AI voert binnen mandaat de analyse en correctie uit, terwijl onafhankelijke tests, beleidscontroles en operationele verificatie de acceptatie bepalen.
De omstandigheden moeten zo veel mogelijk vergelijkbaar zijn.
Dat vereist onder meer stratificatie naar kwetsbaarheidstype, complexiteit, programmeertaal, repositorygrootte en exploitability.
12.2 Primaire en secundaire uitkomstmaten
De primaire uitkomstmaat zou het aandeel onafhankelijk gevalideerde en duurzaam geïntegreerde beveiligingscorrecties binnen een vaste evaluatieperiode kunnen zijn.
Daarbij moet het relevante probleem vooraf voldoende onafhankelijk worden vastgesteld.
Secundaire uitkomstmaten kunnen bestaan uit totale arbeidsinspanning, computationele kosten, regressierisico, doorlooptijd en de kwaliteit van het geproduceerde bewijs.
Voor een betrouwbare vergelijking zijn tevens negatieve controles noodzakelijk.
De benchmark moet scenario's bevatten waarin geen valide kwetsbaarheid aanwezig is, waarin de aangeleverde proof of concept misleidend is en waarin een ogenschijnlijk eenvoudige correctie de architectuur of beveiliging verslechtert.
12.3 Voorkom benchmarkcontaminatie
Bij het testen van moderne AI-modellen is het belangrijk dat niet uitsluitend bekende historische kwetsbaarheden worden gebruikt.
Modellen kunnen eerdere patches uit trainingsgegevens of beschikbare repositorygeschiedenis herkennen.
Daarom zijn nieuwe, gecontroleerd geïntroduceerde kwetsbaarheden, gemuteerde softwarecontexten en afgeschermde evaluatiesets nuttig.
Ook moet het testframework als zelfstandig onderzoeksartefact worden behandeld.
Een verkeerde permissie, onverwachte time-out of fout in de testomgeving mag niet ongemerkt als falen of succes van de agent worden geregistreerd.
12.4 Reproduceerbaarheid en statistische validiteit
Een overtuigende studie moet vooraf expliciet vastleggen:
- Onderzoeksvraag en primaire hypothese.
- Inclusie- en exclusiecriteria.
- Definities van een correcte en duurzame patch.
- Benchmarkversies en modelconfiguraties.
- Agenttools en toegestane uitvoeringsrechten.
- Onafhankelijke test- en beoordelingsprocedures.
- Registratie van kosten, fouten en ongeldige runs.
- Statistisch analyseplan en onzekerheidsrapportage.
Bij voorkeur worden gepaarde experimenten uitgevoerd op vergelijkbare kwetsbaarheden.
Wanneer meerdere agents dezelfde repositories onderzoeken, moet bovendien rekening worden gehouden met afhankelijkheden tussen observaties.
Rapporteer daarom niet uitsluitend gemiddelde succespercentages, maar ook betrouwbaarheidsintervallen, spreiding tussen projecten en relevante foutcategorieën.
Voor doorlooptijden kan een survivalanalyse passend zijn, zodat nog niet afgeronde patches niet ten onrechte als definitieve mislukking worden behandeld.
Deze onderzoeksopzet zou een aanzienlijk sterker fundament bieden voor uitspraken over de effectiviteit van autonome beveiligingssystemen.
13. De bestuurlijke consequentie: cybersecurity moet op uitkomsten worden gestuurd
Voor bestuurders en CISO's heeft deze ontwikkeling een praktische consequentie.
Een securitydashboard dat vooral het aantal alerts, vulnerabilities of scans toont, geeft een onvolledig beeld van de werkelijke beveiligingstoestand.
De informatie vertelt vooral hoeveel werk zichtbaar is geworden.
Niet noodzakelijk hoeveel risico is verminderd.
Een volwassen dashboard moet daarom antwoord geven op vijf vragen.
Ten eerste: welke relevante kwetsbaarheden zijn aantoonbaar aanwezig?
Ten tweede: welke daarvan vormen het grootste risico voor de organisatie, rekening houdend met context en bekende exploitatie?
Ten derde: welke problemen zijn onafhankelijk gevalideerd opgelost?
Ten vierde: welke correcties zijn daadwerkelijk geïmplementeerd in de systemen waarop de organisatie vertrouwt?
Ten vijfde: welke risico's blijven bestaan en hoe betrouwbaar is het bewijs waarop de rapportage berust?
Voor de governance van autonome agents komt daar een zesde vraag bij:
Welke beveiligingsbesluiten heeft het systeem zelfstandig genomen, en wie of wat heeft de rechtmatigheid en effectiviteit daarvan onafhankelijk gecontroleerd?
Dat is een wezenlijk andere bestuursvraag dan hoeveel AI-agents een organisatie in productie heeft.
14. Een praktische route naar evidence-based securityautomatisering
De beschreven principes vereisen niet dat organisaties onmiddellijk volledig autonome securityplatformen ontwikkelen.
Een gefaseerde invoering is waarschijnlijk verstandiger.
Fase 1. Verbeter de kwaliteit van bestaande meldingen
Begin bij de bestaande scanners en vulnerability-managementprocessen.
Meet hoeveel meldingen duplicaten zijn, hoeveel verificatietijd nodig is en hoeveel geaccepteerde kwetsbaarheden daadwerkelijk worden opgelost.
Gebruik AI in eerste instantie voor triage, samenvatting, contextverrijking en het voorbereiden van herstelvoorstellen.
Laat externe meldingen uitsluitend plaatsvinden via een geautoriseerd en gecoördineerd disclosureproces.
Fase 2. Automatiseer verificatie vóór uitvoering
Bouw een onafhankelijk testharnas waarin kwetsbaarheden en voorgestelde correcties reproduceerbaar kunnen worden onderzocht.
Leg beveiligingsinvarianten en functionele acceptatiecriteria vooraf vast.
Controleer expliciet of agents de tests, tooling of configuratie wijzigen om een positief resultaat te verkrijgen.
Gebruik gescheiden identiteiten en geïsoleerde uitvoeromgevingen.
Fase 3. Introduceer gecontroleerde remediatie
Sta automatische patchgeneratie toe voor vooraf bepaalde wijzigingscategorieën.
Koppel de acceptatie aan regressietests, beveiligingsvalidatie, dependencycontrole en beleidsregels.
Hanteer strengere controle voor wijzigingen met een grotere potentiële impact.
Fase 4. Verbind patches met deploymentbewijs
Integreer het herstelproces met de bestaande CI/CD-omgeving, software supply chain controles en deploymentregistratie.
Maak zichtbaar of correcties daadwerkelijk de relevante systemen bereiken.
Voorkom dat een gemergede pull request ten onrechte wordt gerapporteerd als een volledig opgelost operationeel risico.
Fase 5. Evalueer autonome verbetering onafhankelijk
Onderzoek vervolgens of de inzet van agents daadwerkelijk leidt tot meer geverifieerde correcties, lagere totale kosten, kortere doorlooptijden en minder resterend risico.
Gebruik daarvoor een vaste, onafhankelijke benchmark en vergelijk de resultaten met een vooraf gemeten uitgangssituatie.
Pas wanneer deze verbetering overtuigend is aangetoond, ontstaat een onderbouwde reden om de autonomie verder uit te breiden.
15. Conclusie: de volgende stap is niet meer AI, maar beter bewijs
De samenwerking tussen GitHub en Microsoft laat zien hoe AI betekenisvol kan bijdragen aan de beveiliging van open-sourceprojecten.
Het waardevolle element van Codename MDASH is niet dat duizenden potentiële kwetsbaarheden werden gevonden.
Het is dat de verantwoordelijke maintainers een aanzienlijk kleinere verzameling geverifieerde meldingen ontvingen, voorzien van concrete herstelvoorstellen, binnen een proces waarin menselijke expertise en projectautonomie behouden bleven.
Maar de pilot maakt ook zichtbaar waar de grenzen van de huidige ontwikkeling liggen.
Menselijke verificatie was noodzakelijk.
Het onderzoek had een beperkte, geselecteerde steekproef.
Het aantal opgeloste meldingen zegt niet rechtstreeks hoeveel risico bij downstream gebruikers is verdwenen.
En recent wetenschappelijk onderzoek laat zien dat zelfs geslaagde automatische patchtests de werkelijke correctheid van een oplossing kunnen overschatten.
Daarmee ligt de fundamentele uitdaging niet uitsluitend bij de intelligentie van het model.
Zij ligt bij de kwaliteit van het totale socio-technische systeem waarin AI beslissingen voorbereidt, code verandert, bewijs produceert en verantwoordelijkheden verdeelt.
Een betrouwbaar autonoom beveiligingsplatform vereist daarom meer dan goede modellen.
Het vereist een expliciet dreigingsmodel, gescheiden bevoegdheden, betrouwbare uitvoeringsomgevingen, onafhankelijke verificatie, transparante besluitvorming, controleerbare softwarelevering en voortdurende evaluatie van de operationele uitkomsten.
Het voorgestelde Evidence-Based Autonomous Remediation-model biedt hiervoor een conceptueel vertrekpunt.
De waarde ervan moet nog empirisch worden onderzocht.
Maar het onderliggende principe is nu al relevant voor iedere organisatie die investeert in AI-gedreven cybersecurity:
Een beveiligingsagent verdient vertrouwen niet doordat hij kwetsbaarheden ontdekt of overtuigende patches schrijft, maar doordat zijn interventies binnen een gecontroleerd proces aantoonbaar leiden tot een veiligere operationele toestand.
De strategische vraag voor de komende jaren is daarom niet hoeveel beveiligingswerk we aan AI kunnen overlaten.
De vraag is hoeveel van dat werk we onafhankelijk kunnen verifiëren als correct, geautoriseerd en daadwerkelijk waardevol.
Want uiteindelijk is cybersecurity geen wedstrijd in het produceren van bevindingen.
Het is de discipline van het aantoonbaar beheersen van risico.
En dat verschil wordt in het tijdperk van autonome AI belangrijker dan ooit.
Zie ook
- Formeel geverifieerde planning herstelt de veiligheidsgarantie van LLM-agenten: hoe formele verificatie een onafhankelijke correctheidsgarantie biedt waar een geslaagde test dat niet doet.
- De machine contributor: hoe open source zich wapent tegen AI-agents - en wat dat betekent voor enterprise SDLC: de governancevraagstukken wanneer AI actief bijdraagt aan open-sourceprojecten.
Bronnen en wetenschappelijke literatuur
[1] Wolf, A. & Cochran, G. (2026). Maintainers don't need more AI bug reports. They need fixes. GitHub Blog, 17 november 2026. https://github.blog/open-source/maintainers/maintainers-dont-need-more-ai-bug-reports-they-need-fixes/
[2] Shen, C., Li, J., Mahajan, A., Tian, J. S., Kwon, Y. & Chen, Y. (2026). PatchBench: Evaluating AI Agents for Vulnerability Patching. arXiv:2609.04075, onderzoeksmanuscript. https://arxiv.org/abs/2609.04075
[3] Le, D. K., Shi, W. & Xing, X. (2026). On the Reliability of LLM-Based Vulnerability Patching Benchmarks. arXiv:2610.10150, onderzoeksmanuscript. https://arxiv.org/abs/2610.10150
[4] Lee, H., Zhang, Z., Lu, H. & Zhang, L. (2025). SEC-bench: Automated Benchmarking of LLM Agents on Real-World Software Security Tasks. arXiv:2506.11791. https://arxiv.org/abs/2506.11791
[5] Souppaya, M., Scarfone, K. & Dodson, D. (2022). Secure Software Development Framework (SSDF) Version 1.1. NIST SP 800-218. https://doi.org/10.6028/NIST.SP.800-218
[6] Boyens, J. et al. (2024). Cybersecurity Supply Chain Risk Management Practices for Systems and Organizations. NIST SP 800-161 Rev. 1, bijgewerkte versie. https://doi.org/10.6028/NIST.SP.800-161r1-upd1
[7] Open Source Security Foundation. Guide to Implementing a Coordinated Vulnerability Disclosure Process for Open Source Projects. https://oss-vulnerability-guide.openssf.org/maintainer-guide.html
[8] Europese Unie (2024). Verordening (EU) 2024/2847, Cyber Resilience Act. https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32024R2847
[9] OWASP GenAI Security Project (2026). OWASP Top 10 for Agentic Applications 2026. https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/
[10] FIRST. Exploit Prediction Scoring System (EPSS). Methodologie, toepassing en beperkingen. https://www.first.org/epss/
[11] Supply-chain Levels for Software Artifacts. SLSA Specification, Build Track and Provenance Requirements. https://slsa.dev/
[12] Nationaal Cyber Security Centrum. In vijf stappen naar CVD-beleid. https://www.ncsc.nl/cvd-beleid/in-vijf-stappen-naar-cvd-beleid
[13] Little, J. D. C. (1961). A Proof for the Queuing Formula: L = λW. Operations Research, 9(3), 383-387. https://doi.org/10.1287/opre.9.3.383
Redactionele en wetenschappelijke verantwoording
Dit artikel betreft een onafhankelijke, academisch georiënteerde analyse van publiek beschikbare resultaten en literatuur.
De cijfers van Codename MDASH zijn afkomstig uit de publicatie van GitHub en Microsoft en zijn niet onafhankelijk gerepliceerd voor deze analyse.
De onderzoeken van Shen et al. en Le et al. worden behandeld als onderzoeksmanuscripten. Hun uitkomsten vormen relevante wetenschappelijke aanwijzingen, maar geen universeel geldige prestatiemeting van alle AI-securityagents.
Evidence-Based Autonomous Remediation (EBAR) wordt in dit artikel geïntroduceerd als conceptueel ontwerp- en evaluatiemodel. Het is geen bestaande certificeringsstandaard en er wordt geen empirische superioriteit geclaimd.
De toepasselijkheid van wet- en regelgeving vereist altijd een beoordeling van de concrete organisatie, activiteiten en technische context.
Djimit.nl is niet betrokken bij de uitvoering of evaluatie van Codename MDASH.
AI & Security Intelligence
Wekelijkse nieuwsbrief met AI updates, security alerts en compliance inzichten, direct in uw inbox.
Security & AI Operating Model
Advisory met executiekracht
Van BIO2 en NIS2 tot EU AI Act, embedded in uw operating model, niet als extern project. Maandelijks opzegbaar, met assessments als bewijsvoering.