Sla direct naar inhoud
Implementatie

AI-agent geheugen: waarom je Claude-agent vergeet en hoe je dat fixt

Door Mike van BeaumondAI Engineer · company brain & automatiseringgepubliceerd op

9 min leestijd
AI-agent geheugen: waarom je Claude-agent vergeet en hoe je dat fixt
Quick Take: AI-agent geheugen is geen toggle maar een set van vier mechanismen: in-context, extern (RAG), parametrisch en episodisch. Wie dat negeert, bouwt een demo die in productie binnen een maand vastloopt op context rot of ruis.

Reality check: je hebt een Claude-agent gebouwd die er in de demo fantastisch uitzag. Twee weken later in productie vergeet hij halverwege een gesprek wat je in de eerste zin zei, of trekt hij rare conclusies uit documenten die er niets mee te maken hebben.

Dat is geen bug. Dat is een architectuurkeuze die je nooit bewust hebt gemaakt. De meeste teams behandelen "geheugen" als een aan/uit-knop, maar in productie is het het zenuwstelsel van je agent.

Wat is AI-agent geheugen eigenlijk?

Direct antwoord: Agent-geheugen is de informatie die een AI-systeem tijdens en tussen gesprekken actief bijhoudt, los van wat het model al weet uit de training.

Een Claude-agent combineert twee dingen: statische kennis uit de training (parametrische kennis) en realtime informatie die jij of je workflow tijdens het gesprek toevoegt. Die tweede laag is waar het interessant wordt, want dat is de laag die jij als bouwer kunt sturen.

De trainingskennis van een model ligt vast. Daar verander je niets aan zonder een dure hertraining. Het geheugen dat je tijdens runtime injecteert is dus je belangrijkste hefboom om een agent feitelijk juist en consistent te houden.

Welke soorten geheugen heeft een AI-agent?

Quick Take: Er is geen "beste" geheugentype. In-context is snel maar beperkt, extern geheugen schaalt maar introduceert ruis, en episodisch geheugen voelt persoonlijk maar moet actief worden opgeschoond.

Bij vanbeaumond.nl leggen we dit in trainingen altijd uit met vier bouwblokken. Productie-systemen combineren meestal meerdere van deze vier, omdat elk type zijn eigen plafond heeft.

1. In-context geheugen (kortetermijn)

Dit is het geheugen dat in de prompt zelf leeft: de chathistorie en systeeminstructies die het model direct ziet.

  • Voordeel: razendsnel en precies, want het model leest letterlijk elk woord.
  • Nadeel: hard plafond. Bij lange gesprekken verliest het model grip op details uit het midden van het gesprek, of loopt de context simpelweg vol.

2. Extern geheugen (vector search / retrieval)

Te veel data voor in de prompt? Dan verplaats je het naar een retrieval-laag. Documenten worden opgeslagen als embeddings en alleen de relevante stukken worden er op opzoekmoment ingeladen.

  • Voordeel: vrijwel onbeperkte opslag, voorspelbare tokenkosten.
  • Nadeel: retrieval is niet perfect. Een slechte chunking-strategie voedt het model met ruis in plaats van met het juiste antwoord.

3. Parametrisch geheugen (de trainingskennis)

Dit is de kennis die in de modelgewichten zelf zit, opgebouwd tijdens de training.

  • Voordeel: geen extra latency, breed algemeen begrip van de wereld.
  • Nadeel: verouderd vanaf het moment dat de training stopt. Voor actuele bedrijfsdata is dit per definitie geen betrouwbare bron.

4. Episodisch geheugen (over sessies heen)

Om een agent consistent te houden over dagen of weken, heb je persistente opslag van voorkeuren en eerdere beslissingen nodig, gekoppeld aan een sessie- of gebruikers-ID.

  • Voordeel: voelt aan als een systeem dat je daadwerkelijk kent, ook na een herstart.
  • Nadeel: zonder een strategie om oude data samen te vatten of te laten vervallen, wordt de geschiedenis een opgeblazen brij die elke reactie vertraagt.

