Parallax: Why AI Agents That Think Must Never Act

Titel: Parallax: Waarom AI-agenten die denken nooit mogen handelen

Auteur: Joel Fokou (Onafhankelijk Onderzoeker)
Datum: April 2026

1. Het Probleem: De Kruisende Koppeling van Redeneren en Handelen

De snelle overgang van generatieve AI (conversatie) naar autonome AI-agenten (executie) introduceert een fundamenteel veiligheidsprobleem dat niet wordt opgelost door bestaande methoden.

• De Schaalverschuiving: Waar een LLM (Large Language Model) vroeger alleen schadelijke inhoud genereerde, voeren moderne agenten nu daadwerkelijke acties uit: bestandsmanipulatie, shell-commando's, netwerkverzoeken en database-wijzigingen.
• De Architecturale Grootte: De dominante veiligheidsaanpak is prompt-level guardrailing (veiligheidsinstructies in de systeem-prompt). Dit is architectonisch ontoereikend omdat de veiligheidsinstructies en de aanvalsinstructies door dezelfde rekenlaag (het model) worden verwerkt.
• De Kwetsbaarheid: Als een agent wordt gemanipuleerd via prompt-injectie (direct of indirect), vallen de veiligheidsinstructies weg omdat ze zich binnen hetzelfde gemanipuleerde systeem bevinden. Een gemanipuleerde agent kan dus schadelijke acties uitvoeren die door het model zelf als "veilig" worden geredeneerd.
• Het Risico: In tegenstelling tot het genereren van misleidende tekst, kan een veiligheidsfalen bij een agent leiden tot data-exfiltratie, credential-diefstal, systeemcompromittering of onomkeerbare vernietiging van kritieke bronnen.

2. Methodologie: Het Parallax-Paradigma

Het paper introduceert Parallax, een nieuw paradigma voor architecturale veiligheid dat gebaseerd is op vier principes uit de systeemveiligheid (zoals privilege separation en mandatory access control). Het kerninzicht is dat het systeem dat redeneert structureel onmogelijk mag handelen, en vice versa.

De vier principes zijn:

1. Cognitive-Executive Separation (CES):

   • Het systeem wordt opgesplitst in twee volledig gescheiden processen: een Agent-proces (onbetrouwbaar, bevat het LLM, geen toegang tot bestandsysteem of netwerk) en een Engine-proces (vertrouwd, bevat de uitvoeringstools).
   • Communicatie verloopt uitsluitend via een gedefinieerde gRPC-interface. De agent kan alleen acties voorstelen; de engine voert ze uit na validatie.
   • Zelfs als de agent volledig is gemanipuleerd, heeft deze geen uitvoeringscapaciteit.

2. Adversarial Validation met Graduated Determinism:

   • Een onafhankelijke validatielaag (Shield) staat tussen de voorgestelde actie en de uitvoering.
   • Validatie verloopt via vier trappen van afnemende determinisme (stijgende complexiteit):
     • Tier 0: Deterministische beleidsregels (YAML).
     • Tier 1: Dual Classifier (heuristische patronen + een vast ONNX DeBERTa-model).
     • Tier 2: Budget-beperkte evaluatie door een apart LLM (zonder context van de agent).
     • Tier 3: Menselijke goedkeuring (Human-in-the-loop).
   • Fail-closed: Als een laag faalt, wordt de actie geblokkeerd.

3. Information Flow Control (IFC):

   • Gegevens krijgen sensitiviteitslabels (bijv. "geheim", "intern") bij het lezen.
   • Deze labels propageren door de workflow. Als de agent probeert gevoelige data naar een onbetrouwbare bestemming (zoals een extern netwerk) te sturen, blokkeert Shield dit, ongeacht hoeveel tussenstappen er zijn (voorkomt tool-use chain attacks).

4. Reversible Execution:

   • Voor destructieve acties (bestandsverwijdering, wijzigingen) maakt het systeem een snapshot van de staat (Chronicle).
   • Als een actie later als schadelijk wordt geïdentificeerd, kan deze worden teruggedraaid.

Validatiemethode: Assume-Compromise Evaluation
In plaats van te vertrouwen op de LLM om schadelijke acties te weigeren, omzeilt de evaluatie het redeneersysteem volledig. De onderzoekers injecteren tool-calls direct in de Shield-pipeline om te testen of de architecturale grens standhoudt bij een volledig gemanipuleerde agent.

3. Belangrijkste Bijdragen

1. Het Parallax-Paradigma: Een formeel gedefinieerd raamwerk voor veilige autonome uitvoering dat onafhankelijk is van het specifieke AI-model.
2. OpenParallax: Een open-source referentie-implementatie in Go (80 MB statisch gecompileerd binair bestand). Deze implementeert proces-isolatie, het vier-laags validatiesysteem, IFC-tagging en state-capture.
3. Assume-Compromise Evaluatie: Een nieuwe methodologie om agent-veiligheid te testen door de LLM te omzeilen en direct de uitvoeringsgrens aan te vallen.
4. Dynamische Tool Surface Reduction: Een mechanisme waarbij de agent slechts de tools ziet die nodig zijn voor de huidige taak, waardoor het aanvalsoppervlak voor een gemanipuleerde agent wordt geminimaliseerd.

4. Resultaten

De evaluatie omvatte 280 adversariele testcases verdeeld over negen aanvalscategorieën (waaronder directe/indirecte prompt-injectie, multi-agent compromittering en validator-aanvallen).

• Blokkeerpercentage:
  • Standaard configuratie: 98,9% van de aanvallen geblokkeerd met 0% false positives.
  • Maximale beveiligingsconfiguratie: 100% van de aanvallen geblokkeerd, maar met een 36% false positive rate (door de classifier die te streng is op bepaalde actietypes).
• Vergelijking met Prompt Guardrails:
  • Bij een gemanipuleerde agent bieden prompt-guardrails 0% bescherming, omdat ze binnen het gemanipuleerde systeem bestaan.
  • Parallax houdt de architecturale grens in stand, ongeacht de staat van het redeneersysteem.
• Latentie:
  • Tier 0 (beleidsregels) werkt in sub-milliseconden.
  • Tier 1 (classifier) heeft momenteel een latentie van ~1,9s (door initialisatie-overhead), wat geoptimaliseerd kan worden.
  • Tier 2 (LLM-evaluatie) is afhankelijk van de API-latentie.

5. Betekenis en Conclusie

Het paper concludeert dat model-niveau veiligheid (zoals RLHF of Constitutional AI) onvoldoende is voor agenten met uitvoeringsbevoegdheden. Deze methoden verbeteren de kwaliteit van het oordeel, maar beperken niet de actie.

• Architecturale Veiligheid: Parallax biedt een "architecturale verzekering". Zelfs als het AI-model volledig gemanipuleerd is of een doelwit van een "paperclip maximizer"-scenario, kan het geen schade aanrichten omdat het geen directe toegang heeft tot de uitvoeringsomgeving.
• Toekomstbestendigheid: Het paradigma is onafhankelijk van het type AI-architectuur (LLM, reinforcement learning, etc.) en is toepasbaar op software-agenten, maar ook op fysieke robotica (waar de scheiding tussen planning en motorbesturing cruciaal is).
• Implementatie: OpenParallax bewijst dat dit paradigma praktisch realiseerbaar is met een open-source implementatie die voldoet aan strikte veiligheidsnormen zonder afhankelijkheid van complexe infrastructuur.

Kortom, Parallax verschuift de focus van "vertrouwen dat het model niet fout doet" naar "architectuur die het onmogelijk maakt dat het model fouten met gevolgen kan veroorzaken".