Hoe een taalmodel werkt: van token tot agent

Eerlijk, ik dacht dat dit een lange intro zou worden, met verschillende visies op AI erin, misschien een paar gevatte opmerkingen. Maar de zinnen komen niet. Dus ik sla de intro lekker over en ga meteen naar de vraag die ik wilde beantwoorden: hoe werkt een taalmodel nou eigenlijk? Niet tot in de wiskundige details, maar uitgebreid genoeg om het echt te begrijpen.

Steeds het volgende token

In de kern doet een taalmodel, een LLM, maar één ding. Het krijgt tekst en berekent voor elk mogelijk vervolg een kans. Niet voor hele zinnen, maar steeds alleen voor het eerstvolgende stukje: een token. Er wordt één token gekozen, dat wordt geplakt achter de tekst die er al stond, en de hele lap tekst gaat direct weer terug het model in voor de volgende ronde. Het model schrijft dus geen antwoord, maar kiest steeds één token, en dan nog één, etc. Je zou denken dat het model altijd het token met de hoogste kans pakt, maar je raadt het al: dat is niet per definitie zo. Het model trekt er één, gewogen naar de kansen, zodat waarschijnlijke tokens vaker vallen dan onwaarschijnlijke. De favoriet wint alsnog meestal, maar niet altijd.

Het model krijgt niet alleen jouw tekst, maar een heel samengesteld pakket: systeemprompt, eerdere berichten, opgehaalde documenten, beschrijvingen van beschikbare tools, en helemaal achteraan jouw nieuwe vraag. Het ziet niet alleen je laatste invoer, maar de hele context, en voorspelt daarmee het volgende token.

Achter die ene keuze gaan weliswaar miljarden berekeningen schuil (daar kom ik onder Gokken en bijstellen op terug), maar de lus zelf is niet ingewikkelder dan: kans berekenen, kiezen, plakken, opnieuw.

Logische vraag is nu: wanneer stopt die lus dan? Het model kent niet alleen woorden maar ook een aantal speciale tokens, en één daarvan betekent: hier eindigt het antwoord. Dat eindtoken is in de lus steeds een van de kandidaten, met een eigen kans. Wordt het eindtoken gekozen, dan stopt de lus. Er is ook een maximale lengte van het antwoord. Als die lengte wordt bereikt, dan stopt de generatie. Ook als het model nog geen eindtoken heeft gekozen.

De keuze van het volgende token is dus een soort loterij. Het token dat 97% kans heeft, krijgt 97 lootjes, en over de resterende tokens worden de overige 3 lootjes verdeeld.

De temperatuurknop

De temperatuur van een taalmodel bepaalt hoeveel willekeur er in het antwoord zit, door de kansverdeling voor het volgende token scherper of vlakker te maken. In onze loterij betekent dat: bij een lage temperatuur krijgt de favoriet relatief meer lootjes, en bij een hoge temperatuur worden de kansen gelijkmatiger verdeeld. De temperatuur verandert dus niet welke tokens bovenaan staan, maar wel hoe groot de verschillen ertussen zijn.

Zet je de temperatuur op 0.00, dan kiest het model altijd het token met de hoogste kans. Dat heet greedy decoding. In theorie gedraagt het model zich dan volledig deterministisch: bij exact dezelfde invoer krijg je altijd hetzelfde vervolg. In de praktijk zorgen kleine reken- en afrondingsverschillen op de duizenden parallelle chips ervoor dat er soms tóch een ander token uitrolt, maar alle creativiteit is er dan wel uit (voor zover je hier kan spreken over creativiteit, maar dat is weer een ander verhaal). Handig als je voorspelbaarheid wilt, maar de tekst wordt er vlak en repetitief van. Daarom staat een model meestal niet op nul.

Nergens in de lus wordt gecontroleerd of het gekozen vervolg klopt, en hallucinaties ontstaan niet simpelweg doordat het model loot. Ook bij een temperatuur van nul kan er nog onzin uitrollen, maar dan is het telkens dezelfde onzin. De temperatuur heeft dus alleen invloed op de variatie en niet op het waarheidsgehalte.

