Geheugen voor AI-agents: zo bouw je AI-agents met blijvende context

Als je een nieuwe collega zes maanden lang elke ochtend naar de printer moest brengen, zou je je zorgen gaan maken. Als die collega elke eerdere wandeling tot in perfect detail kon navertellen maar toch begeleid moest worden, dan is het geheugen uitstekend… maar sta je nog steeds op van je bureau.

Het geheugen van AI-agents kent op dit moment zijn eigen versie van die eindeloze wandeling naar de printer. Charles Packer, CEO van Letta, zegt in The New Stack dat geheugenbenchmarks verzadigd zijn omdat ze recall meten, wat hij als een opgelost probleem beschouwt. Het open probleem is een agent die beter wordt in zijn werk dankzij de context die hij bewaart, zonder dat er opnieuw getraind hoeft te worden.

Zijn medeoprichter Sarah Wooders vergelijkt het met beginnen aan een nieuwe baan: benchmarks geven de agent alle context die hij nodig heeft, taak na losstaande taak, en dat lijkt in niets op hoe mensen werken. Een nieuwe medewerker moet je misschien naar de printer brengen. Maar na drie jaar hoop je diegene een briefing van één regel te kunnen geven zonder van je bureau op te staan.

Dat is de standaard waar we naartoe werken, en het doel achter Brain, ons zelfverbeterende geheugensysteem voor Perplexity Computer, dat eerder werk en correcties ordent in een kenniswiki die zich steeds verder ontwikkelt.

We bespreken wat een agent zou moeten onthouden en hoe je test of dat de agent helpt beter werk te leveren.

Wat is het geheugen van een AI-agent?

Het geheugen van een AI-agent is de informatie die een agent bewaart uit eerdere interacties en werk, samen met de mechanismen om die informatie bij te werken en te gebruiken. De persistente geheugencontext neemt die informatie mee over sessies heen, zodat het afsluiten van een gesprek niet betekent dat je de volgende taak weer helemaal vanaf nul begint.

Het meeste wat onder die naam wordt uitgebracht, onthoudt de gebruiker. Je voorkeuren, je contacten, je rol, het feit dat je liever pdf's dan png's wilt. Dat is de makkelijke helft.

Toen we Brain bouwden, het geheugensysteem achter Perplexity Computer, richtten we ons op het werk zelf. Welke aanpak werkte? Welke bron kostte twintig minuten voor niets? Wat moest je corrigeren nadat de agent had aangekondigd dat hij klaar was? Die geschiedenis geeft de volgende taak een beter vertrekpunt.

Brain slaat deze informatie op als bestanden in de sandbox van de agent, georganiseerd in drie lagen:

• sessions/ bevat ruwe transcripten en de samenvattingen daarvan.
• notes/ bevat gedistilleerde informatie, geordend per onderwerp.
• knowledge/ bevat de wiki zelf: gekoppelde Markdown-pagina's over mensen, projecten en concepten.

Niets daarvan verbetert vanzelf. 's Nachts lezen achtergrondagents die we “Dream” noemen de sessies van die dag, vatten ze samen en herzien de wiki waar het beeld is veranderd. We zetten die wijzigingen klaar en controleren ze voordat we ze via Git committen, zodat er een diff is om te bekijken als er iets niet lijkt te kloppen.

Maakt het de agent beter in zijn werk? In onze gepaarde evaluatie van 30 dagen verbeterden sessies met Brain de correctheid met 9,3 procentpunt en de recall met 8,9, terwijl ze ongeveer 15% minder tokens gebruikten.

Vergroten

Bron: X

Welke soorten agentgeheugen zijn er?

Er zijn twee brede soorten, en de indeling lijkt sterk op die je voor een mens zou gebruiken: wat je op dit moment in je hoofd hebt, en wat je volgende maand nog weet.

Kortetermijngeheugen

Het kortetermijngeheugen bevat de context van het huidige gesprek of de huidige taak. Je verzoek, recente berichten, het resultaat van een toolaanroep, het document dat de agent net heeft geopend. Genoeg informatie om te bepalen wat de volgende stap is.

