🤖 AI

Effect-Transparent Governance for AI Workflow Architectures: Semantic Preservation, Expressive Minimality, and Decidability Boundaries

Dit artikel presenteert een machine-gecontroleerde formalisering in Rocq die aantoont dat effect-transparante governance voor AI-workflows externe effecten strikt kan beperken en veiligheidspredicaten kan afdwingen zonder in te leveren op interne computationele expressiviteit of semantische transparantie.

Oorspronkelijke auteurs: Alan L. McCann

Gepubliceerd 2026-05-06

📖 5 min leestijd🧠 Diepgaand

CC0 1.0

Oorspronkelijke auteurs: Alan L. McCann

Oorspronkelijk artikel vrijgegeven aan het publieke domein onder CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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 voor dat je een briljante, hyper-capabele AI-assistent hebt. Deze kan code schrijven, dingen onthouden, externe tools aanroepen en zelfs met andere AI-modellen chatten om complexe problemen op te lossen. Maar je maakt je zorgen: wat als het besluit iets gevaarlijks te doen, zoals je bestanden verwijderen of een dienst aanroepen die het niet zou moeten?

Traditioneel dachten mensen dat je moest kiezen tussen veiligheid en capaciteit. Je kon de AI laten doen wat hij wilde (risicovol) of zware restricties opleggen die hem misschien zouden stoppen om zijn werk correct te doen (dom).

Dit paper introduceert een nieuwe manier om AI-systemen te bouwen die bewijst dat je niet die afweging hoeft te maken. Het toont aan dat je een "governance"-laag om de AI kunt leggen die slechte acties stopt zonder te veranderen hoe de AI denkt of problemen oplost.

Hier is de uitleg met eenvoudige analogieën:

1. De Kernidee: De "Portier" versus de "Redacteur"

De meeste huidige veiligheidsmethoden fungeren als een Redacteur. De AI doet zijn werk, schrijft een verhaal, en vervolgens leest de Redacteur het. Als het verhaal een slecht woord bevat, snijdt de Redacteur het eruit of herschrijft de zin.

Het Probleem: De Redacteur verandert het verhaal. Het oorspronkelijke denkproces van de AI wordt gewijzigd, en het eindresultaat kan anders zijn dan wat de AI bedoelde.

Dit paper stelt een Portier-benadering voor (genaamd "Effect-Transparante Governance").

Hoe het werkt: De AI bevindt zich in een kamer. Voordat het een deur kan openen (zoals toegang tot geheugen, het aanroepen van een tool of het vragen aan een LLM), moet het zijn ID aan de Portier tonen.
De Magie: Als de Portier zegt "Ga je gang", loopt de AI door de deur en doet precies wat hij van plan was. De Portier heeft het denkproces van de AI niet veranderd; ze hebben alleen de ID gecontroleerd.
Het Resultaat: Als de AI mag doorgaan, is het resultaat exact hetzelfde als wanneer de Portier er helemaal niet was. Het "brein" van de AI blijft onaangeroerd.

2. De "Interactieboom" (Het Blauwdruk)

De auteurs bouwden een wiskundig model van AI-workflows met behulp van iets dat ze "Interactiebomen" noemen.

Analogie: Denk aan een AI-workflow als een boom. De stam is de logica van de AI. De takken zijn de dingen die het wil doen (zoals "Een database aanroepen" of "Een vraag stellen").
De "Governance" is een omhulsel rond de uiteinden van de takken. Het controleert elke enkele tak voordat deze groeit. Als een tak niet geautoriseerd is, stopt de boom daar met groeien (het "divergeert" of draait op zijn plaats). Als het geautoriseerd is, groeit de tak precies zoals de AI het heeft ontworpen.

3. Zeven Belangrijke Ontdekkingen (De "Zeven Zuilen")

De auteurs gebruikten een computer om wiskundig zeven dingen over dit systeem te bewijzen:

P1 & P2: Het is Nogsteeds Super Slim. Zelfs met de Portier die ID's controleert, kan de AI nog steeds alles doen wat een normale computer kan doen (Turing-compleet) en kan het nog steeds geavanceerde tools zoals LLM's gebruiken. Het veiligheidsnet heeft de AI niet "dommer" gemaakt.
P3: De "Beslisbaarheidsgrens" (De Lijn in het Zand). De Portier is goed in het controleren van structurele regels (bijv. "Is dit een geheugenaanvraag?" "Heeft deze gebruiker een badge van niveau 5?"). Deze zijn eenvoudig direct te controleren. Echter, de Portier kan niet voorspellen of de AI voor altijd in een lus blijft hangen of of een complex wiskundig probleem ooit zal eindigen. Het paper bewijst dat de Portier in zijn eigen baan blijft: hij controleert regels, geen diepe filosofische vragen over het toekomstige gedrag van de AI.
P4: Behoud van Doel. Als de AI mag draaien, zal het zijn doel bereiken. Als het 2+2 moest berekenen, zal het nog steeds 4 berekenen. De veiligheidscontrole heeft de wiskunde niet veranderd.
P5: Expressieve Minimaliteit. Het systeem gebruikt een specifieke set tools (Berekenen, Geheugen, Redeneren, Tools Aanroepen, Observeren). De auteurs bewezen dat als je één van deze tools verwijdert, de AI een specifiek type kracht verliest. Je kunt het systeem niet verder vereenvoudigen zonder zijn vermogen om complex werk te verrichten te breken.
P6: De "Portier" is Sterker dan de "Redacteur". Het paper bewijst dat het controleren van de actie (structurele governance) strikt beter is dan alleen het filteren van de output (inhoudelijke governance). Een Portier kan een slechte actie stoppen voordat deze gebeurt. Een Redacteur kan alleen proberen een slecht resultaat te herstellen nadat het is gebeurd, wat minder betrouwbaar is.
P7: Semantische Transparantie (Het "Spook"-effect). Dit is het belangrijkste deel. Bij elke enkele run waarbij de AI mag werken, is het resultaat observationeel equivalent aan een onbeheerde run. Voor een buitenstaander is het alsof de governance-laag onzichtbaar was (een spook), behalve het feit dat het succesvol de slechte dingen stopte.

4. Het "Artifact" (Het Bewijs)

De auteurs hebben dit niet alleen opgeschreven; ze hebben het gebouwd binnen een bewijshulpmiddel genaamd Rocq (een tool voor het verifiëren van wiskunde).