Hierboven heb ik voor het gemak de eerste stap in de lus, het berekenen van een kans, als één ding behandeld. Maar in die ene stap zit het meeste werk: van tekst naar tokens, van tokens naar getallen, laag na laag, tot er een kansverdeling uitkomt.

Geen letters, maar tokens

Ergens halverwege 2024 was het opeens hip om aan taalmodellen te vragen hoeveel r’en er in het woord strawberry zitten. Inmiddels is het grapje niet meer actueel, maar het is wel een goed voorbeeld om nog wat beter te illustreren hoe dat tokenverhaal werkt.

Het model ziet dus helemaal geen letters of woorden. Voordat tekst het model ingaat, wordt die in stukken geknipt: tokens met elk een eigen nummer. Een veelvoorkomend woord is vaak één token, een zeldzamer woord valt uiteen in twee of meer blokjes. In dit geval herkent het dus geen tien losse letters, maar een paar genummerde tokens. Losse letters tellen kan zo’n model dus niet zonder omweg. Huidige modellen kunnen al beter tellen doordat ze het woord in een redeneerstap letter voor letter uitspellen, of het antwoord uit de trainingsdata kennen. Soms gebruiken ze een stukje code dat het telwerk overneemt.

Tokens zijn de rekeneenheid van een taalmodel, en van de factuur die je krijgt voor het gebruik ervan. Alles wat het model in één keer kan overzien, het contextvenster, wordt gemeten in tokens. En je rekent af per token, voor alles wat erin gaat en alles wat eruit komt: je vraag, instructies, documenten eromheen, en het antwoord.

Van tokens naar betekenis

Nu wordt het eigenlijk pas interessant, want tokens verklaren op zichzelf niet waarom modellen samenhang lijken te snappen. Daarvoor moet je weten wat er met die genummerde blokjes gebeurt. Hierboven zie je dat elk token een ID heeft, maar dat is niks meer dan een label. “berry” is toevallig nummer 19772. Dat getal zegt verder niks: een verwant woord kan een heel ander ID hebben. De betekenis zit ergens anders. Bij elk token zoekt het model een rij van duizenden getallen op. Die rij vormt een soort coördinaat in een ruimte met evenzoveel richtingen.Die getallenrijen heten embeddings. Eén rij is een embeddingvector, opgezocht in een grote tabel die de embeddinglaag heet. Afstand is in die ruimte verwantschap. Koning ligt dicht bij koningin, Amsterdam dicht bij Nederland.

Belangrijker nog: die startplek ligt wel vast, maar de betekenis niet. Neem het woord “python”. In de zin “De python loert op zijn prooi” stuurt de context het woord richting reptielen en biologie. Maar in “Ik schrijf een script in python” trekken de omringende woorden het direct naar software en code. Hetzelfde woord Hoe heette dat ook alweer… O ja, een homoniem., exact dezelfde startplek, maar de context duwt het punt een compleet andere hoek van die ruimte in. Het model zoekt die betekenis niet op in een statische database. Er is geen mapje python-de-programmeertaal dat wordt klaargezet. Het model berekent die verschuiving live, laag na laag, op basis van de relatie met de andere tokens. In elke laag kijkt elk token naar de tokens eromheen en schuift het zijn eigen positie een stukje op, op grond van wat relevant is.Dit mechanisme heet attention: elk token weegt hoe belangrijk de tokens eromheen zijn voor zijn eigen betekenis. Eén laag doet dat subtiel, maar na tientallen lagen draagt het laatste token zoveel van de hele zin in zich dat het model er rechtstreeks een kans voor elk mogelijk vervolg uit afleest. Daar zit het meeste rekenwerk, en daar komt de kansverdeling van het begin vandaan.

Dit is waarom een model samenhang lijkt te begrijpen: niet door een vaste betekenis op te zoeken, maar door elk token een positie te geven die meebeweegt met de rest van de zin. Of dat “begrijpen” mag heten, is een vraag waar ik nog op terugkom.

