Hoe AI-codeeragenten je context vooraf laden en wanneer dat averechts werkt

U opent uw editor en start een sessie. Voordat u iets typt, nog voordat de cursor in het invoerveld tot rust komt, heeft de agent al flink wat gelezen. Hij heeft zijn systeemprompt opgenomen, de definities van elke tool die hij kan aanroepen, zijn gedragsinstructies, de CLAUDE.md van uw project (of .cursorrules, of AGENTS.md), alle van toepassing zijnde pad-specifieke regels en alles wat in zijn geheugenbestand staat. Tegen de tijd dat u uw eerste woord zegt, heeft de agent al een model van u, van uw project en van hoe hij zich hoort te gedragen.

Het naïeve mentale model is: jij typt, de agent antwoordt. De echte volgorde is: de agent leest jouw context, jij typt, de agent antwoordt. In die stille eerste stap, waarin de agent jou leest voordat je iets zegt, wordt een verrassend groot deel van je uitkomst beslist. En het bewijs of de context die je hem voert daadwerkelijk helpt, is ongemakkelijker dan de meesten van ons aannemen.

De korte versie

• AI-codeeragents laden vooraf geschreven context vóór jouw eerste bericht: systeemprompts, tooldefinities en toolspecifieke instructiebestanden zoals CLAUDE.md, Cursor-regels, GitHub Copilot-instructies of AGENTS.md waar dat ondersteund of geïmporteerd is. Jij begint het gesprek niet; het lezen van de agent doet dat.
• Die pre-load vreet een flink deel van het bruikbare contextvenster op nog voordat je één teken hebt getypt, dus je effectieve werkbudget is kleiner dan het geadverteerde venster van het model doet vermoeden.
• De empirische bevinding is het contra-intuïtieve deel: contextbestanden die door ontwikkelaars zijn geschreven helpen een beetje (ongeveer +4% taaksucces) tegen reële kosten (ongeveer +19% inferentiekosten), terwijl door een LLM gegenereerde of gekopieerde contextbestanden de resultaten juist iets slechter.
• Je model zelf hosten verandert wat je kunt zie, niet wat u moet do. De pre-sessie-architectuur is overal hetzelfde; lokale tools laten u alleen toe om het te inspecteren en te auditeren. De discipline van het schrijven van context die u echt begrijpt, verdwijnt niet.

Het naïeve model klopt niet: de agent leest als eerste

Stel je het exacte moment voor waarop een Claude Code-sessie begint. De systeemprompt gaat erin. De tooldefinities gaan erin. Dan wordt, voordat je iets hebt gezegd, je CLAUDE.md afgeleverd, en het mechanische detail doet er hier toe. De eigen documentatie van Anthropic is expliciet dat CLAUDE.md-inhoud wordt “geleverd als een gebruikersbericht na de systeemprompt,” geladen „aan het begin van elk gesprek.“ Dus de allereerste gebruikersturn in het transcript bent u niet. Het is uw bestand, dat namens u spreekt en de voorwaarden instelt voordat u aankomt.

Wat er op dat openingsmoment werkelijk laadt, is een stapel: de systeemprompt, de tooldefinities, de gedragsinstructies, uw project- en gebruikerscontextbestanden, alle pad-specifieke regels die matchen met de bestanden die in het spel zijn, en een geheugenbestand dat de agent zelf bijhoudt. In Claude Code worden de contextbestanden opgelost via een hiërarchie met vier niveaus (beheerd beleid, dan gebruiker (~/.claude/CLAUDE.md), dan project (./CLAUDE.md), dan lokaal (./CLAUDE.local.md)), in die volgorde aan elkaar geplakt. Automatisch geheugen voegt zijn eigen deel toe: de eerste 200 regels (of 25KB) van een MEMORY.md die de agent zelf schrijft en leest, elke sessie geladen.

Niets hiervan is gratis. De infrastructuur-overhead (systeemprompt, tooldefinities, gedragsinstructies) verbruikt een aanzienlijk deel van het effectieve contextvenster nog voordat je eerste bericht binnenkomt. Dat is de belasting die je betaalt zodat de agent weet hoe hij agent moet zijn, en ze blijft onzichtbaar tenzij je ernaar op zoek gaat.