Hoe implementeer je dit in de praktijk?

Quick Take: Kies RAG als startpunt voor de meeste MKB-cases. Agentic RAG en GraphRAG zijn pas nodig als je merkt dat één zoekopdracht structureel niet genoeg is.

Zodra je van theorie naar bouwen gaat, kies je eigenlijk een topologie: hoe stroomt data tussen gebruiker, opslag en het model. Drie aanpakken kom je in elk MKB-project tegen.

RAG: de standaard

Bij standaard retrieval-augmented generation haalt het systeem vooraf de meest relevante stukken tekst op en stopt die in de prompt, voordat het model de vraag zelfs ziet. Dit werkt goed voor een vaste kennisbank, zoals een personeelshandboek of productdocumentatie.

De operationele last zit in de chunking. Te kleine stukken tekst en je verliest context. Te grote stukken en je tokenbudget loopt vol.

Agentic RAG: het model zoekt zelf

Hier beslist het model zelf of, waar en hoe het moet zoeken, in plaats van dat een vaste pijplijn dit vooraf doet. Dit past bij onderzoekstaken waarbij één zoekopdracht niet genoeg is.

Het nadeel: dit is veel moeilijker te debuggen. Je krijgt niet-deterministische zoekpaden en hogere kosten, omdat de agent soms meerdere stappen nodig heeft voor een antwoord.

GraphRAG: voor sterk verbonden data

Hier voeg je een kennisgraaf toe aan de standaard vector-opslag, zodat het model relaties tussen entiteiten kan volgen in plaats van alleen losse tekstfragmenten te vergelijken. Geschikt als je vragen wilt beantwoorden over honderden documenten tegelijk.

Nadeel: je moet eerst die graaf bouwen en onderhouden, wat tijd en geld kost.

Waarom faalt agent-geheugen toch nog in productie?

Quick Take: De meeste geheugenproblemen in productie hebben niets met het model te maken. Het zit in de architectuur eromheen: chunking, samenvatten, en het moment waarop je een agent laat stoppen met zoeken.

Laten we eerlijk zijn: een werkende demo is geen bewijs dat het systeem standhoudt. De problemen die we bij klanten het vaakst zien, zitten in drie patronen.

Context rot bij lange gesprekken

Transformer-modellen letten relatief sterk op het begin en het einde van een lange prompt, en minder op het midden. Daardoor kan een agent de kernopdracht van een lange taak verliezen terwijl hij de begroeting nog perfect onthoudt.

Pro tip: comprimeer oudere stukken van het gesprek periodiek tot een korte samenvatting, zodat de belangrijkste feiten in de zones blijven waar het model het beste op let.

Ruis bij retrieval op schaal

Vector search werkt op semantische gelijkenis, en gelijkenis is niet hetzelfde als relevantie. Bij schaal trekt een zoekopdracht regelmatig stukken tekst aan die wel op woorden lijken, maar niets met de vraag te maken hebben.

Pro tip: combineer dense en sparse vectors (hybride zoeken) en voeg een re-ranker toe die de daadwerkelijke relevantie scoort voordat iets het model bereikt.

Agentic loops die afdwalen

Als een agent zelf zijn zoekopdrachten bepaalt, kan één matige zoekactie een kettingreactie veroorzaken. De agent gebruikt de ruis uit de eerste zoekopdracht om de volgende te formuleren, en raakt zo steeds verder van de oorspronkelijke vraag verwijderd.

Pro tip: bouw een controlestap in. Valt de betrouwbaarheid van een zoekresultaat onder een bepaalde drempel, dan stopt de agent en vraagt om verduidelijking in plaats van door te zoeken.

Wat doet een geheugenoplossing niet voor je?

