David tegen Goliath: een fine-tuned 8B-model evenaart bijna een triljoen-parameter-gigant — op één taak

tekst-naar-actie
Recent onderzoek toont aan dat een klein, lokaal draaiend model binnen een paar procentpunten van een frontier-basismodel kan komen op een specifieke taak. De reden is geen magie — het is specialisatie.
Auteur

Jan Scholtes

Publicatiedatum

31 oktober 2026

Hier is een getal om even bij stil te staan: een fine-tuned 8-miljard-parameter-model, klein genoeg om op een enkele consument-GPU te draaien, behaalde onlangs een resultaat binnen 1,2 procentpunt van een frontier-basismodel op stap-validiteit, en binnen 6,1 punten op taakvoltooiing — op een werkelijk moeilijke taak: het betrouwbaar van begin tot einde volgen van complexe, vertakkende procedures (denk aan standaard operationele procedures, reparatiehandleidingen, meerstaps-bedrijfsworkflows). Het basismodel waarmee het werd vergeleken, heeft een geschatte omvang van 625 keer groter. Dit artikel loopt door wat er werkelijk werd gebouwd, wat de cijfers laten zien, en — het meest belangrijk — waarom dit resultaat geen toeval is. Het is een direct gevolg van wat specialisatie oplevert.

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