Ga naar hoofdinhoud
← Terug naar blog

Formeel geverifieerde planning herstelt de veiligheidsgarantie van LLM-agenten

AI Security

De kern

Veiligheid en bruikbaarheid bij LLM-agenten hoeven niet te worden afgewogen. Soteria, een framework uit Princeton en Snowflake, bewijst dit door plannen vóór uitvoering te verifiëren tegen formele specificaties en tijdens uitvoering af te dwingen met een herstelpad bij geblokkeerde onveilige acties. Over 207 taken in drie benchmarks bereikt het 1,7 maal het gemiddelde taaksucces van de beste vergelijkingsmethoden, met honderd procent conformance en nul specificatieschendingen. Voor organisaties die onder de AI-verordening vallen, verlegt dit de vraag van probabilistische guardrails naar specificatievolledigheid als de nieuwe governance-lag.

Wat de paper aantoont en hoe het mechanisme werkt

Bestaande benaderingen voor veilige LLM-agenten kiezen een kant. Probabilistische guardrails, zoals NeMo Guardrails, plaatsen een secundair model als rechter over elke voorgestelde actie. Dit is eenvoudig uitrolbaar, maar biedt geen formele garantie omdat het secundaire model zelf fouten maakt. Specificatiegebaseerde monitors, zoals AgentSpec of ABC, controleren pre- en postcondities tijdens uitvoering, maar hebben geen geverifieerd herstelpad wanneer een aanroep wordt geblokkeerd. Het gevolg is een dilemma: blokkeren voorkomt schendingen, maar kan de agent stranden zonder principieel alternatief.

Soteria doorbreekt dit dilemma met twee samenhangende mechanismen. Ten eerste genereert de planner een hiërarchisch plan in een domainspecifieke taal, weergegeven als een Guarded Transition System. Elke staat bevat guarded transitions die maximaal één actie uitvoeren, gevolgd door een sprong naar de volgende staat. Subplannen voor standaardprocedures, zoals annulering of terugbetaling, worden hergebruikt als bouwstenen. Ten seconden verifieert een static verifier dit plan vóór enige toolaanroep tegen drie eigenschappen: toolcontractnaleving, voortgangsverzekering en policycompliance. De verificatie gebruikt Dafny om verification conditions af te leiden over een ghost state die bestaat uit een monotoon stapteller, call-logs per spec-refererende actie en een provenance-map voor data-afhankelijkheden. Faalt een check, dan produceert het systeem een gerichte diagnose die de planner binnen een begroting van acht pogingen laat herstellen.

Tijdens uitvoering controleert de SpecMonitor elke voorgestelde toolaanroep tegen de specificaties. Wanneer een aanroep de preconditie of een temporal policy-schending zou veroorzaken, blokkeert de monitor en raadpleegt de executor het geverifieerde plan voor een alternatief pad. Het plan dient dus zowel als uitvoeringsroadmap als als herstelgids.

De evaluatie omvat 207 taken over drie benchmarks: τ²-Airline met vijftig taken, τ²-Retail met honderdveertien taken en Toolathlon met drieënveertig taken. Vier ruggengraatmodellen worden getest: GPT-5.4-mini, Gemini 3 Flash, Claude Haiku 4.5 en Claude Opus 4.6. De vergelijkingsmethoden zijn No Guardrail, NeMo Guardrails, AgentSpec en ABC.

Soteria bereikt honderd procent conformance met nul specificatieschendingen over alle modellen en benchmarks. Geen enkele vergelijkingsmethode haalt volledige conformance. Op τ²-Airline bereikt de beste vergelijkingsmethode 90 procent conformance (ABC met GPT-5.4-mini), maar met vijf schendingen. Op τ²-Retail haalt ABC met Gemini 3 Flash 93 procent conformance, met acht schendingen. Op Toolathlon verliest de sterkste onbeschermde vergelijkingsmethode (Claude Opus 4.6, 30,2 procent ruwe bruikbaarheid) meer dan de helft aan specificatieschendingen en eindigt op 11,6 procent succes. Soteria bereikt op Toolathlon 18,6 procent succes zonder schendingen, en op τ²-Airline zelfs 88 procent met Claude Opus 4.6 tegen 56 procent voor de beste vergelijkingsmethode.

