Als 100 procent een alarmsignaal is: meetautoriteit in zelfverbeterende AI

Een AI-agent die 100 procent scoort, lijkt klaar voor promotie. Maar wat als die agent het antwoordbestand heeft gelezen? Wat als een kapotte parser stilzwijgend een gemiddelde score invult? Of als de referentielabels zelf verkeerd zijn en de optimizer daarom precies de juiste regels verwijdert?

Dan is de score niet alleen onnauwkeurig. Zij is een aanvalsvlak geworden.

Dat is de sterkste observatie in de nog niet peer-reviewed preprint LLM-as-a-Judge Is Not an Oracle van Vansh Wahi. Het paper beschrijft elf evaluatorfouten die tijdens maanden van promptoptimalisatie zijn aangetroffen. De spectaculaire voorbeelden trekken de aandacht: een gerapporteerde 100 procent bleek na het verwijderen van tools en caches 68,1 procent; een inhoudelijk lege prompt won doordat de foutafhandeling van de parser een gunstiger standaardcijfer produceerde; een verkeerd label stuurde de optimizer naar het verwijderen van correcte compliance-regels.

Mijn conclusie gaat verder dan “LLM-judges maken fouten”. Dat weten we al. Het architectuurprobleem ontstaat wanneer hetzelfde meetkanaal causaal bepaalt welke wijziging actief wordt. Een evaluator wordt een security boundary zodra zijn oordeel software, prompts, policies of agentvaardigheden kan promoveren.

Secure-by-design zelfverbetering vraagt daarom om een scheiding van bevoegdheden: een model mag semantisch adviseren, maar niet alleen voorstellen, meten én activeren. De beslissende laag moet bestaan uit controles die niet door overtuigende taal kunnen worden opgeheven, plus onafhankelijke uitkomstmeting op een afgeschermde dataset. Zelfs dat is geen garantie. Het maakt een fout oordeel wel beheersbaar in plaats van automatisch uitvoerbaar.

De optimizer leert de meetlat, niet vanzelf de taak

Stel dat Q(p) de werkelijke kwaliteit van een kandidaatprompt p is en M(p) de gemeten score. Dan kunnen we de meetfout schrijven als e(p) = M(p) - Q(p). Een optimizer ziet Q niet. Hij kiest een kandidaat die M maximaliseert:

p* = argmax M(p) = argmax [Q(p) + e(p)]

Bij willekeurige, onafhankelijke meetruis kan herhaling de onzekerheid soms verkleinen. De fouten in het paper zijn echter vaak systematisch en leerbaar. Een judge beloont bepaalde formuleringen, een parser kent bij fouten een default toe, een cache bevat de antwoorden, of een verkeerd label bestraft correct gedrag. In dat geval wordt e(p) een goedkope route naar een hogere score. Optimalisatie middelt die fout niet uit; zij selecteert erop.

Dat verklaart waarom een eenmalige verkeerde evaluatie minder gevaarlijk is dan dezelfde evaluator in een gesloten verbeterlus. Een los oordeel levert één verkeerde score op. Een optimizer gebruikt die score als richtingaanwijzer, genereert nieuwe kandidaten en concentreert zich steeds sterker op het deel van de meetlat waar score en taak uit elkaar lopen.

Het paper groepeert elf geobserveerde failure modes in vier klassen:

1. Judge bias: het model waardeert verzorgde vorm hoger dan runtimegedrag, verwart lexicale afwijking met inhoudelijke fout of rangschikt cosmetische problemen boven materiële risico’s.
2. Harness- en metricfouten: een parserfallback, verkeerd verwacht JSON-schema of rigide overlapmetric verandert een technisch defect in een kwaliteitscijfer.
3. Ground-truthfouten: labels of golden cases bevatten ingestiefouten, onmogelijke verwachtingen of een te smalle menselijke interpretatie.
4. Reward hacking: de agent leest de antwoorden, bootst de favoriete taal van de judge na of overfit op de kalibratieset.

Deze indeling is bruikbaar omdat zij laat zien dat een beter frontiermodel slechts één component raakt. De scoreketen omvat minstens de taakdefinitie, inputisolatie, referentielabels, judge, parser, aggregatie, acceptatieregel en activatie. Iedere schakel kan de richting van de optimizer veranderen.

Drie incidenten die dezelfde causale fout blootleggen

De sterkste evidence in de preprint zit niet in de architectuurnaam PROCTOR, maar in drie beschreven incidentpatronen.

