Correct is niet governable: waarom provenance de kern van AI-governance wordt

De discussie over AI-governance draait al twee jaar om dezelfde vraag: hoe zorgen we dat een AI-systeem het juiste doet? We bouwen evaluatiesets, testen hallucinatierates, meten of het antwoord feitelijk klopt. Maar we slaan een laag over. Een juist antwoord maakt een systeem nog niet governable. Het geeft toevallig het juiste antwoord, maar we kunnen niet aantonen waarom het juist is, op welk gezag het handelt, of of de onderliggende feiten nog geldig zijn.

Dit artikel, gebaseerd op het arXiv-paper Correct Is Not Governed: Provenance Integrity in Agentic Workflows van Jesus Salas, analyseert waarom deze laag, provenance, de kern van AI-governance wordt, en waarom het Matrix-framework een fundamentele bijdrage levert.

Het probleem: correctheid is geen governance

Laat ik het probleem scherp stellen. Stel je een agentic workflow voor die een beschikking voorbereidt. De workflow haalt data op uit een basisregistratie, combineert die met beleidsregels, en genereert een conceptbesluit. Het resultaat is inhoudelijk correct: de berekening klopt, de argumentatie is consistent.

Maar de vragen die een auditor stelt, gaan niet over correctheid:

• Op welk gezag is deze beslissing genomen? Welke mandaatregeling is gevolgd?
• Welke feiten liggen eronder? Uit welke bron zijn ze afkomstig?
• Zijn die feiten nog geldig op het moment van beslissen? Of is de bron inmiddels gewijzigd?
• Welke afwegingen zijn gemaakt? Waarom is beleidsregel X toegepast en niet Y?

Een correct antwoord beantwoordt geen enkele van deze vragen. Het antwoord is een momentopname van een proces dat niet kan worden gereconstrueerd. Zonder reconstructie is er geen verantwoording. Zonder verantwoording is er geen governance.

Formele definitie: governed execution

Salas definieert governed execution als werk waarvan de beslissingen, de voltooiing, en de reactie op verandering worden ondersteund door inspecteerbare provenance. Laat $W$ een agentic workflow zijn met een reeks stappen $s_1, \ldots, s_n$. Elke stap heeft:

• een gezagsbasis $G_i$, op grond waarvan mag deze stap handelen?
• een feitbasis $F_i$, welke bronnen liggen aan deze stap ten grondslag?
• een volledigheidsclaim $C_i$, is het werk compleet?

Governed execution vereist dat er voor elke stap een inspecteerbare registratie bestaat van $G_i$, $F_i$ en $C_i$, en dat wijzigingen in onderliggende feiten selectief het afgeleide werk invalideren.

Het Matrix-framework is een deterministische causal-state layer die precies dit registreert: autoriteits- en feitafhankelijkheden vastleggen, voltooiingsbewijs verifiëren, en getroffen werk selectief invalideren.

De empirische bevindingen: governed vs. direct

Salas voerde gecontroleerde vergelijkingen uit tussen governed en directe workflows. De bevindingen zijn genuanceerd en daardoor epistemisch sterk:

• Zelfde uitkomsten: governed en directe workflows bereikten vaak dezelfde uitkomsten. Matrix is geen accuracy-verhoger.
• Alleen governed bewaarde bestuurlijk bewijs: alleen het governed pad bewaarde consistent de governing evidence.
• Alleen governed weigerde ongegronde voltooiing: het governed pad weigerde unsupported closure, een stap claimen als voltooid zonder ondersteunend bewijs.
• Alleen governed beperkte recovery: bij wijzigingen beperkte het governed pad recovery tot afhankelijke taken.

Het cruciale negatieve resultaat: een role-separated transfer challenge faalde. Een deterministisch afgedwongen volledigheidscontract overblokte (over-blocked) synthetische pakketten die buiten de auteuringscontext waren geproduceerd.

Dit is een belangrijk negatief resultaat. Het betekent dat de volledigheidslaag van Matrix te strikt kan zijn voor samenwerking tussen rollen: werk dat legitiem is maar buiten de formele context wordt geproduceerd, wordt geblokkeerd. Dit is een real-world beperking die elke implementatie moet adresseren, te strikte volledigheidscontracten kunnen productieve samenwerking hinderen.

Een codevoorbeeld: provenance-gedreven selectieve invalidatie