Het taaksucces verbetert met 4,7 tot 43,9 procentpunt per model-benchmark-paar. Dat is 1,7 maal het gemiddelde succes van de beste vergelijkingsmethoden. De ablatie in Tabel 3 toont dat een plat onverifieerd plan al 44 procent succes haalt op τ²-Airline met GPT-5.4-mini, maar met dertien schendingen. Toevoeging van verificatie vermindert dit tot tien schendingen. De SpecMonitor sluit het gat volledig: nul schendingen en succes gelijk aan ruwe bruikbaarheid.

De kosten per taak zijn op conversationele benchmarks hoger omdat elk beurt een nieuw plan vereist, maar op single-turn Toolathlon-taken kan Soteria kostenefficiënter zijn door minder verspilde stappen en vroegtijdig blokkeren van spec-schendingen.

Het volgende codevoorbeeld implementeert een vereenvoudigde versie van het kernprincipe: een guarded transition system waarbij plannen vóór uitvoering worden gecontroleerd en runtime wordt afgedwongen met trace-vooruitblik.

from dataclasses import dataclass
from typing import List, Callable, Tuple

@dataclass
class Step:
    state: str
    action: str
    args: tuple

class GuardedTransitionSystem:
    def __init__(self, preconditions: dict, policies: List[Callable]):
        self.preconditions = preconditions
        self.policies = policies
        self.trace = []
    
    def verify_plan(self, plan: List[Step]) -> Tuple[bool, str]:
        """Statische verificatie: controleer alle paden vóór uitvoering."""
        for step in plan:
            if step.action in self.preconditions:
                if not self.preconditions[step.action](step.args, self.trace):
                    return False, f"preconditie faalt in staat {step.state}"
            self.trace.append(step)
        return True, "plan geverifieerd"
    
    def enforce_runtime(self, proposed_action: str, args: tuple) -> Tuple[bool, str]:
        """Runtime SpecMonitor: blokkeer als specificatie geschonden zou worden."""
        hypothetical = self.trace + [Step("runtime", proposed_action, args)]
        for policy in self.policies:
            if not policy(hypothetical):
                return False, "geblokkeerd door SpecMonitor"
        self.trace.append(Step("runtime", proposed_action, args))
        return True, "goedgekeurd"
    
    def reset(self):
        self.trace = []

# Voorbeeld: een annulering mag alleen na een No-Flown-check
def cancel_policy(trace: List[Step]) -> bool:
    cancels = [s for s in trace if s.action == "Cancel-Resv"]
    flown_checks = [s for s in trace if s.action == "No-Flown"]
    for c in cancels:
        if not any(f in trace[:trace.index(c)] for f in flown_checks):
            return False
    return True

sys = GuardedTransitionSystem(
    preconditions={"Cancel-Resv": lambda args, tr: len(args) > 0},
    policies=[cancel_policy]
)

De complexiteit van dit mechanisme valt in drie lagen te begrijpen. Planverificatie genereert verification conditions over S staten en T transities. Ghost-state bijhouding voor specificatie-evaluatie kost O(T maal het aantal specificaties). De Dafny-theoremprover is in de worst-case exponentieel in de formulediepte, maar de paper beperkt zich tot first-order theorieën over eindige call-logs. In de praktijk verifieert 95,6 procent van de plannen binnen acht pogingen. Runtime SpecMonitor-evaluatie is O(het aantal specificaties maal de tracelengte) per voorgestelde stap, met verwaarloosbare meetbare overhead volgens Appendix B.4 van de paper. De dominante kostenfactor is de LLM-aanroep voor plangeneratie, niet de formele controle.

Alternatieve verklaringen

Het meetbare succes van Soteria staat vast, maar de oorzaak kent drie materieel verschillende verklaringen die elk een andere governance-implicatie hebben.

