💻 computer science

AMP: A Vendor-Neutral Wire Format for Agent Memory Operations

Dit artikel introduceert memorywire, een vendor-neutraal JSON-Schema draadformaat en referentie-implementatie die agent-geheugenoperaties over diverse frameworks standaardiseert via een verenigde interface, een governance-kanaal en empirisch gevalideerde backend-adapters, met als doel interoperabiliteit mogelijk te maken zonder te concurreren met het Model Context Protocol.

Oorspronkelijke auteurs: Thamilvendhan Munirathinam

Gepubliceerd 2026-06-02

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Thamilvendhan Munirathinam

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een team van AI-assistenten bouwt. Op dit moment heeft elke assistent zijn eigen unieke manier om dingen te onthouden. De één schrijft aantekeningen in een leren dagboek, een ander gebruikt een digitale app met plaknotities, en een derde houdt een spraakmemo bij. Ze spreken allemaal een andere "taal" van het geheugen. Als je een assistent wilt overzetten naar een ander systeem, moet je de hele geschiedenis vanaf nul herschrijven. Erger nog, als een assistent iets vreemds of gevaarlijks opschrijft, is er geen manager om dit te controleren voordat het in hun permanente brein wordt opgeslagen.

memorywire is een nieuw voorstel om deze chaos op te lossen. Zie het als een universele vertaler en een gestandaardiseerd archiefsysteem voor AI-geheugens.

Hier is hoe het artikel het uiteenzet, met behulp van eenvoudige analogieën:

1. Het Probleem: De "Toren van Babel" van het AI-geheugen

Huidige populaire AI-geheugentools (zoals mem0, Letta, Cognee) zijn als verschillende landen met verschillende valuta.

Het Probleem: Als je het geheugen van een AI van "Land A" naar "Land B" wilt verplaatsen, kun je niet gewoon het contante geld overdragen; je moet het eerst omsmelten en opnieuw slaan. Je verliest details en het is duur.
De Ontbrekende Manager: Geen van deze systemen heeft een ingebouwde "manager" om te controleren wat de AI opschrijft voordat het permanent wordt. Het is alsof je een leerling een wiskundevraag op het schoolbord laat schrijven zonder dat een leraar eerst controleert of de berekening wel klopt.

2. De Oplossing: Een Universele "Memory Wire"

De auteurs hebben memorywire gecreëerd, een standaardformaat (een specifieke manier om gegevens te verpakken) dat elk AI-systeem kan begrijpen.

De 5 Acties: In plaats van een rommelige lijst met commando's, definieert memorywire precies vijf dingen die een AI met het geheugen kan doen:
1. Onthouden (Remember): Een nieuwe feit opschrijven.
2. Ophalen (Recall): Vragen om een herinnering.
3. Vergeten (Forget): Een herinnering verwijderen.
4. Samenvoegen (Merge): Twee vergelijkbare herinneringen combineren tot één (om duplicaten te voorkomen).
5. Vervallen (Expire): Oude herinneringen automatisch verwijderen (zoals een "houdbaarheidsdatum").
De 4 Typen Geheugen: Net als mensen sorteert het systeem herinneringen in vier categorieën:
- Semantisch: Feiten (bijv. "Alice haat pinda's").
- Episodisch: Gebeurtenissen (bijv. "Alice was zenuwachtig tijdens haar vlucht gisteren").
- Procedureel: Hoe-te-doen stappen (bijv. "Hoe boek je een vlucht").
- Emotioneel: Gevoelens (bijv. "Alice voelde zich angstig over vliegen").

3. De "Verkeersregelaar": De Router

Het artikel introduceert een "Router" die fungeert als een verkeersregelaar.

Hoe het werkt: Wanneer je een AI vraagt om iets te "Ophalen" (Recall), vraagt de Router niet alleen aan één database. Het roept de vraag tegelijkertijd naar alle verschillende geheugensystemen die eraan gekoppeld zijn.
De Magische Truc (RRF): De Router gebruikt een wiskundige truc genaamd Reciprocal Rank Fusion (RRF). Stel je voor dat drie vrienden een getal raden.
- Als Vriend A "5" zegt, Vriend B "5" zegt en Vriend C (een leugenaar) "100" zegt, dan vertrouwt de Router op de twee vrienden die het met elkaar eens zijn.
- Het artikel bewijst dat zelfs als een van de geheugensystemen gehackt is of liegt, deze wiskundige truc ervoor zorgt dat de AI toch het juiste antwoord krijgt. Het is als een vangnet dat de leugenaar opvangt.

