Context window, tokens en system prompt: hoe AI echt werkt onder de motorkap
Wat is een token?
Voordat je een bericht naar een AI-model stuurt, wordt de tekst opgesplitst in tokens. Dat zijn kleine stukjes tekst — soms een heel woord, soms een woorddeel, soms gewoon een leesteken. De meeste grote modellen, inclusief Claude, gebruiken daarvoor Byte Pair Encoding (BPE): een algoritme dat veelvoorkomende tekenreeksen groepeert tot vaste eenheden. Het woord "onverwachts" is bijvoorbeeld meerdere tokens, terwijl "the" er maar één is.
Een ruwe vuistregel voor Engels: één token is zo'n driekwart woord. Voor Nederlands ligt het anders. Onze samengestelde woorden en langere uitgangen kosten meer tokens — ruwweg de helft van de Engelse verhouding als je er iets over wil zeggen, maar neem dat niet als harde regel. Het varieert sterk per zin. De zin "Hello, world!" is afhankelijk van de tokenizer zo'n vier tokens — dat geeft een idee van de granulariteit.
Waarom maakt dit uit? Omdat modellen niet rekenen in woorden of zinnen, maar in tokens. Alles wordt omgezet, verwerkt en afgerekend in die eenheid.
Het context window: werkgeheugen van het model
Een model heeft geen geheugen tussen sessies. Wat het "weet" tijdens een gesprek staat allemaal in het context window — een soort werkgeheugen dat alles bevat wat tot nu toe is gewisseld: de system prompt, eerdere berichten, antwoorden, en eventueel meegestuurde bestanden of code.
Dat window heeft een vaste maximale grootte, uitgedrukt in tokens. Claude Opus 4 heeft een context window van 1 miljoen tokens — omgerekend zo'n 750.000 woorden. Dat is enorm: je past er een flinke roman in, of een groot codebestand met tientallen bijbehorende bestanden. GPT-4 Turbo introduceerde eerder een context van 128.000 tokens, wat al een grote sprong was ten opzichte van eerdere modellen.
Maar groot is niet onbeperkt. Wat er precies in past hangt af van de content. Code is token-intensief. Lange systeemprompts vreten ruimte. Veel geüploade bestanden ook. En als het window vol raakt, moet er iets wijken.
Wat gebeurt er als het vol is?
Er zijn twee gangbare strategieën.
De eerste is truncatie: oudere berichten worden weggegooid. Simpel, maar gevaarlijk. Als vroege context wegvalt die later relevant blijkt, gaat de kwaliteit achteruit zonder dat je het doorhebt. Het model "vergeet" gewoon wat er aan het begin is gezegd.
De tweede is compactie: in plaats van weggooien wordt de oudere context samengevat. Claude Code doet dit standaard. Als een lange sessie tegen de limiet aanloopt, comprimeert het systeem automatisch eerdere uitwisselingen tot een compactere representatie. Je verliest details, maar de grote lijn blijft bewaard.
Een analogie: stel je voor dat je met een collega werkt aan een project, maar jouw gespreksaantekeningen kunnen maar tien pagina's bevatten. Ofwel je scheurt de oudste pagina's eruit (truncatie), ofwel je maakt periodiek een samenvatting en gooit de detailpagina's weg (compactie). Beide hebben gevolgen voor wat je collega later nog weet.
System prompt vs. user message
Als je een AI-assistent gebruikt — via een app, een API of een tool zoals Claude Code — is er doorgaans meer aan de hand dan alleen jouw bericht. Er is een system prompt.
De system prompt is een instructieset die wordt meegegeven aan het model vóórdat jij iets typt. Die bepaalt hoe het model zich gedraagt: welke toon het aanslaat, wat het wel en niet doet, welke context het heeft over de situatie. Bij Claude Code staat daar bijvoorbeeld uitleg in over het project, de gehanteerde conventies en de permissies die zijn ingesteld.
Het verschil tussen een system prompt en een user message is een kwestie van positionering en gewicht. De system prompt staat bovenaan de context, vóór het gesprek. Het model beschouwt die als configuratie-instructie, niet als onderdeel van de dialoog. Een user message is wat jij invult, en staat ná de system prompt in de context.
Technisch gezien is het verschil klein: beide zijn tekst die in het context window terechtkomt. Maar modellen zijn getraind om system prompts anders te behandelen — ze overschrijven gedragspatronen op een manier die losse gebruikersinput minder snel doet. Dat is ook waarom applicatiebouwers via de system prompt gedrag kunnen "injecteren" dat voor de gebruiker niet zichtbaar is.
Een praktisch gevolg: als je wilt dat een model zich consistent gedraagt — een bepaalde taal spreekt, een bepaalde stijl aanhoudt, specifieke kennis altijd meeweegt — zet dat dan in de system prompt, niet in je eerste bericht. Hetzelfde geldt voor Claude Code's CLAUDE.md-bestanden: die worden geladen als system prompt context, zodat het model ze bij elke stap meeneemt.
Prijsmodel: tokens in en tokens uit
Grote taalmodellen worden doorgaans afgerekend per token. Er zit een asymmetrie in die de meeste mensen niet direct verwachten: output is duurder dan input.
Bij Claude is de verhouding ruwweg 3 tot 5 keer duurder voor gegenereerde tokens dan voor ingevoerde tokens. De redenering: invoer verwerken kan parallel en geoptimaliseerd, maar elke output-token moet sequentieel worden gegenereerd. Dat vraagt meer rekentijd en daarmee meer kosten.
Dit heeft directe gevolgen voor hoe je prompts ontwerpt als je op schaal werkt. Lange antwoorden zijn duur. Een model dat standaard breed antwoordt, met veel toelichting en voorbeelden, kost sneller geld dan een model dat bondig is. Dat is ook waarom veel productieapplicaties expliciet instrueren: "Geef een kort antwoord", of "Vat samen in maximaal drie zinnen."
Prompt caching
Er is een mechanisme dat de kosten bij veelvuldig gebruik fors kan verlagen: prompt caching. Als je dezelfde grote system prompt of context steeds opnieuw meestuurt — wat bij elke API-call standaard gebeurt — kan het systeem die vaste invoer cachen. Bij een cache-hit hoef je niet opnieuw te betalen voor het verwerken van diezelfde tokens. Dat levert tot 90% besparing op de cached invoer.
Voor applicaties met een vaste, lange system prompt is dit praktisch relevant. Een coaching-tool die bij elke sessie dezelfde instructieset van tweeduizend tokens meestuurt, betaalt bij caching een fractie van wat het anders zou kosten.
Hoe je context-gebruik in de praktijk beheert
Als je met AI-tools werkt aan iets complexs — een groot codeproject, een lang document, een uitgebreide analyse — helpen deze patronen:
Houd context relevant. Alles wat je meestuurt kost tokens en vermindert de ruimte voor wat er daarna nog in moet. Een bestand meesturen dat het model toch niet nodig heeft is verspilling.
Begrijp dat eerdere context doorwerkt. Als je vroeg in het gesprek een richting aangeeft, blijft die doorwerken — ook als je later iets anders zegt. Nuttig als je wilt dat een ingestelde instructie standhoudt, maar het kan ook voor drift zorgen als de vroege context verouderd raakt.
Gebruik system prompts voor stabiele instructies. Wat altijd moet gelden hoort niet bij elke user message herhaald te worden.
Wees bewust van lange sessies. Compactie helpt, maar is niet gratis. Na compactie raakt precisie over vroege details kwijt. Als een sessie zo lang wordt dat compactie meerdere keren heeft plaatsgevonden, is het soms beter om opnieuw te beginnen met een schone, gerichte context.
Afsluiting van de trilogie
Dit is de derde post in de reeks over hoe AI-tools technisch werken. Deel 1 ging over de architectuur van grote taalmodellen. Deel 2 over prompts schrijven. Met tokens, context windows en system prompts is nu de laag gedekt die direct bepaalt wat een model ziet, hoe lang het dat onthoudt, en wat het kost.
Niet als academische volledigheid, maar omdat dit de begrippen zijn die je tegenkomt zodra je AI serieus inzet — bij het debuggen van vreemd modelgedrag, het optimaliseren van kosten, of het bouwen van tools die consistent moeten presteren.