De eerste verklaring is dat het succes voortkomt uit decompositie, niet uit verificatie. Een plat plan splitst taak en planning; Soteria splitst daarnaast verificatie en uitvoering. Het zou kunnen dat een onbeschermd systeem met dezelfde hiërarchische structuur hetzelfde taaksucces bereikt. Deze hypothese is onvoldoende. De ablatie in Tabel 3 toont dat een plat onverifieerd plan (Base) op τ²-Airline met GPT-5.4-mini 54 procent ruwe bruikbaarheid haalt, maar slechts 44 procent succes na aftrek van schendingen. Toevoeging van verificatie verhoogt succes tot 46 procent bij tien schendingen. Pas de SpecMonitor brengt succes naar 60 procent mét nul schendingen. Decompositie alleen verklaart het verschil niet.

De tweede verklaring is dat de benchmarks kunstmatig geschikt zijn voor deze methode. τ²-Airline en τ²-Retail zijn procedureel gestructureerde domeinen met expliciete policy-documenten die zich natuurlijk lenen voor first-order formalisering. Toolathlon omvat bestandssysteem- en documentbewerkingen met duidelijke pre- en postcondities. In domeinen zonder dergelijke gestructureerde procedures, zoals open-ended onderzoek of creatieve inhoudsgeneratie, zou de kosten-batenverhouding van specificatie-opstelling de winst tenietdoen. Dit is een sterke alternatieve verklaring die de generaliseerbaarheid beperkt tot procedureel dichte domeinen.

De derde verklaring is dat de nul-schendingsclaim circulair is. De specificaties zijn door de onderzoekers zelf geformaliseerd en gevalideerd. Het systeem garandeert conformance tegen deze specificaties, maar niet noodzakelijk tegen het werkelijke domeinbeleid zoals een menselijke auditor dat zou interpreteren. De onderscheidende toets is een onafhankelijke dekkingstoets: de paper rapporteert dat elke state-changing policy-clause is gemapt op minstens één specificatie, maar kan niet uitsluiten dat onbekende randgevallen buiten de formalisering vallen.

Wat deze conclusie zou weerleggen

De conclusie dat veiligheid en bruikbaarheid niet hoeven te worden afgewogen, kent twee falsificatiecriteria. Ten eerste een meetstudie waarin Soteria zonder specificatieschendingen een taak voltooit die in strijd is met het domeinbeleid zoals een menselijke auditor dat interpreteert. De huidige honderd procent conformance meet immers tegen geformaliseerde specificaties, niet tegen normatieve werkelijkheid. Ten tweede een aanwijzing dat een probabilistische guardrail bij gelijkbare kosten en dezelfde decompositie eveneens honderd procent conformance haalt op de drie benchmarks. De paper toont dat NeMo Guardrails maximaal 86 procent conformance bereikt op Toolathlon, zelfs bij nul procent succes, en dat AgentSpec en ABC consistent achterblijven.

Een counterfactual maakt de claim scherper. Stel dat Soteria geen formeel geverifieerd plan zou gebruiken, maar slechts een runtime SpecMonitor zonder herstelgids. Dan zou een geblokkeerde actie de agent kunnen stranden in een toestand waar geen alternatief pad naar taakvoltooiing bestaat. De ablatie bevestigt dit: zonder SpecMonitor blijven schendingen bestaan, maar zonder het geverifieerde plan als herstelgids zou het succes mogelijk dalen tot het niveau van AgentSpec, dat wel blokkeert maar geen gecontroleerd alternatief biedt. De combinatie van beide lagen is wat het verschil maakt.

Beperkingen van deze analyse

De auteurs noemen vijf beperkingen expliciet in de limitaties-sectie. Ten eerste vereist Soteria een set geformaliseerde specificaties als input, die momenteel via een semigeautomatiseerde workflow worden verkregen die LLM-gebaseerde autoformalisering combineert met handmatige validatie. Ten tweede neemt de planverificatie aan dat toolcontracten het werkelijke toolgedrag getrouw modelleren en dat postcondities runtime worden vervuld. Ten derde leunt het systeem op geautomatiseerde theoreemprovers, Dafny en Z3, die beperkte first-order theorieën ondersteunen en in de praktijk mogelijk niet alle verificaties afronden. Ten vierde worden subplannen momenteel met LLM-assistentie en iteratieve verificatie gegenereerd; automatisch extraheren en doorontwikkelen van een subplanbibliotheek uit policy-documenten is toekomstig werk. Ten vijfde zou plan-caching en hergebruik over taken van hetzelfde type de planningtijd-kosten verder kunnen verlagen.

