Contextcompactie: hoe AI-assistenten hun geheugen opschonen
Stel je voor dat je een assistent hebt die alles onthoudt wat er in een gesprek is gezegd, maar slechts een beperkt aantal blaadjes notitieblok tot zijn beschikking heeft. Zodra het blok vol is, moet er iets gebeuren: ofwel stopt de assistent met werken, ofwel vat hij de oudste notities samen tot een paar kernzinnen om weer ruimte te maken. Dat tweede is in de kern wat contextcompactie is: een techniek waarmee AI-taalmodellen en AI-agents (systemen die zelfstandig meerdere stappen uitvoeren, zoals code schrijven of onderzoek doen) hun gespreksgeschiedenis inkorten zodra die te groot dreigt te worden.
Het probleem waar contextcompactie een antwoord op is, speelt vooral bij AI-systemen die lang en zelfstandig doorwerken: een programmeer-assistent die urenlang bestanden leest, commando's uitvoert en foutmeldingen verwerkt, bijvoorbeeld. Elke regel tekst die het model ziet of produceert, telt mee voor het zogeheten contextvenster, de eindige "werkruimte" van het model. Zonder compactie loopt die werkruimte op den duur vol, met als gevolg dat het systeem vastloopt, trager wordt of eerdere afspraken en instructies simpelweg "vergeet". Contextcompactie probeert dat te voorkomen door tussentijds samen te vatten wat er tot dan toe is gebeurd.
Wat is het precies?
Om contextcompactie te begrijpen, helpt het eerst te weten wat een contextvenster is. Een taalmodel als Claude of ChatGPT verwerkt tekst in kleine stukjes die tokens heten, ongeveer een woorddeel per token. Elk model heeft een maximumaantal tokens dat het tegelijk kan "zien": de vraag, eerdere berichten, eventuele documenten en het antwoord dat het genereert, alles telt mee. Bij een gewoon chatgesprek is dat zelden een probleem, maar bij een AI-agent die zelfstandig taken uitvoert, groeit de geschiedenis razendsnel: elke bestandsinhoud die wordt ingelezen, elke terminaluitvoer, elke tussenstap komt erbij.
Contextcompactie grijpt in voordat dat venster overloopt. Het proces verloopt doorgaans in een paar stappen. Eerst houdt het systeem bij hoeveel van het beschikbare venster al gebruikt is. Nadert dat een kritieke grens, dan wordt de oudere geschiedenis geselecteerd om samen te vatten, terwijl de meest recente en meest relevante berichten intact blijven. Vervolgens wordt het taalmodel zelf gevraagd om die oudere geschiedenis te comprimeren tot een beknopte samenvatting: wat was het doel, welke beslissingen zijn genomen, welke bestanden zijn aangepast, welke problemen zijn nog open. Die samenvatting vervangt daarna de gedetailleerde geschiedenis, waardoor er weer ruimte vrijkomt om door te werken, terwijl de essentie behouden blijft.
Het verschil met simpelweg "de oudste berichten weggooien" is belangrijk. Weggooien verliest informatie zonder onderscheid; compactie probeert selectief te zijn en het belangrijkste te bewaren. Dat maakt het een vorm van geheugenbeheer, vergelijkbaar met hoe een besturingssysteem van een computer actief geheugen (RAM) beheert door minder gebruikte gegevens tijdelijk naar de harde schijf te verplaatsen: niet alles hoeft continu "paraat" te zijn.
Wat wil men ermee bereiken?
De directe motivatie is praktisch: zonder compactie lopen langlopende AI-sessies simpelweg vast tegen de grenzen van het contextvenster. Bedrijven die AI-agents bouwen willen dat gebruikers niet halverwege een taak opnieuw moeten beginnen en alles opnieuw moeten uitleggen. Compactie moet zorgen voor continuïteit: de agent blijft werken alsof er niets is gebeurd, ook al is de onderliggende geschiedenis flink ingekort.
Er speelt ook een kostenoverweging mee. Elk token dat een model verwerkt, kost rekentijd en dus geld, en langere gesprekken worden trager naarmate ze groeien. Door periodiek te comprimeren, blijven verzoeken sneller en goedkoper, zonder dat de gebruiker daar iets van hoeft te merken.
Achterliggend is er een breder streven: het mogelijk maken van "langlopende" AI-agents die uren of zelfs dagen aan een taak kunnen werken zonder menselijke tussenkomst, bijvoorbeeld bij het onderhouden van een softwareproject of het uitvoeren van een onderzoeksopdracht in meerdere stappen. Zulke autonome werkwijzen zijn alleen haalbaar als het systeem een manier heeft om relevante informatie vast te houden zonder dat het geheugen ongelimiteerd blijft groeien. Contextcompactie is een van de bouwstenen die dat mogelijk moet maken, naast verwante technieken zoals grotere contextvensters en systemen die informatie extern opslaan en er later weer bij zoeken.
Voorbeelden uit de praktijk
Contextcompactie is geen abstract idee, het zit al in verschillende bestaande systemen.
Claude Code (Anthropic) is een AI-programmeer-assistent die via de opdrachtregel werkt en lange sessies aan kan gaan waarin bestanden worden gelezen, code wordt geschreven en commando's worden uitgevoerd. Het bevat een handmatig commando om het gesprek samen te vatten en ruimte te maken, en ook een automatische variant die inspringt zodra het contextvenster bijna vol raakt, zodat de gebruiker daar zelf niet actief op hoeft te letten.
MemGPT is een onderzoeksproject uit 2023 van onderzoekers aan de University of California, Berkeley. Zij stelden voor om een taalmodel te behandelen als een besturingssysteem met beperkt werkgeheugen: informatie die niet direct nodig is, wordt "uitgepaged" naar een extern geheugen en later weer teruggehaald wanneer relevant, op dezelfde manier waarop een computer geheugenpagina's beheert. Dit onderzoek groeide later uit tot een apart bedrijf dat zich richt op geheugenbeheer voor AI-agents.
LangChain, een veelgebruikt open source raamwerk voor het bouwen van AI-toepassingen, biedt al enkele jaren kant-en-klare "geheugenmodules" die oudere berichten in een gesprek automatisch laten samenvatten door een taalmodel, zodat ontwikkelaars dit niet zelf van de grond af hoeven te bouwen.
Ook bij andere AI-programmeerassistenten en agentplatformen die de afgelopen jaren zijn verschenen, duiken vergelijkbare mechanismen op, vaak onder net iets andere namen zoals "geheugensamenvatting" of "sessiecompressie". De precieze werking verschilt per aanbieder en wordt zelden volledig openbaar gemaakt.
Hoe ver is de techniek?
Op basaal niveau, het periodiek laten samenvatten van een gesprek door het taalmodel zelf, is de techniek volwassen en in gebruik bij meerdere productiesystemen. Het is relatief eenvoudig te implementeren: vraag het model om een samenvatting, vervang de oude tekst erdoor, ga verder.
De lastigere vraag is wat je wel en niet mag verliezen bij het comprimeren. Een samenvatting is per definitie een keuze: informatie die het model op dat moment onbelangrijk lijkt, kan later alsnog cruciaal blijken, bijvoorbeeld een specifieke technische eis die pas veel later weer relevant wordt. Gebruikers van AI-programmeer-assistenten melden soms dat een systeem na een compactie een eerder gemaakte afspraak "vergeet" of een detail verkeerd reconstrueert. Dit is een bekend en nog niet opgelost knelpunt.
Onderzoekers experimenteren daarom met verfijningen: gelaagde samenvattingen (een korte samenvatting van samenvattingen), het apart bewaren van "harde feiten" zoals bestandsnamen of code, en combinaties met technieken waarbij het model actief in een extern archief kan opzoeken wat het nodig heeft in plaats van alles standaard mee te dragen. Ook groeien de contextvensters van modellen zelf snel, wat de druk op compactie deels vermindert, maar niet wegneemt: hoe groter het venster, hoe groter ook de hoeveelheid tekst die een langlopende agent kan verzamelen.
Kortom: de basistechniek werkt en wordt breed toegepast, maar de betrouwbaarheid ervan bij complexe, langlopende taken is nog een actief onderzoeksgebied zonder pasklare oplossing.
Wie werken eraan?
Anthropic, de maker van Claude en Claude Code, past contextcompactie toe in zijn eigen producten en publiceert daar ook over. OpenAI werkt met vergelijkbare mechanismen in zijn agentgerichte producten en API's. Op onderzoeksniveau is de University of California, Berkeley een belangrijke naam vanwege het MemGPT-werk, dat inmiddels is doorontwikkeld door een gespecialiseerd bedrijf op het gebied van AI-geheugenbeheer. Daarnaast dragen open source gemeenschappen bij, met LangChain als bekend voorbeeld van een raamwerk waarin dit soort geheugenmodules voor iedereen beschikbaar zijn. Grote AI-labs zoals Google DeepMind onderzoeken verwante richtingen, met name het vergroten van contextvensters zelf, wat het compactievraagstuk vanuit een andere hoek benadert. Het geheel is een verspreid en snel bewegend veld: veel van de kennis wordt gedeeld via technische blogposts, preprints en opensourcecode, minder via traditionele wetenschappelijke tijdschriften.