Gokken en bijstellen

Die posities en kansen van daarnet zijn niet geprogrammeerd. Het taalmodel vormt ze zelf. De vraag is hoe, en het antwoord is verrassend simpel: gokken en bijstellen, en dat heel vaak achter elkaar.

Een vers model is niks meer dan een enorme hoeveelheid getallen: de gewichten. Die gewichten staan bij de start op willekeurige waarden. Als je zo’n model iets zou vragen, rolt er pure onzin uit. Het heeft nog nergens een patroon in gezien. Trainen is het proces dat die willekeurige berg omvormt tot iets dat zinnig klinkende tekst produceert.

Dat trainen gebeurt in een lus. Neem een stuk echte tekst, laat het model het volgende token voorspellen, en vergelijk die gok met wat er in werkelijkheid stond. Als het model ernaast zit, dan krijgen alle gewichten een zetje in de goeie richting, zodat de volgende gok een fractie dichterbij komt.Welk zetje precies, dat bepaalt het model met backpropagation. De stapjes bergafwaarts naar minder fouten heten gradient descent. Als je dit één keer doet, verandert er natuurlijk weinig aan de samenhang. Zodra je dit over een gigantische hoeveelheid tekst miljarden keren herhaalt, ontstaat er een model dat grammatica, feiten en schrijfstijl in de gewichten heeft zitten.

Alles wat het model “weet” zit dus in de gewichten. Er is geen opgeslagen tekst, en er is geen database met feiten.Al kunnen stukken trainingstekst wel degelijk vrijwel letterlijk uit de gewichten rollen. Er zijn alleen afgestelde gewichten en de manier waarop ze samen een kansverdeling opleveren. Dit is ook meteen de reden waarom trainen zo duur is. Je kan je voorstellen dat zoveel getallen afstellen op enorme bergen tekst heel veel rekenkracht kost.

Dit deel van de training levert een model dat vloeiend tekst aanvult, maar nog niet per se een behulpzame chatbot. Daarvoor is nog een afwerkfase nodig, de posttraining, en daar kom ik onder Twee levens op terug.

Stampen of snappen?

Met wat we nu weten zou je kunnen concluderen dat een taalmodel de antwoorden gewoon uit zijn hoofd leert, op basis van die reusachtige set aan data waarop het model is getraind. Dat is ook deels waar, maar daar blijft het niet bij. Dat is aangetoond met een simpel experiment waarin een model leerde optellen op een analoge klok. Hierbij is 10 + 5 niet 15 maar 3, want op een klok begin je na de 12 weer bij 1 (modulair rekenen). Dit is hier ideaal omdat er maar twee mogelijke oplossingen zijn: alle uitkomsten uit het hoofd leren, of de methode snappen. Je kan dus zien welke van de twee het model koos.

Eerst leerde het model de voorbeelden: sommen uit de trainingsdata gingen goed, nieuwe sommen gingen fout. Maar na lang doortrainen sloeg het model om, en gingen ook nieuwe sommen goed. Het model was dus overgestapt op de echte methode. Dat wordt grokking Power e.a., 2022. De term grokking komt van grok, een woord uit Heinleins sciencefictionroman Stranger in a Strange Land (1961). Het betekent iets zo volledig begrijpen dat het deel van je wordt, precies wat hier gebeurt. genoemd.

Een ander team ging nog wat verder en ontleedde zo’n grokkend model. Dit model bleek een soort klok te gebruiken: het had geleerd de getallen als punten op een cirkel te zien en draaide eromheen om op te tellen.Nanda e.a., 2023. Geen tabel met antwoorden, maar een uitgevonden procedure.

