From 3aa302d8ac60a16985ea9d35753ad104a1e3bcd2 Mon Sep 17 00:00:00 2001 From: Thamilvendhan Munirathinam <37844963+mthamil107@users.noreply.github.com> Date: Mon, 31 Aug 2026 14:56:24 +0530 Subject: [PATCH] docs(paper): ids are opaque strings, not ULID-shaped The paper described sqlite-vec as keyed by "a stable ULID-shaped string" in Section 1. The reference implementation mints uuid4 hex - 32 lowercase hex chars, not a 26-char Crockford base32 ULID (sqlite_vec.py:434, transformer.py:65) - and the schemas guarantee only {"type": "string", "minLength": 1} with no format at all. The claim has been present since v1 and is live in v4. An implementer binding to the wire format could reasonably write a ULID validator on the strength of it and reject every id the reference store produces. Replaced with an accurate description that also states the format is not part of the contract, which is the property implementers actually need. --- docs/paper/arxiv-submission/memorywire-paper.tex | 2 +- docs/paper/memorywire-paper.md | 2 +- docs/paper/memorywire-paper.tex | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/paper/arxiv-submission/memorywire-paper.tex b/docs/paper/arxiv-submission/memorywire-paper.tex index 19be98d..1e858f6 100644 --- a/docs/paper/arxiv-submission/memorywire-paper.tex +++ b/docs/paper/arxiv-submission/memorywire-paper.tex @@ -70,7 +70,7 @@ \section{Introduction} \subsection{The problem: islanded memory frameworks} \label{sec:intro-problem} -Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a \texttt{memories[]} list keyed by \texttt{user\_id} with a heterogeneous \texttt{created\_at} representation; Letta stores archival memory keyed by \texttt{agent\_id} and exposes a \texttt{tags} list as the only structured-metadata sink; Cognee mints internal \texttt{data\_id} UUIDs that are not surfaced through its public \texttt{add} API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by a stable ULID-shaped string; pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. +Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a \texttt{memories[]} list keyed by \texttt{user\_id} with a heterogeneous \texttt{created\_at} representation; Letta stores archival memory keyed by \texttt{agent\_id} and exposes a \texttt{tags} list as the only structured-metadata sink; Cognee mints internal \texttt{data\_id} UUIDs that are not surfaced through its public \texttt{add} API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by an opaque string id (the reference implementation mints a uuid4 hex; the format is not part of the contract); pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. The same heterogeneity means there is no shared \emph{governance} surface. Each framework provides a write API and a read API; none mediate the write with a ``diff against current state, present to a human, commit only on approval'' workflow. Production governance work such as Taheri's \emph{Governed Memory}~\cite{taheri2026governed} enforces write policy automatically across autonomous agents rather than through such a human-approval gate, so this human-in-the-loop workflow has no production implementation an off-the-shelf agent can drop in. Operators who want auditability over what enters long-term memory must build it themselves and accept that the framework can bypass them. diff --git a/docs/paper/memorywire-paper.md b/docs/paper/memorywire-paper.md index 17210f1..c1532a1 100644 --- a/docs/paper/memorywire-paper.md +++ b/docs/paper/memorywire-paper.md @@ -17,7 +17,7 @@ Agent-memory frameworks --- mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, ### 1.1 The problem: islanded memory frameworks -Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a `memories[]` list keyed by `user_id` with a heterogeneous `created_at` representation; Letta stores archival memory keyed by `agent_id` and exposes a `tags` list as the only structured-metadata sink; Cognee mints internal `data_id` UUIDs that are not surfaced through its public `add` API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by a stable ULID-shaped string; pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. +Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a `memories[]` list keyed by `user_id` with a heterogeneous `created_at` representation; Letta stores archival memory keyed by `agent_id` and exposes a `tags` list as the only structured-metadata sink; Cognee mints internal `data_id` UUIDs that are not surfaced through its public `add` API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by an opaque string id (the reference implementation mints a uuid4 hex; the format is not part of the contract); pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. The same heterogeneity means there is no shared *governance* surface. Each framework provides a write API and a read API; none mediate the write with a "diff against current state, present to a human, commit only on approval" workflow. Production governance work such as Taheri's *Governed Memory* (arXiv:2603.17787) enforces write policy automatically across autonomous agents rather than through such a human-approval gate, so this human-in-the-loop workflow has no production implementation an off-the-shelf agent can drop in. Operators who want auditability over what enters long-term memory must build it themselves and accept that the framework can bypass them. diff --git a/docs/paper/memorywire-paper.tex b/docs/paper/memorywire-paper.tex index cf3111c..3c2633e 100644 --- a/docs/paper/memorywire-paper.tex +++ b/docs/paper/memorywire-paper.tex @@ -67,7 +67,7 @@ \section{Introduction} \subsection{The problem: islanded memory frameworks} \label{sec:intro-problem} -Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a \texttt{memories[]} list keyed by \texttt{user\_id} with a heterogeneous \texttt{created\_at} representation; Letta stores archival memory keyed by \texttt{agent\_id} and exposes a \texttt{tags} list as the only structured-metadata sink; Cognee mints internal \texttt{data\_id} UUIDs that are not surfaced through its public \texttt{add} API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by a stable ULID-shaped string; pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. +Agent runtimes that maintain memory across sessions are now a category. Open-source frameworks include mem0, Letta (formerly MemGPT), Cognee, Zep/Graphiti, MemoryOS, and MemTensor MemOS; closed commercial offerings include Oracle's AI Agent Memory and the memory layers shipped inside major hosted-agent platforms. What the category has not produced is a shared wire format. Each framework defines its own SDK surface, JSON shape for memory records, embedding-provider integration, taxonomy (or absence of taxonomy) for memory types, and implicit lifecycle for record creation and deletion. The heterogeneity is non-trivial to bridge: mem0 stores records under a \texttt{memories[]} list keyed by \texttt{user\_id} with a heterogeneous \texttt{created\_at} representation; Letta stores archival memory keyed by \texttt{agent\_id} and exposes a \texttt{tags} list as the only structured-metadata sink; Cognee mints internal \texttt{data\_id} UUIDs that are not surfaced through its public \texttt{add} API, making per-record deletion impossible from outside the pipeline; sqlite-vec stores tables keyed by an opaque string id (the reference implementation mints a uuid4 hex; the format is not part of the contract); pgvector exposes records through an application-chosen SQL schema. Re-platforming an agent from one framework to another therefore requires a bespoke migrator and field-level losses where the source framework encodes more state than the target's data model holds. The same heterogeneity means there is no shared \emph{governance} surface. Each framework provides a write API and a read API; none mediate the write with a ``diff against current state, present to a human, commit only on approval'' workflow. Production governance work such as Taheri's \emph{Governed Memory}~\cite{taheri2026governed} enforces write policy automatically across autonomous agents rather than through such a human-approval gate, so this human-in-the-loop workflow has no production implementation an off-the-shelf agent can drop in. Operators who want auditability over what enters long-term memory must build it themselves and accept that the framework can bypass them.