Dit wordt ook wel werkgeheugen genoemd. Bij een LLM bevat het contextvenster de informatie die beschikbaar is tijdens een bepaalde modelaanroep. De applicatie kan daarnaast een eigen taakstatus bijhouden en bepalen welke delen bij elke stap worden aangeleverd.

En kortetermijn betekent niet per se wegwerp. Een framework kan de status van het gesprek opslaan en die morgen hervatten; het hoort dan nog steeds bij die draad. Maar of een andere taak de informatie kan gebruiken, is een aparte ontwerpbeslissing.

Langetermijngeheugen

Het langetermijngeheugen maakt informatie beschikbaar over sessies heen. De CoALA-paper leende drie categorieën uit de cognitieve wetenschap, waarmee bouwers van agents een vocabulaire kregen voor ervaringen en knowhow:

• Episodisch geheugen is wat er is gebeurd: dit omvat eerdere sessies, de stappen die een agent heeft gezet en het resultaat dat hij kreeg. In Brain levert sessions/ deze geschiedenis via ruwe transcripten en de samenvattingen daarvan.
• Semantisch geheugen is wat de agent als waar aanneemt: dit kunnen feiten zijn over de gebruiker, diens projecten en diens wereld, gedistilleerd uit de gesprekken. De knowledge/-wiki van Brain bevat dit soort informatie, met links terug naar het bewijs.
• Procedureel geheugen is hoe je dingen doet: dit zijn prompts, herbruikbare workflows en de Skills die Perplexity bouwt om agents de instructies en tools te geven die een taak vereist. Misschien heb je hier al iets van zonder het geheugen te noemen.

Het interessante werk gebeurt tussen de lagen. Een sessie legt vast dat je een png hebt afgewezen. Je instructie om pdf's te gebruiken wordt een voorkeur die de agent kan meenemen. Een correctie op het exportproces wordt iets wat hij de volgende keer kan volgen.

Die omzetting, van “dit is gebeurd” naar “dit is waar” naar “zo doen we het”, is onderdeel van het leerprobleem waarmee we begonnen, en daar steken de nachtelijke runs van de Dream-agent van Brain hun energie in.

Stel dat iemand vis opwarmt in de magnetron van een gedeelde keuken. Er komen klachten, er gaat een raam open. Uiteindelijk verschijnt er een bordje: GEEN VIS.

Zes maanden later is de dader verhuisd, maar het bordje hangt er nog. Dat is persistentie. Je kunt de geheugentypen uitleggen aan de hand van wat er overblijft:

• Werkgeheugen is wat je bijhoudt terwijl je lunch maakt, zoals dat de soep geroerd moet worden.
• Episodisch geheugen is het visincident: de geur die iedereen de gang in volgde.
• Semantisch geheugen is de kennis die je eraan overhield: vis opwarmen kan een blijvende geur achterlaten in een gedeelde keuken.
• Procedureel geheugen is de instructie die bepaalt wat er daarna gebeurt. Warm hier geen vis op in de magnetron. Dankzij het bordje kan iemand die het hele incident heeft gemist zich toch aan de regel houden.

Er is nog één onderscheid dat ertoe doet, omdat het verandert wat we bouwen. Een overzichtsstudie die voor het eerst in december 2025 verscheen, Memory in the Age of AI Agents, stelt dat kort versus lang niet genoeg is en deelt geheugen daarom ook in naar vorm:

• Tokenniveau: dit is de expliciete inhoud die de agent leest. Bestanden, opgeslagen records, opgehaalde fragmenten.
• Parametrisch: dit is informatie die is vastgelegd in geleerde gewichten. Om die bij te werken zijn training of methoden voor modelbewerking nodig.
• Latent: dit is informatie die in interne representaties wordt vastgehouden zonder als leesbare tekst te worden uitgeschreven.

We richten ons hier op geheugen op tokenniveau, oftewel informatie die buiten het model wordt opgeslagen en wanneer nodig in de context wordt ingelezen. De Markdown-wiki van Brain is daar een voorbeeld van.

Vergroten

Wanneer we een pagina bijwerken, veranderen we wat de agent bij zijn volgende taak kan lezen, maar zijn onderliggende gewichten blijven hetzelfde. Dat is het punt dat Packer in de inleiding maakte: beter worden dankzij de context die de agent bewaart, zonder opnieuw te trainen.