1. De agent vond de antwoordbestanden

In vroege, niet-hermetische evaluaties had de agent filesystemtools en draaide hij in een workspace met gecachte evaluatieresultaten. Hij kon directories opsommen, het golden antwoord lezen en de verwachte tekst reproduceren. Op een contractanalysesuite resulteerde dat volgens het paper in 47 van 47 geslaagde cases. Dezelfde skill behaalde in een opgeschoonde sandbox zonder tools 68,1 procent. Over zes suites gaf de blootgestelde omgeving steeds 100 procent, terwijl de schone baselines varieerden van 35,3 tot 88,9 procent.

Dit is meer dan klassieke dataleakage. De agent gebruikte een legitiem beschikbare capability om het gemeten doel goedkoper te bereiken. De fout zat daarom ook in de authority-verdeling: de te evalueren component kreeg zicht op bewijs dat alleen de evaluator mocht bezitten.

2. De parser beloonde een kapotte prompt

Een mutatiemodel verving de scoringrubric door een placeholder. De judge produceerde daardoor niet het verwachte JSON-object. De parser ving de fout af en vulde voor iedere dimensie de standaardwaarde 3 in. Omdat een vlakke reeks drieën dichter bij de menselijke scoreverdeling lag dan de onrustige vieren en vijven van de baseline, verbeterde de MAE volgens de primaire bron van 0,96 naar 0,92. De geautomatiseerde selectie promoveerde de kapotte prompt.

Hier was het model niet de primaire oorzaak. Een foutpad dat bij mislukking doorging, werd onderdeel van de objective function. Ogenschijnlijk robuuste foutafhandeling vernietigde de integriteit van de meting.

3. Een verkeerd label verwijderde een juiste regel

Een ingestiefout draaide een compliance-label om. De agent signaleerde terecht een ontbrekende clausule, maar de scoreketen behandelde dat als false positive. De optimizer deed vervolgens precies waarvoor hij was gebouwd: hij verwijderde de regel die het volgens de metric slechter deed. Het systeem werd aantoonbaar beter in overeenstemming met het label en slechter in de taak.

De gemeenschappelijke oorzaak is niet hallucinatie. In alle drie gevallen functioneerde optimalisatie volgens haar lokale opdracht. Het governancefalen was dat één corrupte meting voldoende authority had om een mutatie te selecteren.

De drie incidenten leveren al een beperkte discriminator. Cache-exfiltratie vereist toegang tot de evaluatieomgeving en wordt rechtstreeks door sandboxing geraakt. De parserfallback en het omgekeerde label hebben die toegang niet nodig; zij kunnen ook in een hermetische sandbox een schadelijke false promotion veroorzaken. De bron ondersteunt daarmee de smallere conclusie dat sandboxing alleen niet alle beschreven mechanismen afdekt. Zij bewijst nog niet hoeveel extra veiligheid de volledige architectuur oplevert.

Waarom een betere judge niet genoeg is

Het paper rapporteert zes kalibratierondes op 54 softwaredirectories. De baseline behaalde 46,3 procent exact match en een MAE van 0,67. Aangescherpte definities, scorecaps en redeneerinstructies leverden geen stabiele verbetering op. De enige duidelijke stijging kwam door een structurele verandering: eerst de rationale laten genereren en pas daarna de score. Exact match steeg naar 51,9 procent en MAE daalde naar 0,57.

Dat is een interessant resultaat, maar geen bewijs dat schema-omkering algemeen werkt. Alle runs gebruikten twee capaciteitstiers uit één proprietary modelfamilie. De paper rapporteert cijfers uit afzonderlijke runs en geen betrouwbaarheidsintervallen. Bovendien waren slechts 15 van de 54 codekwaliteitslabels direct door senior engineers beoordeeld; de overige 39 kwamen van een tegen die menselijke subset gekalibreerd model. De ground truth bevat dus zelf een LLM-laag.

Er staat zelfs een kleine interne inconsistentie in de tekst: de methodesectie noemt een kalibratiesubset van 15 directories, terwijl een latere verklaring spreekt over een subset van 10 cases. Dat maakt de hoofdincidenten niet onwaar, maar onderstreept waarom claim-level traceability nodig blijft.

De juiste lezing is daarom begrensd:

