Een universele jailbreak in GPT-5.6 laat zien dat 'het model is veilig' een belofte is die je leverancier niet kan waarmaken

OpenAI stak er naar eigen zeggen ruim 700.000 GPU-uren aan geautomatiseerd red-teamen in om universele jailbreaks in GPT-5.6 zelf te vinden, voordat iemand anders dat kon. Een Britse overheidsdienst brak het model daarna alsnog. Het AI Security Institute ontsloot met universele jailbreaks de volledige reeks offensieve cybercapaciteiten van het model, in elke testronde tot nu toe, en de onderzoekers hadden hun truc vaak binnen enkele uren klaar. Die twee feiten passen niet bij elkaar. En precies in dat gat zit alles wat een veiligheidsbelofte van een AI-leverancier waard is.

Waar het op neerkomt: zolang de ingebouwde remmen van je leverancier je enige verdedigingslaag zijn, is "het model is veilig" geen garantie maar marketing met een houdbaarheidsdatum. De volgende universele jailbreak opent het risico voor iedereen tegelijk opnieuw, op een model dat jij niet in de hand hebt. Een MKB-bedrijf dat AI serieus inzet, kan daar niet op wachten. Het moet zijn eigen controles ontwerpen op wat er het model in gaat en wat eruit komt, in plaats van te vertrouwen op een patch die misschien komt en misschien op tijd is.

De belofte zit in het ontwerp, niet in een bug

Het verleidelijke aan de kop "universele jailbreak gevonden" is dat het klinkt als een lek dat je dicht en dan ben je klaar. Was het maar zo. Prompt-injectie, de familie waartoe deze jailbreaks behoren, staat niet voor niets bovenaan de OWASP-lijst van de grootste risico's voor taalmodellen. De reden dat het daar staat en blijft staan, is ontnuchterend: door het stochastische karakter van de manier waarop deze modellen werken, is het volgens diezelfde standaard onduidelijk of er überhaupt waterdichte methoden bestaan om prompt-injectie te voorkomen. Dat is geen mening van een criticus, dat is de nuchtere taal van het veiligheidsraamwerk zelf.

De oorzaak is fundamenteel. Prompt-injectie ontstaat doordat data zelf instructies blijkt te bevatten: het model krijgt jouw opdracht en de tekst van een aanvaller door hetzelfde kanaal binnen, als één stroom woorden, en kan het onderscheid niet betrouwbaar maken. Er is geen aparte, beveiligde lijn voor "echte" instructies. Zolang dat zo is, verschuift elke nieuwe modelversie de grens een stukje op, maar haalt de grens niet weg. Beveiligingsonderzoeker Simon Willison, die dit al jaren volgt, zegt het botter: er is nog steeds geen honderd procent betrouwbare manier bekend om dit te voorkomen, en de modelbouwers gaan de gebruiker niet redden. OpenAI zegt zelf dat GPT-5.6 beter is in het vinden en dichten van kwetsbaarheden dan in het uitbuiten ervan. Let op de vorm van die zin: het is een geruststelling met een slag om de arm, geen garantie.

De timing onderstreept hoe rekbaar het woord "veilig" is. Waar Anthropics Fable 5 na een vergelijkbare vondst nog een exportbeperking van de Amerikaanse overheid kreeg opgelegd, bleef GPT-5.6 ondanks bevindingen uit dezelfde categorie gewoon breed beschikbaar. Of een model "veilig genoeg" heet, is dus deels een technische en deels een zakelijke afweging. En die tweede helft beslis jij niet mee.

De leverancier meet het gemiddelde, jij draagt de uitschieter

De cijfers van OpenAI kloppen waarschijnlijk, en juist daarom is het gevaarlijk om er blind op te leunen. In zijn systeemkaart classificeert het bedrijf GPT-5.6 als hoog risico op cybergebied, net onder de kritieke drempel, en het stelt dat de nieuwe laag ongeveer tien keer meer mogelijk schadelijke activiteit tegenhoudt dan eerdere modellen. Tien keer beter dan het vorige niveau is nog altijd niet hetzelfde als veilig. Zulke getallen beschrijven het gemiddelde geval: over duizenden willekeurige pogingen houdt de rem beter stand dan voorheen. Maar een aanvaller die het specifiek op jouw bedrijf heeft gemunt, gooit geen willekeurige pogingen naar het model. Hij zoekt de ene formulering die er wél langs glipt, en hij heeft alle tijd. Het AI Security Institute vond die formulering in uren.

