Eerst: waar hebben we het eigenlijk over?

Voordat we bij de stappen komen, helpt het te zien wat een soevereine agent werkelijk kan doen, want “AI-agent” betekent heel verschillende dingen afhankelijk van de context.

Voorbeelden uit de private sector: - Een klantenserviceagent voor een telecom- of verzekeringsmaatschappij, verankerd in de eigen contracten, beleidsdocumenten en factureringssystemen van de organisatie — in staat een betwiste rekening op te lossen, een dekkingsclausule uit te leggen of een account bij te werken, terwijl alles wat werkelijk ambigu is wordt geëscaleerd naar een mens. - Een contract- en compliancereviewagent voor een interne juridische afdeling, die inkomende leverancierscontracten controleert op afwijkingen van het eigen playbook, precies zoals behandeld in het eerdere artikel over de institutionele slotgracht. - Een HR-casusafhandelingsagent die routinematige verlof-, salaris- en uitkeringsvragen oplost — een van de hoogst-ROI-startpunten precies omdat het regelintensief, hoog-volume en volledig digitaal is, zoals behandeld in het eerdere governance-artikel. - Een agrarische adviesagent voor een boerencoöperatie, verankerd in historische logboeken, huidige EU-biologische wetgeving en realtime weerdata — het boomgaardvoorbeeld behandeld in een eerder artikel. - Een klinische documentatieassistent voor een ziekenhuis, die de impliciete redenering achter behandelbeslissingen reconstrueert uit IC-notities.

Voorbeelden uit de publieke sector — vaak het meest interessant, en het meest veeleisend: - Een beleidsimplementatieassistent die klantbeheerders helpt een nieuw subsidiestelsel of milieuregulering consistent toe te passen over honderden casussen, waardoor de variatie wordt verminderd die onvermijdelijk ontstaat als tientallen mensen dezelfde regel iets anders interpreteren. - Een burgergerichte navigatieagent die iemand helpt een woningtoelage aan te vragen, een belastingaanslag te begrijpen of te achterhalen welke vergunning ze nodig hebben — ze door het daadwerkelijke bureaucratische proces leidend, de juiste formulieren en deadlines citerend, en duidelijk het punt markerend waarop ze een menselijke klantbeheerder of advocaat nodig hebben. - Een uitkeringsgeschiktheidsagent die eenvoudige, ondubbelzinnige aanvragen vooraf screent (waardoor klantbeheerders vrijkomen voor de werkelijk moeilijke gevallen) en alles wat grensgevallen zijn doorroute naar een mens — nooit zelfstandig een definitieve afwijzing uitgevend. - Een gemeentelijke vergunningsassistent die een kleine ondernemer helpt begrijpen welke milieu-, bestemmingsplan- of veiligheidsregels van toepassing zijn op hun specifieke situatie, voordat ze ooit met een ambtenaar hoeven te spreken.

Wat al deze gevallen gemeen hebben, is dezelfde onderliggende vereiste: ze moeten verankerd zijn in jouw regels, jouw procedures en jouw uitzonderingen — niet in de generieke trainingsdata van een basismodel — en, met name in de publieke-sectorcasussen, moeten ze auditeerbaar, eerlijk en duidelijk begrensd zijn in wat ze mogen beslissen versus louter suggereren.

Stap 1: Bouw (of huur) een soeverein hardwareplatform

Voordat het interessante werk begint, heb je ergens nodig om het te draaien dat je werkelijk beheert. Zoals behandeld in het eerdere artikel over AI-soevereiniteit, betekent dit niet dat je Google moet overtreffen — het betekent bewust zijn over waar inferentie daadwerkelijk plaatsvindt, niet alleen waar training plaatsvindt.

Realistische opties, ruwweg in volgorde van hoeveel controle ze geven:

• Volledig on-premise, op hardware die je eigen IT-afdeling beheert — de meeste controle, de meeste initiële investering, en de juiste keuze wanneer gegevensgevoeligheid (medische, opsporings- of geclassificeerde data) al het andere een non-starter maakt.
• Een vertrouwde lokale of nationale cloud — een door de overheid gerunde community cloud (steeds gebruikelijker in de hele EU, precies het soort infrastructuursoevereiniteits-investering behandeld in het eerdere soevereiniteitsartikel), of een regionale/EU-gebaseerde soevereine cloudaanbieder die gebonden is aan binnenlandse gegevensbeschermingswetgeving in plaats van buitenlandse jurisdictie.
• De private cloud van je eigen IT-afdeling, als je organisatie er al een beheert — vaak de pragmatische middenweg voor bedrijven die geen fysieke hardware willen beheren maar wel contractuele en jurisdictionele controle nodig hebben over waar data woont en wie er toegang toe heeft.

De capaciteitsvraag doet er ook toe: een fine-tuning-werklast heeft aanzienlijk meer rekenkracht nodig dan een puur inferentie-implementatie. Als je het compressiepad volgt dat in een latere stap wordt beschreven, kan een gespecialiseerd, gedistilleerd, gekwantiseerd model vaak comfortabel draaien op een enkele consument- of mid-range enterprise GPU voor inferentie — wat precies on-premise of kleinschalige soevereine cloud-implementatie realistisch maakt in plaats van aspirationeel.

Stap 2: Verzamel en structureer de eigen data van jouw organisatie

Dit is de stap waarvoor elke organisatie al het ruwe materiaal heeft, meestal zonder het te beseffen. Zoals behandeld in de eerdere artikelen over agrarische logboeken en tekst naar actie, is het kernidee dat documentatie geschreven voor de volgende mens op het werk — procedures, casusbestanden, beleidshandboeken, historische beslissingen, uitzonderingslogboeken — precies het ruwe materiaal is dat nodig is om de volgende agent op het werk te trainen.

Concreet betekent dit voor de bovenstaande voorbeelden het verzamelen van: - Procedures en protocollen: procedures, beleidshandboeken, casusafhandelingsrichtlijnen — het equivalent van de teelthandleidingen van de boomgaard of de interne procedurehandleiding van een klantbeheerder. - Uitzonderingen en randgevallen: de rommelige, echte afwijkingen van de schone procedure — de situatie van een burger die niet past in de standaard geschiktheidscategorie, een klantklacht die niet overeenkomt met een FAQ-antwoord. - Regulatoire en juridische teksten: de daadwerkelijke wetgeving, regulering of nalevingskader waar het advies van de agent nooit mee in tegenspraak mag zijn — voor een publieke-sector-agent is dit niet-onderhandelbare grondwaarheid, geen optionele context. - Historische casusuitkomsten: eerdere beslissingen en hun rechtvaardigingen, idealiter vastgelegd als observatie-actie-resultaat-drieluiken — een situatie van een burger waargenomen, een beslissing genomen, een uitkomst geregistreerd — hetzelfde structurele patroon behandeld in zowel het agrarische als het tekst-naar-actie-artikel.

Eenmaal verzameld, moet deze tekst worden omgezet van voor menselijk lezen gebouwde documenten naar een gestructureerd, machine-bruikbaar formaat — doorgaans JSON, procedures in workflow-graphs omzettend met expliciete stappen, voorwaarden en vertakkingen, precies zoals beschreven in het eerdere artikel over het omzetten van tekst in agentische trainingsdata.

Stap 3: Extraheer de agentische trainingsdata

Met gestructureerde data in handen is de volgende stap het extraheren van de specifieke trainingsartefacten die elk component van de architectuur nodig heeft:

• RAG-chunks en reranker-paren: semantisch samenhangende secties van wetgeving, beleid of procedure, ingebed voor retrieval, gekoppeld aan echte query-voorbeelden zodat een neurale reranker leert de correcte clausule te vinden, niet alleen een vergelijkbaar klinkende.
• Supervised fine-tuning (SFT)-paren: instructie-respons-voorbeelden die het model de specifieke terminologie, toon en redeneerstijl van jouw organisatie leren — een vraag van een burger gecombineerd met het antwoord dat een goed getrainde klantbeheerder werkelijk zou geven.
• Preference data (DPO): gecombineerde voorbeelden waarbij één respons correct maar niet geprefereerd is — bijvoorbeeld een technisch accuraat antwoord dat nalaat de beroepsrecht van een burger te vermelden, versus één dat dat wel doet — waarmee de agent leert de voorkeur te geven aan de respons die voldoet aan de normen van jouw organisatie, niet alleen aan feitelijk correcte.
• Planning- en taakdecompositiedata: meerstapsprocessen (hoe een uitkeringsaanvraag werkelijk van intake naar beslissing beweegt) gecodeerd zodat de agent een breed doel kan opsplitsen in een geordende reeks subtaken met echte afhankelijkheden.
• Multi-hop-redeneerketens: het “waarom” achter een beslissing — een geschiktheidsconclusie teruggekoppeld via de specifieke regulering, de specifieke feiten van de casus en het specifieke eerdere precedent dat het rechtvaardigde.
• Guardrail- en critic-trainingsdata: contrastieve paren van afgewezen en gecorrigeerde uitvoer, elk met een expliciete redenering (“afgewezen: schendt artikel 9 van Regulering X”), wat precies is wat een critic-agent traint om schendingen op te vangen in plaats van alleen spelling te controleren.

Stap 4: Fine-tune de componenten — niet één groot model

De architectuur die uit deze data voortkomt is niet één enkel fine-tuned model — het zijn meerdere gespecialiseerde componenten die samenwerken, elk getraind op de hierboven geëxtraheerde data: een geheugenlaag (RAG plus reranker), een redeneer-/planningslaag, een fine-tuned critic die jouw specifieke normen handhaaft, en een set guardrails. Zoals aangetoond in het eerdere artikel over een klein gespecialiseerd model versus een frontier-basismodel, kan deze aanpak opmerkelijk dicht bij frontier-niveau prestaties komen voor jouw specifieke taak, precies omdat het kleine model niet wordt gevraagd goed te zijn in alles — alleen in het ene ding dat jouw organisatie daadwerkelijk nodig heeft.

Stap 5: Implementeer op jouw soevereine infrastructuur

Met de componenten getraind, betekent implementatie ze samenverbinden — doorgaans met behulp van een orkestratieraamwerk gebouwd voor cyclisch, meerstaps agentgedrag (LangGraph en CrewAI zijn gangbare keuzes) — en het hele systeem draaien op de in stap één gekozen infrastructuur. Het onderliggende basismodel (of het nu een groot commercieel model is dat alleen voor de zwaarste redeneerstappen wordt gebruikt, of een volledig lokaal open-gewicht model) wordt een vervangbaar, gestandaardiseerd component, precies zoals betoogd in het eerdere artikel over de institutionele slotgracht — de werkelijke waarde, en de werkelijke soevereiniteit, zit in de architectuur en data eromheen, niet in welk basismodel toevallig in het middelpunt staat.

Stap 6 (optioneel maar aanbevolen): Distilleer, prune en kwantiseer

Als energie-efficiëntie, op batterij draaiende implementatie of draaien op werkelijk bescheiden hardware belangrijk is, worden de compressietechnieken behandeld in een eerder artikel hier direct relevant: de fine-tuned componenten destilleren naar kleinere studentmodellen, gewichten kwantiseren naar 8-bit of zelfs agressievere precisie (BitNet-stijl kwantisering aan het extreme einde), en onnodige verbindingen prunen. Naast de voor de hand liggende kosten- en energiebesparingen heeft deze stap een echte beveiligingsbijwerking, ook behandeld in dat artikel: een gecomprimeerd model heeft de neiging een vloeiendere, minder exploiteerbare beslissingsgrens te hebben, waardoor bepaalde klassen van adversariale manipulatie aantoonbaar moeilijker worden.

Stap 7: Valideer op vooringenomenheid en andere faalwijzen

Deze stap is niet optioneel, en verdient even serieus te worden behandeld als de modelarchitectuur zelf — met name voor alles wat burgergericht of beslissingsaangrenzend is. Concreet betekent dit:

• Eerlijkheids- en vooringenomenheidstests over demografische groepen. Voor een uitkeringsgeschiktheid- of beleidsimplementatieagent is dit een wettelijke vereiste in de meeste jurisdicties, niet alleen goede praktijk.
• Feitelijkheids- en hallucinatiecontroles, waarbij elke gegenereerde bewering wordt vergeleken met de opgehaalde waarheidsbron en alles wat niet ondersteund wordt gemarkeerd.
• Adversariale robuustheidstests, de aanvalspatronen volgend behandeld in een eerder artikel — het systeem bewust testen met randgevallen, ambigue formuleringen en adversariaal samengestelde invoer.
• Menselijke audit-steekproeven. Geen validatiesuite vangt alles op; voortdurende, gerandomiseerde menselijke beoordeling van een percentage van de daadwerkelijke beslissingen van de agent blijft noodzakelijk, precies om het “het model had 49 keer gelijk, controleert iemand nog de 50ste” gemakzuchtrisico op te vangen dat behandeld is in het eerdere artikel over governance.

Stap 8: Test op ethische en morele vereisten

De laatste stap, en degene die publieke-sectorimplementaties zich het minst kunnen veroorloven over te slaan, is het systeem houden aan een expliciete ethische en juridische standaard in plaats van een impliciete:

• Schrijf een expliciete grondwet. Zoals behandeld in het eerdere artikel over de institutionele slotgracht, betekent dit een gedocumenteerde set onveranderlijke principes — “weiger nooit een uitkering zonder de specifieke regulering te citeren en een beroepspad aan te bieden,” “neem nooit een definitieve beslissing over X zonder menselijke goedkeuring.”
• Bouw het vierfasen-governance-raamwerk in behandeld in het eerdere governance-artikel: gevalideerde training, getoetste robuustheid, een reflectiemechanisme dat de eigen fouten van het systeem opvangt, en echte uitlegbaarheid.
• Garandeer een menselijk beroepspad. Voor elk publiek-sector- of juridisch consequent gebruik moet de agent de menselijke beslismaker van record ondersteunen, nooit vervangen.
• Wees transparant met de eindgebruiker. Een burger of klant die met het systeem interageert, moet weten dat ze met een AI-agent praten, begrijpen wat die wel en niet kan beslissen, en precies weten hoe ze een mens kunnen bereiken wanneer ze die nodig hebben.

De conclusie

Geen van deze acht stappen is optioneel als het doel werkelijke soevereiniteit is in plaats van een dunne wrapper rondom iemand anders’ model. Maar geen ervan vereist ook het budget van een nationale overheid — dezelfde technieken behandeld in de eerdere artikelen van deze site over landbouw, institutionele strategie, soevereiniteit en modelcompressie zijn direct toepasbaar, of de organisatie die de agent bouwt nu een kersenoogstcoöperatie is, een ziekenhuis, een bedrijfsjuridische afdeling of een gemeentelijk uitkeringskantoor. De rode draad in elke werkelijk soevereine implementatie is dezelfde: jouw eigen data, jouw eigen infrastructuur, jouw eigen expliciete normen voor wat het systeem wel en niet mag beslissen — met het basismodel teruggebracht tot precies wat het zou moeten zijn: een vervangbaar component in het midden van een architectuur die jouw organisatie werkelijk bezit.

Kernpublicaties

• Wang et al. (2023), A Survey on Large Language Model Based Autonomous Agents — arXiv:2308.11432
• Lewis et al. (2020), Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks — arXiv:2005.11401
• European Commission (2024), EU Artificial Intelligence Act — eur-lex.europa.eu

Verder lezen op deze site

• Wat is een AI-agent? — de zeven componenten die deze achtstapdsgids assembleert
• Van tekst naar actie — de diepgaande behandeling van stappen 2 en 3
• De institutionele slotgracht — waarom de architectuur er meer toe doet dan het model
• Waarom Europa eigen AI-modellen nodig heeft — de geopolitieke case voor stap 1
• Het autonome bedrijf besturen — het governance-raamwerk achter stappen 7 en 8
• Bias-analyse in de praktijk — de stapsgewijze technische gids voor de bias-analyse vereist in stap 7
• David tegen Goliath: klein model versus frontier — het bewijs achter stap 4

Waarom dit verder gaat dan kosten

Drie afzonderlijke motivaties convergeren op dezelfde set technieken:

1. Energie en batterijduur. On-device en edge-implementatie — geïmplanteerde medische apparaten, mobiele telefoons, militaire hardware — kan simpelweg geen full-size frontiermodel draaien. Elke watt telt.
2. Lokale, soevereine implementatie. Zoals eerder op deze site behandeld, kan een gespecialiseerd model fine-tuned op jouw eigen data en draaiend op jouw eigen hardware opmerkelijk dicht bij frontier-modelprestaties komen voor een specifieke taak — maar alleen als dat gespecialiseerde model daadwerkelijk klein genoeg is om lokaal te draaien tegen redelijke kosten. Compressie is wat dat “David versus Goliath”-verhaal fysiek mogelijk maakt.
3. Beveiliging. Enigszins contra-intuïtief kan een kleiner, gedistilleerd of gepruned model robuuster zijn voor bepaalde aanvallen, omdat compressie precies het soort redundante, ongebruikte verbindingen verwijdert die adversarial attacks de neiging hebben te benutten.

Laten we de drie hoofdtechnieken één voor één doorlopen.

1. Knowledge distillation: een klein model leren een groot te imiteren

Knowledge distillation comprimeert en draagt wat een groot, duur “teacher”-model heeft geleerd over naar een kleiner “student”-model, terwijl het probeert zoveel mogelijk van de competentie van de teacher te bewaren. Het canonieke voorbeeld is DistilBERT (Sanh, Debut, Chaumond & Wolf, 2019): door BERT-base te destilleren tijdens pre-training reduceerden de auteurs de modelomvang met 40%, lieten het 60% sneller draaien, terwijl ze 97% van BERT’s taalbegripprestaties op de GLUE-benchmark behielden.

De trainingsmechanica is het begrijpen waard, omdat die verklaart waarom dit zo goed werkt. In plaats van de student puur te trainen om het correcte label te voorspellen, traint distillation het op een gecombineerd verlies:

total loss = (alpha * student loss) + ((1 - alpha) * distillation loss)