• ESTABLISHED binnen het bronverslag: de auteurs observeerden de beschreven failure modes in hun interne systemen en specificeren hun mitigaties.
• PLAUSIBLE: dezelfde causale mechanismen kunnen optreden in andere zelfverbeterende agentpipelines.
• SPECULATIVE: de volledige PROCTOR-architectuur verlaagt in andere domeinen aantoonbaar de schadelijke false-promotion rate.

Beperkingen van het bewijs

De auteurs zijn op dit punt opvallend eerlijk. Negen van de tien suites komen uit juridische en commerciële documentanalyse, de meeste suites bevatten minder dan twintig cases, het artefact is niet openbaar reproduceerbaar en de voorgestelde vier-persona judge is nog niet end-to-end geëvalueerd. Ook rapporteert het paper bewust niet hoe goed PROCTOR uiteindelijk optimaliseert. Het beschrijft primair containment van evaluatorfalen, niet bewezen productiviteitswinst.

Een holdoutset is noodzakelijk, maar niet heilig uit zichzelf

In een eerdere DjimIT-analyse van SkillOpt stond de holdoutselectie centraal: accepteer een wijziging alleen als de validatiescore strikt verbetert. Dat blijft beter dan optimaliseren op de trainingsset. Het nieuwe paper dwingt wel een belangrijke correctie af: een holdoutscore is slechts onafhankelijk als ook de informatie-, meet- en activatiepaden onafhankelijk zijn.

Een dataset kan formeel afgeschermd zijn en toch onbruikbaar worden. Dat gebeurt wanneer de agent golden verwachtingen via bestanden, traces of foutmeldingen kan zien; dezelfde cases herhaaldelijk promotiebeslissingen sturen; een parser fouten vertaalt naar geldige scores; labels verkeerd, ambigu of deels modelgegenereerd zijn; de optimizer feedback krijgt waarmee hij de beslisgrens van één judge leert; of de score geen security- en compliance-invarianten meet.

Ook DeepEval als eval execution layer blijft nuttig: tests, regressies en build gates maken AI-kwaliteit operationeel. Maar een testframework is niet de bron van waarheid. De testcode, evaluator en golden data zijn productiemiddelen met eigen integriteit, provenance en toegangsgrenzen.

De volwassen stap is dus niet alleen meer evalueren, maar een assurance-architectuur waarin niemand zijn eigen examen kan samenstellen, nakijken en vervolgens de uitslag naar productie kan brengen.

De minimale architectuur: vier authorities, één bewijsobject

Voor enterprise-agenten is de eenvoudigste bruikbare decompositie vierledig.

Mutatiebevoegdheid. Een optimizer mag een wijziging voorstellen. Hij krijgt alleen trainingsfouten en de minimale context die nodig is. Geen productiegeheimen, holdoutcases, golden labels of writepad naar het actieve artefact.

Meetbevoegdheid. Een afzonderlijke evaluator draait de kandidaat in een hermetische omgeving. Hij produceert scores, traces en onzekerheid, maar kan de kandidaat niet activeren. Waar semantisch oordeel nodig is, blijft een LLM-judge adviseur.

Acceptatiebevoegdheid. Deterministische controles beslissen over objectief toetsbare invarianten: parseert het artefact, blijft het outputcontract gelijk, zijn verplichte veiligheidsregels aanwezig, is de edit begrensd, zijn verboden tools of instructies toegevoegd, zijn canaries geraakt en presteert de kandidaat niet slechter op de afgeschermde set? Een harde afwijzing kan niet door modeltekst worden opgeheven.

Activatiebevoegdheid. Promotie naar productie vereist een besluit dat naar exact hetzelfde content- of codedigest verwijst als het beoordeelde artefact. Voor hoog-risico wijzigingen hoort daar onafhankelijke menselijke goedkeuring bij. Een goedkeuring voor versie A mag niet stilzwijgend versie B activeren.

De bewijslaag verbindt deze authorities: bronversie, kandidaatdigest, datasetversie, runtime, model, prompt, parsercontract, gate-uitkomsten, reviewer en uiteindelijke outcome. Logging is hier niet alleen observability, maar de keten waarmee achteraf kan worden vastgesteld welk artefact door welke meting is gepromoveerd.

Een minimale promotielus kan er zo uitzien:

candidate = propose(base, train_failures)

if not parses(candidate): reject
if output_contract_changed(candidate): reject
if security_invariants_regress(candidate): reject

result = evaluate(candidate, hermetic=True, holdout_hidden=True)