4. De "Human-in-the-Loop": De Goedkeuringspoort

Dit is een belangrijke functie. Het systeem maakt gebruik van een "Diff-and-Approve" workflow.

Het Scenario: Een AI wil een nieuwe herinnering opschrijven: "De gebruiker is allergisch voor pinda's."
De Poort: In plaats van het direct op te slaan, pauzeert het systeem. Het toont een menselijke beoordelaar een "diff" (een vergelijking van wat nieuw is versus wat oud is).
De Beslissing: De mens klikt op "Goedkeuren" of "Afwijzen". Pas daarna wordt de herinnering opgeslagen. Dit voorkomt dat de AI per ongeluk valse of schadelijke feiten opschrijft.

5. Wat ze daadwerkelijk hebben getest (De Resultaten)

De auteurs hebben geen nieuw magisch brein uitgevonden; ze hebben alleen de bestaande tools beter georganiseerd. Ze hebben hun systeem getest met:

Snelheid: Het was erg snel (ongeveer 40 milliseconden om iets te onthouden of op te halen).
Nauwkeurigheid: Tested with 42 questions, the system found the correct answer 100% of the time in the top 5 results. (An additional 8 trick questions were used to ensure the system didn't hallucinate.)
Beveiliging: Ze probeerden het systeem te "hacken" door één van de geheugendatabases te laten liegen. De "Verkeersregelaar" (RFF) negeerde de leugenaar succesvol en behield de juiste antwoorden.
Compatibiliteit: Ze hebben het getest tegenover 5 verschillende bestaande geheugensystemen. Het werkte perfect met de systemen die gebouwd zijn op standaard databases (SQLite en PostgreSQL) en werkte goed genoeg met de anderen, wat bewees dat het verschillende "talen" kan spreken.

De Kernboodschap

De auteurs beweren dat memorywire geen nieuw type AI-intelligentie is. Het is een gestandaardiseerd protocol. Het is de "USB-C-poort" voor het geheugen van AI. Het stelt verschillende AI-systemen in staat om in te pluggen op dezelfde geheugenbank, zorgt ervoor dat slechte gegevens door mensen gefilterd kunnen worden, en beschermt het systeem zelfs als een deel van het netwerk gecompromitteerd is.

De auteurs zijn eerlijk: ze beweren niet dat dit de definitieve, perfecte oplossing is. Ze brengen het uit als een "conceptversie" (versie 0) om feedback te verzamelen, met als doel een standaard te worden die door iedereen wordt geadopteerd, vergelijkbaar met hoe het Model Context Protocol (MCP) een standaard wordt voor AI-tools.

Technisch Overzicht: memorywire – Een Vendor-Neutrale Wire Format voor Agent-Geheugenoperaties

1. Het Probleem: Geïsoleerde Geheugenframeworks

Het huidige landschap van agent-geheugenframeworks (bijv. mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor) wordt gekenmerkt door heterogeniteit. Elk framework levert zijn eigen SDK, opslagindeling, operationele vocabulaire en impliciete levenscyclus voor het aanmaken en verwijderen van records. Er is geen gedeelde "wire format".

Dit gebrek aan standaardisatie creëert drie primaire problemen:

Bespoke Integratie en Migratie: Het integreren van een agent met een nieuw backend of het migreren tussen frameworks vereist aangepaste adapters. Verlies van gegevens op veldniveau komt vaak voor wanneer bronframeworks meer staat coderen dan de datamodellen van de doelversie ondersteunen.
Gebrek aan Gedeelde Governance: Geen enkel framework biedt momenteel een gestandaardiseerde "diff-and-approve" workflow waarbij menselijke reviewers schrijfacties kunnen auditeren voordat ze in het langetermijngeheugen worden opgeslagen. Operators moeten aangepaste governance-lagen bouwen, die door het onderliggende framework omzeild kunnen worden.
Algoritmische Stagnatie versus Protocol-gaten: Het artikel betoogt dat de kernalgoritmen (vector search, Reciprocal Rank Fusion, FSM's, STM/LTM-consolidatie) goed begrepen zijn. De kloof ligt niet in de retrieval-prestaties, maar in het gebrek aan een gedeeld protocol om deze componenten over verschillende runtimes en backends heen te componeren.

2. Methodologie en Architectuur

Het artikel presenteert memorywire, een vendor-neutrale wire format en referentie-implementatie ontworpen om agent-geheugenoperaties te standaardiseren.

2.1 Ontwerp van de Wire Format

Het protocol wordt gedefinieerd via JSON Schema 2020-12 en is transport-agnostisch (REST, JSON-RPC, etc.). Het definieert:

Vijf Kernoperaties: remember (schrijven), recall (lezen), forget (verwijderen), merge (dedupliceren) en expire (toepassing van TTL-beleid).
Vier Geheugentypes: Semantisch, Episodisch, Procedureel en Emotioneel, gebaseerd op cognitieve wetenschappelijke taxonomieën (Tulving, Squire).
MemoryStore Protocol: Een Python Protocol dat de interface voor backends definieert. Backends verklaren hun capabilities (bijv. vector, graph, procedural), waardoor een router heterogene stores kan componeren zonder dat de aanroeper de specifieke beperkingen van de backend hoeft te kennen.

2.2 Referentie-implementatie

De auteurs bieden een open-source referentie-implementatie in Python 3.11+ met:

Vijf Backend Adapters: sqlite-vec, mem0, Letta, Cognee en pgvector. Deze adapters mappen de wire format naar hun respectievelijke interne datamodellen en gaan waar nodig om met fidelity-verlies (bijv. door velden als metadata-tags te coderen).
Memory Router: Een fan-out router die operaties over $N$ $N$ kind-stores parallel uitvoert.
- Recall Fusion: Gebruikt Reciprocal Rank Fusion (RRF) als het standaardalgoritme ( $k=60$ ), wat score-onafhankelijk en additief is. Het ondersteunt ook MAX en weighted fusie.
- Graph Boost: Een optionele one-hop graph boost voor items waarvan de buren ook deel uitmaken van de gefuseerde set.
- Fouttolerantie: Gebruikt asyncio.gather met return_exceptions=True om te garanderen dat een enkele defecte of onbeschikbare backend de gehele recall-operatie niet doet crashen.
Procedural Memory: Slaat Finite State Machines (FSM's) op als JSON-geserialiseerde blobs compatibel met pytransitions, met strikte validatie om Remote Code Execution (RCE) via callback-injectie te voorkomen.
STM/LTM Transformer: Een async achtergrondtaak die items uit het kortetermijngeheugen (STM) scoort op basis van recentheid, salientie en vertrouwen, om ze te promoten naar het langetermijngeheugen (LTM) of te verwijderen.

2.3 Governance Kanaal

Een kernkenmerk is het Co-memorize patroon, dat een "diff-and-approve" workflow formaliseert.

Schrijfacties gemarkeerd met approval_required=true worden achter een sentinel geplaatst (PENDING_APPROVAL_DELETED_AT = -1) en blijven onzichtbaar voor recall totdat een menselijke reviewer ze via een verstrekte UI committeert of afwijst.
Een append-only auditlog dient als de "single source of truth" voor alle governance en mutatie-events.

3. Belangrijkste Bijdragen

Het artikel levert vijf specifieke bijdragen:

C1. Wire Format Specificatie: Een JSON Schema-gebaseerd protocol voor vijf operaties over vier geheugentypes, expliciet versied met een breaking-change beleid tot v0.5.
C2. Referentie-implementatie: Een productie-waardige Python SDK met vijf backend adapters, een parallelle router met RRF, en een tolerant model voor gedeeltelijke fouten.
C3. Governance UI: Een implementatie van het diff-and-approve patroon dat transparant integreert met elke backend adapter.
C4. Empirische Evaluatie:
- Een microbenchmark op 100 feiten/50 queries.
- Een adversariële fusie-experiment dat de robuustheid test tegen kwaadwillende backends.
- Een suite van 16 scenario's voor cross-adapter conformiteit.
C5. Threat Model & Artifacts: Een zes-adversary threat model met line-level mitigaties en open-data artifacts die volledige reproduceerbaarheid van de claims mogelijk maken.

4. Resultaten

4.1 Microbenchmark Prestaties

Op een corpus van 100 handgeschreven feiten en 50 gelabelde queries (gebruikmakend van all-MiniLM-L6-v2 en sqlite-vec):

Recall@5: 1.000 op 42 gelabelde queries (parafraasering, exact-match en multi-hit).
Latency: Ingest p50 = 37.8 ms; Recall p50 = 40.6 ms.
Precisie: 0.214 (beperkt door de ratio van gold IDs per query).
No-Match Handling: 0/8 "no-match" probes gaven vals-positieven terug (hoewel het artikel vermeldt dat dit te wijten is aan een bewuste v0-ontwerpkeuze om tot $k$ hits terug te geven zonder drempelwaarde voor relevantie).

4.2 Adversarial Fusion Experiment

De studie testte de robuustheid van fusie-algoritmen tegen een "1-van-N kwaadwillende backend" die attacker-gecontroleerde ID's injecteert op rank 0.

RRF: Behield een Recall@5 = 1.000 over alle attack budgets ( $K \in \{0, 5, \dots, 50\}$ ). De score-onafhankelijkheid van RRF voorkomt dat een enkele kwaadwillende store de gefuseerde output domineert.
MAX: Klapte onmiddellijk bij $K=5$ , met een Recall@5 die zakte naar 0.500 en een leak rate van 80% (80% van de geretourneerde ID's waren door de aanvaller gecontroleerd).
Weighted: Presteerde identiek aan RRF wanneer de gewichten gelijk waren.

4.3 Cross-Adapter Conformiteit

Een suite van 16 protocol-invariante scenario's werd uitgevoerd tegen alle vijf de adapters (totaal 80 cellen).

Resultaten: 68 PASS, 12 SKIP, 0 FAIL.
Analyse: De SQL-gebaseerde adapters (sqlite-vec, pgvector) passeerden alle scenario's. De SDK-wrapping adapters (mem0, Letta, Cognee) sloegen scenario's over die gerelateerd waren aan ontbrekende functies in hun upstreams (bijv. gebrek aan user_id namespaces, ontbrekende stabiele per-record ID's, of gebrek aan empty-policy guards). Deze skips identificeerden specifieke gebieden voor het aanscherpen van de v0.2 specificatie.

4.4 Voorlopige Long-Context Benchmarks

Voorlopige runs op LongMemEval en LoCoMo toonden significante verbeteringen na het oplossen van een bug waarbij vector-ANN top-k werd berekend vóór de agent-filtering:

LongMemEval: Verbeterde van 0.286 naar 0.417 (+46% relatief).
LoCoMo: Verbeterde van 0.018 naar 0.150 (+8.3× relatief).
De auteurs merken op dat dit voorlopig is (n=10–12, 1 seed) en dat de embedder (all-MiniLM-L6-v2) een zwakke referentie is; het protocol zelf is embedder-agnostisch.

5. Betekenis en Claims

Het artikel frameert de bijdrage expliciet niet als een nieuwe algoritmische doorbraak, maar als een verpakking en standaardisatie van gevestigde componenten (RRF, FSM's, STM/LTM-consolidatie, diff-and-approve workflows).

Positionering: memorywire is gepositioneerd om samen te werken met het Model Context Protocol (MCP) in plaats van ermee te concurreren. Terwijl MCP de standaardisatie van tool-gebruik regelt, mist het een native geheugen-primitief. memorywire vult dit gat en kan in de toekomst dienen als een MCP-extensie of een standalone standaard (via IETF).
Bescheidenheid: De auteurs erkennen dat memorywire v0 een concept is met voorbehouden rechten om compatibiliteit te breken tot v0.5. Ze geven toe dat de huidige evaluatie kleine, synthetische corpora en voorlopige benchmarks gebruikt; volledige schaal evaluaties (5-seed × 200 vragen) zijn uitgesteld naar een v2 release.
Kernwaarde: De primaire waarde ligt in een venue-neutraal protocol dat elke client in staat stelt met elke backend te communiceren, agents in staat stelt om geheugen mee te nemen tussen runtimes, en een gestandaardiseerd oppervlak biedt voor menselijke governance over geheugen-schrijfacties.

Samenvattend biedt memorywire een pragmatisch, empirisch gevalideerd protocol om de fragmentatie in interoperabiliteit en governance aan te pakken die momenteel het agent-geheugenecosysteem teistert.