Ze schreven 12.000 regels code.
Ze bewezen 454 stellingen.
Ze erkenden nul fouten (0 erkende lemma's).
Dit betekent dat de computer hun logica heeft gecontroleerd en bevestigd dat het 100% wiskundig correct is.

Samenvatting

Dit paper betoogt dat we AI-systemen kunnen bouwen met een "veiligheidshuls" die fungeert als een strenge poortwachter. Deze poortwachter stopt ongeautoriseerde acties (zoals hacken of ongeautoriseerde oproepen), maar, cruciaal, hij interfereert niet met het denkproces van de AI wanneer de actie is toegestaan.

Het bewijst dat Veiligheid en Intelligentie geen vijanden zijn. Je kunt een systeem hebben dat volledig beheerd en veilig is, maar toch zijn volledige vermogen behoudt om te berekenen, te redeneren en te handelen, mits de acties zijn geautoriseerd. De governance-laag is transparant voor het succes van de AI en fungeert alleen als een schild tegen ongeautoriseerde effecten.

Technische Samenvatting: Effect-transparante Governance voor AI-workflow-architecturen

Probleemstelling

Naarmate AI-workflowsystemen steeds meer in de wereld handelen—door Large Language Models (LLM's) te raadplegen, toestand te beheren en externe tools aan te roepen—ontstaat er een groeiende behoefte aan governance-mechanismen om onveilig of ongeautoriseerd gedrag te voorkomen. Een heersende aanname in dit vakgebied is dat governance onvermijdelijk ten koste gaat van capaciteit: beperkingen die bedoeld zijn om de veiligheid te verhogen, zouden het spectrum aan gedragingen dat een systeem kan vertonen, verkleinen. Dit artikel daagt die aanname uit door een architecturaal alternatief te formaliseren waarbij governance wordt opgelegd aan de effectgrens, in plaats van door interne berekeningen te wijzigen of uitvoer te post-processen. De centrale semantische vraag die wordt behandeld, is of governance verandert wat toegestane programma's berekenen.

Methodologie

De auteurs presenteren een machine-gecontroleerde formalisering van structureel gegovernede AI-workflow-architecturen met behulp van Interaction Trees binnen de bewijshulp Rocq 8.19 (voorheen Coq). De ontwikkeling bestaat uit 36 modules, 12.000 regels code en 454 stellingen, met nul toegestane lemma's.

Kernformalisatie

Interaction Trees (ITrees): Programma's worden gemodelleerd als co-inductieve bomen over een event-type $E$ , gedefinieerd als Ret(v), Tau(t) of Vis(e, k). Dit maakt de representatie van recursieve en onzuivere programma's mogelijk.
Directive Event Type: Het systeem definieert een DirectiveE-type met constructoren voor primitieve capaciteiten: computationele morfismen, geheugenoperaties, oracle (LLM)-oproepen, externe tooloproepen en observabiliteitsevents.
Governance-operator ( $G$ ): Governance wordt geïmplementeerd als een wrapper rond effectinterpretatie, in de traditie van algebraïsche effecthandlers. De operator $G(h)$ $ bemiddelt elke directive die wordt uitgegeven door een basishandler $h$ . Deze voert pre-checks uit (vertrouwen, toestemming, fasevalidatie) en post-instrumentatie (provenance, observabiliteit). Als een check faalt, divergeert de uitvoering via ITree.spin; als deze slaagt, wordt de directive gedelegeerd aan de onderliggende handler.
Veiligheidspredicaat: Veiligheid wordt gedefinieerd via een co-inductief predicaat gov_safe met behulp van geparametriseerde co-inductie (paco). Dit predicaat onderscheidt tussen governance-only events (die altijd zijn toegestaan) en echte I/O-events (die expliciete autorisatie vereisen).

Belangrijkste Bijdragen en Resultaten

Het artikel stelt zeven primaire eigenschappen (P1–P7) vast die bewijzen dat governance en computationele expressiviteit orthogonale dimensies zijn.

1. Semantische Transparantie (De Kernstelling)

De centrale bijdrage is een machine-gecontroleerde stelling die semantische transparantie bewijst. Voor alle uitvoeringen waarbij governance-checks slagen, is de gegovernede interpretatie observationeel equivalent (modulo governance-only events) aan de ongegovernede interpretatie.

Implicatie: Toegestane programma's berekenen exact dezelfde partiële functie en produceren dezelfde bereikbare retourwaarden als ze dat zonder governance zouden doen. Governance beperkt de grens van effecten zonder de interne berekening van toegestane paden te wijzigen.

2. Gegovernede Expressiviteit (P1 & P2)

De auteurs bewijzen dat de governance-wrapper de computationele kracht niet vermindert:

Gegovernede Turing-compleetheid: Het systeem blijft Turing-compleet onder governance. Registermachine-programma's kunnen worden vertaald naar gegovernede interaction trees zonder verlies van expressiviteit.
Gegovernede Oracle-expressiviteit: De architectuur ondersteunt oracle-extensies (LLM-vragen) onder governance, waarbij het vermogen om complexe redeneerworkflows te modelleren behouden blijft.

3. Beslisbaarheidsgrens (P3)

Het artikel formaliseert een strikte grens tussen wat governance kan beslissen en wat niet:

Governance-predicaten: Deze zijn structureel, syntactisch, totaal en gesloten onder Booleaanse compositie (EN, OF, NIET). Ze kunnen eigenschappen zoals vertrouwensniveaus en capaciteitsklassen beslissen.
Semantische Eigenschappen: Programma-eigenschappen zoals halteren blijven niet-triviaal en onbeslisbaar door governance. Het artikel bewijst dat governance het halt-probleem niet kan beslissen, aangezien twee programma's identieke directive-structuren kunnen delen (en dus governance-checks doorstaan) maar verschillen in globaal terminatiegedrag. Dit sluit aan bij de Stelling van Rice, toegepast op de structurele grens.

4. Expressieve Minimaliteit (P5)

De auteurs bewijzen dat de verzameling primitieve capaciteiten (berekenen, geheugen, redeneren, externe oproep, observabiliteit) minimaal noodzakelijk is.

Strikte Hiërarchie: De capaciteiten vormen een strikte keten: code < code + geheugen < code + geheugen + redeneren < code + geheugen + redeneren + oproep.
Noodzaak: Het verwijderen van elke enkele primitieve capaciteit vermindert strikt de expressieve kracht van het systeem. Zo zijn geheugendirectives structureel noodzakelijk voor Turing-compleetheid, en zijn LLMCall-directives noodzakelijk voor oracle-extensies.

5. Asymmetrie van Subsumptie (P6)

Het artikel vestigt een strikte scheiding tussen structurele governance en inhoudsgerichte filtering:

Structureel omvat Inhoud: Structurele governance omvat inhoudsfiltering strikt. Door effecten te bemiddelen aan de interpretatiegrens, voorkomt structurele governance dat ongeautoriseerde I/O-events plaatsvinden.
Inhoud Omvat Structureel Niet: Inhoudsfilters (bijvoorbeeld herschrijven van uitvoer) kunnen waarden wijzigen, maar kunnen het optreden van een ongeautoriseerde effectstap niet voorkomen. Daarom impliceert inhoudsfiltering alleen geen effectveiligheid.

6. Doelbehoud (P4)

Op alle uitvoeringen waarbij governance toestaat, behoudt het systeem de doelen van het programma. Als een programma is ontworpen om een specifieke retourwaarde $v$ te bereiken, en de governance-checks slagen, zal de gegovernede uitvoering $v$ bereiken.

7. Veiligheid via Ontkenning (Lichtheid versus Veiligheid)

Wanneer een governance-check faalt, wisselt het systeem lichtheid in voor veiligheid. De uitvoering divergeert (spin) in plaats van een onjuist resultaat te produceren. Het systeem garandeert dat er nooit een ongeautoriseerd effect optreedt en dat er nooit een "onveilige" retourwaarde wordt geproduceerd.

Betekenis en Scope

Het artikel claimt aan te tonen dat governance en computationele expressiviteit orthogonaal zijn. Governance kan worden opgelegd om de effectgrens van programma's te beperken zonder hun interne computationele expressiviteit te verminderen of hun semantiek op toegestane traces te wijzigen.

Vertrouwensgrens: De garanties gelden ten opzichte van een Trusted Computing Base (TCB) bestaande uit de Rocq-kernel, de Interaction Trees-bibliotheek en de runtime-implementatie van de $G$ -operator. Het artikel trekt een parallel met geverifieerde compilers (CompCert) en besturingssysteemkernels (seL4), en merkt op dat de kloof tussen het formele model en de ingezette runtime wordt overbrugd door testen (gevalideerd tegen 70.000+ gegenereerde sequenties).
Beperkingen: De transparantiestelling geldt alleen voor toegestane uitvoeringen; geweigerde uitvoeringen divergeren. Het model abstracteert weg van hulpbronuitputting, planning en probabilistisch modelgedrag. De stellingen gelden voor de abstracte architectuur en interpreter, niet voor end-to-end garanties op gecompileerde binaries.

Dit werk breidt eerdere gemecaniseerde ontwikkelingen uit (McCann [2026b, 2026e]) door semantische transparantie, expressieve minimaliteit en een formele beslisbaarheidsgrens toe te voegen, en biedt zo een rigoureuze basis voor "effect-transparante governance" in AI-systemen.