Hoe werken de verschillende soorten agentgeheugen samen?

Een agent kan een eerdere poging opnieuw bekijken, zien waar het misging en de instructies laden die je hem daarna hebt gegeven. Bij dezelfde taak zijn verschillende soorten geheugen betrokken, en ze hebben niet elk een eigen beurt of een aparte database nodig.

Persistentie bepaalt hier wat er beschikbaar blijft nadat het gesprek is afgelopen, terwijl het ophalen bepaalt of de agent het ooit nog te zien krijgt.

In Brain behouden we die route van de les terug naar het bewijs. Stel dat je Computer vraagt een project van vorige week voort te zetten:

• De index van Brain vertelt welke geheugenpagina's er zijn en waar ze te vinden zijn.
• Brain opent de projectpagina om de opgeslagen beslissingen en instructies te lezen.
• Als in een notitie staat dat je een aanpak hebt afgewezen, kan de agent de bronvermelding terugvolgen naar het gesprek en nagaan waarom.

Via de links naar gerelateerde pagina's kan hij de betrokken mensen of andere projecten opzoeken. De agent doet dit door bestanden te lezen en te doorzoeken. Met grep kan hij bijvoorbeeld vermeldingen van een project op naam vinden.

We hebben ook getest wat agents winnen doordat ze bestanden kunnen verkennen. In een interne benchmark met 150 vragen over financiële documenten behaalde een verkenningsagent met standaard bestandstools een antwoordscore van 0,627, tegenover ongeveer 0,37 voor semantisch zoeken in hetzelfde corpus.

Vergroten

Bron: X

Hoe verbeter je het geheugen van AI-agents?

Een paper van Orogat en Mansour uit mei 2026 beschrijft vier terugkerende fouten in agentgeheugen: de opslag blijft groeien, verouderde overtuigingen worden niet herzien, informatie wordt vergeten als de ruimte opraakt, en bij het ophalen wordt gelezen zonder iets van het bezoek te leren.

Hun voorgestelde oplossing is om agentgeheugen niet langer als opslag te behandelen, maar als een “toestand” die zich ontwikkelt via vier bewerkingen: opnemen, herzien, vergeten en ophalen. Dat is onze checklist voor deze sectie.

Wees selectief in wat er wordt onthouden

Zodra er een “slechte” herinnering in zit, neemt elke volgende stap die over.

Workday AI Research testte een selectieve aanpak op zo'n 1.500 kandidaat-herinneringen uit de LoCoMo-benchmark, waarbij vijf vragen werden gesteld voordat er ook maar één werd bewaard:

• Is het nuttig? Komt het waarschijnlijk nog eens terug?
• Is het betrouwbaar? Werd dit echt in het gesprek gezegd, of heeft het model het zelf ingevuld?
• Is het nieuw, of al opgeslagen?
• Is het actueel?
• Is het een blijvend feit of een tijdelijke toestand?

Alleen voor de eerste vraag was een modelaanroep nodig. De andere vier draaiden als regels, samen in minder dan 65 milliseconden. De methode behaalde 12% hogere precisie bij beslissingen over bewaren of weggooien, terwijl 97% van de relevante herinneringen behouden bleef.

De grootste bijdrage kwam van de laatste vraag: als je het onderscheid tussen blijvende en tijdelijke informatie weghaalt, daalt de beslissingskwaliteit met ongeveer 18%.

Herzie het antwoord zonder de geschiedenis te verliezen

Leg vast wanneer een feit geldig werd, welke bron het onderbouwt en wat het heeft vervangen. Als de bronnen het oneens zijn, houd die onenigheid dan zichtbaar totdat er genoeg bewijs is om ze op te lossen. Ook het nieuwste document kan fout zijn.

Brain werkt de wiki bij op basis van brondocumenten, resultaten van connectors en correcties van gebruikers. Elk geheugenitem linkt terug naar de bron. De agent moet het actuele antwoord kunnen vinden en ergens kunnen kijken als dat antwoord verdacht lijkt.