Het kernmechanisme van Matrix is selectieve invalidatie: bij wijziging van een bronfeit worden alleen de afgeleide taken die van dat feit afhangen geïnvalideerd, niet het hele proces. Dit is een dependency-graph-probleem.

from dataclasses import dataclass, field

@dataclass
class ProvenanceNode:
    task_id: str
    facts: list[str]          # feitbronnen waarop deze taak steunt
    authority: str            # gezagsbasis voor deze taak
    depends_on: list[str] = field(default_factory=list)  # afhankelijke taken

def invalidate_stale(workflow: dict[str, ProvenanceNode], changed_fact: str) → list[str]:
    """Selectief invalideren: geef alle taken terug die op changed_fact steunen."""
    affected = set()
    changed = True
    while changed:
        changed = False
        for tid, node in workflow.items():
            if changed_fact in node.facts or node.task_id in affected:
                # markeer deze taak + zijn afhankelijken als stale
                before = len(affected)
                affected.add(tid)
                for dep in node.depends_on:
                    affected.add(dep)
                if len(affected) != before:
                    changed = True
    return sorted(affected)

Complexiteitsanalyse: de selectieve invalidatie is $O(n \cdot k)$ in het slechtste geval voor $n$ taken en $k$ afhankelijkheden, maar in de praktijk veel efficiënter omdat alleen het getroffen subgraaf-onderdeel wordt bezocht. De cruciale eigenschap is selectiviteit: een taak die niet op het gewijzigde feit steunt, wordt niet aangeraakt. Dit is het tegenovergestelde van een "recompute alles" strategie. De beperking is dat de juistheid afhangt van de volledigheid van de dependency-registratie, als een taak zijn feitafhankelijkheid niet correct registreert, wordt hij ten onrechte niet geïnvalideerd. Dit is precies de spanning die het Matrix-paper in het negatieve transferresultaat blootlegt: te strikte contracten overblokken, te losse contracten missen stale werk.

Falsificatie van de centrale stelling

Wat zou aantonen dat de centrale stelling, correctheid is geen governance, onjuist is? Dat zou het geval zijn als een correcte maar niet-verifieerbare uitkomst wel volstaat voor verantwoording. Concreet: als een auditor, bij een correcte beschikking zonder provenance, de beslissing als deugdelijk gemotiveerd zou accepteren louter op basis van de juiste uitkomst. Het Matrix-paper toont het tegendeel aan via de gecontroleerde vergelijkingen: alleen het governed pad bewaarde governing evidence, weigerde unsupported closure, en beperkte recovery. De claim is daarmee falsifieerbaar, en houdt momenteel stand. Een tweede falsifier: als een organisatie aantoonbaar een correct AI-besluit op basis van een achterhaald feit kon verdedigen zonder provenance, zou de stelling verzwakken. Dat scenario blijft ongedocumenteerd.

Competing hypotheses: waarom is correctheid niet genoeg?

De titel van het paper is een stelling: "Correct Is Not Governed". Laten we de competing verklaringen afwegen:

• H1 (Institutionele vereiste): In institutionele contexten is een correcte actie onvoldoende omdat die op de verkeerde autoriteit kan steunen, een ongegronde volledigheidsclaim kan bevatten, of door een latere wijziging achterhaald kan zijn. Correctheid is een momentopname; governance is een proces.
• H2 (Technische tekortkoming): Het is technisch eenvoudig om correcte uitkomsten te produceren zonder governability, omdat de huidige AI-systemen geen ingebouwde provenance-laag hebben. De oplossing is een technische laag zoals Matrix.
• H3 (Organisatorische verwaarlozing): Organisaties bouwen AI-workflows zonder governance-eisen omdat ze correctheid als voldoende beschouwen. De fix is procesmatig, niet technisch.
• H4 (Null-hypothese): Voor de meeste praktische toepassingen is correctheid inderdaad voldoende; governance is alleen relevant voor een klein aantal high-stakes institutionele processen.

Falsificatie: H4 zou worden ontkracht als een organisatie met een correct AI-systeem toch governance-falen ervaart (bijv. een onrechtmatige beslissing op basis van een achterhaald feit). Het paper toont dit scenario impliciet aan: werk dat stale wordt door een latere wijziging, is ongeldig geworden zelfs als het oorspronkelijk correct was.

Het paper positioneert zich primair als H1 + H2: institutionele eisen (H1) die een technische laag (H2) vereisen. Dit is de meest overtuigende combinatie, maar het is belangrijk om H4 niet te verwerpen, de relevantie schaalt met de institutionele context.

