💻 computer science

ChannelGuard: Safe Models Do Not Compose into Safe Multi-Agent Systems

Het artikel introduceert ChannelGuard, een training-vrij, defense-in-depth framework dat multi-agent LLM-systemen beveiligt door deterministische information-bottleneck gates op elk kanaal tussen agenten te plaatsen, waardoor tool-poisoning effectief wordt geblokkeerd en de succesratio van prompt injections wordt verminderd zonder afhankelijk te zijn van ondoorzichtige filters aan de provider-zijde of extra LLM-aanroepen.

Oorspronkelijke auteurs: Elias Hossain, Md Mehedi Hasan Nipu, Fatema Tuj Johora Faria, Tasfia Nuzhat Ornee, Maleeha Sheikh

Gepubliceerd 2026-07-23

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Elias Hossain, Md Mehedi Hasan Nipu, Fatema Tuj Johora Faria, Tasfia Nuzhat Ornee, Maleeha Sheikh

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je een team van expert-robots voor die samenwerken om een complex mysterie op te lossen. Eén robot (de Planner) breekt de grote vraag op in kleine aanwijzingen. Andere robots (de Workers) gaan naar buiten om die aanwijzingen te vinden, hun aantekeningen te controlen en speciale gereedschappen te gebruiken. Ten slotte brengt een vierde robot (de Synthesizer) alle antwoorden samen om het verhaal aan je te vertellen. In de wereld van Kunstmatige Intelligentie wordt dit een "multi-agent systeem" genoemd. Het is als een high-tech estafette waarbij de estafettestok een boodschap is die van de ene AI naar de volgende wordt doorgegeven.

Lama tijd maakten wetenschappers zich zorgen over de allereerste overdracht: wat als een mens de eerste robot misleidt met een sluwe opdracht? We hebben "beveiligingsbewakers" bij de voordeur gebouwd om die trucjes te vangen. Maar dit artikel stelt een angstaanjagende vraag: wat gebeurt er in het midden van de race? Wat als één van de robots wordt misleid door een gereedschap, of door een aantekening in een gedeeld notitieboekje, en vervolgens dat slechte idee doorgeeft aan de volgende robot? Het artikel betoogt dat hoewel de voordeur bewaakt wordt, de gang tussen de robots wagenwijd openstaat. Het blijkt dat veel van deze robotteams alleen veilig zijn omdat het cloudbedrijf dat hen host een geheim, onzichtbaar filter heeft dat slechte ideeën opvangt nadat de robots ze hebben doorgegeven, maar voordat het definitieve antwoord wordt getoond. De auteurs noemen dit "geleende veiligheid", en zij willen een systeem bouwen waarbij de veiligheid bij het team zelf hoort, en niet bij de huisbaas.

Het Probleem: De Onzichtbare Gang

De onderzoekers, Elias Hossain en zijn team, keken naar hoe deze AI-teams werken. Ze ontdekten dat elke keer dat een robot een bericht naar een andere doorgeeft — of het nu een subtaak, een resultaat van een gereedschap of een aantekening in het geheugen is — het door een "kanaal" reist. Deze kanalen worden momenteel niet gemonitord. Een aanvaller zou een kwaadaardige instructie in het resultaat van een gereedschap of in een aantekening in het geheugen kunnen glippen, waardoor de volgende robot wordt misleid om iets gevaarlijks te doen.

Het enge deel is dat wanneer wetenschappers deze systemen testen, ze vaak een perfect veiligheidsrecord zien: nul geslaagde aanvallen. Maar de auteurs ontdekten dat deze veiligheid een illusie is. In hun tests, toen ze het systeem op een specifieke cloudprovider (Azure) draaiden, blokkeerde het systeem 90% van de aanvallen. Het was echter niet het AI-team dat blokkeerde; het was het server-side filter van de cloudprovider. Als ze overschakelden naar een andere cloudprovider (zoals Anthopic) die dat specifieke filter niet had, verdween de "veiligheid" en slaagden de aanvallen. Het systeem zag er alleen veilig uit omdat het bescherming leende van het cloudbedrijf, en niet omdat het AI-team daadwerkelijk veilig was.

De Oplossing: ChannelGuard

Om dit op te lossen, bouwde het team een nieuwe verdediging genaamd ChannelGuard. In plaats van alleen de voordeur te bewaken, plaatst ChannelGuard een beveiligingscontrole bij elke gang tussen de robots.