Er vormt zich een naam rond de discipline van het beheren van dit alles. Het toegepast AI-team van Anthropic noemt het contextengineering: ‘het geheel aan strategieën om tijdens LLM-inferentie de optimale set tokens (informatie) samen te stellen en te behouden’. Het is een nuttige term, omdat hij het bestand dat je schrijft verandert van een briefje aan de robot in een architectuurbeslissing over wat een schaarse, dure bron inneemt.

Vier agents, vier manieren om jou eerst te lezen

De agenten lezen u niet allemaal op dezelfde manier. Ze splitsen zich op langs twee assen die het waard zijn te benoemen: wat wordt geladen bij het starten van de sessie (een samengestelde bestandshiërarchie, versus altijd-actieve regels, versus een volledige repo-scan), en hoeveel je daarvan kunt inspecteren, oftewel of het mechanisme een deterministisch, controleerbaar artefact is of een semantische index die je maar op goed vertrouwen moet aannemen. Op die twee assen lopen Claude Code, Cursor, GitHub Copilot en Aider echt uiteen.

De opsplitsing van Cursor is het meest instructief. De regels staan in leesbare bestanden die u beheert, maar het bouwt ook een semantische index van je volledige codebase, vectorinsluitingen die de @codebase-zoekfunctie aandrijven en die u niet echt kunt inspecteren. Aider bevindt zich aan het andere einde: het leest uw hele git-repository en bouwt een repo-map, deterministisch, zonder embeddings ergens in het spel. Je kunt precies controleren wat er naar het model ging. Dezelfde architectonische omkering, maar een heel ander zicht erop. Voor de diepere vergelijking per tool hebben we het landschap van agentic CLI's behandeld in onze showdown van agentische programmeer-CLI's en het direct opgenomen in OpenCode versus Claude Code elders.

Onder de toolspecifieke formaten consolideert zich een standaard die tools overstijgt. AGENTS.md ontstond binnen het ecosysteem van agent-tooling (OpenAI Codex, Amp, Jules van Google, Cursor en Factory) en wordt nu beheerd door de Agentic AI Foundation onder de Linux Foundation, overgenomen in ruim 60.000 repository's. Daarmee wordt het pre-sessie-contextbestand gepromoveerd van tool-specifiek gemak tot een volwaardig, draagbaar artefact: de sector erkent dat ‘wat de agent leest voordat jij iets zegt’ een eigen standaard verdient.

Wat het bewijs zegt over of dit allemaal helpt

Hier valt het prettige verhaal uiteen. Een team bij ETH Zurich (Gloaguen, Mündler, Müller, Raychev en Vechev) voerde een gecontroleerde evaluatie uit, “AGENTS.md evalueren,” naar de vraag of deze contextbestanden op repositoryniveau de prestaties van coding agents daadwerkelijk verbeteren. Over de bestudeerde agents en modellen heen was de uitkomst niet “contextbestanden werken” of “contextbestanden falen”. De huidige samenvatting stelt dat contextbestanden het slagen van taken over het algemeen niet verbeteren en de inferentiekosten gemiddeld met meer dan 20% verhogen. In de gedetailleerde resultaten van het paper waren door ontwikkelaars geschreven bestanden de uitzondering: ze verbeterden de prestaties met gemiddeld ongeveer 4%, maar verhoogden de kosten met tot 19%. Door een LLM gegenereerde bestanden gingen de verkeerde kant op: ze verlaagden de prestaties met gemiddeld ongeveer 3% en verhoogden de kosten met meer dan 20%. Een derde bevinding scherpt dit aan: agents roepen een tool 1,6 tot 2,5 keer vaker aan wanneer die tool in een contextbestand wordt genoemd, wat helpt of schaadt, volledig afhankelijk van de vraag of die extra aanroepen terecht waren.

Blijf even hangen bij de regel over door LLM's gegenereerde bestanden, want dat is de dragende. Een bestand dat je niet zelf hebt geschreven, of het nu door een model is gemaakt of gedownload uit een communitypakket met “beste CLAUDE.md-configs” en in je repo is gedropt, leest voor de agent als instructies van iemand die je codebase eigenlijk niet kent. In de modellen uit het onderzoek was dat per saldo negatief: je betaalde meer tokens voor iets slechtere resultaten. De Augment Code-artikel hierover vat het goed samen wanneer het opgestapelde resultaat ‘de rommellade van je agentcontext’ wordt genoemd. Elke plausibel ogende instructie die je erin schept, kost iets, en de instructies die jij niet hebt geschreven, voor een codebase die ze niet begrijpen, kosten meestal meer dan ze opleveren.