Vergeet bewust

De paper noemt één faalwijze “capaciteitsgedreven vergeten”: informatie wordt verwijderd om binnen een opslaglimiet te blijven, niet omdat ze niet meer nuttig is.

Terug naar de gedeelde keuken. Na zes maanden maakt het niemand meer uit wie de vis in de magnetron opwarmde of hoe lang het raam openstond. Maar het bordje heeft nog steeds een functie.

Als de volgende persoon lunch maakt, is de regel beschikbaar. De klachten archiveer je gewoon.

De controles van Workday op actualiteit en informatietype vinden plaats vóór de opslag en filteren wat het verdient om een herinnering te worden. In Brain bekijken we bestaande kennis ook opnieuw wanneer brondocumenten veranderen en gebruikers correcties aanbrengen. In beide gevallen is het de inhoud die ingrijpen noodzakelijk maakt.

Laat het ophalen de volgende update voeden

De agent haalt een feit op, gebruikt het en laat de opslag precies achter zoals hij die aantrof. Tenzij het systeem vastlegt wat er daarna gebeurde, registreert niets of dat feit hielp of de agent opnieuw een doodlopende weg in stuurde.

Leg de uitkomst, de bron en eventuele correcties vast. Toen we Brain bouwden, maakten we die werkgeschiedenis onderdeel van wat het onthoudt: welke aanpak werkte, welke bron nergens toe leidde en wat de gebruiker corrigeerde nadat de agent had aangekondigd dat hij klaar was. Brain verwerkt die ervaring in de periodieke updates van de wiki, zodat latere taken die kunnen gebruiken.

Niets hiervan is echter terug te zien in een recall-benchmark. Of de lus werkt, kom je te weten door de agent een taak te geven die hij alleen met geheugen kan voltooien, en te tellen hoe vaak dat lukt, inclusief kosten en latentie. Dat is wat DolphinBench doet, en daarom blijven de topscores nog altijd steken tussen de 70 en 80.

Zo bouw je met Perplexity een agent met persistent geheugen

De Agent API van Perplexity levert geen zelfonderhoudend geheugensysteem zoals Brain. Dat zeggen we liever meteen. Wat je er wel mee krijgt, zijn de onderdelen van het geheugen die je nodig hebt: een plek om procedures te bewaren, een manier om context tussen beurten mee te nemen en tools om te lezen uit en te schrijven naar een opslag die je zelf beheert.

Begin met procedureel geheugen

Een aangepaste Skill bundelt instructies, procedures en ondersteunende bestanden onder een versienummer. Een platformteam kan zijn deploymentcontroles, rollbackcriteria en rapportageformaat één keer vastleggen en applicaties vervolgens naar dezelfde Skill laten verwijzen. Als de procedure verandert, uploadt het team een nieuwe versie.

Vergroten

Bron: X

Een Profile gaat nog een niveau hoger. Profiles slaan het model, de instructies, tools, Skills, connectors en uitvoeringsinstellingen van de agent op onder één ID met versiebeheer.

We hebben beide in september toegevoegd, samen met beheerde connectors, zodat een projectbeheerder een goedgekeurde GitHub- of Slack-verbinding één keer kan configureren en applicaties daarnaar kunnen verwijzen in plaats van afzonderlijke inloggegevens op te slaan. Als de toegang verandert, werkt de beheerder de verbinding op één plek bij.

Waarom telt dit als geheugen? We gaan nog één keer terug naar de keuken met de vis uit de magnetron. Wie daarna binnenkomt, kan zich aan GEEN VIS houden zonder de klachten zelf te hebben meegemaakt.

Een Skill doet hetzelfde voor een agent, met ruimte voor de stappen, uitzonderingen en controles die niet op een magnetrondeur passen. Skills worden vastgelegd, krijgen een versienummer en zijn beschikbaar zodra de taak weer voorbijkomt.

We gebruiken Skills ook om de geheugenupdates van Dream te sturen. Maar wat een Skill niet doet, is zelf leren. De instructies veranderen wanneer er een nieuwe versie wordt geüpload, door een persoon of door een geautomatiseerd proces.