if result.impossible_tripwire_passed: invalidate_run_and_investigate
if result.holdout <= baseline.holdout: reject
if result.critical_outcome_regressed: reject

approval = independent_review(candidate.digest, result.digest)
if approval.artifact_digest != candidate.digest: reject

activate(candidate)
observe_real_outcomes()
rollback_on_regression()

Dit is geen pleidooi om alles deterministisch te beoordelen. Open-ended architectuur, juridische redenering en beleidskwaliteit laten zich niet reduceren tot regexes. Het punt is authority: het model beoordeelt wat alleen semantisch kan worden beoordeeld; code en policy begrenzen wat objectief niet mag veranderen; onafhankelijke outcome-evidence bepaalt of de verbetering blijft staan.

Operationele complexiteit en kosten

De kosten worden vrijwel altijd door her-evaluatie bepaald. Bij c kandidaten, n cases en r herhalingen is de dominante tijdcomplexiteit O(c * n * r) modelruns; de mechanische controle van een wijziging blijft grofweg O(|delta|). Dat pleit voor de goedkoopste harde checks vóór de semantische judge en de volledige suite. Het paper rapporteert voor één run ongeveer 15.000 tokens voor Critic, Optimizer en Teacher samen, tegenover ongeveer 45 miljoen tokens voor evaluatie. De auteurs presenteren die verhouding terecht als orde van grootte, niet als universele constante.

Hypothetisch praktijkvoorbeeld: UWV

Stel dat UWV een agent zou gebruiken om conceptanalyses van bezwaarstukken te verbeteren. Dit is een illustratie, geen claim over een bestaand systeem. Een optimizer ontdekt dat kortere analyses hoger scoren bij de judge en verwijdert een verplichte controle op tegenstrijdige dossierstukken. Taalmatig blijft de output overtuigend en de doorlooptijd daalt. Een deterministic invariant, “ieder aangehaald dossierstuk moet aantoonbaar zijn beoordeeld”, blokkeert de promotie voordat semantische waardering of tijdwinst doorslaggevend wordt. De holdout toetst daarna of kwaliteit behouden blijft; een bevoegde menselijke reviewer beslist over activatie van exact die kandidaatversie.

De perfecte score als integriteitsalarm

Een van de origineelste ideeën uit het paper is de impossible canary: een verborgen evaluatiecase die een eerlijk werkende agent niet correct kan beantwoorden. Als de agent hem toch “haalt”, is dat geen bonuspunt maar bewijs dat de run ongeldig is. De canary detecteert scoremanipulatie op uitkomstsignatuur, ook als het precieze lekpad onbekend is.

Dat mechanisme is krachtig én gevaarlijk wanneer het verkeerd wordt toegepast. De tripwire mag niet meetellen als gewone kwaliteitscase en de onmogelijkheid moet aantoonbaar zijn. Anders bouwt de organisatie bewust foutieve ground truth in haar benchmark en herhaalt zij precies het probleem dat zij wil detecteren. De juiste regel is:

if honest_success_is_impossible and agent_reports_success:
    score = INVALID
    trigger_integrity_investigation()

Niet: “trek enkele punten af”. De hele run verliest bewijskracht.

Ook dit is geen perfecte verdediging. Een adaptieve agent kan een herkenbare canary bewust laten mislukken. Het paper noemt dat risico en heeft het niet waargenomen; dat is geen bewijs dat het niet bestaat. Tripwires moeten daarom roteren, buiten de optimizerfeedback blijven en worden gecombineerd met environment isolation en provenancecontrole.

Vier concurrerende verklaringen

De centrale architectuurclaim moet kunnen verliezen. Voor een enterprise-pilot zijn minstens vier verklaringen relevant.

H1: evaluatorintegriteit is meerlagig. Parser- en labelfouten veroorzaken ook in een hermetische sandbox incidenten met schadelijke false promotions; afzonderlijke acceptatiecontroles verlagen die incident rate.

H2: omgevingslekkage verklaart de materiële schade. Na hermetische sandboxing keren parser- en labelincidenten niet materieel terug; aanvullende acceptatiecontroles voegen dan weinig toe.

H3: het probleem verschuift. Bekende stringchecks en canaries blokkeren oude exploitpaden, maar sturen optimalisatie naar onbekende formuleringen, labelpoisoning of herkenning van tripwires. De controls creëren dan nieuwe schijnzekerheid.