Ik lees dit niet als “contextbestanden zijn slecht” en niet als “contextbestanden zijn goed”. Dat zijn precies de alles-of-niets-kaders die bij aanraking met de data uit elkaar vallen. De smallere lezing is deze: context is infrastructuur die je bewust ontwerpt, en een bestand dat jij niet hebt geschreven, voor een codebase die het niet begrijpt, is een kostenpost en geen cadeau. Het voorbehoud over de reikwijdte telt ook. Dit is wat het paper vond voor de modellen en agents die het testte, geen universele wet over elk LLM. Maar het wijst hard in één richting, en het wordt vanaf de leverancierskant bevestigd: het applied-AI-team van Anthropic zelf wees op de verschuiving naar het “just in time” laden van context via tools tijdens runtime in plaats van alles vooraf in te laden, en beschrijft een hybride aanpak die sommige data vooraf ophaalt en de rest tijdens runtime verkent. Als het bedrijf dat CLAUDE.md uitbrengt neigt naar minder vooraf laden, verdient het instinct om een gigantisch contextbestand te kopiëren en plakken een tweede blik.

Conclusie van deze sectie: het auteurschap is het signaal dat voorspelt of context zich terugbetaalt. De tokenkosten zijn hoe dan ook hetzelfde; wat het rendement verandert, is of de instructies komen van iemand die de codebase echt kent.

De context die vervaagt: waarom de sessiestart niet het hele verhaal is

Preloading legt de randvoorwaarde vast. Het houdt die randvoorwaarde niet vast. Waar ontwikkelaars steeds tegenaan lopen, is de tweede helft van het verhaal: de context die je bij de start van de sessie zorgvuldig hebt neergezet, brokkelt af naarmate de sessie vordert, en dat gebeurt stilletjes.

Een nuttige manier om dit te begrijpen komt van het kader van het Mem0-team, dat stelt dat een het contextvenster is RAM, geen opslag, vluchtig en begrensd, geen blijvende plek waar je instructies wonen. Laad er aan het begin iets in en het is aanwezig; ga lang genoeg door zonder het te gebruiken en het vervaagt, zoals een variabele waar je niet meer naar verwijst uiteindelijk overschreven wordt. Dat is het mechanisme achter een patroon dat onderzoekers instructieverval noemen. Een studie uit 2026 van Gamage en collega's vond dat weglatingsinstructies bijzonder fragiel zijn: in één geteste opzet zakte de naleving van 73% bij beurt 5 naar ruwweg 33% bij beurt 16. Dat is een labresultaat, geen universele constante, maar het komt overeen met wat veel mensen in lange sessies ervaren.

De sessiegrens is waar het scherper wordt. Ontwikkelaars in een Hacker News-discussie melden dat gestarte subagents last kunnen hebben van problemen met de contextoverdracht, waardoor werk dat halverwege wordt overgedragen met minder context uit de bovenliggende sessie aankomt dan je dacht. En stilstand heeft zijn eigen prijs: in een thread waarin Boris Cherny van Anthropic gaf zijn mening, de discussie behandelt hoe een inactieve sessie een grote herbouw na cache-miss kan uitlokken, honderdduizenden tokens, zonder enige waarschuwing aan jou. De rode draad die de community blijft melden is stilte: compactie draait, eerdere redenering wordt weggeknipt, de kwaliteit zakt, en niets op het scherm vertelt je dat het gebeurd is. Je merkt alleen dat de output slechter werd.

Geeft zelf hosten je meer controle?

Draai het geheel zelf (Ollama plus Open WebUI, of een agent als Aider of Continue.dev die naar een lokaal model wijst) en het eerlijke antwoord op “krijg ik nu meer controle?” is: je krijgt meer zichtbaarheid, niet meer inherente controle. Dat onderscheid is het hele punt.