Het distillation loss wordt berekend met KL-divergentie tussen de softmax-uitvoer van de teacher en de student — maar cruciaal, met een verzachte temperatuur (t > 1) zodat de uitvoer niet alleen harde 0/1-labels zijn maar “zachte labels” die het relatieve vertrouwen van de teacher over alle klassen dragen, niet alleen de winnende. Dat zachte signaal is waar de meeste nuttige informatie daadwerkelijk in zit: het vertelt de student niet alleen wat het juiste antwoord is, maar hoe de teacher de alternatieven weegt — een impliciet signaal dat een hard label alleen nooit kan dragen. DistilBERT combineert dit distillation loss specifiek met een masked-language-modeling loss en een cosinus-embedding loss (om de richting van de verborgen vectoren van teacher en student te aligneren), en initialiseert de student door elke andere laag direct van de teacher te nemen in plaats van helemaal opnieuw te beginnen.

Andere bekende voorbeelden in dezelfde familie zijn TinyBERT, dat distillation verder doorvoert voor nog kleinere footprints. Dit is een bijzonder actief onderzoeksgebied — zie de Nature-berichtgeving over lopend modelcompressiewerk voor een idee van hoe snel het veld zich nog steeds beweegt.

2. Quantization: minder bits, bijna hetzelfde antwoord

Een standaard neuraal netwerk slaat zijn gewichten op als 32-bit floating point-getallen. Quantization stelt een eenvoudige vraag: heb je werkelijk alle 32 bits nodig? Vaak niet. Gewichten weergeven met 8-bit integers in plaats van 32-bit floats geeft je een model met een kwart van de geheugenvoetafdruk, met vier keer snellere gegevensoverdracht, en berekeningen die ook dramatisch sneller zijn, met name voor integer-rekenkunde. Afhankelijk van de hardware kan dit alleen al snelheidswinsten opleveren in het bereik van 25% tot 250%.

Er zijn twee hoofdvarianten:

• Post-Training Quantization (PTQ) — neem een al getraind model en kwantiseer daarna de gewichten.
• Quantization-Aware Training (QAT) — train het model terwijl de effecten van quantization worden gesimuleerd, zodat het leert robuust te zijn voor de verminderde precisie vanaf het begin.

Het meest opvallende recente voorbeeld van QAT tot zijn logische uiterste doorgevoerd is BitNet b1.58 (een paper uit 2024), dat elk gewicht beperkt tot slechts drie mogelijke waarden: {-1, 0, 1} — technisch 1,58 bits per gewicht (omdat log₂(3) ≈ 1,585). Opmerkelijk genoeg behaalt dit vergelijkbare prestaties als een standaard LLaMA-model van equivalente omvang, terwijl het dramatisch minder energie verbruikt — het paper rapporteert ruwweg 1/71,4 van het energieverbruik van het equivalente full-precision model, en het is efficiënt genoeg om op gewone CPU’s te draaien in plaats van gespecialiseerde accelerator-hardware te vereisen.

De voor de hand liggende uitdagingen zijn quantization error en numerieke overflow/underflow, wat precies de reden is waarom QAT bestaat — het model trainen om van het begin af aan goed te gedragen onder lage precisie, in plaats van te hopen dat een achteraf afrondingsstap niets belangrijks breekt.

3. Pruning: verwijderen wat het model niet nodig heeft

Waar quantization elk getal kleiner maakt, verwijdert pruning getallen volledig — nul-waarden (sparsity) introduceren in gewichtsmatrices zodat hele verbindingen, of in sommige gevallen hele neuronen, simpelweg ophouden te bestaan. Sparse matrices zijn goedkoper op te slaan en, op de juiste hardware, goedkoper mee te rekenen, omdat bewerkingen op nul-waardige gewichten vaak volledig kunnen worden overgeslagen.

Pruning en quantization sluiten elkaar niet uit — een echte implementatie-pipeline combineert doorgaans meerdere van deze technieken tegelijk: destilleer een kleiner studentmodel, kwantiseer zijn gewichten, en prune onnodige verbindingen, vaak naast Low-Rank Adaptation (LoRA) voor efficiënte fine-tuning (en zijn gekwantiseerde neef, QLoRA), zodat het aanpassen van het gecomprimeerde model aan een specifiek domein ook goedkoop blijft.

Waarom kleinere modellen meer beveiligd kunnen zijn, niet minder

Hier is de verbinding die te zelden wordt gemaakt: compressie is niet alleen een kosten-en-energie-verhaal — het is ook een beveiligingsverhaal. Adversarial attacks op neurale netwerken benutten regelmatig ongebruikte of redundante capaciteit: verbindingen en parameters die niet zinvol bijdragen aan de werkelijke taak van het model, maar die een aanvaller kan manipuleren om een gerichte misclassificatie of ongewenste uitvoer te produceren terwijl de invoer normaal lijkt voor een mens.

Pruning verwijdert precies dit soort speling. Als een verbinding is geëlimineerd omdat die niet bijdroeg aan echte taakprestaties, is die ook niet meer beschikbaar als aanvalsoppervlak — de beslissingsgrens van het model wordt gedwongen uitsluitend afhankelijk te zijn van de kenmerken die er werkelijk toe doen, in plaats van van incidentele correlaties die een aanvaller kan aanpassen. Knowledge distillation doet iets verwants: omdat het studentmodel is getraind om de softened, gegeneraliseerde beslissingsgrens van de teacher te reproduceren in plaats van de trainingsdata direct te memoriseren, heeft het de neiging een vloeier, minder exploiteerbaar responsoppervlak te erven. Dit specifieke idee heeft zijn eigen naam in de adversarial robustness-literatuur — defensive distillation, en een nauw verwante familie van technieken genaamd feature squeezing, die de vrijheidsgraden van de invoer reduceert op een manier die precies weerspiegelt wat pruning doet met de interne vrijheidsgraden van een model.

Dit betekent niet dat een gecomprimeerd model immuun is voor adversarial attacks — dat is het niet, en dedicated adversarial training blijft noodzakelijk bovenop compressie, niet in plaats daarvan. Maar het betekent wel dat het inkrimpen van een model om kosten- en energieredenen geen beveiligingsafruil is die je gedwongen bent te accepteren. Goed gedaan, kan het de andere kant op bewegen.

Voor een volledige behandeling van hoe adversarial attacks op afbeeldingen en tekst er daadwerkelijk uitzien — en de concrete verdedigingen, buiten compressie, die elk type adresseren — zie het eerder gepubliceerde artikel in deze reeks: Adversariale aanvallen: hoe een paar onzichtbare pixels of één omgewisseld woord een AI kan misleiden.

Alles samen

Distillation, quantization en pruning worden gewoonlijk gepresenteerd als afzonderlijke kostenoptimalisatietrucs, maar ze delen een rode draad: elk vraagt het model meer te doen met minder — minder parameters, minder bits, minder verbindingen — terwijl het gedrag dat er werkelijk toe doet behouden blijft. Dat is precies het mechanisme achter het “klein gespecialiseerd model dat bijna een frontiermodel evenaart”-resultaat dat eerder op deze site werd behandeld: een model heeft niet de volledige capaciteit van een generalist nodig als het alleen maar één ding goed hoeft te doen, en compressie is het concrete engineeringpad dat “heeft de capaciteit niet nodig” omzet in “heeft de capaciteit niet, en draait op een laptop in plaats van een datacenter.” Lagere trainings- en inferentiekosten, echte on-device en edge-implementatie, en — als welkom neveneffect — een kleiner, moeilijker-te-benutten aanvalsoppervlak. Die combinatie is waarom dit een van de meest actieve onderzoeksgebieden in het vakgebied blijft.

Kernpublicaties

• Hinton et al. (2015), Distilling the Knowledge in a Neural Network — arXiv:1503.02531
• Sanh et al. (2019), DistilBERT, a Distilled Version of BERT — arXiv:1910.01108
• Ma et al. (2024), The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits (BitNet b1.58) — arXiv:2402.17764
• Hu et al. (2022), LoRA: Low-Rank Adaptation of Large Language Models — arXiv:2106.09685

Verder lezen op deze site

• Adversariale aanvallen: onzichtbare pixels en omgewisselde woorden — de volledige behandeling van aanvalstypen en verdedigingen die compressie gedeeltelijk aanpakt
• Waarom je een model niet kunt fine-tunen of destilleren zonder XAI — waarom distillation specifiek uitlegbaarheid een vereiste maakt, niet een nice-to-have
• David tegen Goliath: klein model versus frontier — compressie en specialisatie samen: wat een klein, taakgericht model daadwerkelijk kan doen
• Waarom Europa eigen AI-modellen nodig heeft — waarom edge- en on-device-implementatie er geopolitiek toe doet, niet alleen voor kosten
• Waarom NLP eindelijk werkt — de transformer-architectuur waarvan de gewichten hier worden gecomprimeerd

De kennis was altijd bedoeld om doorgegeven te worden

De moderne landbouw — fruitteelt in het bijzonder — verliest iets wat niet gemakkelijk teruggewonnen kan worden: een verouderd personeelsbestand gaat met pensioen, en daarmee gaat tientallen jaren empirische kennis over microklimaten, plaagdruk en gewascycli verloren die nooit ergens anders was geformaliseerd dan in handgeschreven logboeken en mondelinge traditie. Die kennis was altijd bedoeld om over te dragen aan een opvolger. Het logboek was het overdrachtsm echanisme.

Tegelijkertijd staan boeren nu voor een genuanceerde afweging: toenemende druk richting biologische methoden en minder gebruik van chemicaliën, afgezet tegen de economische realiteit van het moeten beschermen van opbrengst en kwaliteit. Een general-purpose chatbot kan hier niet verantwoord helpen — een fout bestrijdingsmiddelenadvies kan gewasuitval, milieuschade of het verlies van biologische certificering betekenen, en generieke modellen getraind op het open internet hebben geen toegang tot wat er werkelijk gebeurde, en werkte, in deze boomgaard, onder deze omstandigheden.

De kennis die daadwerkelijk zou helpen bestaat al. Ze zit alleen in een vorm die gebouwd is voor een menselijke lezer, niet voor een machine.

Dezelfde data, anders gelezen

Hier is de herformulering die dit mogelijk maakt: elke invoer in een landbouwlogboek is al, structureel, een observatie → actie → gevolg-record. Bewolkt, geen wind, na de bloei (observatie) → ureum, borium, zink toegepast (actie) → maximale bladopname zonder verdamping (beoogd gevolg). Dat is geen toeval — het is hoe iemand een beslissing documenteert die hij wil dat een opvolger kan vertrouwen en herhalen. En een observatie-actie-gevolg-drieluik is, niet toevallig, precies de datastructuur waarop reinforcement learning is gebouwd: toestand, actie, beloning, volgende toestand. Het formaat dat een boer gebruikte om een menselijke leerling te onderwijzen, blijkt het formaat te zijn dat nodig is om een AI-agent te onderwijzen.

De praktische pipeline ziet er zo uit:

1. Digitaliseren. OCR en multimodale modellen zetten handgeschreven pagina’s — datums, doseringen, weer, uitkomsten, allemaal in de eigen steno van een boer — om in machine-leesbare tekst.
2. Structureren in JSON. Vrije-vorm, tabelmatige handschriften worden geserialiseerd in een consistent schema: datum, weersomstandigheden, toegepaste stof, hoeveelheid, timing en (waar geregistreerd) de uitkomst. Deze gestructureerde laag is waar elke downstream training pipeline op voortbouwt.
3. Component-specifieke trainingsdata extraheren. Dit is het deel dat de moeite waard is om in detail door te lopen, omdat één logboekvermelding kan worden omgezet in verschillende soorten training signal, elk voedend aan een ander deel van een agentische architectuur:

Één logboekinvoer, vijf verschillende soorten trainingsdata

Neem diezelfde aprilinvoer en zie wat het wordt voor elk component van een agent:

Voor retrieval (RAG): de invoer wordt een semantisch gechunked feit dat de agent later kan opzoeken — “op deze boomgaard werd koperooxychloride op deze dosis toegepast onder deze specifieke weersomstandigheden” — embedded en opgeslagen zodat een toekomstige query het direct kan ophalen, met bronvermelding.

Voor reranking: gecombineerd met de vraag die een boer in werkelijkheid zou stellen (“hoe behandel ik het risico op vruchtrot tijdens een natte koude lente”), wordt dezelfde invoer een query-antwoord-paar dat wordt gebruikt om een reranker te trainen om deze historische interventie te herkennen als de relevante, in plaats van een generiek vergelijkbaar maar fout resultaat — precies het “lost in the middle”-probleem oplossend waarbij een agent verdrinkt in twintig breed vergelijkbare opgehaalde passages en de ene mist die er werkelijk toe doet.

Voor instruction-following (SFT): de ruwe invoer wordt herschreven als een gestructureerd instructie-respons-paar — “Het is eind mei, lichte regen en de boomgaard loopt risico op vruchtrot. Wat is de historische interventie?” → “Historisch werd Signum (0,25 kg) gecombineerd met een bladmix toegepast om vruchtrot bij lichte regen te voorkomen.” Dit is wat een model leert de terminologie, toon en redeneerst ijl van een echte agronoom aan te nemen in plaats van een generieke assistent.

Voor preference learning (DPO): hetzelfde scenario, gecombineerd met een afgewezen alternatief — een zware chemische bespuiting die technisch zou werken maar de huidige biologische certificering schendt — leert het model dat niet elk feitelijk correct antwoord het geprefereerde is. Dit is waar een agent leert standaard naar de duurzame, conforme optie te gaan in plaats van naar wat het meest direct effectief lijkt.

Voor planning en multi-hop-redenering: een meerweekse reeks uit het logboek — bloemrijpheid beoordelen, bijen bestellen, kasten op een specifieke datum plaatsen, kasten verwijderen voor het spuiten drie weken later — wordt een taakdecompositie-voorbeeld: hoe een enkel seizoensdoel (“bestuiving beheren”) uiteenvalt in een geordende reeks afhankelijke subtaken, elk met zijn eigen tijdsbeperking.

Één pagina handschrift, vijf verschillende downstream-capaciteiten — en niets ervan vereiste dat de oorspronkelijke boer ook maar aan AI dacht. Ze deden gewoon wat boeren altijd hebben gedaan: opschrijven wat er was gebeurd zodat iemand anders ervan kon leren.

Waarom de oudste tekst misschien de meest waardevolle is

Hier is een genuanceerd contra-intuïtief punt verborgen in deze aanpak: de meest nuttige historische documenten voor het bouwen van een moderne, biologisch-gerichte landbouwagent zijn misschien landbouwteksten uit 1850 tot 1930 — voordat synthetische pesticiden überhaupt bestonden. Deze archieven, gedigitaliseerd in collecties zoals Cornell’s Core Historical Literature of Agriculture en de National Agricultural Library van de USDA, beschrijven ecologisch plaagbeheer en bodembewerkingstechnieken die simpelweg vergeten werden nadat goedkope synthetische chemicaliën het grootste deel van de 20e eeuw overnamen. Nu de landbouw teruggaat naar biologische methoden, is die “verouderde” pre-chemische kennis plotseling weer direct relevant — en ze bestaat in precies dezelfde vorm als het persoonlijke logboek: tekst geschreven door één generatie beoefenaars voor het voordeel van de volgende, die toevallig een generatie of twee oversloeg voordat ze haar beoogde lezer vond.

De guardrails moeten van dezelfde plek komen

Niets hiervan werkt veilig zonder een even serieuze investering in wat niet te doen, en — passend — die data komt van dezelfde soort bron. Een “critic agent” die een conceptaanbeveling controleert, heeft concrete negatieve voorbeelden nodig: een logboekinvoer uit 2020 die een chemicalie noemt (zeg, Calypso) die toen legaal was maar nu beperkt is, gecombineerd met het gecorrigeerde, momenteel conforme alternatief, en — cruciaal — een vermelde redenering (“afgewezen: schendt EU Biologische Verordening 2018/848, artikel 9”). Die redenering is wat een critic-model leert niet alleen dat iets fout is, maar waarom, in een vorm waaruit het kan generaliseren. Historische logboeken en huidige wetgeving, kruiselings gerefereerd aan elkaar, worden het ruwe materiaal voor de veiligheidslaag net zo goed als voor de advieslaag.

Het grotere patroon

Stap terug van de boomgaard specifiek en het patroon generaliseert schoon, en het verbindt direct met iets wat eerder op deze site aan bod is gekomen: de interne handleidingen, standaard operationele procedures, incidentlogboeken en overdrachtsnota’s van elke organisatie werden altijd geschreven met een impliciete lezer in gedachten — de volgende persoon die het werk doet. Dat kader is stilletjes het hele punt geweest van werkplekdocumentatie zolang werkplekken bestaan. Wat er veranderd is, is wie die “volgende persoon” nu kan zijn. Dezelfde discipline die een goede logboekinvoer nuttig maakte voor een menselijke opvolger — concreet zijn over omstandigheden, acties en uitkomsten, in plaats van vaag — is precies wat het bruikbaar maakt als trainingsdata voor een agent. Goede documentatie ging nooit echt over naleving of registratie omwille van zichzelf. Het ging over het overdraagbaar maken van impliciete expertise. Het blijkt alleen dat de ontvanger niet langer menselijk hoeft te zijn.

De conclusie

Een logboekinvoer uit 2013, of een landbouwhandleiding uit 1890, werd nooit geschreven met een taalmodel in gedachten — en dat is precies waarom het zo goed werkt als trainingsdata. Het is eerlijk, concreet en verankerd in wat er werkelijk gebeurde, omdat het werd geschreven voor iemand die het zou moeten vertrouwen en herhalen. Die tekst omzetten in gestructureerde retrieval-data, reranker-paren, instructievoorbeelden, preference pairs en planningssjablonen is geen herinterpretatie van waar de kennis voor was — het is dezelfde overdracht van expertise van de ene beoefenaar naar de volgende, alleen met een nieuw soort opvolger aan het ontvangende einde.

Kernpublicaties

• Lewis et al. (2020), Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks — arXiv:2005.11401
• Rafailov et al. (2023), Direct Preference Optimization — arXiv:2305.18290
• Yao et al. (2022), ReAct: Synergizing Reasoning and Acting in Language Models — arXiv:2210.03629

Verder lezen op deze site

