Agent memory

Wat is agent memory?

Agent memory is alles wat een AI-agent bewust bijhoudt tussen sessies door, in tegenstelling tot wat er op dit moment toevallig in zijn context window zit. Sluit het gesprek af, kom morgen terug, en dat context window is leeg. Wat blijft staan, dat is het geheugen.

De twee worden vaak door elkaar gehaald. Een context window van een paar honderdduizend tokens voelt als geheugen zolang je in datzelfde lange gesprek zit. Dat is het niet. Het is een werkblad dat leeggeveegd wordt zodra de sessie stopt. Geheugen is een keuze die iemand gemaakt heeft over wat de moeite waard was om op te schrijven.

De memory tool van Anthropic beschrijft het nuchter: het model kan bestanden aanmaken, lezen, aanpassen en verwijderen die tussen sessies blijven bestaan, zodat kennis zich opbouwt zonder dat alles in het context window moet blijven staan. Die bestanden staan in een map die jouw eigen toepassing beheert. Het model vraagt de bewerkingen alleen aan.

Kortetermijn- en langetermijngeheugen

Kortetermijngeheugen is het gesprek waar je nu in zit. LangGraph noemt dat thread-scoped memory en omschrijft een thread als iets dat meerdere interacties in één sessie groepeert, zoals mail berichten in één conversatie bundelt. Een checkpointer schrijft die toestand naar een database, zodat de draad later weer opgepikt kan worden.

Langetermijngeheugen is wat over die grenzen heen gaat. De documentatie van LangGraph beschrijft het als gegevens die over sessies heen bewaard worden en gedeeld worden tussen gesprekken. Dat delen is net de bedoeling, en meteen ook waar het spannend wordt: iets wat een agent op een dinsdag oppikt, komt een maand later boven in een gesprek dat er niets mee te maken heeft.

Daaronder onthoudt het model zelf helemaal niets. OpenAI zegt het onomwonden: elke aanvraag staat op zichzelf en is stateless. Alles wat op continuïteit lijkt, of je nu de vorige berichten zelf opnieuw meestuurt of ze aan elkaar rijgt met previous_response_id, is jouw toepassing die tekst opnieuw voorlegt aan een model dat de boel al vergeten was.

Hoe agent memory gebouwd wordt

In de praktijk kom je drie manieren tegen.

• Een geheugenbestand. De agent leest een bestand bij de start van een taak en schrijft er tijdens het werk in bij. Zo werkt de tool van Anthropic, met een /memories-pad dat jouw code doorvertaalt naar echte opslag. Het voordeel is dat het leesbaar blijft: je opent het bestand, ziet precies wat de assistent over een klant denkt te weten, en schrapt een lijn waar je het niet mee eens bent.

• Een vector store. Feiten worden als embeddings bewaard en op betekenis teruggehaald in plaats van op exacte bewoording. Dat is dezelfde machinerie als een vector database voor retrieval, dus teams die al met RAG werken grijpen daar meestal eerst naar.

• Een gestructureerd profiel. Een vaste set velden in een gewone databasetabel: voorkeurstaal, dossierbeheerder, facturatieritme, welke tools er draaien. Saai, makkelijk na te kijken, en moeilijk voor de agent om te vervuilen omdat hij enkel vakjes kan invullen die jij hebt vastgelegd.

LangGraph splitst de inhoud op in drie soorten die het waard zijn om ook in je eigen ontwerp uit elkaar te houden: semantisch geheugen voor feiten en begrippen, episodisch geheugen voor gebeurtenissen uit het verleden, en procedureel geheugen voor de regels waarmee een taak uitgevoerd wordt. "Deze klant factureert maandelijks" is een feit. "We hebben hun rapportering in maart gemigreerd" is een gebeurtenis. "Stuur altijd eerst een korte duiding en dan pas de cijfers" is een regel.