Spoiler: er bestaat geen kant-en-klare geheugenoplossing die je probleem in een middag oplost. Een paar dingen die wij altijd benoemen voordat een klant begint.

  • Geen geheugentype maakt foute brondata correct. Als je kennisbank verouderd is, blijft de agent verouderde antwoorden geven, hoe goed de retrieval ook werkt.
  • Episodisch geheugen onthoudt geen dingen die je nooit hebt vastgelegd. Een agent verzint geen voorkeuren, die moet je actief opslaan.
  • Agentic RAG is geen vervanging voor een heldere taakomschrijving. Een agent die zelf mag zoeken, zoekt niet per se slimmer, alleen vrijer.
  • Meer geheugen is niet altijd beter. Een te volle context verhoogt kosten en kan de output juist minder scherp maken.

Mijn take: begin klein. Eén goed werkende RAG-pijplijn op je belangrijkste kennisbron levert vaak meer op dan een uitgebreide multi-laag architectuur die niemand in je team kan onderhouden.

Hoe pak je dit aan in een Claude-werkproces?

In mijn ervaring werkt een gelaagde aanpak het best voor MKB-teams die met Claude of Claude Code werken. Geen losse vector-database optuigen voor elk klein project, maar bewust kiezen welke laag je nodig hebt.

Een voorbeeld van een instructie om context-samenvatting te forceren bij lange sessies:

text
Vat het gesprek tot nu toe samen in maximaal 5 zinnen.
Behoud alleen: openstaande taken, gemaakte beslissingen, en
afspraken over format of stijl. Laat begroetingen en
herhaalde uitleg weg.

Dit soort instructie geef je periodiek mee, bijvoorbeeld elke twintig berichten, zodat je context window niet vol raakt met ruis terwijl de kern van het gesprek behouden blijft.

Voor automation rond deze geheugenlaag, denk aan periodieke samenvattingen of synchronisatie tussen je database en agent, bouwen we dit vaak als een losse AI workflow. Daarmee zit de opslag- en samenvattingsstap als controleerbare stap in je pijplijn, in plaats van verstopt in je agent-code.

Wat is de bottom line?

Bottom line: agent-geheugen is geen vinkje dat je aanzet, het is een architectuurbeslissing met directe impact op kosten, snelheid en betrouwbaarheid. Wie dit negeert, bouwt een demo die in productie binnen een maand vastloopt op context rot of ruis.

Geen bullshit, gewoon resultaten: de teams die hier goed mee omgaan, beginnen klein, kiezen bewust één geheugentype per probleem, en breiden pas uit als de eerste laag bewezen stabiel draait.

Herkenbaar? Laten we praten.

In 30 minuten kijken we samen met welke afdeling je brein begint. Vrijblijvend.

Veelgestelde vragen

Nee. Een eenmalige vraag-antwoord taak heeft vaak genoeg aan in-context geheugen. Geheugen wordt pas relevant zodra een agent meerdere stappen zet of gesprekken over sessies heen moet onthouden.

Nee. RAG is één implementatie van extern geheugen, gericht op het ophalen van documenten. Geheugen is het bredere begrip waaronder ook episodisch en in-context geheugen vallen.

Ja! Met visuele workflow-tools bouw je de opslag- en retrievallaag zonder custom code te schrijven voor elke synchronisatie-taak. Voor de promptlaag en agentlogica blijft technisch inzicht nuttig, vandaar dat we dit in-company trainen op jullie eigen werkprocessen.

Dat hangt af van waar je je clouddatabase en embedding-model host. Bij elk project bekijken we samen welke leveranciers en regio's passen bij jullie databeleid.

Op aanvraag: de prijs hangt af van de scope en het aantal databronnen. We bespreken dit het liefst concreet in een vrijblijvend gesprek, zodat je een richtprijs krijgt die bij jullie situatie past. In dat gesprek maken we ook de scope helder.

Meer over dit onderwerp