Als je wilt dat de agent opmerkt dat de rollbackcontrole bij één service steeds mislukt en zich daarop aanpast, dan is dat de lus van sessies naar wiki die we eerder bespraken.

Je moet vastleggen wat er is gebeurd, bepalen wat er moet veranderen en de correctie de volgende keer beschikbaar maken. Daarvoor zijn de volgende twee onderdelen nodig.

Neem werkgeheugen mee tussen beurten

De agent voert een deploymentcontrole uit. Je vraagt: ‘Waarom is dat mislukt?’ Een redelijke vervolgvraag, mits de agent nog kan zien waar “dat” naar verwijst.

Onze Agent API ondersteunt twee manieren om gesprekscontext mee te nemen naar de volgende beurt:

• Speel het gesprek zelf opnieuw af: Neem eerdere berichten op in de input-array van het volgende verzoek. Jij bepaalt wat je bewaart, samenvat, afschermt of weglaat voordat je het verstuurt.
• Ga verder vanaf een voltooid antwoord: Sla het ID ervan op en geef dat als previous_response_id mee met het volgende bericht. Wij bewaren de gespreksstatus aan de serverkant, zodat je applicatie de eerdere beurten niet opnieuw hoeft te versturen. Je kunt verdergaan vanaf het meest recente antwoord in de keten.

Met opnieuw afspelen bepaal je zelf wat de agent ziet, en verdergaan via een ID bespaart je het werk om het gesprek opnieuw samen te stellen. Geef in beide gevallen alle nieuwe instructies, tools of modelinstellingen mee die nodig zijn voor het volgende antwoord.

Gebruik je eigen episodische en semantische opslag

Dit deel laat de Agent API aan jou over.

Eén mogelijkheid is function calling. Jij definieert de tools, de agent vraagt een aanroep aan en je applicatie voert die uit en stuurt het resultaat terug. Voor geheugen is een eenvoudig startpunt een leesbewerking voordat de agent iets doet en een schrijfbewerking daarna.

Log je alleen het feit dat de agent iets heeft opgehaald, dan weet je nog steeds niet of het heeft geholpen. Log je de uitkomst, de bron en wat de gebruiker heeft gecorrigeerd, dan heb je het begin van een episodische laag.

Onze MCP-ondersteuning biedt je nog een mogelijkheid. Als een compatibele externe MCP-server de bewerkingen aanbiedt die je nodig hebt, kan de agent ze aanroepen zonder dat je ze stuk voor stuk als aangepaste functie hoeft te verpakken.

Onze connectors geven de agent toegang tot het bewijs achter de herinneringen. GitHub, Slack, Google Drive, Datadog, Linear en Notion zitten in onze beheerde catalogus, en je kunt aangepaste connectors toevoegen voor interne systemen.

Bepaal ten slotte wanneer de geschiedenis wordt beoordeeld en het huidige beeld wordt herzien.

Test wat een nieuwe sessie overleeft

Sluit nu het gesprek. Start een nieuw verzoek zonder de oude berichten opnieuw af te spelen of previous_response_id mee te geven, maar geef de agent toegang tot dezelfde geheugenopslag. Vraag de agent om gerelateerd werk te doen zonder de correctie te herhalen.

Als de agent een geheugensteuntje nodig heeft, ben je nog niet klaar.

Bouw voor de deployment-agent een paar tests rond wat er moet worden meegenomen:

• De correctie blijft behouden: De agent haalt het geverifieerde rollbackcommando voor de betreffende service op en gebruikt het.
• De correctie blijft binnen haar bereik: De procedures van andere services blijven ongemoeid.
• Nieuwe informatie vervangt oude richtlijnen: Als het commando opnieuw verandert, gebruikt de agent de huidige versie en kan hij de wijziging herleiden tot de bron.

Ons cookbook voor regressietests laat zien hoe je agentoutputs en opgehaald bewijs opslaat, ze toetst aan het verwachte gedrag en runs vergelijkt nadat je instructies of modellen hebt gewijzigd.

Houd de versies van het model, het Profile en de Skill gelijk terwijl je runs met en zonder geheugen vergelijkt. Begin elke vergelijking vanaf een bekende snapshot van de opslag; anders kan de ene test de agent het antwoord op de volgende leren.