Wat self-hosting u werkelijk oplevert, is inzage. Er verlaten geen gespreksgegevens uw infrastructuur. U kunt de volledige systeemprompt lezen in plaats van een propriëtaire op goed vertrouwen te accepteren. Met een deterministisch hulpmiddel als Aider kunt u precies controleren wat er in elke modelaanroep terechtkwam: de repo-map is een leesbaar artefact, geen semantische black box zoals de embedding-index van Cursor. Voor iedereen die om controleerbaarheid en reproduceerbaarheid geeft, om het kunnen beantwoorden van de vraag “wat heeft de agent daadwerkelijk gezien?”, is die inzichtelijkheid echt, en dat is niet niks.

Maar de architecturale omkering maakt het niet uit waar het model draait. Of je nu een lokaal model via Ollama gebruikt, Claude Code tegen een cloud-API of Cursor op abonnement, de agent leest nog steeds zijn pre-sessiecontext voordat jij iets zegt, en jij moet die context nog steeds bewust ontwerpen. De discipline is identiek. Zelf hosten geeft je een helderder venster op het mechanisme; het geeft je geen ander mechanisme, en het ontslaat je zeker niet van de les van ETH Zurich over wat er gebeurt als je context laadt die je niet zelf hebt geschreven. De ene verschuiving die het waard is om hieruit mee te nemen: behandel het contextbestand niet langer als een cadeau dat je de agent geeft, maar als infrastructuur met terugkerende kosten. Schrijf op wat je echt van de codebase begrijpt, laad liever minder dan meer, en onthoud dat de agent jou als eerste heeft gelezen. De versie van jou die hij las, zou er dus een moeten zijn waar je achter staat.

Veelgestelde vragen

Lezen AI-codeeragenten je bestanden voordat je iets typt?

Ja. Bij het starten van een sessie laadt een AI-codeeragent zijn systeemprompt, zijn tooldefinities en jouw contextbestanden (CLAUDE.md, .cursorrules of AGENTS.md), samen met een eventuele repo-map of geheugenbestand, allemaal vóór je eerste bericht. In Claude Code wordt de CLAUDE.md specifiek als gebruikersbericht afgeleverd, direct na de systeemprompt, waardoor het gesprek in feite met jouw bestand begint in plaats van met jou.

Verbeteren contextbestanden zoals CLAUDE.md de agentprestaties werkelijk?

Gedeeltelijk, en minder dan de meeste mensen aannemen. In de ETH Zurich-evaluatie van AGENTS.md-stijlbestanden, zegt de huidige samenvatting dat contextbestanden het slagen van taken over het algemeen niet verbeteren en de inferentiekosten gemiddeld met meer dan 20% verhogen. De gedetailleerde resultaten zijn nuttiger voor de praktijk: door ontwikkelaars aangeleverde bestanden verbeterden de prestaties gemiddeld met ongeveer 4%, maar verhoogden de kosten met tot 19%, terwijl door een LLM gegenereerde bestanden de prestaties gemiddeld met zo'n 3% verlaagden en de kosten met meer dan 20% opdreven. De praktische lezing: een bestand dat je zelf schreef en begrijpt kan een beetje helpen; een bestand dat je niet schreef kan je stilletjes geld kosten.

Hoeveel van het contextvenster wordt gebruikt voordat ik een bericht stuur?

Een aanzienlijk deel. De systeemprompt, tooldefinities en gedragsinstructies laden vóór enige gebruikersinvoer en samen verbruiken ze een merkbaar stuk van het effectieve contextvenster. Je bruikbare werkbudget is kleiner dan het geadverteerde contextvenster van het model door deze vaste opstartoverhead.

Geeft zelf hosten van een AI-model je meer controle over de context?

Meer inzicht, niet meer intrinsieke controle. Zelf hosten laat je de volledige systeemprompt inspecteren, houdt gespreksdata op je eigen infrastructuur en (met een deterministische tool als Aider) laat je precies auditen wat er in elke aanroep ging. Maar de architectuur van de context vóór de sessie is dezelfde als bij cloudtools, en je moet je context nog steeds bewust ontwerpen.

Wat is AGENTS.md?

AGENTS.md is een open formaat dat coding agents vertelt hoe ze met een codebase moeten werken, de agentgerichte tegenhanger van een README. Het ontstond breed in het ecosysteem van agent-tooling (OpenAI Codex, Amp, Jules van Google, Cursor en Factory) en wordt nu beheerd door de Agentic AI Foundation onder de Linux Foundation, met adoptie in ruim 60.000 repositories. Daarmee is het de opkomende tooloverstijgende standaard voor agentcontext vóór de sessie.