Er zit ook een timingkeuze in. Je kan geheugen wegschrijven tijdens het gesprek zelf, waardoor het meteen bruikbaar is, of achteraf in een aparte taak, waardoor de gebruiker minder lang wacht en het beheer van geheugen los komt te staan van de rest van de toepassing.

Agent memory tegenover RAG

Allebei zetten ze tekst voor het model die er een tel eerder nog niet stond, dus de verwarring is begrijpelijk. Het verschil zit in wie die tekst geschreven heeft.

RAG haalt op uit materiaal dat iemand bewust verzameld heeft: jouw procedures, productfiches, een kennisbank. De agent leest dat en verandert er niets aan. Geheugen haalt op uit materiaal dat de agent zelf geschreven heeft, over jou, zonder dat iemand elke lijn heeft goedgekeurd. Daarom moet iemand geheugen kunnen nakijken en een zoekindex meestal niet.

Het Agent Framework van Microsoft houdt die twee ook uit elkaar. Ophalen gebeurt via een context provider die een store doorzoekt, terwijl de gesprekstoestand in een sessieobject zit dat je wegschrijft en later opnieuw inleest.

Wat niet in agent memory hoort

Van zodra een assistent dingen onthoudt, wordt hij een systeem dat persoonsgegevens bewaart. Daarmee komt de GDPR binnen bij een functie die de meeste teams als een gemakje uitrollen. Artikel 5(1)(c) vraagt dat persoonsgegevens toereikend zijn, ter zake dienend en beperkt tot wat noodzakelijk is voor het doel. Artikel 5(1)(e) vraagt dat ze niet langer herleidbaar bewaard blijven dan dat doel nodig heeft.

Leg die twee naast een geheugenbestand dat achttien maanden lang notities over een contactpersoon heeft verzameld en de spanning is snel duidelijk. Wat dat concreet betekent:

• Geen wachtwoorden, tokens of verbindingsgegevens. Het model weigert dat meestal zelf, maar de garantie moet uit controle in jouw code komen, niet uit de goede manieren van een model.

• Geen cijfers die bewegen. Omzet, aantal medewerkers, openstaande tickets: die horen in het systeem dat ze beheert, niet in een notitie die de agent volgend kwartaal nog altijd citeert.

• Niets wat je niet zou durven tonen aan de persoon over wie het gaat. Dat is de eerlijke test, en strenger dan om het even welk beleid dat je opschrijft.

Je hebt ook een manier nodig om te wissen. Als een klant vraagt wat een assistent over hem bijhoudt, is "dat zit ergens in de vectoren" geen antwoord.

Waar moet je op letten bij het gebruik van agent memory

Geheugen veroudert en niemand krijgt een seintje. Een agent die in januari een contactpersoon noteerde, blijft mails richten aan iemand die in maart vertrokken is. Niets in de keten gaat een opgeschreven feit opnieuw na, dus oude lijnen worden met evenveel stelligheid geciteerd als verse. Zet een datum bij elke lijn en ruim op wat niemand nog aanraakt.

Eén slechte sessie besmet de rest. Geheugen is een plek waar geschreven wordt, dus een prompt injection die één keer binnengeraakt, stopt niet bij dat gesprek. Instructies die in een geheugenbestand belanden, worden bij elke volgende run opnieuw ingelezen. Zo wordt een eenmalige truc een blijvende. Behandel alles wat de agent zelf geschreven heeft als onbetrouwbare invoer op het moment dat het terugkomt.

De privacyvraag wordt het vaakst overgeslagen. Een assistent die je klanten onthoudt, doet iets waar die klanten niet mee akkoord zijn gegaan tenzij iemand het hen gezegd heeft. Beslis wat er bewaard wordt, zet het in je privacyverklaring, en geef mensen een manier om het te lezen en te laten wissen. Anthropic wijst zelf dezelfde richting uit: begrens hoe groot geheugenbestanden mogen worden en verwijder periodiek de bestanden die al lang niet meer geraadpleegd zijn.