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.