Denk aan een uitsmijter bij elke deur van een club.

De Controlepost: Elke keer als een bericht probeert te bewegen van de ene robot naar de andere, komt het een poort tegen.
De Scan: Deze poort gebruikt geen complexe AI om te raden of het bericht slecht is. In plaats daarvan gebruikt het een eenvoudige, snelle wiskundige truc. Het breekt het bericht op in zinnen en vergelijkt ze met een kleine lijst van "slechte zinnen" (zoals een "Gezocht"-poster voor gevaarlijke instructies).
De Beslissing: Als het bericht te veel lijkt op een slechte zin, stopt de poort het onmiddellijk. Als het een beetje verdacht is, kan het de risicovolle tekst eraf hakken en het veilige deel doorlaten. Als het schoon is, laat het het door.

Cruciaal is dat deze poorten "training-vrij" zijn, wat betekent dat ze niet hoeven te leren of nieuwe gegevens te bestuderen om te werken. Ze gebruiken simpelweg de lijst van slechte zinnen en een wiskundige formule om direct een beslissing te nemen.

Wat Ze Vonden

Het team testte ChannelGuard tegen 2.100 verschillende aanvalspogingen met behulp van acht verschillende soorten trucs. Dit is wat ze ontdekten:

Echte Veiligheid, Niet Geleende Veiligheid: Bij de "Tool Poisoning" aanval (waarbij een slecht resultaat van een gereedschap probeert een worker te misleiden), vertrouwde het oude systeem op de cloudprovider om 90% van de aanvallen te blokkeren. ChannelGuard blokkeerde echter 100% van de aanvallen zelf, ongeacht welke cloudprovider werd gebruikt. Het maakte de veiligheid "provider-invariant", wat betekent dat het systeem veilig is waar het ook draait.
Snelheidsboost: Omdat ChannelGuard een slecht bericht kan stoppen voordat het de dure, trage AI-modellen bereikt, maakte het het systeem zelfs sneller. Voor "Prompt Injection" aanvallen (trucjes bij de voordeur) was ChannelGuard 3,30 keer sneller dan het onbeschermde systeem, omdat het de slechte berichten vroegtijdig afsneed en de computer zo spaarde van onnodig werk.
Geen Breinverlies: Het systeem werd niet "dommer". Wanneer het werd getest op wiskundeproblemen (GSM8K) zonder aanvallen, hield ChannelGuard de nauwkeurigheid exact gelijk (0,867), wat bewijst dat het niet per ongeluk goede ideeën blokkeert.
Het Zwakke Punt: Het systeem is niet perfect. Als een aanvaller weet welke "slechte zinnen" op de lijst staan en hun truc herschrijft met andere woorden die hetzelfde betekenen (wat "adaptive paraphrasing" wordt genoemd), raken de poorten in de war. In deze gevallen faalde het systeem ongeveer 66% van de tijd, net als het onbeschermde systeem. De auteurs geven toe dat voor deze slimme, herformuleerde trucs een ander soort verdediging (één die de woorden licht verandert om de aanvaller in de war te brengen) beter werkt.

De Conclusie

Het artikel concludeert dat we niet alleen de cloudbedrijven kunnen vertrouwen om onze AI-teams veilig te houden. We moeten onze eigen bewakers binnen het team bouwen. ChannelGuard laat zien dat door eenvoudige, snelle controlepunten tussen elke robot te plaatsen, we aanvallen kunnen vangen die de voordeur passeren en ze kunnen stoppen voordat ze zich verspreiden. Ho help het niet elke enkele soort truc (vooral niet de varianten die zichzelf herformuleren), het verandert "geleende veiligheid" in "eigen veiligheid", waardoor het systeem betrouwbaar is waar het ook draait. De auteurs hebben al hun gegevens en code vrijgegeven zodat anderen hun werk kunnen controleren, wat bewijst dat veiligheid in AI-teams in de architectuur moet worden ingebouwd, en niet alleen gehoopt mag worden.

Technische Samenvatting: ChannelGuard: Veilige modellen componeren niet tot veilige multi-agent systemen

1. Probleemstelling

