Toward Securing AI Agents Like Operating Systems

Dit artikel betoogt dat het beveiligen van op LLM's gebaseerde AI-agenten vereist dat principes voor besturingssysteembeveiliging worden toegepast, en toont aan via een geünificeerde architectuuranalyse en een casestudy dat hoewel sommige risico's inherent zijn, veel kwetsbaarheden kunnen worden verzacht met gebruik van gevestigde OS-technieken zoals resource-isolatie en privilege-scheiding.

De kern

Stel je voor dat je een super slimme, ongelooflijk enthousiaste persoonlijke assistent hebt ingehuurd met de naam "Agent". Deze assistent kan je e-mails lezen, je agenda beheren, vluchten boeken en zelfs voor jou code schrijven. Het is alsof je een magische werknemer hebt die nooit slaapt.

Maar hier zit de addertje onder het gras: je hebt deze werknemer de sleutels gegeven van je hele huis, je bankrekening en je dagboek. Als een slimme dief de assistent kan overtuigen dat hij jou is, of het kan overhalen om de achterdeur open te doen, krijgt de dief alles in handen.

Dit is het kernprobleem dat het artikel aanpakt. De auteurs stellen dat we deze AI-agenten bouwen alsof het gloednieuwe, magische wezens zijn, maar we zouden ze eigenlijk moeten behandelen als Besturingssystemen (de software die je computer laat draaien, zoals Windows of macOS).

Hier is de uiteenzetting van hun bevindingen, met gebruikmaking van eenvoudige analogieën:

1. Het Grote Idee: De Agent is het Besturingssysteem

De auteurs zeggen: "Stop met het zien van de AI als slechts een chatbot. Zie het als het OS van je digitale leven."

• De AI (LLM) is de Gebruiker: In een computer typt de gebruiker commando's. In een AI-agent is het het Grote Taalmodel (het "brein") dat de commando's typt. Maar net zoals een menselijke gebruiker kan worden bedrogen door een phishing-e-mail, kan een AI worden bedrogen door een "jailbreak"-prompt.
• De Hulpmiddelen zijn Systeemoproepen: Wanneer je op je computer op "Afdrukken" klikt, controleert het OS of je toestemming hebt. Wanneer een AI wil "een e-mail sturen", is dat een hulpmiddel. Het artikel stelt dat deze hulpmiddelen moeten worden behandeld als strikte systeemoproepen, niet als vrijblijvende commando's.
• De Runtime is de Kernel: Het deel van de software dat de code daadwerkelijk uitvoert, is de "Kernel". In een veilige computer is de Kernel de baas. Het bepaalt wie wat mag aanraken. Bij huidige AI-agenten is de "Kernel" vaak te aardig en laat het de "Gebruiker" (de AI) doen wat hij wil, zelfs als het gevaarlijk is.

2. Het Probleem: Het "Open Huis"-feest

Het artikel bekijkt populaire AI-agenten (zoals OpenClaw en zijn verwanten) en stelt vast dat ze zijn gebouwd als een open huis waar iedereen binnen kan lopen en alles kan aanraken.

• Geen Muren: In een veilige computer zijn verschillende programma's geïsoleerd. Als een virus je rekenmachine-app infecteert, zou het niet je bankbestanden moeten kunnen lezen. Maar bij deze AI-agenten bevinden de "rekenmachine" (een hulpmiddel) en de "bankbestanden" (geheugen) zich allemaal in dezelfde kamer. Als de AI in de war raakt, kan het ze per ongeluk (of kwaadwillig) door elkaar halen.
• De "Vertrouw Me"-Fout: Deze agenten vertrouwen erop dat de AI zich "herinnert" om veilig te zijn. Ze hebben regels zoals "Verwijder geen bestanden", maar deze zijn gewoon in gewoon Engels geschreven. Als een hacker een truc fluistert naar de AI, vergeet de AI de regel. Het is alsof je een bewaker vraagt om te waken, maar hem vertelt: "Gebruik gewoon je beste oordeel."
• Het "Derde Partij"-Risico: Deze agenten laten je "vaardigheden" installeren (zoals apps). Stel je voor dat je een "Weer-app" kunt downloaden die in het geheim een achterdeur naar je bankrekening heeft. Het artikel vond dat veel van deze agenten je toestaan deze vaardigheden te installeren zonder te controleren of ze veilig zijn.

3. Het Experiment: De Agenten Breken