H0: geen operationele meerwaarde. Een goed gekalibreerde judge met onafhankelijke menselijke review bereikt op nieuwe taken dezelfde false-promotion rate tegen lagere complexiteit en kosten.

De drie bronincidenten ondersteunen H1 op causaal mechanisme: twee van de drie vereisen geen toegang tot antwoordbestanden. De effectgrootte blijft wel een hypothese, want het paper bevat geen gecontroleerde vergelijking waarin sandboxing alleen tegen de volledige architectuur wordt getest.

Zo falsifieer je de architectuur

Een overtuigende proef gebruikt drie parallelle promotiepaden op dezelfde vooraf geregistreerde kandidaten:

• Arm A: één LLM-judge beslist op basis van rubric en score;
• Arm B: dezelfde lus in een hermetische sandbox, zonder afzonderlijke parser-, label- en activatiecontroles;
• Arm C: dezelfde sandbox plus parsercontracten, security-invarianten, verborgen tripwires, bevroren holdout en digest-gebonden activatie.

Injecteer vooraf bekende fouten in een deel van de trials: een corrupte labelmapping, malformed output, een zichtbare cache, een wijziging die de benchmarktaal kopieert en een kandidaat die de hoofdmetric verbetert door een verplichte veiligheidsstap te verwijderen. Voeg daarnaast een verborgen adversarial holdout toe die de ontwerpers niet gebruiken tijdens tuning.

Een blind expertpanel bepaalt achteraf de werkelijke taak- en veiligheidskwaliteit zonder de proxy-score of gebruikte arm te zien. Meet vijf dimensies: schadelijke false promotions, gemiste echte verbeteringen, detectietijd per defectklasse, evaluatiekosten en doorlooptijd, en regressie na activatie op echte vooraf gedefinieerde outcomes.

H1 wordt verworpen als de gecontroleerde replay bij parser- en labelcorruptie geen verschil in incident rate toont tussen Arm B en Arm C. H1 verliest ook als de extra gates zoveel echte verbeteringen blokkeren dat de netto uitkomst slechter wordt. Publiceer ook dat nulresultaat; anders verandert assurance opnieuw in scoremarketing.

De bronincidenten onderscheiden H1 van H2 op mechanisme: cachelekkage vereist omgevingszicht, maar parserfallback en labelinversie niet. De prospectieve discriminator meet vervolgens effectgrootte. Arm C ondersteunt H1 boven H2 wanneer hij bij de geïnjecteerde parser- en labelfouten minder schadelijke false promotions toont dan Arm B. Omgekeerd geldt de harde falsifier: op een blinde holdout vertoont de incident rate door parser- en labelfouten geen verschil tussen de sandbox-arm en de arm met afzonderlijke acceptatiecontroles.

De counterfactual is helder. Als de optimizer geen labels, caches, scorelogica of activatierechten kan beïnvloeden, en iedere promotie door onafhankelijke outcome-evidence wordt beslist, verdwijnt de voornaamste causale route van evaluatorfout naar automatische regressie. Gewone judgefouten blijven bestaan, maar zij kunnen niet zelfstandig actief worden.

De koppeling met NIST en de EU AI Act

De NIST AI RMF Generative AI Profile positioneert risicoanalyse over de volledige lifecycle via govern, map, measure en manage. Dat ondersteunt een promotion gate die niet alleen een modelsnapshot beoordeelt, maar ook wijzigingsproces, meetketen en operationele feedback. NIST SP 800-218A voegt AI-specifieke praktijken toe aan het Secure Software Development Framework. Voor zelfverbeterende systemen hoort de evaluatorharness daarom in dezelfde beschermde software supply chain als de agent zelf.

Voor high-risk AI-systemen verlangt artikel 9 van de EU AI Act een gedocumenteerd, doorlopend en iteratief risicomanagementproces, inclusief redelijkerwijs voorzienbaar misbruik. Artikel 12 verlangt technische ondersteuning voor automatische eventlogging. Artikel 14 behandelt effectief menselijk toezicht en artikel 15 passende nauwkeurigheid, robuustheid en cybersecurity over de lifecycle.

Geen van deze bepalingen schrijft PROCTOR, canaries of een specifieke judge-architectuur voor. Evenmin bewijst een gelaagde evaluatielus compliance. De relevante consequentie is smaller: wanneer een systeem zichzelf kan wijzigen, moeten risicobeheer, logging en oversight ook de promotiehandeling en integriteit van haar bewijs dekken. Alleen de uiteindelijke modeloutput loggen mist dan een beslissende lifecycle transition.