• Van tekst naar actie — de algemene pipeline waarvan dit agrarische voorbeeld een instantie is
• Wat is een AI-agent? — wat de getrainde agent waarvoor deze data bedoeld is eigenlijk is
• David tegen Goliath: klein model versus frontier — wat een domein-gespecialiseerd model gebouwd op dit soort data kan bereiken
• De institutionele slotgracht — waarom propriëtaire trainingsdata als deze het echte concurrentievoordeel is

Het probleem dat nooit verdween: taal volgt regels niet netjes

Natuurlijke taal is op elk niveau ambigu. “Ik zag de man op de heuvel met een telescoop” heeft minstens vijf geldige lezingen, afhankelijk van wie de telescoop heeft en wie op de heuvel staat. Woorden als “lopen” dragen een dozijn gerelateerde betekenissen (polysemy); woorden als “bank” dragen twee volledig ongerelateerde (homonymy). Negatiebereik, pronomenresolutie, ironie, sarcasme, discoursstructuur — elk voegt een extra dimensie van ambiguïteit toe die moet worden opgelost met context, niet alleen met grammatica.

Onder dit alles ligt een nog moeilijker wiskundig feit: taal volgt de Zipf’s Law. Een klein aantal woorden en constructies komt extreem vaak voor, en dan is er een enorme, onvoorspelbare “lange staart” — idiomen, zeldzame vakterm, nieuwe formuleringen — die te zelden voorkomt om ooit volledig te worden opgesomd. Elk systeem gebouwd op een vaste set regels zal onvermijdelijk gevallen tegenkomen die de regels niet dekken, hoeveel regels je ook schrijft.

Dat ene feit — de lange staart is onoplosbaar met vaste regels — verklaart bijna de gehele vijftigjarige geschiedenis van het vakgebied.

Generatie 1: Grammatica’s en logica (het regelgebaseerde tijdperk)

De vroegste computationele aanpak van taal, teruggaand via Chomsky’s generatieve grammatica’s tot Aristoteles’ originele grammaticale categorieën, probeerde taal te formaliseren als een systeem van regels: woordsoortcategorieën, zinsstructuur, syntactische afleidingen. Dit geeft je precisie — een grammatica accepteert een zin of niet — maar het is fundamenteel kwetsbaar. Handgeschreven regels kunnen de lange staart niet omvatten, passen zich niet aan aan nieuwe woordenschat (een neologisme als “Zoomen” als werkwoord bestond gisteren niet en bestaat vandaag wel), en vereisen dat een taalkundige het systeem handmatig uitbreidt elke keer dat echte tekst het breekt.

Generatie 2: Probabilistische en corpus-gebaseerde modellen

De volgende generatie voegde kansen toe bovenop structuur: in plaats van een regel die wel of niet vuurt, ken je er een waarschijnlijkheid aan toe die geleerd is uit een corpus echte tekst. Dit was een echte stap vooruit — het liet systemen graceus omgaan met ambiguïteit in plaats van volledig te falen, en het leerde patronen direct uit geannoteerde data in plaats van ze handmatig te coderen. Maar probabilistische modellen werkten grotendeels nog steeds over vaste, ontworpen kenmerken (n-grams, handgebouwde lexicale bronnen zoals WordNet die synoniemen en hyponiemen met de hand coderen). Ze waren robuuster dan pure grammatica’s, maar ze leerden nog steeds niet de diepe structuur van taal — ze leerden statistieken over een structuur die iemand anders had gedefinieerd.

Generatie 3: Neurale netwerken leren sequentiële afhankelijkheden (RNN, LSTM)

Vroege kunstmatige neurale netwerken, en vervolgens recurrente neurale netwerken en LSTM’s, vertegenwoordigden een echte architectuursprong: in plaats van handgebouwde kenmerken leert het netwerk sequentiële afhankelijkheden direct uit data. Een RNN geeft een verborgen toestand door door een zin, wat betekent dat het in principe “wat er daarvoor was” kan gebruiken om “wat er nu is” te interpreteren — precies het soort contextresolutie dat ambiguïteit vereist. LSTM’s, geïntroduceerd in 1997, voegden een gated geheugenmechanisme toe om het netwerk te helpen informatie te bewaren over langere afstanden (“Ik groeide op in Frankrijk … ik spreek vloeiend Frans” vereist het verbinden van woorden die ver uit elkaar staan).

Hier verscheen de muur opnieuw, en het was een serieuze. RNN’s en LSTM’s verwerken een zin strikt sequentieel — token voor token, elke stap afhankelijk van de uitvoer van de vorige. Dat heeft twee gevolgen die fataal bleken op schaal: training kan niet worden geparalleliseerd (je kunt stap 10 niet berekenen voordat stap 9 klaar is), en de sequentiële keten van vermenigvuldigingen zorgt ervoor dat gradients vervagen of exploderen naarmate zinnen langer worden, waardoor het moeilijk is echte langeafstandsafhankelijkheden te leren, hoe slim het gating-mechanisme ook is. Bovendien moest de volledige betekenis van een invoerreeks worden gecomprimeerd in één enkel definitief verborgen-toestandsvector — vaak slechts een handvol dimensies — voordat die werd doorgegeven aan een decoder. Te veel relaties, te kleine bottleneck.

Halverwege de jaren 2010 had het vakgebied een echte diagnose: RNN’s en LSTM’s waren datahongerig, onstabiel, computationeel duur om te trainen, en structureel niet in staat parallel te draaien. Er was ruimte — eigenlijk een echte behoefte — aan iets fundamenteel anders.

Generatie 4: Transformers — de bottleneck en de sequentiële beperking tegelijk oplossen

Het paper “Attention Is All You Need” uit 2017 verving terugkoppeling volledig door self-attention: in plaats van informatie stap voor stap door een keten te sturen, wordt elk token in een reeks direct vergeleken met elk ander token, allemaal tegelijk, via matrixvermenigvuldiging. Die ene verandering lost beide RNN/LSTM-problemen tegelijkertijd op. Omdat er geen sequentiële afhankelijkheid tussen tokens is tijdens training, paralleliseert de volledige berekening — en matrixvermenigvuldiging is toevallig precies wat moderne GPU- en TPU-hardware met enorme snelheid uitvoert. En omdat attention direct wordt berekend tussen elk paar tokens, is er geen enkele bottleneck-vector meer die de betekenis van een volledige zin probeert vast te houden; het model kan direct naar elk eerder of later token kijken wanneer dat nodig is.

Maar het interessantere deel, voor iedereen die geeft om waarom dit specifiek voor taal werkt, is wat er gebeurt als je meerdere lagen self-attention op elkaar stapelt. Elke laag neemt de uitvoer van de laag ervoor en verfijnt die verder — en empirisch specialiseren de lagen zich in iets dat opvallend lijkt op de klassieke linguïstische pipeline die computationele taalkundigen al decennia handmatig aan het bouwen waren: de lagere lagen pikken relatief duidelijke relaties op zoals interpunctie en morfologie, de middelste lagen beginnen syntaxis en basale semantische relaties te vangen, en de bovenste lagen behandelen de echt moeilijke dingen — pronomen en co-referenties oplossen, langeafstandslogische relaties bijhouden, het soort discoursstructuur waarvoor vroeger speciale handgebouwde modules nodig waren.

Dit is het punt om bij stil te staan: de klassieke NLP-pipeline — tokenization, morfologie, syntaxis, semantiek, discours — verdwijnt niet in een transformer. Hij herrijst automatisch, laag voor laag, puur als gevolg van training op genoeg tekst, zonder dat iemand ook maar één grammaticaregel handmatig heeft gecodeerd. Vijftig jaar taalkunde probeerde die pipeline expliciet te specificeren, laag voor laag. Transformers leiden dezelfde structuur impliciet af, uit data, en — cruciaal — ze lopen niet vast op de manier waarop elke vorige generatie dat deed bij de lange staart, omdat het model niet vertrouwt op één vaste regel; het bouwt een probabilistische representatie die flexibel genoeg is om te generaliseren naar invoer die het nooit eerder heeft gezien.

Geluk, of wisten ze precies wat ze deden?

Hier is een genuanceerde historische vraag die gesteld wordt over de acht auteurs van “Attention Is All You Need”: was deze doorbraak een gelukkig architectuurongeluk, of begrepen de mensen die het bouwden daadwerkelijk de taalkunde die ze codeerden?

Het eerlijke antwoord neigt naar het laatste. Verschillende auteurs van het paper hadden echte, substantiële achtergronden in computationele taalkunde in plaats van puur in machine learning — met name Jakob Uszkoreit, wiens vader, Hans Uszkoreit, een bekende computationele taalkundige is. Opgroeien in dat vakgebied is geen kleine biografische details; het is een plausibele reden dat de architectuur werd gebouwd met een intuïtie voor hoe betekenis werkelijk gelaagd is in taal — morfologie, dan syntaxis, dan semantiek, dan discours — in plaats van puur een engineeringoefening in het schalen van matrixvermenigvuldigingen. Het is een zeldzaam geval waarbij de vraag “toeval versus bewust plan” geen voor de hand liggend antwoord heeft, en waarbij de bewust-plan-interpretatie werkelijk goed wordt ondersteund door wie er in de kamer was.

Waarom “eindelijk werkt” de juiste formulering is

Zet de volledige geschiedenis naast elkaar en het patroon is onmiskenbaar. Grammatica’s gaven precisie maar geen robuustheid voor de lange staart. Statistische modellen gaven robuustheid maar waren nog steeds gebouwd op vaste, handontworpen kenmerken. RNN’s en LSTM’s leerden eindelijk sequentiële structuur direct uit data, maar konden niet schalen — sequentiële verwerking begrenste zowel de trainingssnelheid als hoe ver terug ze daadwerkelijk konden “onthouden.” Transformers zijn de eerste architectuur die echte datagedreven lering van taalkundige structuur op elk niveau combineert — van morfologie tot discours — met een berekening die voldoende paralleliseert om te worden getraind op een schaal die geen eerdere architectuur kon bereiken. Die combinatie — niet één enkele truc — is waarom, na vijftig jaar van gedeeltelijke oplossingen, natural language processing eindelijk werkt.

Cursusmateriaal waarnaar wordt verwezen: Advanced NLP-collegereeks, Department of Advanced Computing Sciences.

Kernpublicaties

• Vaswani et al. (2017), Attention Is All You Need — arXiv:1706.03762
• Hochreiter & Schmidhuber (1997), Long Short-Term Memory — Neural Computation
• Devlin et al. (2018), BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding — arXiv:1810.04805

Verder lezen op deze site

• Wat is een AI-agent? — het op transformers gebaseerde taalmodel als de ontbrekende motor die agentische systemen laat werken
• David tegen Goliath: klein model versus frontier — wat er gebeurt als je een van deze architecturen specialiseert op één taak
• De gigant inkrimpen: pruning, quantization en distillation — hoe je comprimeert wat transformers hebben geleerd tot iets dat op bescheiden hardware draait
• Adversariale aanvallen: onzichtbare pixels en omgewisselde woorden — de beveiligingskwetsbaarheden die voortkomen uit hoe deze modellen hun beslissingsgrenzen trekken

Het probleem: AI-agents zijn slecht in het volgen van instructies

Het is verleidelijk aan te nemen dat als een taalmodel een essay kan schrijven of code kan debuggen, het vanzelfsprekend een standaard operationele procedure van een bedrijf kan volgen. Recent benchmarkonderzoek zegt iets anders. Een onderzoek uit 2025 waarbij AI-agents werden ingezet om echte bedrijfsprocedures uit te voeren, vond dat het beste frontier-model slechts een succespercentage van 30,3% behaalde, terwijl open-source modellen onder de 8% vielen. Afzonderlijk werk dat frontier-modellen testte op meerstapsredenering in een klinische dossiercontext vond nauwkeurigheden onder de 11%. De rode draad: ongestructureerde proceduretekst — vol voorwaardelijke vertakkingen, lussen en ambigue formuleringen (“als de naam al in de database staat… start anders een registratieproces en voer stappen 1 tot 10 uit”) — is precies waar general-purpose modellen struikelen, omdat ze redeneren over vrije tekst in plaats van een gestructureerd begrip van waar ze zich in een proces bevinden en wat er daadwerkelijk nog geldig is om vervolgens te doen.

De aanpak: handleidingen omzetten in trainingssignaal, niet alleen in context

Het kernidee is te stoppen met het behandelen van een procedure als tekst om over te redeneren tijdens inferentie, en het in plaats daarvan te behandelen als een bron van gestructureerde, stap-niveau trainingsdata waarvan het model werkelijk kan leren. De pipeline loopt in vijf fasen:

1. Extraheer de workflow als een graph. Een op LLM gebaseerde extractielus leest een proceduredocument en herstelt het als een gerichte graph — acties, beslissingspoorten, vertakkingsvoorwaarden — met een zelfcontrolerende verfijningslus (een structurele checker die verifieert dat elk knooppunt bereikbaar is en een pad van begin tot eind bestaat, plus een semantische checker die de geëxtraheerde graph vergelijkt met de originele tekst op gemiste stappen).
2. Zet de graph om in een begrip van voortgang. Elk geldig pad door de graph, deterministisch opgesomd (via breedte- en diepte-eerst-zoeken), wordt een reeks toestanden: wat tot nu toe is gedaan, welke voorwaarden golden, en wat er vervolgens geldig beschikbaar is.
3. Genereer zowel positieve als bijna-fout trainingssignalen. Naast de correcte volgende actie in elke toestand genereert de pipeline bewust verkeerde volgende acties — een overgeslagen stap, twee stappen in de verkeerde volgorde uitgevoerd, een herhaalde actie, een verkeerd startpunt — elk gelabeld met precies waarom het fout is.
4. Train een klein, gespecialiseerd model op deze data — een Process Reward Model dat kandidaat-volgende-acties beoordeelt gegeven de huidige toestand, als een LoRA-adapter bovenop een klein open-gewicht basismodel (Llama 3.1 8B).
5. Implementeer een agent die het kleine getrainde model combineert met de geëxtraheerde graph zelf als een realtime filter: wanneer het model onzeker is, beperkt het zijn kandidaatacties tot alleen wat de graph zegt dat op dat punt daadwerkelijk geldig is — zonder extra trainingskosten.

De resultaten: elke laag verdient zijn plek

De stapsgewijze verbetering is het duidelijkste bewijs dat dit niet één slimme truc is maar een werkelijk samengestelde architectuur:

• Een kaal, onverankerd klein model verzint acties die niet in de procedure bestaan ongeveer 35% van de tijd, voltooit slechts 10,2% van de procedures van begin tot eind, en produceert geldige vervolgstappen slechts 56% van de tijd.
• Het eenvoudigweg verankeren in de geëxtraheerde actielijst (zonder training vereist) tilt de voltooiing al op naar 36,7% en geldige stappen naar 81%, en — cruciaal — elimineert gehallusineerde acties volledig, omdat het model nu alleen kan kiezen uit wat daadwerkelijk bestaat.
• Het toevoegen van het getrainde Process Reward Model, gemengd met het eigen oordeel van het basismodel, duwt de voltooiing naar 51% en geldige stappen naar 87%.
• Het toevoegen van de graph als een live veiligheidsnet voor onzekere momenten brengt de voltooiing naar 55,1% en geldige stappen naar 88,7% — met bijna geen extra kosten, omdat de graaf al in stap één was geëxtraheerd.

En de clou: vergeleken met een frontier-basismodel (ook voorzien van de geëxtraheerde actielijst, zodat het niet op achterstand staat) — scoorde het frontier-model 89,9% op geldige stappen en 61,2% op voltooiing, versus 88,7% en 55,1% van het kleine systeem. Een kloof van ongeveer één en zes punten, tegenover een model dat geschat wordt op 625 keer groter.

Nog een bevinding die het vermelden waard is: toen de trainingsdata zelf werd deduplicated en herbalanceerd — het verkleinen van de dataset met 43%, maar het verwijderen van redundante, bijna-identieke voorbeelden en het corrigeren van een scheefheid naar “correcte” labels — presteerde het resulterende model beter op sommige configuraties dan het model dat was getraind op de grotere, rommeligere dataset. Kwaliteit versloeg volume, niet alleen voor de basisarchitectuur, maar ook voor de trainingsdata die deze voedde.

Waarom dit resultaat volledig logisch is

Het is verleidelijk een resultaat als dit te lezen als “kleine modellen zijn stiekem even goed als grote” — dat is niet de juiste les, en het loont de moeite precies te zijn over waarom.

Een frontier-basismodel is een generalist. Het moet tegelijkertijd goed zijn in poëzie schrijven, Rust debuggen, kwantummechanica uitleggen, Portugees vertalen, en — slechts als één van duizenden competenties — het volgen van de specifieke leninggoedkeuringsprocedure van een bedrijf. Zijn capaciteit is verspreid over een enorme ruimte van mogelijke taken waarvoor het gevraagd kan worden. Dat is precies waarom het in de eerste plaats een 5-triljoen-parameter-klasse systeem is: breedte is duur.

Een gespecialiseerd model dat specifiek is getraind op stap-niveau, toestandsbewuste procedurele data heeft niets van die breedte nodig. Het moet exact één engere vraag extreem goed beantwoorden: gegeven waar we zijn in dit specifieke proces, wat is de geldige volgende stap? Al zijn (verhoudingsgewijs kleine) capaciteit wordt besteed aan die ene competentie, versterkt door duizenden concrete voorbeelden van wat correct is en — net zo belangrijk — gelabelde voorbeelden van wat bijna correct is maar op een specifieke, benoemde manier fout. Een generalistisch model heeft nooit dat soort dichte, gestructureerde, negatieve-voorbeeld-rijke trainingssignaal gezien voor jouw specifieke procedures, omdat het niet publiekelijk bestaat — het moet worden gebouwd uit de eigen handleidingen van een organisatie.

Dit is dezelfde logica die opduikt wanneer een nauwe specialist concurreert met een generalist: een schaakengine die alleen schaakt, verslaat een menselijke generalist bij schaken, niet omdat het over het algemeen intelligenter is, maar omdat het geen capaciteit besteedt aan iets anders. De 625x parameterkloof verdwijnt niet — hij is gewoon grotendeels irrelevant voor deze specifieke, nauwe taak, omdat het kleine model nooit werd gevraagd goed te zijn in al het andere waarvoor het grote model ook goed moet zijn.