Counterfactual: zonder provenance-laag

De meest informatieve counterfactual: als een agentic workflow geen provenance-laag heeft, maar wel correcte uitkomsten produceert, zou een auditor dan hetzelfde vertrouwen hebben?

Het antwoord is nee. Beschouw twee scenario's:

• Scenario A (correct + provenance): de workflow produceert een correcte beschikking, en kan aantonen op welk gezag, op basis van welke feiten, en met welke volledigheidsclaim.
• Scenario B (correct, geen provenance): de workflow produceert dezelfde correcte beschikking, maar kan niets aantonen over gezag, feiten of volledigheid.

Onder de Awb (Algemene wet bestuursrecht) artikel 3:2 vereist een besluit een deugdelijke motivering. Een auditor kan scenario A verifiëren; scenario B niet. Zelfs als de uitkomst identiek is, is alleen scenario A verantwoordbaar.

De counterfactual leert: provenance is niet een extra laag bovenop correctheid, het is de voorwaarde waaronder correctheid bestuurlijk relevant wordt. Een correcte maar niet-verifieerbare uitkomst is, in institutionele zin, geen gevestigde uitkomst.

Dit provenance-probleem hangt samen met een breder governance-vraagstuk: de stille wijziging van modellen en de revocatie van frontier-modellen. Provenance lost het artefact-controleprobleem niet op, maar het is de laag die bepaalt of een geautomatiseerd besluit verantwoordbaar is, ongeacht welk artefact het produceerde.

Waarom dit cruciaal is voor Nederlandse overheidsorganisaties

Dit is geen academisch onderscheid. Voor Nederlandse publieke organisaties heeft het directe juridische implicaties:

• Awb artikel 3:2 (zorgvuldigheidsbeginsel): vereist een deugdelijk gemotiveerd besluit. Een AI-besluit zonder inspecteerbare provenance kan niet aantonen dat het zorgvuldig tot stand is gekomen.
• Wet open overheid (Woo): vereist uitleg over overheidsbesluiten. Provenance is de basis voor die uitleg.
• AVG artikel 22: burgers mogen niet worden onderworpen aan puur geautomatiseerde besluiten, tenzij er adequate waarborgen zijn, menselijke tussenkomst, het recht om je standpunt naar voren te brengen, en het recht op uitleg. Provenance is de technische basis voor deze waarborgen.
• BIO2: vereist aantoonbare informatiebeveiliging. Een audit trail is een kernvereiste.
• EU AI Act: high-risk systemen vereisen traceerbaarheid en auditability.

Een AI-systeem dat alleen het juiste antwoord produceert, kan geen van deze waarborgen bieden. Het kan geen uitleg geven over zijn eigen redenering. Het kan niet aantonen welke feiten het gebruikte, of die feiten nog geldig waren op het moment van beslissen.

Praktijkvoorbeeld: UWV en een geautomatiseerde beschikking

Neem een UWV-systeem dat een WW-uitkering berekent via een agentic workflow. De workflow haalt het arbeidsverleden op uit een basisregistratie, combineert dat met beleidsregels, en genereert een conceptbeschikking. Het resultaat is inhoudelijk correct, het bedrag klopt.

Maar een auditor vraagt: is het arbeidsverleden nog geldig op het moment van beslissen? Als de werkgever tussentijds correcties aanlevert, en de workflow gebruikt een verouderde versie van het arbeidsverleden zonder dat dit wordt geregistreerd, is de beschikking gebaseerd op een achterhaald feit. Zonder provenance-laag kan het systeem dit niet aantonen, en kan een betrokkene bezwaar maken met de vraag "op welke gegevens is deze beslissing genomen?" die niet beantwoord kan worden. Dit is de praktische vertaling van het Matrix-probleem naar een Nederlandse bestuursrechtelijke context.

Architectuur-implicaties: provenance als systeemlaag

Het Matrix-paper impliceert dat provenance geen rapportage-functie is die achteraf wordt toegevoegd, maar een systeemlaag die vanaf het begin in de architectuur zit. De architectuur-implicaties:

1. Deterministische causal-state layer: de provenance-laag is deterministisch, hij voert geen AI-redenering uit, maar registreert feitelijk de afhankelijkheden.
2. Selectieve invalidatie: bij wijziging van een bronfeit, worden alleen de afgeleide taken die van dat feit afhangen geïnvalideerd, niet het hele proces.
3. Volledigheidsbewijs: elke stap moet aantonen dat hij compleet is, niet slechts dat hij een uitkomst produceerde.
4. Autoriteitsregistratie: elke actie registreert op welk gezag hij handelde.

