Autonome beveiligingsagenten worden steeds beter in het opsporen van zwakheden. Alleen blijft één vraag lastig: hoe weet je of een agent werkelijk vindt wat hij zegt, en of hij ook echt getest heeft waar jij om vroeg? XRanges for AI probeert die meetkloof te dichten door de prestaties van een agent niet te baseren op zijn verslag, maar op wat er tijdens de aanvalstest in de doelapplicatie zelf gebeurt.
In dit artikel leggen we uit hoe XRanges for AI werkt, welke signalen het gebruikt om runs te beoordelen en waarom de aanpak vooral waardevol is wanneer je agenten in grote experimentmatrices vergelijkt.
Waarom rapporten van agenten niet genoeg zijn
Het typische scenario bij autonome pentesting en bug bounty-achtige agents is eenvoudig. Je zet een doel op, laat de agent draaien, en leest daarna het outputrapport. Het probleem: zo’n rapport beschrijft het verhaal van de agent—niet noodzakelijk de waarheid over wat er daadwerkelijk is uitgevoerd.
Een bevinding kan bijvoorbeeld kloppen, maar ook deels of helemaal niet. De tekst klinkt daarbij vaak overtuigend en in alle gevallen vergelijkbaar. Daardoor is het achteraf handmatig controleren van claims tijdrovend en komt het al snel neer op expertwerk per run.
Bovendien kijken teams niet alleen naar één poging. In de praktijk test je meerdere modellen, verschillende promptvarianten en herhalingen om variatie te begrijpen. Als je elke run opnieuw volledig moet nalopen, wordt de review-queue al snel onhandelbaar.
XRanges for AI: evalueren via de doelapplicatie
XRanges for AI is ontworpen als een evaluatiewerkruimte voor het beoordelen van autonome security agenten. De kern zit in twee onderdelen: een bibliotheek met realistische benchmarkdoelen en een instrumentatielaag die precies registreert wat een agent doet.
1) Benchmarktargets die op echte software lijken
De platformtargets zijn geen losse puzzels. Het gaat om complete applicaties met meerdere services en eigen bedrijfslogica. Ze bevatten data, achtergrondprocessen en simulaties van gebruikersverkeer. Omdat software in het echt ook zo is opgebouwd, zijn doelen bovendien gebouwd over meerdere talen en frameworks.
Belangrijk detail: in elk doel zijn tientallen kwetsbaarheden ingebouwd (van eenvoudige issues tot ketens die over services heen lopen). Daarnaast kan het platform ook kwetsbaarheden bevatten die niet in publieke trainingdata voorkomen.
2) Instrumentatie met OpenTelemetry per service
Waar traditionele aanpak vaak teruggrijpt op generieke HTTP-logging, gaat XRanges for AI verder. Elke service binnen elk target kan gestructureerde telemetrie uitsturen via OpenTelemetry.
Die instrumentatie wordt niet “one size fits all” gedaan. Volgens de beschrijving wordt ze handmatig geschreven door engineers en security-specialisten specifiek voor dat doel. Daardoor gaan de metingen dieper en missen ze minder context.
De data wordt vervolgens per deployment verwerkt op het platform (ai.xranges.com) en vertaald naar meerdere onafhankelijke scores die live kunnen worden bijgewerkt terwijl de agent nog bezig is.
Vier onafhankelijke signalen voor één run
Een run wordt beoordeeld op vier metingen die bewust onafhankelijk van elkaar zijn. Dat is cruciaal: een agent kan niet simpelweg één score “optimaliseren” terwijl hij de rest negeert. De uitkomst is dus minder vatbaar voor misinterpretatie.
Dekking: hoeveel van het legitieme oppervlak is geraakt?
Het dekkingssignaal kijkt of de agent het doel daadwerkelijk heeft doorlopen. Daarbij gaat het niet om URL’s, maar om coveragepunten als zakelijke acties—bijvoorbeeld een account registreren, vacatures bekijken, een gedeelde conversatie openen of code uitvoeren in een assessment.
Een belangrijk onderscheid: coveragepunten zijn alleen bereikbaar via normale, legitieme use-cases, dus niet via een exploit-truc. Daardoor vormt het signaal een relatief zuivere maat voor hoe grondig de agent zijn “werk” op de echte functionaliteit uitvoert.
De onbereikte punten worden bovendien opgesomd. In de praktijk blijken die “blind spots” voor teams vaak waardevoller dan de totale score.
Grenzen: respecteerde de agent de regels van engagement?
Elk target bevat guard rules, met expliciete verboden acties. Denk aan regels zoals het niet verwijderen van specifieke content of het niet intrekken van API-sleutels.
Wanneer een agent een regel overtreedt, wordt dat moment vastgelegd inclusief container en tijdstip. De verwachting is daarbij dat er geen schendingen zijn—en elke overtreding is een directe aanwijzing dat het gedrag van de agent niet acceptabel was.
Exploited: welke kwetsbaarheden zijn écht uitgebuit?
In plaats van alleen te rapporteren “we vonden een issue”, registreert XRanges for AI welke kwetsbaarheden daadwerkelijk zijn uitgebuit. Elke vulnerability wordt gedefinieerd als een kill chain: een reeks fasen van eerste contact tot een exploit-signaal dat alleen afgaat bij echte succesvolle uitvoering.
Omdat de detectie vanuit de doelomgeving plaatsvindt, kan het platform bijhouden waar de agent in die keten bleef steken. Het resultaat is dus minder interpretatie en meer bewijs: je ziet precies welke stappen wel zijn gezet en welke niet.
Integriteit: bleef de applicatie functioneel werken?
Het integriteitssignaal controleert continu of de toepassing nog klopt zoals bedoeld. Er worden metingen uitgevoerd die bevestigen dat seed data aanwezig blijft, services de juiste content leveren en vertrouwensrelaties tussen services intact zijn.
Valt zo’n check uit, dan volgt een penalty—ongeacht de oorzaak. Daarmee detecteert het platform ook situaties waarin een agent een bug “vond”, maar ondertussen de omgeving rond die bug kapot maakte.
Zo ziet een run eruit: van deployment tot vergelijking
Een target draait als een geïsoleerde multi-container omgeving en kan in ongeveer negentig seconden worden uitgerold. Het platform kan daarbij tot ongeveer duizend deployments tegelijk draaien. Dat maakt het mogelijk dat verschillende teams hun experimenten kunnen uitvoeren zonder onderlinge wachtrij.
Vervolgens draait de agent tegen het deployment-endpoint. Een opvallend punt: de beschrijving stelt dat het platform niet als tussenlaag fungeert tussen agent en doel, maar de acties observeert vanuit “inside the target”. Daarmee ontstaat een eerlijker beeld van wat een agent echt doet.
Tijdens het testen legt het systeem een tijdlijn vast die de acties koppelt aan zakelijke functionaliteit. Als engineers de ruwe data willen, kunnen ze de OpenTelemetry-stream doorzoeken met een querytaal die ook regex en attribuutfilters ondersteunt.
Wanneer een agent iets meldt wat niet in de kwetsbaarhedenlijst van het target staat, kan de timeline helpen verklaren waarom. Dat kan gaan om een false positive, maar soms blijkt ook dat een echte bug is opgedoken die niet vooraf was ingebouwd.
Retesten kan met dezelfde omgeving
Retesten betekent hier niet automatisch dat je een compleet nieuw lab opbouwt. Kwetsbaarheden kunnen in plaats daarvan worden aangepast: uitgeschakeld of gepatcht in een lopende deployment. Sommige fixes werken direct, andere vereisen een korte herstart.
Daarna draait de agent opnieuw tegen dezelfde omgeving en (volgens de beschrijving) dezelfde staat. Dat is belangrijk om veranderingen toe te wijzen aan de patch of parameterwijziging, en niet aan “een andere wereld”.
Elke deployment krijgt ook metadata zoals modelnaam, agentversie en promptvariant. De platformweergave groepeert runs en toont zowel gemiddelden als beste scores, plus per kwetsbaarheid welke run welke kill chain afrondde. Juist omdat één run weinig zegt, zijn herhalingen onderdeel van het ontwerp.
Automatisering voor experimentmatrices
Een ander verschil met ad-hoc testen is dat XRanges for AI automatisering ondersteunt. Niet alleen via een console, maar ook via een API en via een Model Context Protocol-server.
Met een bearer token kunnen teams batch-deployments opzetten, de agent starten, dekking en kill-chain voortgang ophalen en bij afloop de vergelijking verzamelen. Volgens de beschrijving kan dit vanuit een CI-pipeline of via een chat-assistent gebeuren, zonder dat er continu een persoon moet meekijken.
Field proof tijdens DEF CON 34
De aanpak werd getest in een realistische competitiecontext. Bij de Bug Bounty Village CTF op DEF CON draait jaarlijks een evenement voor bug hunting. Voor DEF CON 34 (augustus 2026) bouwde CTF.ae een doelomgeving onder de naam Xenoptic: een fictief AI-bedrijf met een geavanceerde scope.
Alle 545 geregistreerde spelers kregen volgens de beschrijving een eigen geïsoleerde kopie van het volledige bedrijf. Gedurende 48 uur keek XRanges for AI mee naar wat er werkelijk gebeurde.
De reden voor die observatie draait om eerlijkheid. Een ingeleverd rapport zegt niet per se hoe de speler bij de resultaten kwam. Iemand kan bijvoorbeeld op een ongepland bugspoor terechtkomen dat alle “flags” tegelijk ontsluit of via een extern probleem de container ontkomen. In zo’n setting wil je juist zien hoe een agent zich beweegt in het echte deployment.
Het platform leverde daarbij consistent dezelfde vier signalen: integriteit (bleef alles gezond), grenzen (werd de engagement-regelset gerespecteerd), dekking (hoe ver ging de speler/agent in het doel) en exploited (welke kwetsbaarheden echt waren uitgebuit en via welk pad).
Ook hier is het stressargument relevant: honderden gelijktijdige deployments onder aanhoudende druk van ervaren researchers is zwaarder dan één agent in een handmatig lab.
Voor wie is XRanges for AI bedoeld?
Volgens de beschrijving is XRanges for AI bedoeld voor teams die autonome security agenten ontwikkelen en vooral willen weten wat de agent deed, niet alleen wat hij opschreef. Het kan als managed cloud service draaien of (mogelijk) self-hosted op eigen infrastructuur, waarbij niets buiten de omgeving hoeft te verlaten.
Ook teams die een agent tegen een nieuw, nog onbekend target willen zetten, kunnen volgens de bron contact opnemen om het te integreren in hun evaluatieproces.
Praktische waarde: minder giswerk, meer vergelijkbare resultaten
Autonome security agents zijn nuttig, maar vertrouwen op enkel tekst uit een rapport is riskant. Met XRanges for AI verschuift de evaluatie naar wat er aantoonbaar in de doelapplicatie gebeurde: hoeveel het legitieme oppervlak werd geraakt, of de agent zich aan de regels hield, welke kill chains echt afliepen en of de omgeving heel bleef.
Dat maakt het eenvoudiger om niet alleen “een score” te zien, maar vooral om te begrijpen waarom die score tot stand kwam. Voor wie agenten in grote experimentmatrices test, is dat precies de informatie die anders verloren gaat in handmatige review.
Wil je ook weten hoe teams hun security zicht organiseren rondom (AI-)incidenten en detectie? Lees dan ook SOC zicht op DORA-aanvallen: kan dat echt? en vergelijk de uitdagingen rond meten en verifiëren in andere contexten.
Tot slot: als je agenten test op “output”, meet je gedrag indirect. Met XRanges for AI kun je diezelfde agenten juist direct beoordelen op interne telemetry en reproduceerbare runs—waardoor je onderzoek sneller, eerlijker en beter onderbouwd wordt.
Bron: https://thehackernews.com/2026/09/545-hackers-tested-it-first-now-xranges.html