Het instituut voegde er iets aan toe dat elke ondernemer zou moeten lezen: bedrijven die zo'n model in een agentopstelling inbouwen, zijn zelf verantwoordelijk voor de risico's van deze kwetsbaarheden. Dat is geen kleine lettertjes, dat is de toezichthouder die je recht in het gezicht zegt dat de bal bij jou ligt. De leverancier levert een filter dat op papier steeds beter wordt. Het restrisico, het moment dat het filter faalt op precies jouw invoer, staat op jouw naam.

Wat 'eigen controle' is, en wat je leverancier je niet kan verkopen

Eigen controle betekent niet dat je zelf een veiliger model gaat bouwen. Dat kun je niet, en dat hoeft ook niet. Het betekent dat je het model behandelt als een onbetrouwbare component in een systeem dat jij wél ontwerpt. Willison vat de gevaarlijkste combinatie samen als de lethal trifecta: een agent die tegelijk bij je gevoelige gegevens kan, blootstaat aan tekst van buitenaf, en naar buiten kan communiceren. Zitten die drie dingen in één agent, dan is hij structureel te misbruiken, hoe grondig het onderliggende model ook is getest. De verdediging is dan niet "wacht op een veiliger model", maar: zorg dat die drie niet ongecontroleerd samenvallen.

Dat vertaalt zich naar precies de maatregelen die OWASP zelf aanraadt, en die één ding gemeen hebben: jij bezit ze, niet je leverancier. Beperk en filter wat er het model in gaat. Valideer wat eruit komt voordat het iets mag doen. Geef het model de minste rechten die het werk toelaat, zodat een geslaagde injectie weinig schade kan aanrichten. En zet een mens tussen het model en elke onomkeerbare actie. In de praktijk begint dat bij de saaie basis die te vaak wordt overgeslagen: je API-sleutels en secrets zo afschermen dat een tool die op hol slaat er niet zomaar bij kan, en je agents monitoren met logging, budgetplafonds en een noodstop zodat je een incident ziet aankomen en kunt ingrijpen. Dat is de laag die geen enkele leverancier kan meeleveren, want hij zit per definitie bij jou in huis.

Om eerlijk te zijn: die remmen zijn niet waardeloos

Het eerlijke tegenargument verdient ruimte, want het is er. Die 700.000 GPU-uren zijn geen toneelstuk. Het red-teamen, het harden tegen prompt-injectie, het tegenhouden van tien keer zoveel schadelijk gedrag: dat maakt het model daadwerkelijk veiliger. Voor een klein bedrijf zonder eigen beveiligingsteam is de ingebouwde rem van de leverancier vaak de beste enkele laag die er is, en niets in dit betoog zegt dat je die moet weggooien. Wie eruit concludeert "dan is het hopeloos, laat AI maar zitten", slaat door naar de andere kant en laat het echte voordeel liggen.

Maar dat versterkt mijn punt, het weerlegt het niet. De rem van de leverancier is de beste éérste laag, niet de enige. Een filter dat gemiddeld beter wordt, faalt nog steeds op de specifieke invoer die iemand voor jou in elkaar zet, en die ene keer draag jij, niet je leverancier. Het verschil tussen roekeloos en volwassen AI-gebruik is niet of je de leverancier vertrouwt, maar of je iets achter de hand hebt voor het moment dat dat vertrouwen niet opgaat. Het is dezelfde denkfout als AI de code laten controleren die AI zelf schreef: dezelfde laag twee keer stapelen levert geen tweede laag op, alleen dezelfde blinde vlek in het kwadraat.

De vraag die ertoe doet

Zevenhonderdduizend GPU-uren rekenkracht tegenover een paar uur werk van een overheidslab: dat is de verhouding om te onthouden. De vraag die je leverancier je voorlegt, luidt "is het model veilig?", en het antwoord daarop is altijd een geruststellend verkoopverhaal, want de leverancier stelt de vraag en geeft zelf het antwoord. De vraag die er echt toe doet, is een andere: wat gebeurt er aan jouw kant op het moment dat het model tóch doet wat het niet zou moeten?

Veiligheid is geen eigenschap van het model dat je huurt. Het is een eigenschap van het systeem dat jij eromheen bouwt. De volgende universele jailbreak is geen kwestie van of, maar van wanneer, en hij gaat voor iedereen tegelijk open, op een model dat niemand buiten de leverancier controleert. Wie tegen die tijd zijn eigen controles op orde heeft, merkt een incident en grijpt in. Wie op de patch wachtte, merkt een datalek.