Moderne Large Language Model (LLM) applicaties vertrouwen steeds vaker op multi-agent systemen waarbij een planner taken deelt op, worker-agents de taken uitvoeren (vaak door tools aan te roepen of gedeeld geheugen te lezen), en een verifieerder/synthesizer een definitieve output produceert. De auteurs identificeren een kritieke beveiligingskloof: terwijl bestaande verdedigingen zich richten op de input-grens (Gebruiker $\to$ Planner) of vertrouwen op ondoorzichtige, stochastische provider-zijde filters (bijv. Azure Content Safety), blijven de inter-agent kanalen (Planner $\to$ Worker, Tool $\to$ Worker, Memory $\to$ Worker, etc.) onbewaakt.

Het paper betoogt dat huidige evaluatiemetrieken, specifiek de Attack Success Rate (ASR), misleidend zijn. Een pipeline kan een ASR van 0.000 tonen op een specifieke backend (bijv. Azure GPT-5), niet omdat de applicatie veilig is, maar omdat de server-side filter van de cloudprovider de aanval heeft onderschept. Dit creëert een "mechanisme-substitutie" probleem: als de backend wordt vervangen door een model zonder dergelijke filters (bijv. Anthropic Sonnet), blijft de veiligheidsuitkomst 0.000, maar verschuift het beschermingsmechanisme volledig naar de interne alignment van het model, wat buiten de controle en observatie van de ontwikkelaar valt. Gevolgelijk kunnen beoefenaars niet redeneren over de werkelijke robuustheid van hun systemen.

2. Methodologie: Het ChannelGuard Framework

ChannelGuard is een training-vrij, defense-in-depth framework ontworpen om elk inter-agent kanaal te instrumenteren. Het wijzigt de agent-modellen niet en vereist geen hertraining.

Kerncomponenten

Information-Bottleneck (IB) Gates:
- Plaatsing: Zes gates zijn geplaatst op specifieke kanalen: Input (IB-0), Planner-naar-Worker (IB-1), Tool-naar-Worker (IB-3), Memory-naar-Worker (IB-3-mem), Worker-naar-Verifier (IB-2/IB-4), en Worker-naar-Synthesizer (IB-5).
- Mechanisme: Elke gate verwerkt de tekst op zijn kanaal door deze op te splitsen in zinnen, ze te embedden (met behulp van een lokale all-MiniLM-L6-v2 model), en de maximale cosinus-gelijkenis te berekenen tegen een vaste, door mensen gecureerde adversariële frasebank.
- Beslissingslogica: De gate berekent een risicoscore en neemt een deterministische driedelige beslissing:
  - Pass: Risico < $\alpha\theta$ (tekst gaat ongewijzigd door).
  - Compress: $\alpha\theta \le$ Risico < $\theta$ (tekst wordt afgekort tot de eerste $N=2$ zinnen).
  - Block: Risico $\ge \theta$ (tekst wordt vervangen door een lege string, waardoor de pipeline wordt afgebroken).
- Eigenschappen: De gate voegt geen LLM-calls toe, vereist geen trainingsdata, en de beslissing is onafhankelijk van het downstream agent-model.
Uncertainty-Aware Verifier:
- Een apart LLM (Claude Sonnet 4.5) scoort de overgebleven worker-outputs met behulp van 5 Monte-Carlo-samples om een gemiddelde veiligheidsscore en dispersie te bepalen.
- Het markeert outputs als "unsafe" (onveilig) of "uncertain" (onzeker).
Triple-Filter Synthesizer:
- De uiteindelijke synthesizer accepteert alleen antwoorden die de IB-5 gate passeren, een gemiddelde veiligheidsscore $\ge 0.5$ hebben, en niet zowel als "unsafe" als "uncertain" zijn gemarkeerd.
- Als er geen output overblijft, wordt een harde weigering (hard refusal) geretourneerd zonder verdere LLM-calls aan te roepen.

Evaluatiemethodologie

Het paper introduceert een per-trace attributie-methodologie. In plaats van alleen ASR te rapporteren, registreert het systeem exact welke laag (IB gate, provider filter, verifier, of model alignment) de aanval als eerste heeft gestopt. Dit maakt een "mechanisme-substitutie" analyse mogelijk, waarbij onderscheid wordt gemaakt tussen applicatie-eigendom blokkeren en geleend provider-blokkeren.

3. Belangrijkste Bijdragen

