Het AI-agentgeheugen
De meeste agentgeheugens zijn een vectoropslag van fragmenten uit eerdere gesprekken — die halen tekst op die vergelijkbaar klinkt, geen feiten. In de ontologie verankerd geheugen slaat op wat agenten leren als entiteiten, relaties en feiten, zodat recall precies en uitlegbaar is en gedeeld wordt over elke agent en elke sessie.
Feiten, geen fragmenten
Geheugen wordt geschreven en opgeroepen als entiteiten, relaties en feiten op de knowledge graph — niet als ingebedde flarden van oude gesprekken.
Gedeeld over agenten heen
Omdat geheugen in de graph leeft in plaats van in een vectorindex per thread, kan elke agent — of de volgende sessie — het met volledige context oppakken.
Uitlegbaar & auditeerbaar
Elk opgeroepen feit is te herleiden tot wanneer het is geschreven en uit welke bron, zodat geheugen net als elke andere data kan worden gecontroleerd, gecorrigeerd en beheerd.
AI-agentgeheugen is het mechanisme waarmee een agent informatie bewaart en oproept die verder reikt dan één context window — wat een gebruiker heeft verteld, wat de agent heeft gedaan en wat die heeft geleerd. Verankerd agentgeheugen slaat dit op als getypeerde entiteiten, relaties en feiten in een knowledge graph in plaats van als ingebedde tekstfragmenten, zodat agenten exacte feiten oproepen in plaats van passages die vergelijkbaar klinken, en dat geheugen kan worden geauditeerd, gecorrigeerd en hergebruikt over agenten heen.
Geef een agent een gesprek dat lang genoeg duurt en die vergeet, spreekt zichzelf tegen of verzint stilletjes details — omdat het meeste "geheugen" niet meer is dan een vectordatabase van eerdere berichten, opgehaald op gelijkenis terwijl de echte vraag er een van feiten is. De aanpak van Scrydon behandelt geheugen als data: agenten schrijven wat zij leren als entiteiten en relaties weg in de in de ontologie verankerde knowledge graph, en halen het op zoals zij elk ander beheerd feit ophalen, met de herkomst intact. Dat geheugen blijft bestaan over sessies heen, wordt gedeeld tussen agenten die aan hetzelfde dossier werken, en verlaat nooit uw perimeter. Deze pagina legt uit wat agentgeheugen werkelijk moet kunnen, waarom vector-recall tekortschiet, en hoe context engineering — het ontwerpen van wat een agent ziet — ervan afhangt dat geheugen goed geregeld is.
AI-agentgeheugen in het Scrydon-platform
Eén geïntegreerde, soevereine architectuur. Hier past AI-agentgeheugen — uitgelicht binnen de volledige stack waarmee het samenwerkt.
Het AI OS voor mensen en AI-agenten
Ontologie- en semantische laag: één samenhangend model voor uw data, kennis en processen
Het beste van data lakes, datawarehouses en search gecombineerd
AI-agenten, workflows en automatiseringen die uitvoeren over al uw systemen heen
Integreer via A2A, MCP, legacy systemen en databronnen
Veilige domeinfederatie, vertrouwd datadelen en intelligentie over organisatiegrenzen heen
Soevereine fundamenten
AI-agentgeheugen in detail
Human + AI-orchestratie
Het AI OS voor mensen en AI-agenten
De Human + AI Orchestrator is de operationele runtime in het hart van het AI OS — ook wel het Agentic OS genoemd — die elke taak in uw organisatie inplant, routeert en governt, of die nu wordt uitgevoerd door een AI-agent, een bestaand systeem of een mens.
De meeste organisaties hebben vastgelopen processen: verstopt in gescheiden systemen of opgeslagen in de hoofden van mensen. Het AI OS maakt ze zichtbaar en uitvoerbaar. Het legt de intentie vast, brengt de context samen, handelt — en voedt elk resultaat terug in de ontologie, zodat de volgende ronde slimmer verloopt. Allemaal binnen uw eigen perimeter.
Cognitive Enterprise
Ontologie- en semantische laag: één samenhangend model voor uw data, kennis en processen
De meeste organisaties hebben data die zij niet kunnen gebruiken — niet omdat die er niet is, maar omdat niets haar verbindt. De Cognitive Enterprise-laag is de bepalende intelligentie van het AI OS: een levend, bevraagbaar semantisch model van de entiteiten, processen en regels van uw organisatie. Het is de single source of truth waarmee elke agent, analist en workflow met een consistent begrip over uw business kan redeneren.
Zonder die laag redeneren AI-agenten op ruis. Mét die laag redeneren ze op de business.
- Entiteitengraaf: Modelleer klanten, accounts, orders, producten en elk ander domeinbegrip — en verbind ze met getypeerde, doorzoekbare relaties.
- Procesintegratie: Koppel echte workflows aan ontologie-entiteiten, zodat agenten begrijpen hoe data door uw organisatie stroomt.
- Continue verrijking: Agenten verrijken ontologieknooppunten automatisch met verse data uit het lakehouse en houden het model actueel zonder handwerk.
Agentic AI maakt van frontier-modellen geen geïsoleerde chatbots meer, maar echte autonome uitvoerders binnen het AI OS. In plaats van alleen tekst te genereren, zijn deze agenten gebouwd om precies die taken uit te voeren die uw mensen niet handmatig zouden moeten doen — redeneren, plannen en handelen in complexe processen met meerdere stappen.
Het AI OS steunt op een fundament van zowel creativiteit als controle om autonome agenten effectief in te zetten:
- AI Workflows als fundament: De kern van het AI OS bestaat uit georkestreerde AI-workflows die frontier-modellen, interne tools en enterprise memory veilig met elkaar verbinden.
- Deterministische en niet-deterministische flows: Door het redeneervermogen van frontier-AI te combineren met strikte, deterministische workflows garandeert het AI OS zowel wendbaarheid als absolute voorspelbaarheid in bedrijfskritische processen.
- Autonome uitvoering: Agenten handelen autonoom binnen vastgelegde grenzen, halen context op uit uw data lakehouse en voeren acties uit via goedgekeurde tools.
Veilig geïmplementeerd binnen uw eigen infrastructuur putten deze agenten uit uw cognitive enterprise om doortastend te handelen. Strikte, policygestuurde guardrails houden ze stevig binnen de grenzen die uw organisatie bepaalt, voor een perfecte balans tussen productiviteit en beveiliging op enterprise-niveau.
Wat AI-agentgeheugen werkelijk is
Het context window van een agent is kortetermijnwerkgeheugen — het reset elke sessie en kan maar zoveel bevatten. Agentgeheugen is wat dat overleeft: de feiten, voorkeuren en eerdere beslissingen die een agent nodig heeft om verder te gaan waar die is gebleven, of waar een andere agent is gebleven. Goed gedaan scheidt dat geheugen wat er in een sessie is gebeurd van wat duurzaam waar is over een entiteit, en schrijft het beide terug als gestructureerde feiten in plaats van als ruw transcript. Dat schrijfpad doet er net zoveel toe als retrieval — een agent die niet kan vastleggen wat die leert in een gedeelde, beheerde opslag heeft helemaal geen geheugen, alleen een langere prompt.
Kortetermijncontext — Het actieve context window — waarover de agent op dit moment redeneert, elke beurt ververst.
Langetermijngeheugen — Feiten, entiteiten en relaties die een agent heeft geleerd en die moeten blijven bestaan nadat het context window is gereset.
Episodisch versus semantisch — Wat er in een sessie is gebeurd (episodisch) versus wat duurzaam waar is over een entiteit (semantisch) — verankerd geheugen houdt beide gescheiden en bevraagbaar.
Schrijfpad — Agenten leggen wat zij leren terug vast in de in de ontologie verankerde graph, niet in een private opslag per thread.
Waarom de meeste agentgeheugens lossy en niet-auditeerbaar zijn
Het meeste agentgeheugen is vandaag een vectordatabase van eerdere gespreksbeurten, ingebed en opgehaald op gelijkenis — wat betekent dat het optimaliseert op tekst die relevant klinkt, niet op feiten die kloppen. Een gesprek comprimeren tot een embedding is inherent lossy: specifieke details vervagen tot één geheel, en achter een opgehaalde brok zit geen gestructureerde bewering om te controleren, te corrigeren of aan te halen. Omdat dat geheugen doorgaans is afgebakend tot één thread of één agent, is wat in een supportgesprek wordt geleerd onzichtbaar voor de salesagent die een uur later aan hetzelfde account werkt. In de ontologie verankerd geheugen voorkomt alle drie deze tekortkomingen tegelijk door wat agenten leren weg te schrijven als entiteiten en relaties op dezelfde graph waarover al het andere redeneert.
Lossy vanuit het ontwerp — Een gesprek in een vector inbedden comprimeert het tot een benadering — fijnmazige feiten vervagen of vallen weg.
Haalt gelijkenis op, geen feit — Similarity search levert het fragment op dat het meest op de vraag lijkt, niet noodzakelijk het fragment dat waar of actueel is.
Verkokerd per thread — Vectorgeheugen is doorgaans afgebakend tot één gesprek of één agent, zodat kennis uit de ene sessie onzichtbaar is voor de volgende.
Geen audit trail — Achter een opgehaalde brok zit geen gestructureerde bewering — u kunt niet naar het feit wijzen, niet naar wanneer het is geleerd, en het niet corrigeren zonder opnieuw in te bedden.
Context engineering: ontwerpen wat een agent ziet
Prompt engineering ging over het goed formuleren van een instructie; context engineering gaat over het bepalen van al het andere dat het model ziet — welke feiten worden opgehaald, welke toolschema's worden blootgesteld, en welke herinneringen vóór het genereren in het window worden getrokken. Nu agenten tegelijk putten uit RAG, geheugen en toolaanroepen, is die samenstelling het lastigere engineeringprobleem geworden, en het is structureel, niet stilistisch. In de ontologie verankerde context stelt zich voorspelbaar samen: entiteiten en relaties passen als getypeerde, begrensde feiten in het window, terwijl ad-hoc prompt-stuffing onvoorspelbaar groeit en de modelprestaties gaandeweg verslechtert. Omdat retrieval, toolargumenten en geheugen alle putten uit dezelfde beheerde graph, betekent context engineering op Scrydon dat u één retrievalstrategie ontwerpt, en niet drie losstaande.
Voorbij prompt engineering — Prompt engineering vormt de instructie; context engineering vormt al het andere dat het model ziet — opgehaalde feiten, toolschema's en geheugen.
Retrieval als ontwerpvlak — Wat er uit geheugen en RAG wordt gehaald, in welke volgorde en hoeveel, is nu een expliciete engineeringbeslissing en geen bijzaak.
Gestructureerd wint van ad hoc — In de ontologie verankerde context — getypeerde entiteiten en relaties — stelt zich voorspelbaar samen in een context window; erin gepropte promptteksten doen dat niet.
Hetzelfde substraat, elk vlak — Retrieval, toolargumenten en geheugen putten alle uit dezelfde beheerde graph, zodat de context die een agent samenstelt consistent blijft over tools heen.
Veelgestelde vragen
Wat is AI-agentgeheugen?+
Waarom is vectorgebaseerd agentgeheugen onbetrouwbaar?+
Hoe werkt in de ontologie verankerd geheugen?+
Wat is context engineering?+
Kan geheugen worden gedeeld tussen meerdere agenten?+
Hoe blijft agentgeheugen auditeerbaar en beheerd?+
Ontdek het platform
E-mail ons
Schrijft u liever? Mail naar hello [at] scrydon.com en wij nemen contact met u op.
Partners