Waarom dit er praktisch toe doet

De praktische implicaties reiken verder dan de ruwe cijfers:

• Het draait lokaal, op een enkele consumentenkwaliteit GPU — geen data verlaat het gebouw, wat direct van belang is voor het soort institutionele en datasoevereiniteitszorgen dat eerder op deze site is behandeld.
• Er hoeft geen propriëtaire procedurele data naar een externe API-aanbieder te worden gestuurd om dit prestatieniveau te bereiken — de specialisatie vindt volledig plaats op infrastructuur die de organisatie beheert.
• De kosten- en energievoetafdruk dalen met ordes van grootte ten opzichte van het herhaaldelijk bevragen van een frontier-model, zonder dat er veel taakspecifieke prestaties verloren gaan die ertoe doen.
• Het knelpunt dat overblijft is extractiekwaliteit, niet modelomvang — wanneer de onderliggende workflow-graph perfect is (gouden standaard), voltooit hetzelfde kleine model 98% van de procedures met 99,6% geldige stappen. Het verschil met frontier-modelprestaties in echte implementatie komt bijna volledig van onvolmaakte automatische extractie van de workflow-graph uit rommelige brontekst, niet van de redenercapaciteit van het kleine model zelf.

De conclusie

Een handvol procentpunten dat een 8-miljard-parameter specialist scheidt van een multi-triljoen-parameter generalist, op een taak die er werkelijk toe doet voor de operaties van een organisatie, is geen toeval en geen truc — het is het directe, voorspelbare resultaat van het ruilen van breedte voor diepte. Basismodellen zijn gebouwd om goed te zijn in bijna alles; een fine-tuned klein model gebouwd op de eigen procedurele data van een organisatie hoeft slechts goed te zijn in één ding. Wanneer dat ene ding eng genoeg is en de trainingsdata goed genoeg, houdt de omvangskloof op de doorslaggevende factor te zijn. Dat is het volledige argument voor het bouwen van je eigen gespecialiseerde agentische componenten bovenop een gestandaardiseerd basismodel, in plaats van de volledige capaciteit te huren van iemand anders’ veel grotere, veel duurdere, veel minder beheersbare systeem.

Kernpublicaties

• Hu et al. (2022), LoRA: Low-Rank Adaptation of Large Language Models — arXiv:2106.09685
• Sanh et al. (2019), DistilBERT, a Distilled Version of BERT — arXiv:1910.01108
• Ouyang et al. (2022), Training Language Models to Follow Instructions with Human Feedback — arXiv:2203.02155

Verder lezen op deze site

• Van tekst naar actie — hoe je de trainingsdata pipeline bouwt die zo’n model oplevert
• Van logboeken naar agent-trainingsdata — een concreet domeinvoorbeeld van precies dit soort gespecialiseerd trainingssignaal
• De gigant inkrimpen: pruning, quantization en distillation — de complementaire compressietechnieken die kleine modellen nog kleiner en goedkoper maken
• Waarom Europa eigen AI-modellen nodig heeft — waarom dit model lokaal draaien op soevereine infrastructuur ertoe doet
• De institutionele slotgracht — de strategische case voor specialiseren in plaats van huren

De waarschuwing van Kissinger, toegepast op het klaslokaal

Voordat we bij de opwindende toepassingen komen, is het de moeite waard stil te staan bij een ongemakkelijke observatie van Henry Kissinger, schrijvend over AI en schaken: “AI zal waarschijnlijk elk spel winnen dat het wordt gegeven. Maar voor ons als mensen gaan de spelen niet alleen over winnen; ze gaan over denken… Door een wiskundig proces te behandelen alsof het een denkproces is, en ofwel te proberen dat proces zelf na te bootsen ofwel de resultaten gewoon te accepteren, lopen we het risico de capaciteit te verliezen die de kern van menselijke cognitie is geweest.”

Vervang “spelen” door “opdrachten” en de waarschuwing geldt direct voor onderwijs. Het doel van onderwijs was nooit alleen het halen van examens — het is leren denken. Toch heeft beoordeling historisch gezien vaak geheugenwerk boven redeneren beloond. Nu modellen als GPT in seconden een verzorgd essay kunnen produceren, is die mismatch niet langer te negeren. AI kan het onderwijs revolutioneren door te fungeren als een schaalbare, gepersonaliseerde onderwijsassistent — maar alleen als instellingen herdenken hoe ze lesgeven en beoordelen, in plaats van AI te plakken op een beoordelingsmodel dat gebouwd is voor een pre-AI-wereld.

Wat generatieve AI werkelijk goed doet in de klas

Zet de risico’s even opzij — de concrete toepassingen zijn werkelijk overtuigend, en de meeste zijn al getest in echte cursussen.

Sokratische dialogen, op aanvraag gegenereerd. De sokratische methode — doorvragende vragen die aannames uitdagen en redeneren stimuleren in plaats van antwoorden te geven — is precies het soort interactie dat AI op schaal kan produceren. Vraag een model vijf sokratische dialogen te genereren over een onderwerp (wat een aanpak krachtig maakt, waar het faalt, wat de maatschappelijke risico’s zijn) en je krijgt kant-en-klaar lesmateriaal dat de ruimte verschuift van lezing naar dialoog, in minuten in plaats van uren voorbereiding.

Een onderwijsassistent die 24/7 werkt. Studenten lopen tegen conceptuele muren aan om 2 uur ’s nachts voor een tentamen, niet tijdens spreekuren. Een AI-tutor met oneindig geduld — bereid een moeilijk concept zo vaak en op zo veel verschillende manieren opnieuw uit te leggen als een student nodig heeft — vult een gat dat geen menselijk onderwijspersoneel realistisch kan dekken.

Oefeningen, readers en lesmateriaal, op schaal gegenereerd. Een concreet voorbeeld: een volledige 240-pagina’s tellende reader — hoofdstukken, oefeningen, antwoorden en programmeeropdrachten — gegenereerd uit 1.300 collegeslides in een paar avonden, hoofdstuk voor hoofdstuk. Dat is geen marginale efficiëntiewinst; het is werk dat anders weken zou kosten, waardoor de tijd van een docent vrijkomt voor de onderdelen van onderwijs die daadwerkelijk een mens vereisen — diepere interactie, begeleiding, oordeelsvermogen over waar een specifieke student vastloopt.

Gepersonaliseerde uitleg en adaptieve inhoud. Hetzelfde onderliggende materiaal kan op verschillende complexiteitsniveaus opnieuw worden uitgelegd, afhankelijk van wat een specifieke student nodig heeft — iets wat een enkelvoudige lezing, eenmalig gegeven aan een zaal van 200 mensen, structureel niet kan doen.

Directe feedback op je eigen lessen. Docenten kunnen dezelfde tools gebruiken om hun eigen lesmateriaal te beoordelen en concrete feedback te krijgen over duidelijkheid en structuur — een tweede paar ogen altijd beschikbaar.

Geautomatiseerde gespreksbeoordeling. Vroeg onderzoek (waaronder lopend werk bij de DACS-groep van de Universiteit Maastricht) verkent gesprekagenten die de rubric van een docent, het inhoudsdocument en een dialoog met de student combineren om beoordelingsaanbevelingen te produceren — niet om het oordeel van de docent te vervangen, maar om een proces dat momenteel handmatig en traag is te structureren en te versnellen.

De wapenwedloop die niemand wilde

Hier wordt het eerlijke beeld ingewikkelder. Op het moment dat AI goed genoeg werd om een acceptabel essay te schrijven, verscheen er een complete contra-industrie. Er bestaan nu tools specifiek om AI-gegenereerde tekst te “humaniseren” zodat het detectiesoftware omzeilt — en in een vreemde wending laten studenten die hun eigen originele werk schrijven het nu ook door diezelfde detectoren lopen, bezorgd dat hun authentieke schrijven als AI-gegenereerd wordt gemarkeerd. Docenten gebruiken AI-detectietools om AI-geschreven inzendingen te betrappen; studenten gebruiken humaniseringstools om die detectoren te omzeilen; sommige studenten laten hun eigen echte schrijven defensief door detectoren lopen. Iedereen schrijft nu deels voor de detector, niet voor de lezer.

Dit is niet volledig nieuw — “huiswerkm achines” bestaan al decennia voor ChatGPT, en elke generatie technologie heeft vergelijkbare paniek veroorzaakt (dezelfde angst werd twee decennia geleden geuit over Google: “Is Google ons dom aan het maken?”). Maar de vloeiendheid van generatieve AI maakt de kat-en-muisdynamiek scherper en sneller bewegend dan ooit tevoren, en het zorgt voor werkelijk ongelukkige studenten en gefrustreerde docenten aan beide kanten van de detectiewapenwedloop.

Waarom de onderliggende technologie nog steeds guardrails nodig heeft

Het is de moeite waard precies te zijn over wat deze modellen werkelijk doen — en niet doen — omdat dat zowel hun bruikbaarheid als hun faalwijzen in een onderwijsomgeving verklaart. Een model als GPT is fundamenteel een volgende-token-voorspeller: gegeven een reeks woorden schat het de waarschijnlijkheid van wat er vervolgens komt, tekst autoregressief genererend, één token tegelijk. Het heeft geen ingebouwde feitelijkheidscontrole, geen persistent geheugen over sessies heen tenzij expliciet ontworpen, en geen echte-wereldverankering voor de woorden die het produceert — kritieken vaak samengevat als “stochastische papegaai”: vloeiende taalproductie zonder werkelijk begrip.

Dat heeft directe onderwijsgevolgen: hoe langer de gegenereerde tekst, hoe groter de kans op feitelijke afwijking of regelrechte hallucinatie — een ernstig probleem wanneer de inhoud een formule, een citaat, een historische datum of een stuk code is dat een student zal vertrouwen. De mitigatietechnieken die hier van belang zijn voor een onderwijsomgeving zijn dezelfde als bij elke serieuze implementatie: retrieval-augmented generation om antwoorden te verankeren in het daadwerkelijke cursusmateriaal in plaats van de algemene trainingsdata van het model, kennisgraaf-gebaseerde context-injectie voor gestructureerde feiten, en simpelweg het systeem instrueren om “ik weet het niet” te zeggen in plaats van zelfverzekerd een antwoord te verzinnen wanneer het vertrouwen laag is. Niets hiervan is optionele afwerking — het is het verschil tussen een tutor die soms fout zit op een manier die studenten kunnen opmerken, en een die zelfverzekerd fout zit op een manier die ze niet kunnen.

De echte herontwerpvraag

De meest productieve formulering is niet “moeten we dit verbieden” of “moeten we dit kritiekloos omarmen” — het is “wat moet beoordeling worden nu dit bestaat.” Een paar concrete richtingen die serieus genomen verdienen te worden:

• Herontwerp opdrachten rondom begrip, niet rondom uitvoer. Laat studenten GenAI gebruiken om hun eigen werk te bekritiseren en te verbeteren, en begrijpen waarom iets verbeterd kan worden — waardoor de AI een teamgenoot wordt in plaats van een snelkoppeling.
• Overweeg de klas om te draaien. Als het overbrengen van informatie een opgelost probleem is dat AI redelijk goed kan doen, kan lestijd verschuiven naar sokratische dialoog en toegepast redeneren — hoewel dit een echte verschuiving vereist in wat er van studenten wordt verwacht, niet alleen van docenten.
• Houd werkelijk AI-vrije beoordeling waar het ertoe doet. Sommige eindbeoordelingen moeten “doe het zelf” blijven, zonder AI-tooling, specifiek om de redeneervaardigen te verifiëren waarnaar de AI-ondersteunde werkzaamheden toe bedoeld waren te leiden.
• Vermijd “AI-vriendelijke opdrachten” — taken die in de eerste plaats geen kritische analyse vereisen zijn precies de taken die AI niet te onderscheiden van een mens zal voltooien, zonder je iets te vertellen over wat de student werkelijk heeft geleerd.

Er is ook een stiller risico dat benoemd verdient te worden: als een AI-beoordelings- of tutorassistent 49 keer achter elkaar gelijk heeft, zal een docent dan nog zorgvuldig de 50e controleren? Automatiseringsgemakzucht is een echte faalwijze, geen hypothetische, en dat pleit ervoor om een mens werkelijk in de lus te houden in plaats van AI-uitvoer rubber te stempelen omdat die tot nu toe betrouwbaar is geweest.

Eerlijk afwegen

Het argument voor: 24/7 toegang tot uitleg, werkelijk gepersonaliseerd tempo, ondersteuning voor moeilijke onderwerpen, efficiënte tutorondersteuning op een schaal dat geen instelling met mensen alleen kon bemensen, lagere drempels voor studenten in ondervoorziene situaties, en taalondersteuning voor niet-moedertaalsprekers.

Het argument voor voorzichtigheid: overafhankelijkheid die precies de vaardigen uitholt die onderwijs bedoeld is te bouwen, het risico dat zelfverzekerd onjuiste informatie studenten bereikt die het verschil nog niet kunnen zien, ongelijke toegang als tools kostbaar zijn, en de zeer reële mogelijkheid dat opdrachten worden uitbesteed in plaats van begrepen.

De conclusie

De technologie werkt nu werkelijk, na decennia van onderzoek — dat deel staat niet ter discussie. Wat nog wordt uitgewerkt, in real time, in echte klaslokalen, is hoe docenten verschuiven van informatieverstrekkers naar facilitators van kritisch denken, en hoe beoordeling verschuift van het belonen van geheugen naar het belonen van redenering en toepassing. Goed gebruikt ziet AI in het onderwijs eruit als een onvermoeibare, geduldige, altijd beschikbare onderwijsassistent die menselijke docenten vrijmaakt voor de onderdelen van onderwijs die machines nog steeds niet kunnen doen. Onzorgvuldig gebruikt ziet het eruit als een wapenwedloop tussen detectietools en humaniseringstools die iedereen voor het algoritme laat schrijven in plaats van voor begrip. De technologie bepaalt niet welke van die toekomsten we krijgen — het herontwerp van beoordeling en pedagogiek eromheen doet dat.

Gebaseerd op “Exploring the Potential of AI Tutors in Higher Education” (Prof. dr. ir. Jan Scholtes, UM Education Day, juni 2025).

Kernpublicaties

• Kasneci et al. (2023), ChatGPT for Good? On Opportunities and Challenges of LLMs for Education — Learning and Individual Differences
• Bender et al. (2021), On the Dangers of Stochastic Parrots — ACM FAccT 2021
• Mollick & Mollick (2023), Assigning AI: Seven Approaches for Students, With Prompts — SSRN

Verder lezen op deze site

• Wat is een AI-agent? — de architectuur achter de AI-tutors en beoordelingsagenten hier besproken
• Waarom NLP eindelijk werkt — de transformer-architectuur die generatieve AI in het onderwijs mogelijk maakte
• Adversariale aanvallen: onzichtbare pixels en omgewisselde woorden — waarom AI-systemen guardrails nodig hebben, ook in onderwijscontexten
• Van tekst naar actie — hoe cursusmateriaal en correcties trainingsdata kunnen worden voor een gespecialiseerde onderwijsagent

Het bestuursraamwerk dat niemand heeft opgeschreven (tot nu)

Een nuttige manier om na te denken over het besturen van een AI-agent is de levenscyclus in vier fasen in te delen, elk met een eigen bestuursvraag — en elk met een bijbehorende evaluatiestandaard, zoals Stanford’s HELM-benchmarksuite, die je iets concreets geeft om te meten in plaats van een vaag vertrouwensgevoel.

1. Training — is de basis solide? Dit is de fase van pre-training en instructie-afstemming waarin het model patronen, taal en basistaken leert. De bestuursvraag hier is eenvoudig maar fundamenteel: heeft dit systeem voldoende nauwkeurigheid en kenniskwaliteit voor de scenario’s die het daadwerkelijk zal tegenkomen? Als de basis zwak is, zal niets wat erop wordt gebouwd betrouwbaar zijn, hoe geavanceerd de toezichtlagen ook zijn.

2. Validatie — gedraagt het zich consistent onder druk? Een agent testen in gesimuleerde omgevingen — kan het betrouwbaar API’s aanroepen en code uitvoeren zonder te breken? — onthult twee governance-kritieke eigenschappen: robuustheid (veroorzaakt een kleine variatie in invoer een grote variatie in gedrag?) en kalibratie (weet het systeem hoe zeker het zou moeten zijn?). Een model dat tegelijkertijd fout en zelfverzekerd is, is veel gevaarlijker te besturen dan een model dat fout is maar dat ook zegt.

3. Reflectie — onderschept het zijn eigen fouten? Agentische raamwerken zoals ReAct en Reflexion geven een systeem de mogelijkheid om naar de uitkomst van zijn eigen handeling te kijken — een foutmelding van een tool, een onverwacht resultaat — erover na te denken en zijn eigen plan te corrigeren. Vanuit een bestuursperspectief beoordeel je hier de aanpassingsvermogen: blijft de agent een logische, verdedigbare reeks stappen volgen, of ontspoort het onder onzekerheid? Dit is de laag die problemen opvangt voordat een mens dat ooit hoeft te doen.

4. Uitleg — kan het zijn werk laten zien? Dit is Explainable AI (XAI): waarom koos de agent actie A in plaats van actie B? Een bestuurde agent moet zijn interne beslissingsboom blootleggen, het gewicht dat het aan concurrerende overwegingen gaf, of op zijn minst een duidelijk logboek — aan de menselijke toezichthouder die verantwoordelijk blijft voor de uitkomst. Dit is ook waar eerlijkheid en vermindering van vooringenomenheid in de praktijk worden afgedwongen, want je kunt niet controleren wat je niet kunt zien. Zonder deze laag is “de AI heeft besloten” geen antwoord — het is een uitvlucht.

Samen zijn deze vier fasen niet alleen een engineeringpijplijn. Ze vormen een bestuursraamwerk: elke fase beantwoordt een specifieke vraag die een raad van bestuur, een toezichthouder of een auditor uiteindelijk zal stellen, en elke fase heeft een meetbare standaard achter zich in plaats van een handgebaar.