Als er iets misgaat, sla de casus dan op. De volgende wijziging moet die casus doorstaan.

Of sla het bouwen over: Brain in Computer

Wil je de complete lus in plaats van de losse onderdelen, dan is dat Computer. Brain draait daaronder en leert van vier bronnen: je sessies, gekoppelde tools, de bestanden en artefacten die je maakt, en je correcties. De achtergrondupdates van Brain bevestigen wat nog klopt, herzien wat is veranderd en markeren verouderde informatie.

Je hoeft die lus niet zelf te bouwen. Je doet gewoon het werk.

Geheugen onthoudt voorkeuren en details die je hebt gedeeld. Brain verbindt projecten, mensen, beslissingen en onafgemaakt werk met het bewijs erachter.

Je kunt in de Geheugenweergave bekijken wat het heeft geleerd, items terugvolgen naar hun bronnen en ze bewerken of verwijderen. Brain gebruikt je eigen activiteit, sluit incognitosessies uit en heeft een eigen schakelaar.

Vergroten

Bij Rho waren de beslissingen voor een facturatieproject bijvoorbeeld verspreid over Slack, Notion, Jira, Figma en Google Docs. Het team stelde Computer zo in dat het ’s nachts wijzigingen beoordeelt, inconsistenties signaleert en ’s ochtends een overzicht in Slack publiceert.

Hun software-engineer Oktawian Jurkiewicz merkte dat Computer ook geheugen opbouwde voor het project. “Dat hadden we niet gedefinieerd”, zegt hij. “Computer heeft zelf uitgezocht welke datapunten het uit elke bron moest opslaan.”

Het team meldt dat de wekelijkse vergadertijd is teruggebracht van 2,5 uur naar 15 minuten en schat dat het over het project van 12 weken 120 werkuren heeft bespaard.

De 120 uur worden toegeschreven aan de hele workflow: connectors, nachtelijke runs en het Slack-overzicht. Hoeveel van de bespaarde tijd kwam alleen door geheugen? Dat kunnen we nog niet kwantificeren.

Maar wat we wel kunnen aanraden, is om voor je eigen build terug te gaan naar de test van eerder: voer vergelijkbare taken uit met de geheugenlaag aan en uit, en vergelijk daarna voltooiingspercentages, kosten en tijd, inclusief de tijd die iemand kwijt is aan het corrigeren van het resultaat.

Veelgestelde vragen over geheugen voor AI-agents

Kunnen AI-agents een geheugen hebben?

Ja. AI-agents kunnen informatie over sessies heen bewaren via opgeslagen gesprekken, feiten, voorkeuren en herbruikbare procedures. Het systeem moet die informatie ophalen wanneer die relevant is en bijwerken wanneer de omstandigheden veranderen.

Brain in Perplexity Computer bouwt bijvoorbeeld werkcontext op uit sessies, gekoppelde tools, bestanden en correcties van gebruikers.

Hoeveel RAM gebruikt een AI-agent?

Daar is geen vaste vereiste voor. Als je agent een gehost model aanroept via de Perplexity Agent API, hoef je dat model niet in je eigen RAM te laden. Je applicatie en lokale tools hebben nog wel geheugen nodig.

Een lokaal model draaien is anders. Bij vier bits per parameter komen acht miljard parameters neer op ongeveer 4 GB aan ruwe gewichtsdata. Het werkelijk benodigde geheugen is hoger zodra je de overhead van kwantisatie, contextverwerking en de software die het model draait meerekent.

Wat is het beste geheugen voor een AI-agent?

De beste opzet hangt af van wat de agent moet meenemen. Een gespreksstatus ondersteunt vervolgvragen; episodische records bewaren wat er is gebeurd; semantisch geheugen bevat actuele kennis; procedureel geheugen levert herbruikbare instructies.

Voor het meeste doorlopende werk is een combinatie nuttig. Voor Brain gebruiken we een gekoppelde wiki die met bronnen is onderbouwd. Test voor je eigen build of de opzet de agent helpt om taken te voltooien, correcties toe te passen en verouderde richtlijnen uit te faseren.