AI‑agenten staan klaar om te handelen. De meeste bedrijven zijn niet klaar om ze toe te laten.

Voor het grootste deel van het generatieve‑AI-tijdperk hebben we ons gericht op wat modellen zeggen en wat we in hen stoppen. We inspecteren prompts, filteren reacties, voeren red‑team‑tests uit op modellen en bouwen controles rond invoer en uitvoer. Die beschermingen blijven belangrijk, maar ze waren ontworpen voor een wereld waarin AI voornamelijk iets genereerde voor menselijk gebruik.

Agenten veranderen die vergelijking. Ze consumeren of genereren niet alleen informatie. Ze handelen.

Een agent kan tools uitvoeren, sub‑agenten aanroepen, samenwerken met andere agenten, API‑s aanroepen, gegevens benaderen, inloggegevens gebruiken, MCP‑servers benaderen, code genereren en uitvoeren, en een reeks beslissingen autonoom nemen in het nastreven van een doel. Een meedogenloze achtervolging. Zodra dat gebeurt, is de centrale vraag niet langer alleen of het model een veilig antwoord heeft geproduceerd. Het is of de acties die het onderneemt veilig zijn om uit te voeren.

Recente onthullingen van OpenAI maken dat onderscheid steeds belangrijker. OpenAI is begonnen systematisch rapporteren over onverwacht of zorgwekkend modelgedrag, terwijl het bredere veiligheidswerk steeds meer de risico’s aanpakt die ontstaan wanneer modellen meer autonomie en toegang tot tools krijgen.

De les is niet dat agenten per definitie onveilig zijn. Het is dat de beveiligingsgrens is verschoven.

Agentische systemen vereisen een ander operationeel model

Agentische AI is niet zomaar een andere applicatie‑architectuur. De software zelf bepaalt steeds meer hoe werk wordt uitgevoerd.

Een agent kan een obstakel tegenkomen, interpreteren wat er is gebeurd en een ander pad kiezen. Hij kan tools combineren op manieren die niet expliciet van tevoren zijn ontworpen. Hij kan code genereren en die code uitvoeren als onderdeel van dezelfde workflow. De reeks acties kan bij elke uitvoering van de agent veranderen.

Tegelijkertijd groeit de populatie die deze software maakt dramatisch. Zoals we geschreven over de opkomst van de burgerontwikkelaar, zet AI mensen die zichzelf nooit als ontwikkelaar beschouwden om in software‑makers. Een marketeer, financieel analist of operationeel leider kan nu beschrijven wat hij of zij wil en een agent creëren die kan communiceren met echte bedrijfssystemen.

Dat is een buitengewone uitbreiding van wie software kan bouwen en wat die software kan doen. Het betekent ook dat organisaties veel meer autonome software zullen hebben die in veel meer delen van het bedrijf opereert.

Het antwoord kan niet simpelweg zijn om de controles van gisteren toe te passen op deze nieuwe omgeving. Als ondernemingen deze systemen niet veilig kunnen exploiteren, zal de alternatieve oplossing zijn ze te beperken en uiteindelijk de productiviteitswinst die ze proberen te behalen te vertragen.

Controle moet bestaan waar agenten handelen

Naarmate AI autonomer wordt, verschuift de uitdaging van het beheersen van wat in een model wordt gestopt naar het beheersen van wat gebeurt wanneer zijn beslissingen acties worden.

Een agent kan beginnen met een goedgekeurde gebruiker, een acceptabele prompt, legitieme inloggegevens en geautoriseerde toegang tot een tool. Geen van deze zaken garandeert dat elke daaropvolgende actie uitgevoerd moet worden.

Dit is waar runtime cruciaal wordt. Organisaties moeten niet alleen weten wie de agent is, maar vragen stellen over wat hij nu doet:

• Welke tools hij aanroept,
• Welke bronnen hij benadert, welke code hij probeert uit te voeren, 
• Welke sub‑agenten en andere agent‑communicaties plaatsvinden,
• Wat er direct vóór die actie gebeurde en of zijn gedrag binnen acceptabele grenzen blijft,
• Wat de agent in de runtime onder de motorkap doet.

En wanneer dat niet het geval is, moet het systeem in staat zijn om in realtime in te grijpen vóór uitvoering.

Dit is een belangrijk onderscheid. Observeerbaarheid vertelt je wat er gebeurde. Runtime‑controle geeft je de mogelijkheid om de uitvoeringslaag van de agent te beheersen.

Dat wordt vooral belangrijk omdat agentisch gedrag zowel niet‑deterministisch als multidimensionaal is.. Een geblokkeerde actie zal een agent ertoe brengen een andere aanpak te proberen om zijn doel te bereiken. Een ogenschijnlijk onschuldige tool‑aanroep kan riskant worden door wat eraan voorafging. Alleen observeren of “detecteren en reageren” is te laat om daadwerkelijk de toegang tot en uitvoering van de agent te beheersen.  