Hoe dit er in de praktijk uitziet: de Amerikaanse marine

Abstracte raamwerken zijn gemakkelijker te vertrouwen als je kunt aantonen dat ze werken onder echte operationele druk. De recente agentische AI-implementaties van de Amerikaanse marine zijn instructief, precies omdat de inzet — veiligheid, kosten, inzetbereidheid van de missie — geen ruimte laat voor governance als bijzaak.

MyNavy HR: bureaucratie elimineren, niet alleen automatiseren. Interne administratie was een van de grootste bronnen van verspilde tijd en frustratie voor matrozen, wat direct bijdroeg aan lagere retentie. Het antwoord van de marine was AI-agents te plaatsen als een onzichtbare vertaler tussen de matroos en de logge ERP-systemen van de marine — een matroos dient een HR-, salaris- of verlofwijziging in via een radicaal eenvoudige interface, en de agent werkt de backendsystemen autonoom bij. Het resultaat: honderdduizenden bespaarde arbeidsuren per jaar, een verminderd HR-personeelsbestand en operationele bemanningen bevrijd van papierwerk. De bestuursles hier is dat de matroos de AI nooit direct hoeft te begrijpen of te vertrouwen — ze vertrouwen erop dat de uitkomst correct is, omdat de governance één laag verder terug zit, in hoe de acties van de agent worden gevalideerd tegen HR-beleid.

Condition-Based Maintenance Plus (CBM+): soevereiniteit als bestuurseis, niet als voorkeur. De marine stapt af van reactief of puur op kalender gebaseerd onderhoud op schepen en onderzeeërs, met behulp van wat zij Sovereign Edge AI noemen — modellen die fysiek en lokaal op het schip draaien, onafhankelijk van een satellietverbinding. Sensoren voeden een lokaal model; wanneer het een abnormaal patroon detecteert, genereert de agent niet alleen een rapport — het bestelt autonoom het benodigde reserveonderdeel en plant de reparatie voor de volgende havenbezoek. Het resultaat: enorme besparingen door het minimaliseren van “Wachten op onderdelen”-stilstand — een miljardenschip staat niet langer stil omdat een klep van honderd dollar ontbreekt. Let op wat hier het bestuurswerk doet: de AI is gemachtigd om te handelen (onderdelen bestellen, reparaties plannen) precies omdat het draait op infrastructuur die de marine volledig beheert, met een begrensd, goed getest actiebereik. Autonomie en soevereiniteit zijn geen afzonderlijke zorgen — de eerste hangt af van de tweede.

NAVSUP: predictieve logistiek die behoeften anticipeert. Het Naval Supply Systems Command beheert wereldwijde depots en moet vloten op zee bevoorraden, waar bureaucratische vertraging daadwerkelijk gevaarlijk kan zijn. De AI koppelt een missieprofiel aan logistiek: als een vloot opereert in zwaar weer, berekent het systeem proactief verhoogde slijtage en positioneert de benodigde onderdelen vooruit in het dichtstbijzijnde depot — voordat de bemanning er zelfs om vraagt. Het resultaat is een bijna-eliminatie van dure noodlogistiekvluchten en een scherpe verlaging van overtollige “dode” voorraad die in havens ligt.

Bij alle drie is het patroon hetzelfde: AI krijgt echte besluitvormings- en handelingsbevoegdheid, maar alleen binnen een strak bestuurde envelop — begrensde acties, lokale/soevereine infrastructuur waar de inzet dat vereist, en een duidelijke keten terug naar een mens die verantwoordelijk is voor de uitkomst.

Digitale soevereiniteit is onderdeel van governance, geen apart onderwerp

Het is verleidelijk om “wie de beslissingen van de AI bestiert” en “wie de infrastructuur beheert waarop de AI draait” als twee verschillende gesprekken te behandelen. De CBM+-casus van de marine laat zien waarom het hetzelfde gesprek is. Soevereiniteit en governance zijn dezelfde vraag — zoals het vijf-dimensies-kader uitvoerig behandeld in het begeleidende artikel laat zien. Het besturen van een autonoom besluitvormingssysteem vereist controle over:

• Trainingsinfrastructuur — wie bepaalt wat het model leert
• Inferentie-infrastructuur, inclusief edge-implementatie — waar en hoe het model werkelijk draait wanneer het een beslissing neemt
• Betrouwbare, vaak kleinere modellen die je volledig kunt valideren, in plaats van een ondoorzichtig general-purpose model dat je alleen kunt aansturen via prompts
• Fine-tuning, RAG, RLHF en reflectie — de mechanismen waarmee je gedrag daadwerkelijk kunt vormgeven in plaats van er alleen maar op te hopen
• Compressie, pruning en distillatie — de technieken die het haalbaar maken om een bestuurbaar model lokaal, aan de edge, te draaien in plaats van afhankelijk te zijn van een externe API die je niet beheert

Een organisatie die alleen de promptlaag bestiert, terwijl elke daadwerkelijke inferentie-aanroep naar infrastructuur gaat die ze niet beheert, heeft het governanceprobleem niet echt opgelost — ze heeft een deel ervan uitbesteed aan een partij buiten de verantwoordingsketen.

De open vraag: gecentraliseerde of gedecentraliseerde governance?

Dit is waar het raamwerk geen gemakkelijke antwoorden meer heeft, en dat is eerlijk gezegd ook terecht. Moet AI-governance in een grote organisatie gecentraliseerd zijn — één orgaan dat standaarden, validatiedrempels en uitlegbaarheidsvereisten stelt voor elk AI-systeem in de organisatie — of gedecentraliseerd, waarbij elke afdeling of elk schip, in het geval van de marine, zijn eigen agents bestiert aan de hand van een gedeelde basislijn?

Er valt voor beide een redelijk argument te maken. Gecentraliseerde governance geeft je consistentie, een enkel auditiepunt en schaalvoordelen in validatie- en XAI-tooling. Gedecentraliseerde governance geeft je snelheid en domeinspecifiek oordeel — het team dat AI voor scheepsonderhoud beheert begrijpt storingscondities die een centrale AI-ethietraad nooit in dezelfde diepte zal begrijpen. De meeste organisaties die het verst zijn gegaan met agentische AI lijken te convergeren op een hybride: centraal gedefinieerde standaarden (het vierfasenraamwerk hierboven, minimale XAI-vereisten, escalatiedrempels voor menselijke goedkeuring) gecombineerd met gedecentraliseerde implementatie en monitoring dicht bij waar de beslissingen daadwerkelijk worden genomen. Soevereiniteit en verantwoordelijkheid worden centraal vastgesteld; dagelijks oordeel blijft lokaal.

Waar te beginnen: HR, juridisch en financiën

Als het besturen van agentische AI over een hele organisatie ontmoedigend aanvoelt, is er een gevestigde plek om de capaciteit op te bouwen voordat je die uitbreidt naar domeinen met hogere inzet: HR, interne juridische zaken en financiën. Deze functies opereren bijna volledig in een digitale en papieren realiteit — geen onvoorspelbare fysieke wereld van slecht weer, kapotte pompen of fysieke afstand om mee om te gaan. Ze werken met tekst en cijfers in kantoorbestanden, volgen strikte regels en protocollen, en vertegenwoordigen doorgaans een trage, dure flessenhals voor de rest van de organisatie. Die combinatie — hoge regeldichtheid, hoog volume, lage fysieke onvoorspelbaarheid — maakt ze de ideale laagrisico-proeflocatie voor het bovenstaande bestuursraamwerk: je kunt de vier fasen valideren, je uitlegbaarheidstooling testen en je escalatiedrempels vaststellen op een plek waar de kosten van een vroege fout een vertraagde factuur zijn, niet een gestrand schip.

De conclusie

De technologievraag — werkt agentische AI daadwerkelijk? — ligt achter ons. Wat overblijft is de bestuursvraag, en die heeft nog geen enkel vaststaand antwoord, maar wel een werkbare vorm: train en valideer aan de hand van meetbare standaarden, bouw reflectie in zodat het systeem zijn eigen fouten onderschept, eis echte uitlegbaarheid zodat een mens de beslissing daadwerkelijk kan controleren, beheers de infrastructuur waarop de beslissingen worden genomen, en besluit bewust — niet per ongeluk — hoeveel ervan centraal staat versus dicht bij waar het werk plaatsvindt. Organisaties die dit behandelen als een engineeringbijzaak, zullen op de harde manier ontdekken dat “de AI heeft besloten” geen aanvaardbaar antwoord is voor een raad van bestuur, een toezichthouder of een matroos wiens schip in de haven staat.

Gebaseerd op “AI en Bestuurlijke Besluitvorming” (Prof. dr. ir. J.C. Scholtes, rondetafelsessie, augustus 2026).

Kernpublicaties

• Jobin et al. (2019), The Global Landscape of AI Ethics Guidelines — Nature Machine Intelligence
• Doshi-Velez & Kim (2017), Towards a Rigorous Science of Interpretable Machine Learning — arXiv:1702.08608
• Cath (2018), Governing Artificial Intelligence: Ethical, Legal and Technical Opportunities and Challenges — Phil. Trans. R. Soc. A

Verder lezen op deze site

• De institutionele slotgracht — de architectuurlaag waarop governance rust
• Waarom Europa eigen AI-modellen nodig heeft — soevereiniteit als infrastructuurvoorwaarde voor echte governance
• Wat is een AI-agent? — wat het systeem dat wordt bestuurd eigenlijk is
• Wat er nodig is om een soevereine AI-agent te bouwen — de end-to-end praktische gids die dit governance-raamwerk toepast
• Bias-analyse in de praktijk — hoe je de vereiste bias-analyse, rechtvaardigingstoets en ethische wenselijkheidstoets uitvoert

De sandbox waar je werkelijk in bouwt

Aanbieders van basismodellen verschepen niet langer alleen slimmere chatbots — ze bouwen volledig geïntegreerde, gesloten agentische ecosystemen: meerstapsredeneerketens, native tool-integratie, propriëtaire kennisgrafen, neurale rerankers getraind op miljarden queries en toenemend recursieve zelfverbetering. Wat ze externe ontwikkelaars geven, is daarentegen een gecontroleerde sandbox: systeem-prompts (oppervlakkige controle), function calling om tools te activeren, standaard RAG (basis vectorzoekopdracht) en kant-en-klare sjablonen. Je krijgt geen toegang tot hun RLHF-lagen, hun modelgewichten of hun interne herrangschikking. Je mag op het platform bouwen — niet erin.

Die kloof doet er meer toe dan op het eerste gezicht lijkt. Een systeem-prompt, hoe zorgvuldig ook ontworpen, behandelt het model als een black box. Als je volledige “agent” een Markdown-bestand is dat over een general-purpose LLM is gelegd, heb je geen propriëtair systeem gebouwd — je hebt een configuratie van iemand anders’ product gebouwd. Dat is de val: je bouwt uiteindelijk een afhankelijkheid, geen bedrijf.

Waarom “de volgende modelversie lost het op” een fatale strategie is

Het is verleidelijk om uit te stellen. Basismodellen verbeteren elke paar maanden, dus waarom nu investeren in een eigen architectuur? Omdat volledig vertrouwen op het voortdurend verbeterende basismodel je bedrijf omzet in een tijdelijke functie op iemand anders’ roadmap. Klantloyaliteit gebouwd op “goed genoeg” is een illusie, met name in conservatieve markten — op het moment dat een aanbieder van basismodellen een superieure geïntegreerde capaciteit in jouw exacte niche uitbrengt, verdwijnt die loyaliteit van de ene dag op de andere. Zonder je eigen geheugenlaag, je eigen redeneerlogica en je eigen verificatielussen ben je geen bedrijf met een AI-product. Je bent een wrapper die wacht om geabsorbeerd te worden.

De ongemakkelijke vraag die elke CTO zou moeten stellen, is niet of de platforms jouw niche zullen overnemen — maar of jouw organisatie zich eerder kan specialiseren dan zij dat doen.

Waar de echte slotgracht zich werkelijk bevindt

De toegevoegde waarde is verschoven. Het zit niet meer in welk basismodel je aanroept — dat is steeds meer een vervangbare, gestandaardiseerde keuze tussen Claude, GPT, Gemini of een open-gewicht model zoals Llama. De slotgracht zit in de propriëtaire architectuur en datasoevereiniteit die je eromheen bouwt. Vier componenten doen het zware werk.

Het samengestelde voordeel: redeneerdrieluiken

Zet deze vier samen en er begint iets samen te stellen. Elke echte interactie genereert een redeneerdrieluik: de observatie die het systeem zag, de actie of tool-aanroep die het koos, en de consequentie — succes of mislukking. Die data verfijnt je reranker, je critic en je planner, wat betere uitkomsten oplevert, wat meer gebruik stimuleert, wat meer data oplevert. Dit is het vliegwiel dat een eenmalig integratieproject omzet in een werkelijk verdedigbaar bedrijfsmiddel — en het is precies het soort propriëtaire dataset waarmee je later kunt fijnregelen rondom elke nieuwe generatie basismodellen, in plaats van erdoor vervangen te worden.

Wat je maandagochtend kunt doen

Als je als CTO of CIO dit leest en je eigen stack herkent, vereist de oplossing geen maanlandingsproject:

1. Auditeer je AI-stack. Als het prompts plus API-aanroepen zijn en verder niets, heb je momenteel geen slotgracht.
2. Begin vandaag met het verzamelen van redeneerdrieluiken, vanuit elke expertinteractie — deze data bestaat alleen vooruitgaand, niet retroactief.
3. Implementeer een neurale reranker op je domeindata. Dit is doorgaans de eerste stap met de hoogste ROI.
4. Bouw je eerste Critic-agent. Vijftig gecureerde voorbeelden zijn voldoende voor een werkend prototype.
5. Ontkoppel je architectuur in modulaire, onafhankelijk upgradeable componenten — reranker, critic, planner en guardrails moeten elk vervangbaar zijn zonder het hele systeem te herbouwen.

De EU-hoek: waarom dit hier niet optioneel is

Alles hierboven geldt wereldwijd. Maar Europese CTO’s en CIO’s hebben een extra, zeer concrete reden om dit niet als een nice-to-have te behandelen: bijna alle architectuur staat momenteel bovenop Amerikaanse infrastructuur en Amerikaanse basismodellen — en die afhankelijkheid heeft al eens zijn kwetsbaarheid bewezen. Dit is de dimensie die uitvoerig wordt behandeld in het begeleidende artikel over AI-soevereiniteit op deze site.

Half 2026 schortte Anthropic de toegang tot zijn nieuw uitgebrachte Fable- en Mythos-modeltiers gedurende enkele weken op om te voldoen aan exportcontroles van het Amerikaanse Ministerie van Handel, voordat het Ministerie die beperkingen ophief en de toegang werd hersteld. Wat de specifieke details van dat voorval ook zijn, het is een concreet, recent en praktijkgericht bewijs van precies het risico waar dit artikel over gaat: als je volledige operatie draait op een dunne laag prompts over een in het buitenland gehost model, kan een exportcontrolebeslissing, een prijswijziging of een beleidswijziging gemaakt in Washington — niet in Brussel, en niet door jou — je kernkapaciteit met onmiddellijke ingang opschorten of duurder maken, zonder voorafgaande kennisgeving en zonder verhaal.

Dit is precies waarom Stanford’s AI Index 2026 AI-soevereiniteit omschrijft over vijf dimensies — infrastructuur, data, model, applicatie en talent — en waarom het rapport laat zien dat Europa zwaar investeert maar nog steeds achterblijft in ruwe rekenkracht en modelproductie. Een organisatie die niets heeft gebouwd behalve een promptlaag op een Amerikaans model heeft in dat scenario nul onafhankelijke invloed. Een organisatie die haar eigen RAG-en-herrangschikking-geheugen heeft gebouwd, haar eigen fine-tuned critics, haar eigen planningslogica en haar eigen guardrails — allemaal getraind op propriëtaire Europese data — kan een modelwissel overleven. Het basismodel wordt wat het altijd had moeten zijn: een vervangbaar component, niet het hele bedrijf.

Voor Europese instellingen specifiek — ziekenhuizen, juridische kantoren, financiële diensten, publieke instellingen gebonden aan de AVG en sectorspecifieke regelgeving — is dit geen abstracte risicomanagement. Het is het verschil tussen een AI-capaciteit die je beheert en een die je slechts huurt, tegen een prijs en op voorwaarden die iemand anders op elk moment kan wijzigen.

De conclusie

De vraag waarop elke CTO en CIO een eerlijk antwoord nodig heeft, is niet of ze Claude, GPT of Gemini moeten gebruiken — het is wat je eromheen hebt gebouwd. Als het antwoord “een systeem-prompt en wat function calling” is, heb je een sandbox, geen slotgracht, en een enkel punt van buitenlandse afhankelijkheid dat onder je volledige operatie ligt. Bouw de architectuur — geheugen, tools, planning, critics, guardrails — en het basismodel eronder wordt precies wat het zou moeten zijn: inwisselbaar, gestandaardiseerd en niet langer het ding waarvan je bedrijf afhankelijk is voor zijn voortbestaan.

Dit artikel put uit “The Institutional Moat: Beyond the Big Tech AI Trap” (Prof. dr. ir. J.C. Scholtes, Endeit Capital, maart 2026).

Kernpublicaties

• Bommasani et al. (2021), On the Opportunities and Risks of Foundation Models — arXiv:2108.07258
• Brown et al. (2020), Language Models are Few-Shot Learners (GPT-3) — arXiv:2005.14165
• Ouyang et al. (2022), Training Language Models to Follow Instructions with Human Feedback — arXiv:2203.02155

Verder lezen op deze site

• Wat is een AI-agent? — wat de zeven agentische componenten die je bouwt eigenlijk zijn
• Van tekst naar actie — de concrete pipeline voor het bouwen van de propriëtaire architectuur beschreven hier
• Waarom Europa eigen AI-modellen nodig heeft — de geopolitieke dimensie van waarom deze architectuur niet op buitenlandse infrastructuur kan rusten
• Het autonome bedrijf besturen — de governance-laag die er bovenop zit
• Wat er nodig is om een soevereine AI-agent te bouwen — de stapsgewijze gids die alles uit dit artikel in de praktijk brengt