Of iets vergelijkbaars ook gebeurt tussen de miljarden gewichten van een echt taalmodel is lastiger na te gaan. Men begrijpt de architectuur van die modellen tot in detail, maar teruglezen welke methodes een getraind model daarin heeft gevormd, is een ander verhaal. Recentere berichten wijzen wel die kant op: onderzoekers van Anthropic zagen een groot model een vraag als “de hoofdstad van de staat waar Dallas ligt” intern in stappen oplossen, eerst van Dallas naar Texas, dan van Texas naar Austin.Anthropic, “Tracing the thoughts of a large language model”, 2025.

Daarmee is het te simpel om te beweren dat een model alleen heel veel feiten in zijn geheugen stampt en daartussen verbanden legt. Een model stampt niet alleen, maar het vormt ook methodes. Iets wat alleen maar tekst herkauwt, zou nooit een som kunnen oplossen die het nog nooit heeft gezien.

Of je dat “begrijpen” kan noemen, weet ik niet. Dat is sowieso een definitiekwestie, en aan die discussie ga ik in dit verhaal mijn vingers niet branden.

Twee levens

Een taalmodel leidt twee levens. Het eerste is het trainen: gokken en bijstellen tot de gewichten kloppen. Het tweede begint zodra het trainen afgelopen is en je het model gebruikt. Na de training ligt het model vast. De gewichten bevriezen, en praten met een model verandert daar niks meer aan. Het leert niet van jouw gesprek.Dat wil niet zeggen dat je gesprekken nooit gebruikt worden om een nieuwe versie te trainen. Of dat gebeurt, verschilt per aanbieder. Zakelijke abonnementen zijn er meestal van uitgezonderd.

Het trainen heeft twee stappen. De eerste stap is het ruwe trainen van hierboven: de pretraining. Daarna kan het model vloeiend tekst aanvullen, maar net zo goed jouw vraag met een wedervraag beantwoorden of blijven doorratelen. Het is immers simpelweg tekst uit de trainingsdata aan het imiteren.

In de tweede stap van de training wordt het model bijgeschaafd met menselijke feedback. Mensen beoordelen antwoorden, en het model leert daarvan welke toon en vorm de bedoeling zijn. Het bekendste onderdeel van deze posttraining is precies dat bijsturen. Dat is ook waar een model zijn omgangsvormen en grenzen leert. Deze stap verandert vooral hóé het model antwoordt, en voegt daarnaast vaardigheden en soms wat kennis toe.

Bij elk gesprek komt er nog een laatste laag bovenop: de systeemprompt. Dat is een reeks instructies die je niet ziet, maar die vooraan de context staat en definieert hoe het model zich moet gedragen.

Het wordt wel een lang verhaal zo, nog even volhouden. Dan heb je een aardig overzicht van hoe modellen in elkaar zitten. We weten nu dat een model min of meer drie soorten “geheugen” heeft:

• De gewichten. Alles wat tijdens het trainen is opgepikt. De gewichten staan stil. Na de training komt er niks meer bij.
• De context. Alles in het lopende gesprek, van de systeemprompt tot jouw laatste zin. Eigenlijk is dit het vluchtige werkgeheugen, want bij een nieuwe sessie begin je weer alsof er nooit iets gezegd is.Sommige chatproducten zoals ChatGPT en Claude omzeilen dit met een geheugenfunctie. Informatie uit eerdere gesprekken wordt dan bij een nieuw gesprek in de context geplakt. Dat is dan dus onderdeel van het externe geheugen van het volgende punt.
• Extern geheugen. Wat het model erbij haalt. Dat kan een document zijn, een zoekopdracht of een tool. Opgehaald op het moment zelf, en in de context geplakt.

Dat verklaart ook waar een hoop verwarring vandaan komt. Geef je een model tijdens een gesprek een paar voorbeelden, dan lijkt het een patroon op te pikken. Maar dat gebeurt dus alleen in de huidige context, niet in de gewichten, en bij een volgend gesprek is het weer weg.Als je echt interessant wilt doen: in-context learning.

Omdat de gewichten na de training bevriezen, heeft elk model een kennisgrens. Het weet niks van wat er daarna gebeurt, tenzij je dat in de context stopt of via een tool toevoegt. Daarom zoeken recente modellen het web af en kunnen ze documenten lezen. Ze kennen het nieuws niet, maar halen het op en lezen het ter plekke.