Voor een Nederlandse overheidsorganisatie die agentic AI overweegt, betekent dit: provenance moet een ontwerpeis zijn, geen achteraf-feature. De workflow moet vanaf het begin zo worden gebouwd dat elke stap een inspecteerbare registratie produceert.

Wat blijft onzeker?

Het Matrix-paper is methodologisch sterk maar kent belangrijke grenzen:

• Het negatieve transferresultaat: de role-separated transfer challenge faalde. De volledigheidslaag overblokte legitiem werk buiten de auteuringscontext. Dit is een real-world beperking die nog niet is opgelost.
• Geen accuracy-verbetering aangetoond: het paper stelt expliciet dat Matrix geen general accuracy enhancer is. De waarde is institutioneel, niet functioneel.
• Schaalbaarheid: de prestaties van de provenance-laag op zeer grote agentic workloads zijn niet uitgebreid getest.
• Adoptie: of organisaties deze laag daadwerkelijk zullen adopteren, gezien de overhead, is een HYPOTHESIS over de marktontwikkeling.

Een nieuw inzicht dat niet direct in de bron staat

De bron stelt dat correctheid geen governance is, en presenteert Matrix als technische oplossing. Wat niet rechtstreeks in het paper staat, is de volgende derived claim: provenance is geen nieuwe governance-vereiste, maar de technische vertaling van een bestaande Nederlandse bestuursrechtelijke eis. De Awb vereist sinds 1994 dat bestuursorganen hun besluiten deugdelijk motiveren (artikel 3:2). Matrix is, in essentie, het mechanisme waarmee die bestaande juridische eis van toepassing wordt op een nieuwe vorm van geautomatiseerd handelen. Dit is geen verplaatsing van de bron, maar een synthese die de bron met de Nederlandse rechtscontext verbindt.

Beperkingen van deze analyse

Deze analyse kent grenzen die moeten worden benoemd. Het Matrix-paper rapporteert een significant negatief resultaat, de role-separated transfer challenge faalde, omdat de deterministische volledigheidslaag legitiem werk buiten de auteuringscontext overblokte. Dit betekent dat de praktische toepasbaarheid van Matrix in multi-rol-omgevingen nog niet is opgelost, en de adoptie kan hinderen. Ten tweede stelt het paper expliciet dat Matrix geen general accuracy enhancer is; de waarde is institutioneel, niet functioneel. De schaalbaarheid op zeer grote agentic workloads is niet uitgebreid getest. Methodologisch is dit artikel een interpretatie van primaire onderzoeksbevindingen; de juridische vertaling naar de Nederlandse context is mijn eigen analyse (een DERIVED CLAIM), geen conclusie van het paper zelf. De claims over de Awb en de AVG zijn feitelijk juist, maar hun toepassing op Matrix is een interpretatie.

De synthese die de bron niet direct trekt

De originele synthese van dit artikel verbindt het Matrix-paper met de Nederlandse bestuursrechtelijke context: provenance is de technische vertaling van het Awb-zorgvuldigheidsbeginsel naar de agentic AI-realiteit. De Awb eist al sinds 1994 dat bestuursorganen hun besluiten deugdelijk motiveren. Matrix is, in essentie, het mechanisme waarmee die bestaande eis van toepassing wordt op een nieuwe vorm van geautomatiseerd handelen.

Dit is belangrijk omdat het het debat verschuift van "moeten we AI-governance bouwen?" naar "hoe brengen we bestaande bestuursrechtelijke eisen in overeenstemming met agentic AI?" De juridische basis bestaat al; wat ontbreekt is de technische laag die agentic workflows aan die basis laat voldoen.

En er is een tweede synthese: het negatieve transferresultaat toont dat provenance-laag niet zonder kosten is. Dezelfde deterministische laag die institutionele integriteit waarborgt, kan productieve samenwerking hinderen. Dit is de spanning die elke implementatie moet managen: te weinig governance ondergraaft de verantwoording, te veel governance ondergraaft de flexibiliteit. De kunst is het juiste volledigheidscontract per use case te vinden.

De conclusie is helder: een AI-systeem dat het juiste antwoord geeft, is nog geen governable systeem. En voor Nederlandse overheidsorganisaties die geautomatiseerde besluiten nemen, is governability geen luxe maar een wettelijke eis.