Onzeker blijft of de bevinding generaliseert naar Nederlandse overheidsprocessen, die vaak ongeschreven regels, discretionaire ruimte en meervoudige beleidslagen kennen die zich slecht laten formaliseren als first-order specificaties over toolaanroepen. De benchmarks zijn gecontroleerde toolgebruikssimulaties, geen productiesystemen met onverwachte invoer en veranderende omgevingen. Wie de nul-schendingsclaim overdraagt naar een productiecontext, overclaimt.

De Nederlandse consequentie

De AI-verordening vereist in artikel 14 passend menselijk toezicht op high-risk AI-systemen. Voor een NIS2-plichtige instantie die LLM-agenten inzet op geautomatiseerde besluitvorming, zoals een uitvoeringsorganisatie die burgerdossiers verwerkt of een ziekenhuis dat patientroutes plant, stelt Soteria een methodologische eis die boven de huidige praktijk uitstijgt.

De huidige praktijk van probabilistische guardrails biedt geen formele garantie; een NeMo-achtige rail kan een actie goedkeuren die een specificatie schendt zonder dat een mens dit merkt. Soteria draait dit om: de menselijke curator formaliseert het beleid vooraf, de machine garandeert naleving achteraf. Dit verlegt de verantwoordelijkheid van realtime-toezicht naar specificatievolledigheid. Onder artikel 14 is dit relevant omdat adequate menselijke tussenkomst een structurale vereiste is, geen probabilistisch comfort. Een systeem dat 93 procent conformance haalt met acht schendingen op honderdveertien taken, voldoet formeel gezien niet aan het verbod op fundamentele-rechteninbreuken als één van die acht een beschikkingsrecht schendt.

Drie concrete controles voor een Nederlandse organisatie die dit overweegt:

  1. Specificatievolledigheid. Is elke state-changing bedrijfsregel gemapt op een first-order specificatie? Dit vereist een expliciete dekkingstoets clause-voor-clause, zoals de paper beschrijft. Zonder deze toets is de formele garantie hol.

  2. Toolcontractvalidatie. Zijn de pre- en postcondities van externe API's empirisch getoetst, of zijn ze afgeleid uit documentatie die achterhaald kan zijn? De paper waarschuwt dat verificatie ongeldig wordt als de toolcontracten het werkelijke gedrag niet weerspiegelen.

  3. Herstelpadcontrole. Biedt het systeem bij een geblokkeerde actie een alternatief dat de taak nog kan voltooien, of strandt de agent? De paper toont dat het geverifieerde plan hier de doorslag geeft, maar dit vereist dat het plan daadwerkelijk alle branching-paden dekt.

De synthese die de paper zelf niet trekt: onder de AI-verordening en NIS2 is het onderscheid tussen probabilistische naleving en formele garantie geen academisch detail, maar een juridisch relevant verschil. Een NIS2-plichtige die een LLM-agent inzet voor procesautomatisering, kan met Soteria aantonen dat het veiligheidsmechanisme niet afhangt van modelcapaciteit of prompt-tuning, maar van een controleerbare specificatie die vooraf is gevalideerd. Dat maakt het beleidsformuleringsproces, niet het runtime-toezicht, tot het nieuwe knelpunt. Het verhoogt de lat voor wat telt als adequate menselijke tussenkomst.

Zie ook

Bronnen

  1. Soteria: Formally Verified Planning with Runtime Enforcement for Safe LLM Agents, Mike He, Ankush Desai, Sharad Malik, Aarti Gupta, Princeton University en Snowflake, 13 november 2026
  2. AI-verordening (EU AI Act), Verordening (EU) 2024/1689
  3. NeMo Guardrails: a toolkit for controllable and safe LLM applications with programmable rails, T. Rebedea e.a., 2023
  4. Dafny: an automatic program verifier for functional correctness, K. R. M. Leino, LPAR 2010

AI & Security Intelligence

Wekelijkse nieuwsbrief met AI updates, security alerts en compliance inzichten, direct in uw inbox.

Security & AI Operating Model

Advisory met executiekracht

Van BIO2 en NIS2 tot EU AI Act, embedded in uw operating model, niet als extern project. Maandelijks opzegbaar, met assessments als bewijsvoering.