Wat “AI-soevereiniteit” werkelijk betekent

De Index definieert AI-soevereiniteit als het vermogen van een staat — of, in bredere zin, een organisatie — om “bewust te handelen en onafhankelijke beslissingen te nemen over de ontwikkeling, het gebruik en het beheer van AI-systemen”, in plaats van voor kritieke capaciteit afhankelijk te zijn van externe partijen. Het rapport splitst dit op in vijf afzonderlijke lagen, en elke laag komt direct overeen met een beslissing die jouw eigen organisatie moet nemen, niet alleen een overheid:

• Infrastructuursoevereiniteit — wie de rekenkracht beheert waarop jouw modellen draaien
• Datasoevereiniteit — waar jouw data zich bevindt en wie er toegang toe heeft
• Modelsoevereiniteit — of je de modellen zelf kunt bouwen, aanpassen en beheren
• Applicatiesoevereiniteit — hoeveel controle je hebt over de systemen die bovenop zijn gebouwd
• Talentsoevereiniteit — of je de mensen hebt om dit alles te realiseren

Laten we doornemen wat de data over elk ervan zegt — en waar edge computing een rol speelt.

Infrastructuursoevereiniteit: Europa investeert, maar de kloof is reëel

Binnenlandse rekenkracht wordt “in toenemende mate gebruikt als indicator van compute-soevereiniteit” — een manier om de afhankelijkheid van buitenlandse aanbieders te verminderen en de continuïteit van toegang te waarborgen bij exportcontroles of geopolitieke verstoringen. De cijfers laten zien dat Europa snel beweegt, maar vanuit een achterstandspositie: door de staat gesteunde AI-supercomputerclusters in Europa en Centraal-Azië groeiden van 3 naar 44 tussen 2018 en 2025 — de scherpste versnelling van alle regio’s, grotendeels aangedreven door gecoördineerde inspanningen zoals de European High Performance Computing Joint Undertaking (EuroHPC JU). Dat is echte voortgang. Maar China loopt nog steeds voorop met 85 clusters, en Noord-Amerika groeide bijna zevenvoudig tot 41 in dezelfde periode.

Hier is de directe link met edge computing: infrastructuursoevereiniteit gaat niet alleen over wie de grootste trainingssupercomputer bezit. Het gaat evenzeer over waar inferentie plaatsvindt — het dagelijkse gebruik van modellen nadat ze zijn gebouwd. Een organisatie die een model traint op soevereine Europese infrastructuur, maar vervolgens elke query door een buitenlandse cloud-API moet sturen, heeft slechts de helft van het probleem opgelost. Edge- en on-premise-implementatie — modellen lokaal draaien, dicht bij waar de data wordt gegenereerd en gebruikt — is hoe infrastructuursoevereiniteit de dagelijkse operaties daadwerkelijk bereikt in plaats van een beleidsterm te blijven.

Datasoevereiniteit: Europa stelde al de wereldstandaard

Dit is het gebied waar Europa’s positie werkelijk sterk is, en de Index bevestigt dat met harde cijfers. Datalocalisatiemaatregelen — wettelijke vereisten dat data binnen de grenzen van een land wordt opgeslagen of verwerkt — zijn wereldwijd sterk gestegen sinds 2016, “samenvallend met de implementatie van de AVG in Europa en het daaropvolgende Brussels Effect, waarbij andere landen soortgelijke kaders overnamen.” Europa en Centraal-Azië hebben nu 66 dergelijke maatregelen, onderdeel van wat het rapport een hoog-lokalisatiecluster noemt, samen met Oost-Azië (77) en sub-Sahara Afrika (71). Noord-Amerika staat daarentegen op slechts 3 maatregelen.

Dat regelgevingskader is in de praktijk alleen zinvol als de infrastructuur bestaat om het te ondersteunen. AVG-niveau databeheer en edge computing zijn natuurlijke partners: gevoelige data — medische dossiers, juridische documenten, landbouwsensordata — fysiek binnen een binnenlandse of zelfs on-premise omgeving houden is veel eenvoudiger wanneer het model dat de verwerking uitvoert lokaal draait in plaats van elke query te versturen naar infrastructuur buiten de jurisdictie.

Modelsoevereiniteit: het concentratieprobleem

Modelproductie blijft sterk geconcentreerd. De data van het rapport over openbaar gepubliceerde modellen laat zien dat de Verenigde Staten in 2025 1.618 cumulatieve modelreleases bereikten, China 849, en Europa en Centraal-Azië 666 — met het VK (229) en Frankrijk (141) als de voornaamste Europese bijdragers. Europa staat wereldwijd op een verre derde plaats, hoewel de trajectorie stabiel is in plaats van stagnerend.

Dit doet er toe omdat modelsoevereiniteit bepaalt of een organisatie een model werkelijk kan aanpassen aan het eigen domein — fijnregelen op propriëtaire juridische, medische of landbouwdata, bijvoorbeeld — in plaats van beperkt te zijn tot wat een buitenlands general-purpose model toevallig ondersteunt. Open-source raamwerken hebben de drempel verlaagd, en dat is precies waarom kleinere, gespecialiseerde modellen — het soort dat realistisch aan de edge kan draaien, op bescheiden hardware, dicht bij de data — een levensvatbare Europese strategie worden in plaats van een bijzaak.

Applicatiesoevereiniteit: hier heeft Europa echte ruimte om te concurreren

Opvallend genoeg merkt het rapport op dat de applicatielaag — hoe AI daadwerkelijk wordt ingezet binnen specifieke sectoren zoals gezondheidszorg, financiën of landbouw — “minder geconcentreerd is dan de model- of rekenlaag,” waardoor landen “meer ruimte hebben… om niche-specialisaties te ontwikkelen.” Duitslands kracht ligt in industriële en productietoepassingen; Estlands in onderwijstechnologie. Dit is precies de laag waarop een kleinere, soevereiniteitsbewuste Europese organisatie kan concurreren op domeindiepte in plaats van op ruwe modelschaal — wat opnieuw een voordeel is voor een edge-geschikte, domeinspecifieke implementatie boven een one-size-fits-all cloud-API.

Talentsoevereiniteit: een stille waarschuwing

De vijfde dimensie — het vermogen om AI-talent te ontwikkelen en te behouden — laat een minder zichtbare maar structureel belangrijke trend zien: grensoverschrijdende AI-talentcirculatie is wereldwijd vertraagd, waarbij zowel in- als uitstroom afnemen, wat betekent dat talent steeds meer binnen nationale of regionale systemen blijft. Voor Europa snijdt dit aan twee kanten — behouden talent is talent dat niet verloren gaat aan de VS, maar het betekent ook dat de regio er niet simpelweg van uit kan gaan dat ze zich een weg uit een capaciteitskloof kan importeren. Het opbouwen van de binnenlandse expertise om soevereine AI-infrastructuur te ontwerpen, te implementeren en te onderhouden maakt zelf deel uit van de soevereiniteitsversterking.

Waarom dit leidt tot “draai het zelf, dicht bij huis”

Zet deze vijf dimensies samen en er ontstaat een helder strategisch beeld voor Europese organisaties, niet alleen Europese overheden:

1. Je opereert al onder enkele van de strengste gegevensbeschermingsvereisten ter wereld (datasoevereiniteit) — maar dat kader bijt pas als jouw infrastructuurkeuzes de verwerking daadwerkelijk lokaal houden.
2. De rekenkracht wordt gebouwd (infrastructuursoevereiniteit) — Europese supercomputercapaciteit groeide sneller dan in enige andere regio tussen 2018 en 2025 — maar trainingscapaciteit alleen helpt niet als elke inferentie-aanroep de regio nog steeds verlaat.
3. Open-source modellen hebben de drempel voor modelsoevereiniteit verlaagd — wat betekent dat kleinere, gespecialiseerde, fijn-afstembare modellen realistisch zijn, zelfs voor organisaties ver onder de staatsschaal.
4. De applicatielaag is waar Europa echt kan winnen — domeinspecifieke implementatie, niet algemene schaal, is de concurrentieopening waar de data op wijst.

Edge computing is het praktische mechanisme dat alle vier samenvoegt. Het is wat een compliance-gevoelige sector — gezondheidszorg, juridische dienstverlening, landbouw — in staat stelt daadwerkelijk te profiteren van Europa’s regulatoire kracht in plaats van erdoor ondermijnd te worden, omdat de data en het model nooit het gebouw hoeven te verlaten, laat staan de jurisdictie.

De conclusie

De Stanford AI Index gebruikt de term “edge computing” niet, maar zijn eigen soevereiniteitskader maakt er impliciet en herhaaldelijk het geval voor: soevereiniteit is alleen reëel wanneer die helemaal doorloopt tot waar inferentie daadwerkelijk plaatsvindt. Voor Europa specifiek — met werkelijk sterke gegevensbeschermingswetgeving, snel groeiende maar nog steeds tweede-tier rekenkracht, een groeiende basis van open, aanpasbare modellen, en een echte opening op de applicatielaag — is het draaien van eigen modellen op eigen infrastructuur, zo dicht bij de edge als de use case vraagt, geen defensieve of nostalgische keuze. Het is de versie van de strategie die de data daadwerkelijk ondersteunt.

Bron: Stanford HAI, 2026 AI Index Report, hoofdstuk 8.3, “AI Sovereignty.”

Kernpublicaties

• Stanford HAI (2026), AI Index Report — hai.stanford.edu/ai-index
• Bommasani et al. (2021), On the Opportunities and Risks of Foundation Models — arXiv:2108.07258
• European Commission (2024), EU Artificial Intelligence Act — eur-lex.europa.eu

Verder lezen op deze site

• De institutionele slotgracht — hoe je architectuur bouwt die een modelwissel of exportcontrolebeslissing overleeft
• Het autonome bedrijf besturen — soevereiniteit en governance als één vraag, niet twee
• David tegen Goliath: klein model versus frontier — het bewijs dat kleine, lokale modellen bijna frontier-prestaties kunnen halen op specifieke taken
• Wat er nodig is om een soevereine AI-agent te bouwen — de praktische achtstapdsgids voor het bouwen van een systeem dat jouw organisatie werkelijk bezit

Waarom het model niet jouw slotgracht is

Het is verleidelijk te denken dat een sterk LLM koppelen aan een systeem-prompt bouwen aan een agent is. Dat is het niet. Volledig vertrouwen op systeem-prompts en Markdown-“skill files” geeft je slechts oppervlakkige controle — je behandelt het model als een black box en bouwt, nog belangrijker, een afhankelijkheid op van iemand anders’ roadmap in plaats van van een eigen systeem. Veel teams die beweren een agent te hebben “gebouwd”, hebben in werkelijkheid alleen instructietekst over een general-purpose model gelegd. Dat is de God-Prompt-val, en die is kwetsbaar: rigide als-dan-regels kunnen de oneindige lange staart van uitzonderingen die echte tekstmining en operaties bevatten, niet omvatten.

Het echte concurrentievoordeel — de slotgracht — zit helemaal niet in het onderliggende LLM. Big Tech-modellen zijn generalisten: ze beheersen meerstapsredeneerketens, native tool-integratie en recursieve zelfverbetering, maar wat je via hun API’s krijgt, is grotendeels een sandbox — systeem-prompts, function calling en standaard vectorzoekopdrachten. Als de waarde van jouw bedrijf puur gebonden is aan welk model je ook aanroept, sta je in de weg van een vloedgolf: de volgende modelupdate kan simpelweg absorberen wat jij hebt gebouwd. De slotgracht zit in de architectuur rondom het model — en die architectuur moet getraind zijn op jouw tekst.

Stap 1: Van ruwe tekst naar gestructureerde JSON

Ruwe tekst — zeker uit PDF’s — is gebouwd voor menselijke ogen, niet voor machineredenering. Een LLM dat een vlakke tekstdump leest, kan niet betrouwbaar een hoofdstuktitel onderscheiden van een technische definitie, of een waarschuwingslabel van een procedurestap. Die ambiguïteit is precies wat downstream agentische componenten laat breken, dus de eerste echte engineeringstap is het omzetten van ongestructureerde tekst in een hiërarchisch, machine-leesbaar JSON-schema — een “foundationele ontologie” die expliciet hoofdstukken koppelt aan subonderwerpen, definities en procedures.

Deze stap doet er meer toe dan het lijkt, omdat fouten zich voorplanten. Als de JSON-conversie de hiërarchie platslaat of niet-gerelateerde alinea’s samenvoegt:

• RAG-chunks verliezen hun bovenliggende context — een opgehaalde procedure zoals “beëindig het kwaadaardige proces” kan stilzwijgend het feit verliezen dat deze alleen op één specifiek scenario van toepassing is, en de reranker downstream kan het juiste antwoord niet naar boven halen.
• Sequentiële workflows worden in de verkeerde volgorde aangeleerd — als de Fase 1/2/3-structuur niet behouden blijft, kan de fine-tuned planningslaag van een agent leren stap 3 vóór stap 1 uit te voeren.
• Kennisgrafen verliezen hun verbindingen — entiteitsrelaties die niet hiërarchisch zijn vastgelegd, kunnen later geen multi-hop-redenering ondersteunen.
• RLHF-voorkeursparingen verliezen hun rechtvaardiging — zonder de omringende context kan een Critic-agent niet beoordelen of een actie daadwerkelijk een regel heeft geschonden.

Zorg één keer, vroeg in het proces, voor de juiste structuur, en elke downstream trainingspipeline profiteert ervan. Doe het fout, en elk downstream component erft de fout.

Stap 2: Geheugen — RAG en neurale herrangschikking als bedrijfsgeheugen

Zodra je tekst gestructureerd is, wordt die de ruggengraat van het geheugen van de agent. De mechanismen zijn bekend, maar het loont de moeite er precies over te zijn:

1. Chunking — splits lange documenten op in semantisch samenhangende secties (circa 500 woorden is een veelgebruikt doel), geen willekeurige stukken van vaste lengte.
2. Indexering — zet chunks om in vectoren en sla ze op in een vectordatabase (Pinecone, pgvector, Azure AI Search).
3. Retrieval — haal bij een query de meest relevante chunks op.
4. Augmentatie — instrueer het model om uitsluitend die opgehaalde bronnen te gebruiken.
5. Generatie — produceer een geciteerd, feitelijk antwoord.

Een gewone vectorzoekopdracht vindt dingen die gelijkaardig zijn; het vindt niet betrouwbaar het ding dat correct is. Dat is de taak van een neurale reranker — een fine-tuned cross-encoder getraind op je eigen query/beste-antwoord-paren, die de top 50-100 kandidaten opnieuw bekijkt en het werkelijke “doorslaggevende” antwoord naar positie één duwt. Dit vermindert hallucinaties drastisch en lost het “lost in the middle”-probleem op waarbij een model dat begraven is in twintig vergelijkbare chunks het ene relevante chunk mist. Dit goed opbouwen vereist echte infrastructuurkeuzes: een sterk embeddingmodel (bezuinig hier niet op — een slechte vertaler levert slechte zoekopdrachten op), een orkestratieraamwerk zoals LlamaIndex of LangChain om bestanden, database en model te verbinden, en een betrouwbare documentparser voor de rommelige PDF’s waarmee je begint.

Stap 3: Tools — tekst omzetten in operationele ledematen

Skills en tools zijn de “ledematen” van een agentische architectuur — gestructureerde definities (API-schema’s, JSON-functies, SQL-interfaces) waarmee een model kan handelen in plaats van alleen praten. Propriëtaire interne API’s zijn waar dit een echte bedrijfsslotgracht wordt: een general-purpose model van een grote aanbieder is juridisch en technisch geblokkeerd van het aanraken van jouw interne systemen, hoe slim het ook is. Een agent die is aangesloten op jouw eigen elektronisch patiëntendossier, CRM of monitoringtools kan echte historische waarden ophalen, ze kruislings raadplegen en handelen op basis van live context in plaats van te gokken vanuit voorgetrainde gewichten.

Dit is ook waar multi-hop-orkestratie noodzakelijk wordt in plaats van optioneel. Complexe professionele taken lossen zelden op in één zoekopdracht — een agent die een HR-database (wie heeft dienst), een monitoringtool (huidige belasting) en een uitvoeringstool (herstart de service) aan elkaar koppelt, voert een OODA-lus uit: waarnemen, oriënteren, beslissen, handelen, en herhalen totdat het doel bereikt is, waarbij het plan wordt aangepast naarmate elke tool-aanroep nieuwe informatie teruggeeft.

Stap 4: Redenering en een digitale peer reviewer

Planningsraamwerken zoals Chain-of-Thought, Tree-of-Thought en Skeleton-of-Thought geven een groot model ruimte om een taak op te splitsen in subdoelen met afhankelijkheden in plaats van in één stap te antwoorden. Maar een groot, algemeen model dat een eerste versie genereert, profiteert nog steeds van een tweede, veel kleiner en gespecialiseerder model dat het beoordeelt — een Critic — fine-tuned specifiek op de correcties van jouw eigen organisatie.

De trainingsdata voor die critic is concreet en verzamelbaar: de afgewezen of bewerkte ruwe uitvoer, de door experts gecorrigeerde versie, de reden voor de correctie (“schendt artikel 4.2”), en eventuele harde negatieve beperkingen of compliance-grenzen. Als ruwe schaalrichtlijn: 50-100 voorbeelden levert een prototype op, 500-1.000 een productiewaardige critic, en 2.000+ begint echte domeinexpertise te benaderen. Dit is precies het soort propriëtaire, praktijkgerichte correctiedata waartoe een general-purpose LLM-aanbieder nooit toegang zal hebben — en dat is precies waarom het een duurzaam voordeel is in plaats van een tijdelijk.

Stap 5: Guardrails — waar institutioneel vertrouwen werkelijk vandaan komt

Hallucinatie- en compliancerisico is de grootste enkelvoudige drempel voor echte institutionele AI-adoptie, dus de architectuur heeft onafhankelijke verificatielagen nodig rondom het kernmodel, niet daarin ingebakken:

• Feitencontrole — vergelijk elk concept met de RAG-waarheidsbron; elke bewering moet citeerbaar zijn.
• Veiligheidsfilters — handhaving van juridische, ethische en compliance-beperkingen, waarbij uitvoer die gedefinieerde grenzen overschrijdt, wordt geblokkeerd.
• Zelfconsistentiecontroles — voer dezelfde query uit via meerdere redeneerroutes en verwerp antwoorden die het niet met elkaar eens zijn.

Niets hiervan mag volledig worden gedelegeerd aan een andere instantie van hetzelfde probabilistische model dat zichzelf bewaakt. Deterministische, hardgecodeerde controles — invoerbeveiliging voordat een prompt de hoofdagent ook maar bereikt, strikte schema-handhaving op uitvoer — bieden het vangnet dat een puur LLM-gebaseerde critic niet kan garanderen.

Het vliegwiel

Zet deze onderdelen samen en er gebeurt iets samengesteld. Elke echte interactie genereert een redeneerdrieluik: de observatie die het systeem zag, de actie of tool-aanroep die het koos, en de consequentie — succes of mislukking. Die data blijft niet liggen; ze verfijnt je rerankers, je critics en je planners, wat betere uitkomsten oplevert, wat meer gebruik stimuleert, wat meer data oplevert. Dit is het vliegwiel dat een eenmalig tekstminingproject omzet in een samengesteld, verdedigbaar bedrijfsmiddel — en het is precies de dataset die je later in staat stelt om te fijnregelen rondom elke nieuwe generatie basismodellen, in plaats van erdoor vervangen te worden.

De conclusie

Tekst omzetten in agentische trainingsdata is geen enkele technische truc — het is een pipeline: structureer de tekst in een getrouwe JSON-hiërarchie, gebruik die hiërarchie om een echte geheugenlaag te bouwen (RAG plus herrangschikking), extraheer de API-definities die de agent handen geven, verzamel de correctiedata die een critic traint, en omhul dat alles met deterministische guardrails. Doe dit goed met je eigen propriëtaire tekst, en je huurt geen intelligentie van een basismodelleverancier — je bouwt een architectuur, en een dataset, die waardevoller wordt elke keer dat die wordt gebruikt.

Voor een concreet domeinvoorbeeld van deze exacte pipeline* toegepast op agrarische logboeken en institutionele kennis, zie Van de volgende boerenknecht naar de volgende AI-agent.*

Kernpublicaties

• Lewis et al. (2020), Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks — arXiv:2005.11401
• Ouyang et al. (2022), Training Language Models to Follow Instructions with Human Feedback (InstructGPT) — arXiv:2203.02155
• Rafailov et al. (2023), Direct Preference Optimization — arXiv:2305.18290

Verder lezen op deze site

• Wat is een AI-agent? — wat de zeven componenten die hier worden getraind eigenlijk zijn
• Van logboeken naar agent-trainingsdata — dezelfde pipeline toegepast op een echte agrarische kennisbase
• David tegen Goliath: klein model versus frontier — wat een goed getraind gespecialiseerd model zo gebouwd kan bereiken
• De institutionele slotgracht — waarom het bouwen van deze propriëtaire architectuur er strategisch toe doet

Agents bestaan al langer dan je denkt

Nog voor ChatGPT definieerde Artificial Intelligence: A Modern Approach (Russell & Norvig, 1995) een agent als alles wat:

1. zijn omgeving waarneemt,
2. invoer uit die omgeving percipieert,
3. over die invoer redeneert, en
4. via acties op de omgeving inwerkt.

Die definitie vermeldt taalmodellen niet — ze omvat thermostaten, robots, webcrawlers en zelfrijdende auto’s. Wat een gewoon “computerprogramma” onderscheidt van een agent, is dat een agent autonoom opereert, voortduurt in de tijd, zich aanpast aan verandering en doelen nastreeft in plaats van simpelweg één instructie uit te voeren en te stoppen.

In de late jaren negentig was “agent” overal — intelligente agents, software-agents, persoonlijke digitale assistenten. Ze werden gebouwd op symbolische AI, expertsystemen en regelgebaseerde redenering. En ze slaagden er grotendeels niet in de hype waar te maken. API’s waren primitief, het web was nauwelijks programmatisch toegankelijk, geheugen was statisch en taalbegrip beperkte zich tot het herkennen van trefwoorden. De concepten — geheugen, doelen, planning, een interface met de wereld — waren solide. De technologie om ze te laten werken was er simpelweg nog niet.

Wat er veranderde: het LLM is de ontbrekende motor

Een handig mentaal model: denk aan een losstaand LLM als een hersenen in een pot. Het kan redeneren in taal, maar heeft geen lichaam, geen zintuigen buiten de tekst die je het geeft, en geen geheugen zodra het gesprek eindigt. Een agent geeft dat brein:

• een lichaam — tools die het kan aanroepen om in de wereld te handelen,
• zintuigen — retrievalsystemen en API’s die verse informatie aanleveren,
• geheugen — contextvensters en externe databases, en
• doelen — een planner die bepaalt wat er als volgende moet gebeuren.

Dat is het moment waarop een taalmodel ophoudt een welbespraakte autocomplete te zijn en iets wordt dat kan handelen.

Dit is belangrijk omdat losstaande LLM’s reële, goed gedocumenteerde beperkingen hebben: ze hallucineren zelfverzekerd, hun kennis heeft een afkapdatum, hun contextvenster is eindig, ze kunnen niet zelfstandig het web raadplegen of een API aanroepen, ze redeneren slecht in één stap over meerstapsproblemen, en ze hebben geen ingebouwde manier om hun eigen fouten op te merken of te corrigeren. Agentische architectuur elimineert deze beperkingen niet — maar geeft je wel het raamwerk om ermee om te gaan.

De zeven dingen die een agentarchitectuur nodig heeft

Of je nu naar een symbolisch systeem uit de jaren negentig kijkt of een LLM-gebaseerd systeem uit 2026, een werkende agentarchitectuur heeft steeds dezelfde zeven ingrediënten nodig:

• Geheugen (kort- en langetermijn)
• Toegang tot kennis
• Gebruik van tools / uitvoering van acties
• Planning & besturingslus
• Doelbeheer
• Verificatie & guardrails
• Een gebruikers-/systeeminterface

Wat er veranderd is, is niet de lijst — maar de kracht achter elk onderdeel. Laten we de onderdelen doorlopen die er in de praktijk het meest toe doen.

Waarom dit er nu toe doet

Niets hiervan is bereikbaar met alleen eenvoudige retrieval. Overweeg vier voorbeelden van wat agentische architecturen mogelijk maken die gewone RAG niet kan:

• Autonoom onderzoek en synthese — het plannen van meerstapsquery’s over medische, juridische en financiële domeinen, het identificeren van conflicterende studies, en het produceren van een gestructureerd rapport zonder dat een mens elke stap aanstuurt.
• End-to-end probleemoplossing — een probleem diagnosticeren via gesprek, diagnostische API’s aanroepen om systeemlogboeken te controleren, en autonoom een oplossing uitvoeren.
• Strategische beslissingsondersteuning — een brede vraag zoals “analyseer ons marktuitbreidingsrisico” opsplitsen in subquery’s, live concurrentiedata ophalen, berekeningen uitvoeren en strategie aanpassen naarmate bevindingen binnenkomen.
• Forensics en compliancemonitoring — continu logboeken of communicatie bewaken op patronen van zorgelijk gedrag en escalatie activeren wanneer drempelwaarden worden overschreden.

Geen van deze taken is eenmalige tekstgeneratie. Ze vereisen geheugen over stappen heen, tools die de echte wereld bereiken, een plan dat kan worden herzien, en een mechanisme om de eigen fouten van het systeem op te vangen voordat ze andermans probleem worden.

De conclusie

Een AI-agent is geen chatbot met een langer geheugen, en het is ook geen rebrand van een regelgebaseerd systeem uit de jaren negentig. Het is wat er gebeurt wanneer een taalmodel — voor het eerst werkelijk in staat tot open-ended redenering — wordt gewikkeld in dezelfde zeven componenten die AI-onderzoekers dertig jaar geleden al identificeerden: geheugen, kennistoegang, gebruik van tools, planning, doelbeheer, verificatie en een interface om door te handelen. De concepten zijn niet veranderd. Wat veranderde, is dat we eindelijk een motor hebben die krachtig genoeg is om ze te laten werken.

Dit artikel is een overzicht op hoog niveau. Latere artikelen in deze reeks gaan dieper in op specifieke componenten — RAG-architecturen en neurale herrangschikking, multi-agent-orkestratie en governance en de trainingsdata die nodig is om deze componenten te specialiseren.

Kernpublicaties

• Russell & Norvig (2020), Artificial Intelligence: A Modern Approach (4e druk) — norvig.com/aima.html
• Yao et al. (2022), ReAct: Synergizing Reasoning and Acting in Language Models — arXiv:2210.03629
• Wang et al. (2023), A Survey on Large Language Model Based Autonomous Agents — arXiv:2308.11432

Verder lezen op deze site

• Van tekst naar actie: NLP-pipelines omzetten in agentische workflows — hoe je de trainingsdata bouwt achter elk van deze componenten
• Het autonome bedrijf besturen — wie verantwoordelijk is als de agent handelt
• Waarom NLP eindelijk werkt — de transformer-architectuur die agents mogelijk maakte
• De institutionele slotgracht — waarom de architectuur rondom het model er meer toe doet dan het model zelf

Waarom dit überhaupt mogelijk is

Elk getraind model trekt een beslissingsgrens door een extreem hoog-dimensionale ruimte, die “panda” scheidt van “gibbon,” of “positieve recensie” van “negatieve recensie.” Die grens wordt geleerd uit data en wordt gevormd door welke correlaties er toevallig bestaan in de trainingsset — niet noodzakelijk door dezelfde kenmerken die een mens zou gebruiken om hetzelfde onderscheid te maken. Een adversarial attack werkt door het kortste mogelijke pad over die grens te vinden: een kleine, bewust berekende verstoring van de invoer die die net voorbij de andere kant duwt, zonder iets te veranderen wat een mens zou opmerken. De kwetsbaarheid is geen bug in één bepaald model — het is een structureel gevolg van hoe deze beslissingsgrenzen in de eerste plaats worden geleerd, wat verklaart waarom het probleem opduikt in verschillende modeltypes en domeinen.

Adversariale aanvallen op afbeeldingen

Gradient-gebaseerde perturbatieaanvallen. De klassieke aanpak — de Fast Gradient Sign Method en zijn meer iteratieve opvolger, Projected Gradient Descent — berekent de gradient van het verlies van het model ten opzichte van de invoerpixels in plaats van de gewichten van het model, en stuurt elke pixel een kleine hoeveelheid in de richting die het verlies het snelst verhoogt (d.w.z. het model het meest fout maakt). Omdat de verstoring over de hele afbeelding is verspreid en binnen een kleine grens blijft, is het onwaarneembaar voor een menselijke toeschouwer terwijl het precies is afgesteld om de beslissingsgrens van het model te overschrijden.

Patch-aanvallen. In plaats van een hele afbeelding subtiel te verstoren, plaatst een patch-aanval één kleine, goed zichtbare, vaak vreemd uitziende sticker of regio ergens in het beeld — op een stopbord, op een kledingstuk, in de hoek van een foto — die betrouwbaar een gerichte misclassificatie veroorzaakt, ongeacht al het andere in de afbeelding. In tegenstelling tot gradient-gebaseerde verstoringen zijn deze vaak robuust tegen gefotografeerd worden vanuit verschillende hoeken en afstanden, wat ze tot een praktisch probleem maakt in de fysieke wereld (een gewijzigd stopbord dat een zelfrijdend systeem leest als een snelheidsbord) in plaats van alleen een digitale curiositeit.

Black-box en transfer-aanvallen. Beide aanvalsfamilies hierboven gaan ervan uit dat de aanvaller toegang heeft tot de interne werking van het model om gradients te berekenen. In de praktijk hebben veel echte aanvallen dat niet nodig: adversariale voorbeelden gemaakt tegen één model transferren regelmatig en misleiden een ander model getraind op vergelijkbare data, zelfs zonder toegang tot de gewichten van dat tweede model. Dit is wat de dreiging praktisch maakt in plaats van puur academisch — een aanvaller hoeft je exacte model niet te stelen om het aan te vallen.

Adversariale aanvallen op tekst

Tekst is discreet — je kunt een woord niet met 0,1% aanpassen zoals je de helderheid van een pixel kunt aanpassen — dus text-based adversarial attacks zien er structureel anders uit, maar het onderliggende doel is identiek: verander de invoer zo weinig en zo onopvallend mogelijk terwijl de uitvoer van het model wordt omgekeerd.

Verstoringen op tekenniveau. Het verwisselen van visueel vergelijkbare tekens, het invoegen of verwijderen van een teken, of het introduceren van veelvoorkomende typefouten kan de uitvoer van een classifier omgooien terwijl het perfect leesbaar blijft voor een mens — “excellent” wordt “excel1ent” of “exceellent,” en het vertrouwen van een sentimentclassifier stort in hoewel geen redelijke lezer het woord verkeerd zou lezen.

Word-level substitutieaanvallen. Een geavanceerdere familie van aanvallen vervangt afzonderlijke woorden door nauwe synoniemen — specifiek gekozen om de werkelijke betekenis van de zin voor een menselijke lezer te bewaren, terwijl die net genoeg verschuift in de embedding-ruimte van het model om een beslissingsgrens te overschrijden. Omdat de vervanging semantisch getrouw is, zijn deze moeilijker te onderscheppen met een eenvoudig spellingfilter.

Universal adversarial triggers. In plaats van voor elke individuele invoer een maatwerk-verstoring te maken, ontdekken sommige aanvallen een korte reeks woorden of tokens die, wanneer toegevoegd aan bijna elke invoer, het model betrouwbaar naar een specifieke verkeerde uitvoer duwt — een soort herbruikbare “skeletsleutel” voor een bepaald model, in plaats van een eenmalige aanval op één zin.

Prompt injection (de LLM-specifieke variant). In agentische systemen is een toenemend relevante variant prompt injection: tekst ingebed in een document, webpagina of tool-uitvoer die een taalmodel leest als onderdeel van zijn context — niet iets wat de eigenlijke gebruiker heeft getypt — maar die is opgesteld om te lijken op een instructie die het model moet opvolgen. Dit is structureel dezelfde onderliggende kwetsbaarheid als klassieke adversariale tekstaaanvallen (een zorgvuldig gekozen invoer duwt het model ergens heen waar het niet zou moeten zijn), toegepast op de specifieke zwakte van een systeem dat niet altijd onderscheid kan maken tussen “data die ik lees” en “instructies die ik moet opvolgen.”

Wat werkelijk werkt als verdediging

Geen enkele techniek lost dit volledig op, wat verklaart waarom echte implementaties er meerdere combineren:

Adversarial training. De meest directe verdediging: bewust adversariale voorbeelden genereren tijdens training en deze in de trainingsset opnemen, zodat het model een beslissingsgrens leert die niet zo gemakkelijk te overschrijden is door kleine verstoringen. Dit kan worden uitgebreid met bredere data-augmentatie — willekeurig ruis, handgemaakte negaties, synonymvervanging en algemene diversiteit van de trainingsset — zodat het model niet overfit aan een smal, kwetsbaar begrip van hoe “normale” invoer eruitziet.

Defensive distillation en feature squeezing. Een kleinere studentmodel trainen op de softened uitvoerdistributie van een docent heeft de neiging een vloeiendere, minder strak gevouwen beslissingsgrens te produceren die moeilijker te benutten is met een kleine, precies berekende druk. Feature squeezing werkt op een verwante maar directere manier: het reduceert de vrijheidsgraden van de invoer voordat het model die ooit ziet — voor afbeeldingen kan dit betekenen dat de kleurdiepte wordt verlaagd of milde afvlakking wordt toegepast; voor tekst, het normaliseren van spellingvarianten en tekenvervangingen vóór classificatie — specifiek om de fijnmazige ruimte in te krimpen die een aanvaller nodig heeft.

Invoertransformaties en randomisatie. Technieken zoals lichte beeldcompressie, bijsnijden of aanpassen van de grootte vóór classificatie kunnen de zeer precieze pixelberekeningen verstoren waarvan een adversariale verstoring afhankelijk is, zonder een echte afbeelding zinvol te beïnvloeden. Aan de tekstkant dient spelling-normalisatie een vergelijkbaar doel tegen aanvallen op tekenniveau.

Ensembles. Dezelfde invoer door meerdere onafhankelijk getrainde modellen sturen en overeenstemming vereisen (of gebrek daaraan markeren) verhoogt de drempel voor een aanvaller aanzienlijk, omdat een verstoring gemaakt om één specifiek model te misleiden vaak niet schoon transfert naar een anders getraind model met een andere grens.

Detectie in plaats van pure preventie. In plaats van te proberen een model onvoorwaardelijk robuust te maken voor elke mogelijke verstoring, kan een aparte detectielaag invoer markeren die statistisch ongewoon lijkt — eigenaardige hoog-frequente ruispatronen in een afbeelding, ongewone tekstreeksen — en deze doorsturen voor aanvullend onderzoek voordat ze ooit een beslissing bereiken.

Voor agentische systemen specifiek: invoerbewaking en deterministische guardrails. Omdat prompt injection de grens tussen “data” en “instructies” benut, is de meest effectieve verdediging niet het taalmodel vragen om zichzelf te bewaken — het is het routeren van niet-vertrouwde invoer (documenten, webinhoud, tool-uitvoer) door een aparte, deterministische controle vóór die de hoofd-redeneermotor bereikt, en alles wat eruitziet als een ingebedde instructie standaard als verdacht behandelen in plaats van als een legitiem commando.

De rode draad

Elke verdediging doet eigenlijk hetzelfde: de beslissingsgrens van het model soepeler maken, minder gevoelig voor kleine of nauwkeurig gerichte veranderingen, en minder vertrouwend op een enkel niet-geverifieerd signaal. Geen van hen maakt een model perfect onbreekbaar — dit blijft een genuanceerd actieve wapenwedloop tussen aanvals- en verdedigingsonderzoek, op zowel afbeeldingen als tekst — maar het combineren van meerdere van deze technieken (adversariale training plus distillation plus invoernormalisatie plus detectie) verhoogt de kosten en moeilijkheid van een succesvolle aanval zinvol, wat in de meeste echte implementaties precies het praktische doel is.