Per-Trace Attributie: Een methodologie die outcome-only ASR omzet in een mechanisme-niveau account, waardoor "mechanisme-substitutie" (de afhankelijkheid van backend filters) meetbaar en zichtbaar wordt gemaakt.
Provider-Afhankelijkheidsanalyse: Empirisch bewijs dat op Azure GPT-5 een onverdedigde pipeline 90% van zijn zero-ASR bescherming ontleent aan de provider filter, en dat wanneer er wordt overgeschakeld naar Anthropic backends, deze bescherming volledig wordt herbronnen naar de model alignment, wat bewijst dat de veiligheidsuitkomst identiek is maar de provenance anders en oncontroleerbaar is.
Het ChannelGuard Framework: Een systeem van zes embedding-gelijkenis gates dat provider-invariante, applicatie-eigendom blokkering biedt.
Precieze Afbakening van Limieten: Het paper identificeert expliciet waar het framework faalt (white-box adaptive paraphrasing) en waar het slaagt, ondersteund door uitgebreide ablation studies en baselines.

4. Resultaten

De evaluatie omvatte 2.100 traces over acht aanvalfamilies, vijf verdedigingen en drie model backends (Azure GPT-5, Anthropic Sonnet 4.5, Anthropic Haiku 4.5).

Tool Poisoning: ChannelGuard bereikte 30/30 blokkeringen bij de IB-3 gate (Tool $\to$ Worker) over alle drie de backends. In contrast hiermee vertrouwde de onverdedigde pipeline op Azure 100% op de Azure provider filter voor blokkering op Azure, en 100% op de eigen alignment van het model op Anthropic backends. ChannelGuard's mechanisme bleef vast en applicatie-eigendom.
Prompt Injection: ChannelGuard verminderde de ASR met 50% (0.333 $\to$ 0.167) vergeleken met de onverdedigde baseline.
Memory Poisoning: Op de Azure stack domineerde de provider filter de blokkering voor beide systemen. Echter, op Anthropic backends bood ChannelGuard's IB-3-mem gate gedeeltelijke blokkering, waarbij de rest werd afgehandeld door de model alignment, wat een "shared-credit" resultaat aantoont in plaats van een totale substitutie.
Adaptive Paraphrase (White-Box): Zowel ChannelGuard als de onverdedigde baseline faalden, met een ASR van ~0.667. De statische frasebank kon semantisch equivalente maar lexicaal afstandelijke herschrijvingen niet detecteren. Het paper merkt op dat een non-signature baseline (SmoothLLM) beter presteerde op deze specifieke aanval.
Efficiëntie: ChannelGuard is 1.19 $\times$ sneller op de gepoolde adversariële workload. Specifiek op Prompt Injection is het 3.30 $\times$ sneller omdat de IB-0 gate de pipeline afkapt voordat dure model-calls plaatsvinden.
Redeneringsgetrouwheid (Reasoning Fidelity): Op benigne GSM8K taken (geen aanvallen) behield ChannelGuard de redeneernauwkeurigheid exact (CTCA = 0.867 voor beide systemen).

5. Betekenis en Claims

Het paper claimt dat veilige modellen niet componeren tot veilige multi-agent systemen zonder expliciete monitoring van de inter-agent kanalen. De primaire betekenis ligt in:

Blootleggen van de "Veiligheidsillusie": Het demonstreren dat zero ASR in huidige evaluaties vaak een totale afhankelijkheid maskeert van ondoorzichtige, stochastische provider filters die ontwikkelaars niet kunnen controleren of auditeren.
Provider-Invariantie: Het bewijzen dat ChannelGuard een deterministisch, inspecteerbaar blokkeringsmechanisme biedt dat consistent blijft ongeacht de onderliggende model backend, in tegen tegenstelling tot de "geleende" veiligheid van onverdedigde pipelines.
Defense-in-Depth: Het positioneren van ChannelGuard niet als een vervanging voor provider filters of input-only verdedigingen, maar als een noodzakelijke laag die het interne pipeline-oppervlak beveiligt.

De auteurs zijn bescheiden over de beperkingen van het framework, waarbij zij erkennen dat statische frasebanks geen adaptieve white-box paraphrasing kunnen verslaan en dat de huidige implementatie afhankelijk is van Engelstalige, handgecureerde templates. Zij concluderen dat de volgende stap is om de frasebank adversarieel te leren om de dekking van de kanalen te evenaren.