Context compaction

Wat is context compaction?

Context compaction is wat een AI-assistent doet wanneer een lange sessie tegen de grens van zijn context window loopt. Hij vat het gesprek tot dan toe samen en begint opnieuw met een vers context window waarin enkel die samenvatting zit. Anthropic omschrijft het net zo: een gesprek dat de grens van het context window nadert, samenvatten en een nieuw context window starten met die samenvatting. De sessie loopt door, de ruwe geschiedenis erachter niet.

Even dit vooraf, want het woord betekent in onze sector twee verschillende dingen. Dit is niet hetzelfde als table compaction, waarbij veel kleine Parquet-bestanden in een lakehouse samengevoegd worden tot minder grote. Zelfde werkwoord, andere laag. Bij table compaction verandert er geen enkele rij, enkel de bestandsindeling. Bij context compaction verlies je wel degelijk detail.

De versie die je in de praktijk tegenkomt: een assistent werkt al een uur met je mee en vergeet dan plots een regel die je helemaal in het begin hebt meegegeven. Meestal is dat compaction. Die regel zat in het stuk gesprek dat is weggesamenvat.

Wat overleeft een compaction en wat niet?

De scheidslijn is eenvoudig. Alles wat opnieuw van schijf wordt ingeladen, overleeft, want het wordt herlezen in plaats van onthouden. Alles wat enkel als bericht in het gesprek bestond, hangt volledig af van de samenvatting.

Claude Code documenteert die splitsing voor de eigen opzet. De system prompt blijft ongewijzigd, want die maakte nooit deel uit van de berichtengeschiedenis. Een CLAUDE.md in de projectroot en het automatische geheugen worden opnieuw van schijf ingeladen. Regels met paths:-frontmatter en CLAUDE.md-bestanden in submappen zijn verloren tot er weer een passend bestand gelezen wordt, precies omdat ze pas in het gesprek terechtkwamen toen zo'n bestand gelezen werd. Skills komen terug, maar afgetopt op 5.000 tokens per skill en 25.000 tokens in totaal, waarbij de oudste er eerst uit vliegen.

De samenvatting zelf is een inschatting van een model. Anthropic beschrijft de aanpak van Claude Code als: architectuurbeslissingen, openstaande bugs en implementatiedetails bewaren, en overbodige toolresultaten of berichten laten vallen. Verstandige keuzes. Het zijn wel keuzes over de stand van het werk, niet over de afspraken die je errond gemaakt hebt.

Daarom is een instructie uit je allereerste bericht het klassieke slachtoffer. "Nooit naar de productieomgeving schrijven." "Alles in het Nederlands." "Deze klant betaalt per uur, dus geen refactors die niemand gevraagd heeft." Dat zijn zinnen van één regel zonder verdere draad eraan, en een samenvatter die naar de voortgang van het werk kijkt, heeft weinig reden om ze mee te nemen. Anthropic waarschuwt daar zelf voor: te agressief samenvatten kost je subtiele context waarvan het belang pas later duidelijk wordt.

Compaction versus oude berichten weggooien

Het bottere alternatief is trimmen: tokens tellen en de oudste berichten schrappen zodra je de grens nadert. De documentatie van LangChain is daar eerlijk over en zegt dat je bij het schrappen of verwijderen van berichten informatie verliest. Compaction is precies het antwoord daarop. Samenvatten in plaats van weggooien, zodat er van de oudere beurten iets overblijft in samengeperste vorm.

Niets doen is slechter dan beide. OpenAI waarschuwt in zijn documentatie over gespreksstatus dat een te grote prompt het context window van een model kan overschrijden, en dat tokens boven die limiet afgekapt kunnen worden in het antwoord. Compaction gaat tenminste bewust achteruit in plaats van zomaar af te breken.

Het is intussen ook een functie van de API zelf en niet enkel gedrag van een assistent. De Responses API van OpenAI voert compaction aan serverzijde uit zodra de context een ingestelde tokendrempel passeert, en er is een apart endpoint dat je zelf oproept om een samengeperst context window terug te krijgen voor je volgende oproep. Wat je terugkrijgt is bewust ondoorzichtig en niet bedoeld om zelf te lezen. Dat detail is het onthouden waard: je kan niet nakijken wat er precies bewaard is.

Automatische compaction of zelf het moment kiezen

Automatische compaction springt aan wanneer je tegen het plafond botst. Ze perst samen wat er op dat moment toevallig aan de gang is, en gokt naar wat belangrijk was. Claude Code doet dat automatisch naarmate je de limiet nadert, zodat een vol context window je sessie niet beëindigt. Op zich prima, maar het moment wordt bepaald door je tokenteller en niet door de vorm van het werk.

Zelf overdragen betekent dat jij het moment en de inhoud kiest. Met /compact maak je in Claude Code plaats vrij door het gesprek samen te vatten, en met een instructie erbij, bijvoorbeeld /compact focus op de auth-bug, bewaar je wat jij aanduidt in plaats van wat de automatische ronde vermoedt. /clear gaat verder en start een gesprek met een leeg context window. Dat is de betere keuze wanneer de volgende taak niets met de vorige te maken heeft.

De gewoonte die daaruit volgt: comprimeer voor je aan een lange nieuwe taak begint, niet nadat de contextbalk rood kleurt.

Waarom een bestand op schijf beter is dan de samenvatting

De duurzame oplossing is het gesprek niet langer als opslagplaats gebruiken. Zet de beslissingen in een bestand in de repository, dan leest de assistent ze terug in plaats van ze te moeten onthouden. Anthropic noemt die techniek gestructureerd notities nemen, of agentgeheugen: de agent schrijft regelmatig notities weg buiten het context window en haalt ze er later opnieuw bij.

Voor een data- of BI-project betekent dat concreet dat wat je anders in elke chat herhaalt, gewoon opgeschreven staat: naamgeving voor measures, welke omgeving veilig is om naar te schrijven, de berekening die al rechtgezet is en niet opnieuw uitgevonden moet worden, de rapporteringskalender van de klant. Dat kost vijf minuten en het haalt een hele categorie verrassingen weg.

De scheefheid is het punt. Een bestand op schijf overleeft een compaction, overleeft /clear, en staat er volgende week nog wanneer een collega het werk overneemt. Een samenvatting doet dat geen van drieën betrouwbaar.

Waar moet je op letten bij het gebruik van context compaction?

• Herhaal je harde afspraken na een compaction. Draait een sessie lang genoeg om samengevat te zijn, ga er dan van uit dat de regels uit je openingsbericht niet meer meespelen. Zeg ze opnieuw, of beter, zet ze in een bestand dat de assistent herlaadt.

• Een zelfzekere assistent is geen assistent die het zich herinnert. Na een compaction behandelt het model zijn eigen samenvatting als het verslag. Staat er iets onvolledig of fout in, dan is er niets in de sessie dat daarover aan de bel trekt.

• Compaction is niet gratis. Een bijna vol context window samenvatten is zelf een modeloproep over dat volledige window, dus het kost tokens en tijd op het moment dat het gebeurt.

• Een langere sessie is geen betere sessie. Is de taak echt veranderd, dan is leegmaken beter dan samenvatten. Een samenvatting van werk dat er niet meer toe doet, neemt plaats in en geeft het model oude aannames om mee verder te redeneren.