Waarom een taalmodel hallucineert

Een taalmodel verkondigt soms heel stellig dingen die niet kloppen: niet-bestaand beleid, een verzonnen boektitel, een citaat dat nooit is uitgesproken. Zulke verzinsels heten hallucinaties, en ze komen direct voort uit hoe een model werkt. Een model voorspelt een waarschijnlijk vervolg, niet per se de waarheid. Er zit nergens in de lus een controlestap. Als het model iets niet “weet”, dan valt het niet stil, maar vult het in wat plausibel is.

Toch zit hier wel een rem op. Onderzoekers van Anthropic ontdekten hoe dit intern werkt. In een bijgeschaafd model zit een soort ingebouwde handrem, die het bij twijfel naar “ik weet het niet” laat neigen. Zodra er een naam of term voorbijkomt die bekend klinkt, gaat de handrem eraf. Soms gebeurt dat onterecht, en dan zit er geen echte kennis achter de herkenning. Het model begint dan met volle overtuiging te fantaseren.De onderzoekers bewezen dit door de handrem er handmatig af te halen, waarna het model meteen de grootste onzin produceerde. Zie: Anthropic, “Tracing the thoughts of a large language model”, 2025.

Het model maakt dus geen betrouwbaar onderscheid tussen een feit dat vastligt en een gat dat het opvult. Juist bij namen, datums, cijfers en citaten is de kans op overtuigende onzin het grootst. De remedie is om het niet op zijn woord te geloven, het een bron te geven en te controleren wat eruit komt.

De voorspeller in een lus

Tot nu toe hebben we het eigenlijk maar over één ding gehad: een taalmodel dat tekst voorspelt. Zo’n model kan niet betrouwbaar rekenen, niet in je agenda kijken, en niks opzoeken op internet. Als je naar het weer van morgen vraagt, dan krijg je een nutteloos antwoord.

De oplossing is het aanreiken van een stukje software dat het model mag gebruiken, een tool (je zag de term eerder al een paar keer voorbijkomen). Dat kan een rekenmachine zijn, een zoektool of zelfs een omgeving waarin code kan worden uitgevoerd. In de context staat welke tools beschikbaar zijn, en hoe ze aangeroepen kunnen worden. Het model kiest die aanroep zoals het elk ander token kiest: als het waarschijnlijkste vervolg. Met andere woorden: het model voorspelt de aanroep. Om die aanroep ook daadwerkelijk uit te voeren, zit er om het model een laag gewone software heen: het harnas dat de tekstvoorspeller handen en voeten geeft. Het harnas ziet de aanroep, voert de tool uit, en plakt het resultaat terug in de context. Daarna voorspelt het model weer verder, met het resultaat uit de tool erbij.

Zet die stap in een lus en je hebt een agent. Het model doet iets, ziet het resultaat, en kiest de volgende stap. Het kan verder met het genereren van tekst, nog een tool aanroepen, of stoppen als het doel bereikt is. Het bepaalt zelf wanneer het klaar is. Dit is nog steeds dezelfde lus waar we het heel de tijd al over hebben, maar nu met echte acties ertussen.

Zo simpel is het

Dat was het wel zo’n beetje. Nog even terug naar de vraag waarmee ik begon: hoe werkt een taalmodel nou eigenlijk?

Het antwoord past nu in een paar zinnen. Een model berekent voor elk mogelijk vervolg de kans, en trekt uit die opties een token. Die voorspellingen zijn aangeleerd door tijdens het trainen miljarden keren te gokken en bij te stellen, tot alle kennis in de gewichten zat. Met een lus en wat tools erbij wordt die tekstvoorspeller opeens een agent die echte taken uit kan voeren.

Een model heeft geen begrip zoals een mens, en er is geen database met vaststaande gegevens die wordt geraadpleegd.

Het is geen magie. Maar dat maakt het niet minder indrukwekkend, en zeker niet minder bruikbaar.