De runtime moet inline en synchroon zijn om het tempo van AI‑snelheid bij te houden.  De fundamentele uitdaging bij het omarmen van dergelijke benaderingen berust op denkbeelden uit het pre‑AI‑tijdperk die vertrouwen op een langdurigere analyse‑ en detectiemethodologie.  Die principes zijn niet langer van toepassing in de wereld van vandaag..

Runtime‑beveiliging vereist context, niet alleen controles

Er is een neiging om op opkomende AI-risico’s te reageren door de autonomie te verminderen: agents minder rechten te geven, vaker menselijke goedkeuring te eisen of de omgevingen waarin ze opereren te beperken. Die controles zullen soms passend zijn, vooral voor hoog‑risicovolle handelingen.

Maar ze kunnen niet het langetermijn‑bedrijfsmodel zijn.

Als een mens elke betekenisvolle beslissing moet goedkeuren, hebben we een groot deel van de waarde van een autonome agent verwijderd. Door te vertrouwen op strenge human‑in‑the‑loop‑interacties, hebben we sommige van de meest getalenteerde individuen veranderd in “knop‑drukkers.” Dit heeft een directe impact op het vermogen om de reikwijdte en onderlinge afhankelijkheden van de code‑basis te begrijpen waarop agentische organisaties draaien.

De economische belofte van agentische AI komt precies voort uit het toestaan dat software betekenisvol werk onafhankelijk en continu – 24/7 – uitvoert. Het doel zou daarom niet moeten zijn om autonomie te elimineren, maar om grotere autonomie veilig te laten opereren.

Dat vereist onafhankelijke controles buiten het eigen redeneerproces van de agent. Het onderzoek van Anthropic naar agentic misalignment, uitgevoerd in opzettelijk geconstrueerde simulaties, laat zien waarom dit belangrijk is. Naarmate systemen autonomer worden, kan hun gedrag afwijken van wat hun operators verwachten, zelfs wanneer het oorspronkelijke doel duidelijk lijkt.

De praktische implicatie is eenvoudig: organisaties kunnen niet uitsluitend vertrouwen op het begrijpen van wat een agent gevraagd werd te doen. Ze moeten begrijpen en controleren wat hij daadwerkelijk doet.

De Agent is Niet Meer het Moeilijke Deel

De industrie heeft enorme energie gestoken in het capabeler maken van agents. We naderen snel het punt waarop capaciteit niet langer de belangrijkste beperking is voor adoptie in bedrijven.

De beperking is controle.

Naarmate agents autonomer worden, nemen de gevolgen van hun acties toe – en worden controles die zijn ontworpen voor voorspelbare software minder effectief. Bedrijven hebben continue zichtbaarheid nodig in wat agents doen, de context om te begrijpen waarom die acties belangrijk zijn, en de mogelijkheid om in te grijpen zonder een mens in het midden van elke beslissing te plaatsen.

Dat verandert wat het betekent om software te exploiteren.

• Ontwikkelaars moeten begrijpen hoe agents zich daadwerkelijk gedragen, niet alleen hoe ze ontworpen zijn te gedragen.
• Platform‑ en beveiligingsteams moeten grenzen vaststellen die handhaafbaar blijven terwijl agents over systemen en tools heen opereren.
• Bedrijfsleiders moeten erop kunnen vertrouwen dat meer autonomie niet betekent dat ze de controle opgeven.

Dit is fundamenteel anders dan het beveiligen van een andere applicatie of het besturen van een ander model. We introduceren autonome actoren in bedrijfsomgevingen: systemen die kunnen redeneren, beslissingen nemen en handelen. Als organisaties die acties niet kunnen zien en beheersen terwijl ze plaatsvinden, zullen ze uiteindelijk moeten beperken wat agents kunnen doen, waardoor een groot deel van de waarde die autonomie zou moeten creëren, verloren gaat.

Het antwoord is niet te veronderstellen dat we elke slechte beslissing kunnen voorkomen. Naarmate systemen autonomer en niet‑deterministisch worden, wordt dat steeds moeilijker te garanderen.

Het doel is ervoor te zorgen dat een slechte of destructieve actie niet leidt tot een nadelig resultaat.

Dit vereist een nieuwe operationele laag rond agents: een laag die gedrag continu kan observeren, acties in context kan begrijpen, grenzen kan handhaven gedurende de volledige agent‑runtime‑stack en kan ingrijpen voordat een onbedoelde of onaanvaardbare actie een onomkeerbaar resultaat wordt.

De volgende fase van enterprise‑AI zal niet alleen worden bepaald door hoe capabel agents worden. Ze zal worden bepaald door hoeveel autonomie organisaties ze veilig kunnen geven.