De onderzoekers namen vier populaire AI-agenten en probeerden ze te breken, optredend als een hacker met een bescheiden vaardigheidsniveau. Ze hoefden geen genieën te zijn; ze moesten alleen weten hoe het "huis" was gebouwd.

Wat ze vonden:

• OpenClaw (De "Vanilla" Agent): Dit was de populairste. Het was kwetsbaar voor elk enkel aanval dat de onderzoekers probeerden. Het was alsof je de voordeur, achterdeur en ramen wijd open liet staan.
• IronClaw (De "Veiligheid" Agent): Deze probeerde veiliger te zijn. Het zette sommige hulpmiddelen in een "sandbox" (een glazen doos waar ze de rest van het huis niet kunnen aanraken). Het deed het beter, maar de onderzoekers vonden nog steeds manieren om het te bedriegen of het glas te breken.
• Nanobot (De "Minimale" Agent): Deze had zeer weinig code, in de hoop dat minder code minder bugs betekent. Maar zelfs met een kleine codebasis miste het de basis "muren" die nodig zijn om gegevens gescheiden te houden.
• NemoClaw (De "Wrapper" Agent): Deze zette de hele agent in een veilige container (zoals een zeecontainer). Het was het moeilijkst te breken, maar de onderzoekers vonden nog steeds een manier om naar binnen te gluren of het te bedriegen.

Het Schokkende Resultaat: Zelfs de "veilige" versies faalden bij basiszaken, zoals het voorkomen dat één gebruiker de privé-notities van een andere gebruiker leest, of het voorkomen dat de agent berichten stuurt naar vreemden.

4. De Oplossing: Lenen van het Verleden

De belangrijkste conclusie van het artikel is simpel: We hoeven geen nieuwe magie te verzinnen om dit op te lossen. We moeten gewoon de beveiligingsregels gebruiken die we al 50 jaar kennen.

Besturingssystemen hebben deze exacte problemen eerder opgelost. De auteurs stellen voor dat we deze ouderwetse regels toepassen op AI:

• Isolatie: Zet elk hulpmiddel in zijn eigen glazen doos (sandbox) zodat het geen andere hulpmiddelen of je privébestanden kan aanraken, tenzij expliciet toegestaan.
• Minimale Rechten: Alleen omdat de agent je e-mail kan lezen, betekent niet dat hij het moet. Geef hem alleen de sleutels die hij nodig heeft voor de specifieke taak die hij op dat moment uitvoert.
• Versterkte Logging: Houd een record bij van alles wat de agent doet, maar zorg ervoor dat de agent deze records niet kan verwijderen of wijzigen (zoals een vervalvrije beveiligingscamera).
• Strikte Grenzen: Laat de AI niet beslissen wat veilig is. De "Kernel" (het systeem) moet de regels afdwingen, niet het "brein" van de AI.

Samenvatting

Het artikel stelt dat AI-agenten momenteel worden gebouwd als wilde, ongeregelde grensgebieden. Ze zijn krachtig maar gevaarlijk omdat ze gevoelige gegevens mengen met onbetrouwbare instructies.

De auteurs zeggen: "Stop met proberen de AI 'slimmer' te maken om veilig te zijn. Bouw in plaats daarvan het systeem eromheen als een veilig Besturingssysteem." Als we de AI behandelen als een gebruiker die moet worden bewaakt en beperkt door een strenge beveiligingsbewaker (het OS), kunnen we deze krachtige tools veilig maken voor gebruik in onze huizen en bedrijven.

De Kernboodschap: We bouwen digitale werknemers met hoofdsleutels voor onze levens, maar we hebben nog geen sloten, hekken of beveiligingsbewakers gebouwd. Het is tijd om de blauwdrukken te lenen van de computerbeveiligingsexperts die al decennia lang die sloten bouwen.

Technische samenvatting

Technische Samenvatting: Op weg naar het beveiligen van AI-agenten zoals besturingssystemen

Probleemstelling