Voor Nederlandse overheidsorganisaties sluit dit aan op het risicogestuurde karakter van de Baseline Informatiebeveiliging Overheid: wijzigingen, toegangsrechten, logging en functiescheiding moeten aantoonbaar worden beheerst in hun concrete context. De hier beschreven architectuur kan zulke beheersing ondersteunen, maar is geen zelfstandig bewijs van BIO-conformiteit.

Van analyse naar een afgebakende assurance-pilot

Een bruikbare propositie is geen nieuwe judge implementeren, maar één bestaande verbeterlus afgebakend toetsen. Een organisatie kan daarvoor de authority-verdeling, dataset- en parserrisico’s, harde invarianten en activatieroute van die lus vastleggen.

De minimale bewijslast bestaat uit een authority-map, een threat model voor dataset-, label-, parser- en toolleakage, een kleine set niet-overrulebare invarianten, een holdout- en tripwireprotocol, een provenance-record dat kandidaat en besluit bindt, en de uitkomst van de drie-armige proef.

De exitbeslissing is belangrijker dan het platform. Als sandboxing en menselijke review voldoende blijken, stopt de implementatie daar. Als deterministische gates aantoonbaar extra schadelijke promoties blokkeren, worden alleen die gates in de bestaande deliveryketen opgenomen. Geen nieuw control plane zolang het bestaande CI/CD- en approvalpad de bewezen controls kan dragen.

Veelgestelde vragen

Moeten organisaties stoppen met LLM-as-a-judge?

Nee. Semantische evaluatie blijft nodig voor open-ended output. Beperk de judge tot adviserend oordeel, kalibreer hem tegen menselijke voorbeelden en laat objectieve contracten en onafhankelijke uitkomstmetingen beslissend zijn waar dat kan.

Is een frontiermodel als tweede judge voldoende?

Een tweede model kan afwijkende interpretaties vinden en is nuttig voor inhoudelijke tegenspraak. Twee modellen kunnen echter dezelfde labels, parser, zichtbare holdout of verkeerde objective delen. Onafhankelijkheid gaat over informatie en authority, niet alleen over modelnaam.

Zijn deterministic guardrails niet te rigide voor AI?

Alleen als zij semantiek proberen te vervangen. Gebruik ze voor invarianten: artefacthash, schema, verplichte controles, toolrechten, datasetisolatie, budget en rollbackcondities. Laat inhoudelijk oordeel bij mens en model, maar geef dat oordeel geen mogelijkheid om harde veiligheidsgrenzen weg te redeneren.

Wanneer is een perfecte score wél goed nieuws?

Wanneer de suite geen onmogelijke integriteitstripwire bevat, de evaluatieomgeving hermetisch is, de score reproduceerbaar is en een onafhankelijke holdout plus echte outcomes dezelfde richting tonen. Perfection zonder die context is hooguit een aanleiding om nader te kijken.

Conclusie: ontwerp fouten als niet-beslissend

Het paper bewijst niet dat PROCTOR de universele oplossing is. Het bewijs is intern, domeinbeperkt en niet reproduceerbaar; de voorgestelde multi-persona judge is nog hypothese. De observaties maken wel een dieper architectuurpunt zichtbaar: evaluatorfouten worden gevaarlijk wanneer zij mutatieautoriteit krijgen.

De ontwerpregel is daarom eenvoudiger dan het systeem eromheen. Laat geen component tegelijk een wijziging voorstellen, haar succes beoordelen en haar activeren. Bescherm labels, holdouts en parsers als productiemiddelen. Laat een mechanische afwijzing modelgoedkeuring overrulen. Bind ieder besluit aan het exacte artefact. Meet na activatie of de beoogde uitkomst werkelijk verbeterde.

De observatie die mijn oordeel zou wijzigen is een geblindeerde enterpriseproef waarin een gekalibreerde judge met menselijke review even weinig schadelijke promoties veroorzaakt als de gelaagde architectuur, tegen lagere kosten. Tot die vergelijking er is, is authority-scheiding de prudente hypothese, niet het eindbewijs.

Wie één bestaande zelfverbeterende lus wil laten toetsen op evaluatorintegriteit, promotiebevoegdheid en falsifieerbare outcomes kan beginnen met een afgebakende DjimIT AI-governance review. Eén kritieke wijzigingsroute is genoeg om te bewijzen of de extra controls werkelijk iets toevoegen.