Kernpublicaties

• Goodfellow et al. (2014), Explaining and Harnessing Adversarial Examples (FGSM) — arXiv:1412.6572
• Madry et al. (2017), Towards Deep Learning Models Resistant to Adversarial Attacks (PGD) — arXiv:1706.06083
• Wallace et al. (2019), Universal Adversarial Triggers for Attacking and Analyzing NLP — arXiv:1908.07125

Verder lezen op deze site

• De gigant inkrimpen: pruning, quantization en distillation — hoe modelcompressie als neveneffect een hele klasse adversarial attacks buitensluit
• Waarom je een model niet kunt fine-tunen of destilleren zonder XAI — hoe LIME-gebaseerde vóór/ná-testen adversariale kwetsbaarheid detecteert die door fine-tuning is geïntroduceerd
• Het autonome bedrijf besturen — de governance-laag die beveiligingsdreigingen in institutionele AI-implementaties aanpakt
• De institutionele slotgracht — waarom deterministische guardrails rondom een model er meer toe doen dan een model vragen zichzelf te bewaken
• Wat is een AI-agent? — de agentische architectuur waar prompt injection specifiek een bedreiging wordt

Drie woorden die geen synoniemen zijn

Beoefenaars gebruiken “transparantie”, “interpreteerbaarheid” en “uitlegbaarheid” vaak door elkaar, maar ze betekenen werkelijk verschillende dingen:

• Transparantie bestaat wanneer het proces dat modelparameters extraheert uit trainingsdata, en labels genereert uit testdata, kan worden beschreven en gerechtvaardigd door de persoon die de aanpak ontwierp.
• Interpreteerbaarheid is het vermogen het model te begrijpen en de basis voor zijn besluitvorming te presenteren op een manier die een mens werkelijk kan volgen.
• Uitlegbaarheid — een term waarover nog geen volledige consensus bestaat in het vakgebied — is het best te begrijpen als de set kenmerken uit een interpreteerbaar domein die bijdroegen aan een specifieke beslissing voor een specifiek voorbeeld.

Het onderscheid doet er praktisch toe: je kunt een transparant proces hebben (je weet precies welk algoritme je gebruikte en waarom) zonder een interpreteerbaar model te hebben (je kunt nog steeds geen enkele individuele beslissing uitleggen).

Wat telt werkelijk als een geldige uitleg?

Dit verdient serieuze aandacht als een werkelijk menselijke, sociale vraag, niet alleen een technische. Een geldige uitleg is onderdeel van een sociale interactie — die moet deugdelijk, overtuigend en begrijpelijk zijn, en vertrouwen wekken bij de ontvanger, gegeven als een stapsgewijze overdracht van kennis die ze werkelijk kunnen volgen. Daarnaast moet een goede uitleg het verschil laten zien tussen mogelijke uitkomsten (waarom dit antwoord in plaats van dat), relevant zijn voor wat de persoon werkelijk wil weten, en — belangrijk — mag onvolledig zijn. Het benadrukken van een paar relevante voorbeelden is vaak voldoende; een uitleg hoeft niet volledig uitputtend te zijn om nuttig te zijn.

De fundamentele afruil: nauwkeurigheid versus uitlegbaarheid

Er bestaat een bekende, ruwe hiërarchie van modelfamilies, van sterk interpreteerbaar maar vaak minder krachtig (beslisbomen, lineaire/logistische modellen, eenvoudige statistische modellen) tot sterk nauwkeurig maar veel moeilijker te interpreteren (deep learning, ensemblemethoden, grote neurale netwerken). Drie brede strategieën bestaan om met deze afruil om te gaan:

1. Interpreteerbare modellen — technieken die inherent gestructureerde, causale, interpreteerbare modellen leren.
2. Diepe uitleg — aangepaste deep learning-technieken die specifiek ontworpen zijn om uitlegbare kenmerken te leren als onderdeel van training.
3. Model induction — technieken die een uitlegbaar model afleiden van elk ander model, puur behandeld als een black box.

De meeste praktische tools hieronder vallen in de derde categorie — ze vereisen niet dat je je architectuur wijzigt, alleen dat je die achteraf ondervraagt.

De praktische XAI-gereedschapskist

Waarom dit niet langer optioneel is als je zelf het model traint

Alles hierboven is nuttig voor het begrijpen van elk model, inclusief een model dat je alleen via een API aanroept. Het wordt een werkelijke vereiste — geen nice-to-have — op het moment dat je zelf fine-tunet, destilleert of een component traint, om meerdere concrete redenen.

Fine-tuning en distillation kunnen veranderen hoe een model beslist zonder te veranderen of het het juiste antwoord geeft. Zoals behandeld in het eerdere artikel over pruning, quantization en distillation, is een gedestilleerd studentmodel getraind om de verzachte uitvoerdistributie van een teacher te matchen — maar het matchen van de uitvoerdistributie garandeert niet dat de student via dezelfde redeneerroute aankwam. Een validatienauwkeurigheidsscore die identiek lijkt voor en na distillation kan een werkelijk ander — en mogelijk minder betrouwbaar — beslissingsproces verbergen. XAI-tools zijn hoe je dit daadwerkelijk controleert.

Dit verbindt direct met de “getrouwheid versus plausibiliteit”-val. Een methode als LIME is specifiek gebouwd om een vereenvoudigde, voor mensen aangenaam lokale benadering te produceren. Dat roept een ongemakkelijke vraag op: als je de uitleggen van je fine-tuned model controleert en ze redelijk lijken, verifieer je dan dat het model werkelijk op die manier redeneerde, of genereer je gewoon een geruststellende post-hoc rationalisatie? Dit is precies waarom een serieus verificatieproces voor een zelf-getraind model meer dan één XAI-methode nodig heeft.

Fine-tuning kan nieuwe adversariale kwetsbaarheid introduceren die een schone validatieset niet zal onthullen. Zoals behandeld in het eerdere artikel over adversariale aanvallen, kan een model dat fine-tuned is op een engere dataset gevoeliger worden voor kleine, betekenisbehoudende verstoringen. Er is een concrete detectiemethode die het waard is als standaardstap te adopteren: voer LIME uit op een voorbeeld vóór een adversariale verstoring, pas de verstoring toe, voer dan LIME opnieuw uit. Als de uitleg sterk verschuift, is dat een direct signaal van adversariale gevoeligheid.

Regelgevings- en governance-kaders vereisen dit expliciet. Zoals behandeld in de eerdere artikelen over AI-governance en bias-analyse onder het Algoritmekader, is het kunnen tonen waarom een specifieke beslissing werd genomen — niet alleen dat het systeem gemiddeld goed presteert — vaak een wettelijke vereiste. Een fine-tuned of gedestilleerd model dat wordt ingezet in een publieke-sector-, medische of financiële context moet precies dit soort per-beslissing-uitleg ondersteunen.

Een praktische checklist voor wie zelf fine-tunet of destilleert

1. Voer attention-visualisatie (BERTViz) uit vóór en ná fine-tuning op een vaste set representatieve voorbeelden.
2. Voer SHAP of LIME uit op dezelfde validatievoorbeelden vóór en ná distillation, en vergelijk niet alleen het voorspelde label maar welke kenmerken het aandreven.
3. Gebruik saliency of Integrated Gradients om kwetsbaarheid te spotten, met name enkelvoudige woordvervangingen die een voorspelling omdraaien.
4. Test expliciet op adversariale gevoeligheid geïntroduceerd door training, met de vóór/ná LIME-vergelijkingsmethode.
5. Kijk verder dan attention naar neuronactivaties en verborgen-toestandsevolutie, aangezien twee derde van de capaciteit van een transformer zit in de feed-forward-lagen die de meeste standaardtools negeren.
6. Documenteer dit alles, op dezelfde manier als de eerdere artikelen over governance en bias-analyse pleiten voor het documenteren van eerlijkheidstests.

De conclusie

Een basismodel via een API lenen betekent iemand anders’ uitlegbaarheidsverplichtingen lenen samen met zijn capaciteit. Op het moment dat je het fine-tunet, destilleert of een gespecialiseerd component zelf traint — precies het pad dat deze site herhaaldelijk heeft bepleit als de route naar echte soevereiniteit en specialisatie — gaat die verplichting volledig op jou over. Een model dat goed scoort op een gehouden testset heeft je verteld wat het doet. Alleen XAI vertelt je hoe — en zonder dat implementeer je een systeem dat je hebt gebouwd maar werkelijk niet kunt verantwoorden.

Gebaseerd op “XAI for NLP” (Advanced Natural Language Processing-cursus, Department of Advanced Computing Sciences).

Kernpublicaties

• Ribeiro et al. (2016), “Why Should I Trust You?”: Explaining the Predictions of Any Classifier (LIME) — arXiv:1602.04938
• Lundberg & Lee (2017), A Unified Approach to Interpreting Model Predictions (SHAP) — arXiv:1705.07874
• Sundararajan et al. (2017), Axiomatic Attribution for Deep Networks (Integrated Gradients) — arXiv:1703.01365
• Vig (2019), A Multiscale Visualization of Attention in the Transformer Model (BERTViz) — arXiv:1906.05714

Verder lezen op deze site

• Waarom NLP eindelijk werkt — de transformer-architectuur waarvan XAI-tools de interne werking openen
• De gigant inkrimpen: pruning, quantization en distillation — waar de behoefte aan XAI tijdens distillation vandaan komt
• Adversariale aanvallen: onzichtbare pixels en omgewisselde woorden — de kwetsbaarheid die LIME-gebaseerde adversariale testen detecteert
• Het autonome bedrijf besturen — het governance-raamwerk dat uitlegbaarheid een wettelijke vereiste maakt
• Bias-analyse in de praktijk — de complementaire eerlijkheidstests die XAI mogelijk maakt
• Wat er nodig is om een soevereine AI-agent te bouwen — stap 7 (validatie) is waar de XAI-checklist in dit artikel thuishoort

Waarom dit meer is dan een compliance-vinkje

Het Algoritmekader koppelt dit aan een verplichting vanuit de Autoriteit Persoonsgegevens rond geautomatiseerde besluitvorming: het risico op discriminerende verwerking moet worden onderzocht en gemitigeerd. Twee recente Nederlandse casussen laten zien wat er misgaat als dit niet gebeurt:

• DUO / controle studentenbeurs uitwonenden: tussen 2010 en 2023 gebruikte DUO een risicoprofiel om misbruik van de uitwonendenbeurs op te sporen. Een onderzoek van Algorithm Audit constateerde onvoldoende statistische onderbouwing voor meerdere selectiecriteria — het profiel werd stopgezet.
• Ministerie van Buitenlandse Zaken / visumaanvragen: het Rijks ICT Gilde voerde een kwantitatieve bias-test uit op de beoordeling van kort-verblijf-visumaanvragen en vond een significant verschil op basis van nationaliteit — met als aanbeveling het gebruik van profielscores en risicogroepen geheel te beëindigen.

Beide casussen illustreren dezelfde les: bias zit zelden in een expliciete variabele “ras” of “nationaliteit”. Het zit in de patronen die een model destilleert uit data.

Stap 1: Analyseer of bias aanwezig is

Stap 2: Voer een rechtvaardigingstoets uit

Een waargenomen verschil is niet automatisch verboden — maar het vereist altijd een expliciete toets aan vier deelvragen:

1. Streeft het algoritme een legitiem doel na?
2. Is het algoritme geschikt om dat doel te bereiken?
3. Is het noodzakelijk — zijn er geen redelijke, minder ingrijpende alternatieven?
4. Is het, alles afwegend, proportioneel?

Bij directe discriminatie is er alleen ruimte voor een uitzondering als de wet die uitdrukkelijk biedt. Bij indirecte discriminatie kan ook een objectieve rechtvaardiging volstaan — maar alleen als alle vier bovenstaande vragen bevestigend worden beantwoord. Zonder geldige rechtvaardiging is een waargenomen verschil per definitie verboden discriminatie en mag het algoritme niet worden gebruikt. Het College voor de Rechten van de Mens heeft een gedetailleerd Toetsingskader Risicoprofilering gepubliceerd dat specifiek ingaat op discriminatie op grond van ras en nationaliteit.

Stap 3: Voer een ethische wenselijkheidstoets uit

Dit is de stap die verder gaat dan de juridische vraag. Zelfs met een geldige, objectieve rechtvaardiging kan een waargenomen verschil ethisch onwenselijk zijn. Betrek hier bewust een brede groep stakeholders — niet alleen juristen en datawetenschappers, maar ook de mensen die het algoritme daadwerkelijk raakt — en bespreek expliciet: wat zijn de mogelijke nadelige effecten, vinden we dit eerlijk en zijn er alternatieven? Zoals het Algoritmekader zelf opmerkt, kan deze afweging uiteindelijk een politiek-bestuurlijke vraag worden — zorg dat die verantwoordelijkheid dan ook expliciet daar wordt belegd.

Een concreet voorbeeld: bias zit al ingebakken in de bouwstenen (Word2Vec)

Alles hierboven gaat over hoe je bias meet in de uitvoer van een algoritme. Maar bias sluipt er vaak veel eerder in — in de taalrepresentaties waarop een model is gebouwd. Een tastbare, praktische illustratie hiervan komt uit een tutorial over documentrepresentatie, en het laat precies zien waarom “meetbias” en “historische bias” (genoemd in stap 1) niet abstract zijn — ze zijn letterlijk zichtbaar in de getallen van een woordvector.

Word2Vec en GloVe leren dichte woordvectoren op basis van de distributionele hypothese: een woord wordt gekarakteriseerd door het gezelschap dat het houdt (Firth, 1957). Semantisch vergelijkbare woorden belanden dicht bij elkaar in vectorruimte — wat opvallend goed werkt voor analogieën als king - man + woman ≈ queen. Maar hetzelfde mechanisme pikt ook maatschappelijke stereotypen op uit het trainings-corpus, met concrete en herkenbare gevolgen:

man : programmer :: woman : ?

Query een GloVe-model (getraind op Wikipedia plus nieuwsartikelen) hiermee, en de termen die verschijnen weerspiegelen duidelijk een genderstereotype in plaats van een neutrale vertaling van het beroep. Hetzelfde geldt voor man:doctor :: woman:? en father:doctor :: mother:? — het model heeft niet geleerd wat een dokter is; het heeft geleerd welke woorden samen voorkomen in tekst die al doordrenkt is van maatschappelijke aannames.

Waarom dit er niet alleen insluipt maar ook blijft: deze embeddings zijn getraind op enorme hoeveelheden webtekst, nieuwsartikelen en boeken — bronnen die historische en maatschappelijke vooroordelen weerspiegelen. Als zulke embeddings vervolgens terechtkomen in een downstream-toepassing — een cv-screeningstool, een chatbot, een risico-inschattingsinstrument — kunnen ze die discriminatie doorgeven en versterken. Een cv-screener die draait op GloVe-embeddings die “programmeur” sterker associeert met “man” dan met “vrouw”, zal mannelijke kandidaten systematisch hoger rangschikken, zonder dat “geslacht” ooit als expliciete invoervariabele is gebruikt. Dit is precies het type indirecte discriminatie beschreven in stap 1 — alleen ontstaat het op het representatieniveau, dieper in de pipeline dan de meeste bias-audits doorgaans kijken.

Hoe je dit operationaliseert in een AI/agent-project

Voor iedereen die dit wil operationaliseren binnen een groter agentisch AI-project — zoals behandeld in het eerdere artikel over het bouwen van soevereine agents en het governance-raamwerkartikel op deze site:

1. Documenteer de drie stappen als een vaste onderdeel van je validatiefase — niet als een eenmalige check bij oplevering, maar als een terugkerend proces.
2. Kies je fairness-maatstaven vóórdat je de resultaten ziet, samen met stakeholders.
3. Bouw de bias-test in als een aparte, herhaalbare stap in je pipeline — met een van de bovengenoemde open-source tools.
4. Documenteer elke oordeelsvraag expliciet, inclusief waarom een bepaald verschil wel of niet gerechtvaardigd werd geacht.
5. Blijf monitoren na de livegang — via het bezwaar- en klachtenproces, en door periodieke herhaling van de analyse.

De conclusie

Bias-analyse is geen eenmalige checklist — het is een herhaald proces van meten, verklaren, rechtvaardigen en, waar nodig, bijsturen. De Nederlandse casussen hier laten zien dat dit geen theoretische oefening is: profielen die jaren in productie draaiden, bleken bij nader inzien onvoldoende onderbouwd en werden stopgezet. Bouw deze drie stappen in vanaf de ontwerpfase van je algoritme — niet als reactie op een incident achteraf.

Bron: Algoritmekader, Ministerie van Binnenlandse Zaken en Koninkrijksrelaties, maatregel 5-VER-03.

Kernpublicaties

• Bolukbasi et al. (2016), Man is to Computer Programmer as Woman is to Homemaker? Debiasing Word Embeddings — arXiv:1607.06520
• Gonen & Goldberg (2019), Lipstick on a Pig: Debiasing Methods Cover up Systematic Gender Biases — arXiv:1903.03862
• Hardt et al. (2016), Equality of Opportunity in Supervised Learning — arXiv:1610.02413
• Barocas, Hardt & Narayanan, Fairness and Machine Learning — fairmlbook.org

Verder lezen op deze site

• Het autonome bedrijf besturen — het vierfasen-governance-raamwerk waar bias-testen deel van uitmaakt
• Wat er nodig is om een soevereine AI-agent te bouwen — stap 7 van de gids behandelt bias-validatie in de praktijk
• Adversariale aanvallen: onzichtbare pixels en omgewisselde woorden — de verwante categorie van beveiligingskwetsbaarheden in modelinvoer
• De institutionele slotgracht — waarom guardrails en compliance-architectuur er voor instellingen toe doen
• Waarom NLP eindelijk werkt — de transformer-architectuur waarvan de embeddings de representationele bias bevatten die hier wordt besproken