Autonome agenten gebaseerd op Large Language Models (LLM's) evolueren van smalle assistenten naar algemeen toepasbare systemen die complexe taken kunnen plannen en uitvoeren met toegang tot gevoelige gebruikersgegevens, lokale bestanden en externe diensten. Hoewel systemen zoals OpenClaw aanzienlijke bruikbaarheid bieden via het gebruik van tools en vaardigheden van derden, introduceren ze aanzienlijke veiligheidsrisico's. Huidig onderzoek richt zich vaak te enge op prompt-injectie, terwijl het bredere aanvalsoppervlak – bestaande uit runtime-uitbreidbaarheid, persistente staat en ongemiddelde toegang tot bevoorrechte functionaliteit – onderbelicht blijft. Bestaande beveiligingsmechanismen in populaire agent-implementaties zijn vaak ontoereikend en falen zelfs onder bescheiden aanvalscapaciteiten om data-exfiltratie, privilege-escalatie of ongeautoriseerde systeemtoegang te voorkomen. Het artikel betoogt dat de veiligheidsuitdagingen waarmee AI-agenten geconfronteerd worden structureel vergelijkbaar zijn met die welke historisch zijn opgelost door besturingssystemen (OS), maar dat huidige agentontwerpen fundamentele OS-beveiligingsprincipes zoals isolatie, privilege-scheiding en bemiddeling vaak schenden.

Methodologie

De auteurs hanteren een drievoudige methodologie om agentveiligheid te onderzoeken:

1. Conceptuele Analogie en Architectuurafleiding: Het artikel vestigt een structurele analogie tussen AI-agenten en besturingssystemen. Het koppelt agentcomponenten aan OS-concepten: de LLM fungeert als een onbetrouwbare gebruiker, tools en vaardigheden komen overeen met systeemoproepen en programma's, de agent-runtime fungeert als de kernel, en de agentcontext lijkt op procesgeheugen. Op basis van deze analogie leiden de auteurs een verenigde architectuur af voor OpenClaw-achtige agenten, waarbij ze sleutelcomponenten (runtime-kern, agentkern, gateways, persistente/vergankelijke staat) en vertrouwensgrenzen identificeren.

2. Systematische Defensie-afbeelding: De auteurs onderzoeken gevestigde OS-beveiligingsmechanismen (zoals procesisolatie, sandboxing, least privilege, netwerkfiltering en Data Execution Prevention) en brengen deze in kaart met hun agent-achtige tegenhangers. Ze analyseren welke mechanismen direct overdraagbaar zijn, welke aanpassing vereisen en welke agentcapaciteiten per ontwerp onveilig blijven.

3. Empirische Casestudie: Om hun analyse te valideren, evalueren de auteurs vier veelgebruikte, open-source OpenClaw-achtige agenten die verschillende ontwerpfilosofieën vertegenwoordigen:

   • OpenClaw: Een "vanilla"-variant gericht op breedte van functies.
   • IronClaw: Een "veiligheids"-variant die prioriteit geeft aan isolatie en sandboxing.
   • Nanobot: Een "minimalistische" variant met een gereduceerde codebasis.
   • NemoClaw: Een "wrapper"-variant die een agent binnen een beveiligde container uitvoert.

   De evaluatie maakt gebruik van een gecontroleerde omgeving (Debian 13.4 VM's) met eBPF-gebaseerde monitoring om systeemoproepen, bestands toegang en netwerkverkeer te observeren. De auteurs definiëren een dreigingsmodel waarbij de aanvaller volledige kennis heeft van de broncode maar geen directe hardware- of host-level toegang, en de LLM behandelen als een volledig onbetrouwbare component die vatbaar is voor manipulatie. Ze voeren een reeks realistische aanvalsscenario's uit die gericht zijn op hardware-interface, procesisolatie, sandboxing, netwerkfiltering en systeemlogging.

Belangrijkste Bijdragen

• OS-beveiligingsperspectief op AI-agenten: Het artikel vestigt een formele analogie tussen AI-agenten en besturingssystemen, en biedt een raamwerk om na te denken over agentveiligheid met behulp van gevestigde concepten zoals isolatie, privilege-scheiding en bemiddeling.
• Verenigde Agentarchitectuur: Het leidt een geconsolideerde architectuur af voor OpenClaw-achtige agenten die expliciet componenten, vertrouwensgrenzen en communicatiekanalen definieert, wat systematische veiligheidsanalyse faciliteert.
• Systematische Overdracht van OS-defensies: De auteurs brengen OS-defensiemechanismen in kaart met het agent-domein, categoriseren ze op basis van toepasbaarheid en identificeren gaten waar huidige agentontwerpen fundamentele beveiligingsprincipes niet afdwingen.
• Empirische Evaluatie: De studie biedt een uitgebreide empirische beoordeling van vier populaire agent-runtimes, en toont aan dat huidige beveiligingsmechanismen in de praktijk vaak falen en dat kwetsbaarheden kunnen worden verklaard en gemitigeerd met OS-level technieken.

Resultaten

De casestudie onthult dat geen van de vier geëvalueerde agenten zich kan verdedigen tegen alle geteste aanvalsvectoren. Belangrijke bevindingen zijn:

• Wijdverspreide Kwetsbaarheden: Zelfs agenten die met het oog op veiligheid zijn ontworpen (zoals IronClaw) zijn vatbaar voor specifieke aanvallen, zoals configuratiemanipulatie of extractie van systeemprompts, vaak vanwege een onvolledige implementatie van sandboxing of privilege-scheiding.
• Falende Isolatie: Een kritieke bevinding is dat alle vier de agenten vertrouwde en onbetrouwbare data voeden in een gedeelde LLM-context, wat het principe van procesisolatie schendt. Dit maakt het mogelijk dat tussenresultaten van de ene tool de daaropvolgende tools beïnvloeden, waardoor aanvallen zoals shell-commando-injectie mogelijk worden.
• Privilege-scheidingschendingen: Bestands toegangscontrole wordt vaak afgedwongen op hetzelfde privilege-niveau als inputverwerking, in plaats van bemiddeld te worden door een minder bevoorrechte referentiemonitor.
• Ondoeltreffende Sandboxing: Hoewel sandboxing (bijvoorbeeld WebAssembly in IronClaw, containers in NemoClaw) bepaalde aanvalsvectoren effectief kan blokkeren, laten gedeeltelijke of verkeerd geconfigureerde implementaties aanzienlijke gaten achter. Zo was NemoClaw bijvoorbeeld kwetsbaar voor extractie van systeemprompts ondanks zijn gecontaineriseerde ontwerp.
• Universele Zwaktes: Twee klassen van zwaktes werden waargenomen bij alle agenten: data-exfiltratie tussen gebruikers (ontbreken van procesisolatie op gebruikersniveau) en ongeautoriseerd berichtenverzenden (ontbreken van strikte egress-filtering).
• LLM-onafhankelijkheid: De studie bevestigt dat deze kwetsbaarheden voortkomen uit de agentarchitectuur en runtime-ontwerp in plaats van specifieke LLM-resonatiecapaciteiten, aangezien aanvallen succesvol waren bij verschillende modellen (Qwen, Gemini, GPT).

Betekenis en Aanspraken

Het artikel beweert dat het beveiligen van AI-agenten een afschrikkende taak is vanwege hun enorme en heterogene aanvalsoppervlak, maar dat betekenisvolle vooruitgang haalbaar is door gebruik te maken van decennia aan besturingssysteembeveiligingsonderzoek. De auteurs betogen dat:

1. Retrospectieve Analyse Waardevol Is: Veel veiligheidsuitdagingen bij AI-agenten zijn niet geheel nieuw, maar manifestaties van klassieke OS-problemen. Het opnieuw bekijken van gevestigde OS-aanpakken biedt een principieel raamwerk voor het beveiligen van agent-systemen.
2. Defensie-in-Depth Vereist Is: Het vertrouwen uitsluitend op LLM-gerichte defensies (zoals mitigatie van prompt-injectie) is ontoereikend. Veilige werking vereist gedetailleerde systeemkennis, zorgvuldige configuratie en de implementatie van gelaagde defensies, waaronder isolatie, privilege-scheiding en bemiddeling.
3. Ontwerpfouten Inherent Zijn aan Huidige Systemen: Sommige agentcapaciteiten blijven per ontwerp onveilig omdat ze fundamentele principes zoals least privilege en procesisolatie schenden. Echter, veel kwetsbaarheden kunnen worden gemitigeerd met goed begrepen OS-technieken.
4. Directe Actieerbare Stappen: De auteurs concluderen dat het simpelweg consolideren van de reeds ingezette gedeeltelijke beveiligingsmechanismen in verschillende implementaties (bijvoorbeeld het combineren van sandboxing, netwerkfiltering en logging) aanzienlijke veiligheidsverbeteringen zou opleveren zonder dat nieuw onderzoek vereist is.

Het artikel positioneert zichzelf niet als een definitieve oplossing, maar als een noodzakelijke stap richting het structureren van het aanvalsoppervlak van AI-agenten en het leiden van toekomstig ontwerp naar een veiligere staat die is geworteld in OS-beveiligingsprincipes.