Pith.

Cryptography and Security · arXiv:2606.01138 v4 · submitted 31 May 2026

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

Thamilvendhan Munirathinam

The paper says

“Agent-memory frameworks – mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor – each ship their own SDK, storage layout, and operational vocabulary.”

more of the abstract

There is no shared wire format: every integration is bespoke, every migration rebuilds memory from scratch, and no framework ships a governance surface that lets a human review writes before they enter long-term storage. We present memorywire, a JSON-Schema 2020-12 wire format for five memory operations (remember, recall, forget, merge, expire) over four memory types (semantic, episodic, procedural, emotional), with a MemoryStore interface, a fan-out router, and an optional HITL governance channel. We describe an open-source reference implementation with five backend adapters (sqlite-vec, mem0, Letta, Cognee, pgvector); a microbenchmark on a 100-fact / 50-query labelled corpus (42 with non-empty gold ids + 8 no-match probes) achieving recall@5 = 1.000 on the 42 gold-id queries with ingest p50 = 37.8 ms and recall p50 = 40.6 ms; an adversarial-fusion experiment showing Reciprocal Rank Fusion holds recall@5 = 1.000 across a 1-of-N rank-0 injection sweep (K in 0, 5, ..., 50) where max fusion collapses to 0.500 with 80% leak at K >= 5; and a 16-scenario cross-adapter conformance suite passing 68 of 80 cells with zero failures. The contribution is not a new algorithm; it is a packaging of established components (RRF, FSMs, STM/LTM consolidation, diff-and-approve workflows) into a venue-neutral protocol with an empirically validated reference, positioned to compose with the Model Context Protocol rather than compete with it. We further show that memorywire's provenance field is the strongest lever for recovering a poisoned store, evaluated with an companion benchmark (PurgeBench).

from the abstract

Pith says

Machine review · deepseek-v4-flash · 2 Aug 2026 · of version 3 of the paper; version 4 is newer · what was read was not recorded · not checked by a person

It can be wrong. Challenge this review or reply to it.

Holds up, with conditions. Honest, well-engineered systems paper: the wire format and reference implementation are real, but the abstract's PurgeBench claim is unsupported and 'any backend' overstates what the conformance suite's 12 SKIP cells show. This line is wrong

3 major objections · 4 minor

How often objections from reviews like this one are right: not yet measured

Are you an author? What you can do.

Not checked: figures, code, what the references say.

The paper says, at §5.3, Table 5; §1.1, Table 2

The review did not quote this passage.

Pith says: Objection 1 of 3 · major

The central claim that 'any client can talk to any backend' (§1.1) is not supported by the conformance evidence. The 12 SKIP cells in Table 5 are semantic losses, not cosmetic gaps: Cognee has no stable per-record id, so forget_by_ids, expire_by_age, and merge_keep_canonical are no-ops; Letta and Cognee have no user_id namespace, so user-scoped recall is silently unavailable; mem0, Letta, …

more of objection 1

… and Cognee skip empty-expire-policy guards and silently fall through to 'match everything'. §5.3 itself calls these 'real gaps in the v0 spec' and defers them to v0.2. As shipped, full conformance is demonstrated only for sqlite-vec and pgvector, the adapters whose schemas memorywire was designed against. Either narrow the claim to 'full conformance for SQL-backed stores, partial with documented degradation for SDK adapters', or show that the v0.2 tightenings are implementable against the upstream APIs.

The paper says, at Abstract

The review did not quote this passage.

Pith says: Objection 2 of 3 · major

The abstract asserts that 'memorywire's provenance field is the strongest lever for recovering a poisoned store, evaluated with an external benchmark (PurgeBench).' No section, table, figure, dataset description, or reference supports this claim in the manuscript; the word 'PurgeBench' appears only in the abstract. The evaluation sections (§5.1–§5.5) cover the microbenchmark, adversarial fusion, conformance, and preliminary LongMemEval/LoCoMo runs; none address PurgeBench. This claim must either be substantiated with an experimental section and citation, or removed from the abstract.

The paper says, at §5.2, Table 4

The review did not quote this passage.

Pith says: Objection 3 of 3 · major

The adversarial-fusion result is a worked consequence of the RRF formula rather than an empirical test. With two benign stores returning gold at rank 0 and k=60, a gold id scores 1/60 + 1/61 ≈ 0.0330, while a single rogue rank-0 vote scores 1/60 ≈ 0.0167; RRF must therefore keep gold ahead for any K.

more of objection 3

The construction forces the reported outcome, so it does not validate robustness to imperfect benign stores, distractor overlap, or an attacker who fabricates ids that also appear in benign lists (listed as future hardening in §5.4). The paper's own caveat that 'benign stores are perfect by construction' is appropriate, but the abstract's phrase 'adversarial-fusion experiment showing RRF holds' overstates its evidentiary value. Please relabel this as a worked demonstration or sanity check.

4 minor objections

The paper says, at §5.1, Table 3

Pith says: minor objection 1 of 4

The row 'No-match probes correctly empty 0 / 8' is ambiguous; as written it can be read as '0 of 8 correctly empty', which is what the text says, but I recommend 'No-match probes correctly empty: 0 of 8' for clarity.

The paper says, at §5.5, Table 6

Pith says: minor objection 2 of 4

The column header 'n q seeds grader mean' runs together; split into n_q, n_seed, grader, and mean. Currently the table resembles a formatting artifact.

show 2 more

The paper says, at §5.1, Table 3

Pith says: minor objection 3 of 4

Precision@5 mean is dominated by queries with a single gold id; reporting recall@1 and recall@10 alongside recall@5 would give a fuller picture of retrieval quality.

The paper says, at References

Pith says: minor objection 4 of 4

Reference [9] is cited as a 'line of work' on Governed Memory but appears to be a single work; if it is not yet formally published, a URL or version identifier would help readers verify the provenance of the Co-memorize pattern.

What would settle it

Write a strict conformance pass that forbids SKIP: for each shipped adapter (mem0, Letta, Cognee, plus SQL controls), execute the 12 currently-skipped scenarios as real assertions — remember a record, then user-filter recall, forget_by_ids followed by recall-verify deletion, merge_keep_canonical, and expire with an empty policy. Assert either the protocol-visible effect occurs or the adapter raises an explicit NotImplementedError/capability error. Run this on the pinned commit. If any adapter returns success while the record persists, the five-operation contract is not implemented and vendor-neutrality must be scoped to capability subsets. If all adapters raise cleanly, the paper's SKIP framing should be replaced by explicit capability negotiation; either way the claim needs revision.

from the skeptic's reading

How the review went

4 readings by deepseek-v4-flash · 2 Aug 2026

  1. Reader holds up, with conditions confidence moderate
  2. Skeptic agrees 1 min 16 s · 18,331 tokens read, 7,286 written
  3. Editor wrote the verdict above 31 s · 19,117 tokens read, 3,117 written
  4. Referee major revision: 3 major objections, 4 minor 1 min 15 s · 18,678 tokens read, 8,401 written

Not run on this paper: the simulated authors' defence.

Pith did not check this review's objections against the paper.

The review in full

The review in brief, machine-written

This is a solid systems contribution, better than its own abstract. The authors say up front it's not a new algorithm — it's a packaging of RRF, FSM procedural memory, STM/LTM consolidation, and diff-approve governance into a versioned JSON-Schema wire format with five operations and four memory types. That's what they deliver, and the artifact is substantial: a 15k-line Python reference, five adapters, schemas, a governance UI, a conformance suite, and an open-data adversarial sweep. The threat model section is unusually candid, with line-level mitigation citations. Credit is deserved here.

The two things I'd fix are both in the abstract. First, it claims the provenance field was 'evaluated with an external benchmark (PurgeBench)' — no PurgeBench appears anywhere in the text. That's an unsupported claim as written and needs either a section or a removal. Second, 'any client can talk to any backend' is too strong. The conformance suite passes 68/80 cells, and the 12 SKIPs are real: Letta and Cognee have no user_id namespace, Cognee can't forget/merge by stable id because its public API never surfaces the pipeline data_id, and three adapters silently accept empty expire policies. The paper itself calls these 'real gaps in the v0 spec,' which is honest, but the vendor-neutrality headline should be qualified to 'any backend supported by an adapter, with documented capability limits.'

The RRF adversarial experiment is the third thing. It doesn't test a hypothesis so much as illustrate the formula: two benign rank-0 votes beat one rogue vote because 1/60 + 1/61 > 1/60, and the benign stores are perfect by construction. The authors know this — they list it as a caveat — but 'empirically validated' is doing a bit too much work.

None of these are deal-breakers. The spec is detailed, the implementation is real, and the limitations are front-loaded. If a venue has room for serious systems work, this deserves a referee, not a desk reject. My recommendation: accept conditional on adding or removing the PurgeBench sentence, pinning the artifact to a commit hash, and softening the abstract's vendor-neutrality claim to match the SKIP cells.

The strongest objection

The central claim is that the five-operation/four-type wire format lets "any client talk to any backend" and "carry memory across runtimes." The conformance suite meant to prove this reports 68 PASS / 12 SKIP / 0 FAIL (Table 5, Section 5.3). The SKIPs are not cosmetic. Cognee cannot implement forget_by_ids, expire_by_age, or merge_keep_canonical because its public add API never surfaces the pipeline-assigned data_id, so per-record deletion is impossible. Letta and Cognee have no user_id namespace, so user-scoped recall is silently unavailable. mem0, Letta, and Cognee skip both empty-expire-policy guards and silently fall through to "match everything." The paper itself calls these "real gaps in the v0 spec" and promises v0.2 tightenings. Because the gaps track upstream API limits rather than adapter bugs, the reference's vendor-neutrality is currently demonstrated only for the two SQL-backed adapters whose schemas memorywire was designed against; Table 2 marks Letta and Cognee metadata as lossy. A client issuing standardized operations against a router with these adapters receives no-op or degraded semantics, so the headline claim overstates what the shipped artifacts deliver.

The reader's weakest assumption is exactly the load-bearing concern: the five-operation/four-type vocabulary cannot fully bridge backends whose native data models lack core memorywire dimensions, and the paper's own conformance matrix quantifies the gaps. This is the strongest attack on the central claim because it targets the "any client/any backend" promise directly, not a side experiment. I considered the adversarial-fusion experiment's synthetic benign-store assumption; it is disclosed and not central to the protocol claim. I also noted the abstract promises a PurgeBench evaluation that is absent from the text; that is a real error but secondary. The conformance SKIPs are authored, quantified, and explicitly tied to upstream API limitations, making them the best focal point. The paper is otherwise honest and front-loads limitations, so this does not warrant rejection; it warrants a conditional acceptance with a clarified, capability-scoped neutrality claim or a strict conformance demonstration.

The referee's report

If the interoperability claim held at full conformance, memorywire would be a useful contribution to the agent-memory ecosystem: it offers a schema-pinned wire format, a working open-source reference, a governance diff-and-approve channel, and a detailed threat model with line-level mitigation citations. The paper is unusually candid about its limitations (§1.3, §5.4), ships reproducible scripts and open data, and its conformance suite is explicitly used as a spec-discovery tool. The main unresolved issue is that the shipped artifact supports full vendor-neutrality only for the two SQL-backed adapters; the SDK-wrapping adapters have documented semantic gaps. The PurgeBench claim in the abstract is unsupported, and the adversarial-fusion result is a worked mathematical consequence rather than an empirical test. These issues are fixable within the manuscript's scope.

Pith's reading of the paper (a machine's summary, not the authors')

This paper argues that agent-memory frameworks are islanded: each has its own SDK, storage layout, and operational vocabulary, so integrations are bespoke and migrations rebuild memory from scratch. It tries to establish that a shared wire format—five operations (remember, recall, forget, merge, expire) over four memory types (semantic, episodic, procedural, emotional)—can serve as a vendor-neutral protocol that lets any client talk to any backend, any agent carry memory across runtimes, and any write be diffed and approved by a human. The contribution is explicitly not a new algorithm but a composition and standardization of established pieces, backed by a reference implementation and empirical validation. If correct, this would give the agent-memory ecosystem a common substrate and a governance surface that no current framework ships.

What carries the argument. The central object is the memorywire wire format itself: JSON Schema 2020-12 definitions for five operations and four memory types, plus the MemoryStore Protocol, the fan-out router, the governance channel, and the reference implementation with five backend adapters. The load-bearing mechanism inside the router is Reciprocal Rank Fusion, whose score-independence and additivity make a single malicious backend unable to dominate fused recall by inflating scores. The governance channel works through a PENDING_APPROVAL_DELETED_AT = -1 sentinel, keeping unapproved writes invisible to recall until a human commits them.

Core claim. On the paper's own terms, the central claim is that memorywire provides a venue-neutral protocol for agent memory operations, giving memory the same first-class treatment that a widely adopted tool-use protocol gave to tool calls. The paper specifies a JSON Schema 2020-12 wire format, a MemoryStore interface implemented by five backend adapters, a fan-out router that fuses recall results via Reciprocal Rank Fusion, and an optional human-in-the-loop governance channel that stages writes behind a sentinel until a reviewer commits or rejects them. The empirical evidence includes a microbenchmark where all 42 labelled queries retrieve every gold id in the top five results, an adversarial-fusion

The premise it rests on. The load-bearing premise is that a fixed vocabulary of five operations and four memory types can faithfully bridge backends whose native data models lack some of those dimensions; the conformance suite's 12 skipped cells show this is not yet universally true.

If the paper is right (Pith's inferences, not the authors')

A single client could talk to any compliant memory backend, and an agent could carry its memory across runtimes without bespoke migrators.

Writes could be routed through human approval before entering long-term storage, making prompt-injected memory planting auditable rather than silent.

Operators with untrusted backends would have a quantitative reason to default to RRF over score-sensitive fusion, since the paper shows RRF resists rank-0 injection while max fusion does not.

The conformance suite's skipped cells motivate concrete spec tightenings: stable per-record IDs, an explicit user_id fallback, and a mandatory empty-expire-policy guard.

Beyond the paper: the 12 skipped conformance cells suggest vendor-neutrality is currently fully realized only for backends that own their schema; SDK-wrapping adapters inherit upstream data-model limits, so 'any client, any backend' is an aspiration until the spec raises the floor.

Beyond the paper: the standalone-first, propose-upstream-later strategy means memorywire could become the memory primitive for a broader agent protocol, but adoption by the ecosystem will matter more than the technical design.

Beyond the paper: a natural stress test is rerunning the adversarial-fusion sweep with a 2-of-3 malicious-backend configuration; the paper's own consensus argument predicts RRF would lose its robustness, which would bound the claim.

Beyond the paper: swapping the deliberately weak reference embedder for a stronger one on standard long-context memory benchmarks would isolate whether the wire format itself contributes to recall, as the paper claims it is embedder-agnostic.

Check this review

Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.

How often reviews like this one are right

Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.

How often objections from reviews like this one are right: not yet measured

Every value above, in the review's public record (JSON)

Reviews by people

This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.

Request a human review

How Pith checks papers · The full audit of this paper · Review history (2 versions)

The paper

Abstract

Agent-memory frameworks – mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor – each ship their own SDK, storage layout, and operational vocabulary. There is no shared wire format: every integration is bespoke, every migration rebuilds memory from scratch, and no framework ships a governance surface that lets a human review writes before they enter long-term storage. We present memorywire, a JSON-Schema 2020-12 wire format for five memory operations (remember, recall, forget, merge, expire) over four memory types (semantic, episodic, procedural, emotional), with a MemoryStore interface, a fan-out router, and an optional HITL governance channel. We describe an open-source reference implementation with five backend adapters (sqlite-vec, mem0, Letta, Cognee, pgvector); a microbenchmark on a 100-fact / 50-query labelled corpus (42 with non-empty gold ids + 8 no-match probes) achieving recall@5 = 1.000 on the 42 gold-id queries with ingest p50 = 37.8 ms and recall p50 = 40.6 ms; an adversarial-fusion experiment showing Reciprocal Rank Fusion holds recall@5 = 1.000 across a 1-of-N rank-0 injection sweep (K in 0, 5, ..., 50) where max fusion collapses to 0.500 with 80% leak at K >= 5; and a 16-scenario cross-adapter conformance suite passing 68 of 80 cells with zero failures. The contribution is not a new algorithm; it is a packaging of established components (RRF, FSMs, STM/LTM consolidation, diff-and-approve workflows) into a venue-neutral protocol with an empirically validated reference, positioned to compose with the Model Context Protocol rather than compete with it. We further show that memorywire's provenance field is the strongest lever for recovering a poisoned store, evaluated with an companion benchmark (PurgeBench).

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.

abstract compiled · 2026-09-23

The authors' main claim, as the classifier picked it out 0.81

“The contribution is not a new algorithm; it is a packaging of established components (RRF, FSMs, STM/LTM consolidation, diff-and-approve workflows) into a venue-neutral protocol with an empirically validated reference, positioned to compose with the Model Context Protocol rather than compete with it.”

How the main claim is stated: asserted 1.00

What the abstract itself states, as probabilities: claims first 0.20 · states limitation 0.91 · human participants 0.08 · controlled comparison 0.66 · randomized assignment 0.02 · states quantitative result 0.99 · compares with prior results 0.81 · mentions code or data availability 0.87

The abstract, sentence by sentence

This table labels the abstract only (arXiv listing abstract v4). The number is the probability the classifier gave the label.

SentenceRoleThe authors' own workStates the main conclusionStrength
Agent-memory frameworks -- mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor -- each ship their own SDK, storage layout, and operational vocabulary. background 0.98 0.06 0.02 asserted 1.00
There is no shared wire format: every integration is bespoke, every migration rebuilds memory from scratch, and no framework ships a governance surface that lets a human review writes before they enter long-term storage. gap 0.95 0.11 0.04 asserted 1.00
We present memorywire, a JSON-Schema 2020-12 wire format for five memory operations (remember, recall, forget, merge, expire) over four memory types (semantic, episodic, procedural, emotional), with a MemoryStore interface, a fan-out router, and an optional HITL governance channel. contribution 0.99 0.89 0.24 asserted 1.00
We describe an open-source reference implementation with five backend adapters (sqlite-vec, mem0, Letta, Cognee, pgvector); a microbenchmark on a 100-fact / 50-query labelled corpus (42 with non-empty gold ids + 8 no-match probes) achieving recall@5 = 1.000 on the 42 gold-id queries with ingest p50 = 37.8 ms and recall p50 = 40.6 ms; an adversarial-fusion experiment showing Reciprocal Rank Fusion holds recall@5 = 1.000 across a 1-of-N rank-0 injection sweep (K in {0, 5, ..., 50}) where max fusion collapses to 0.500 with 80% leak at K >= 5; and a 16-scenario cross-adapter conformance suite passing 68 of 80 cells with zero failures. result 0.59 0.97 0.14 asserted 1.00
The contribution is not a new algorithm; it is a packaging of established components (RRF, FSMs, STM/LTM consolidation, diff-and-approve workflows) into a venue-neutral protocol with an empirically validated reference, positioned to compose with the Model Context Protocol rather than compete with it. contribution 0.74 0.59 0.43 asserted 1.00
We further show that memorywire's provenance field is the strongest lever for recovering a poisoned store, evaluated with an companion benchmark (PurgeBench). result 0.76 0.94 0.15 asserted 1.00

What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.99

What was examined, and what was not

Sources read

  • arXiv listing abstract v4

Not examined

  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers

Levels run

  • P abstract

Not run

  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

How the labels were made

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 5,517 input tokens.

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON

Figures (1)
Figure 1 of the paper
Figure 1. memorywire architecture. A client (SDK or CLI) issues one of the five spec operations against the Memory facade, which validates the request and delegates to the MemoryRouter. The router fans out across heterogeneous backend adapters (sqlite-vec, mem0, Letta, Cognee, pgvector) and fuses recall re￾sults with Reciprocal Rank Fusion (k = 60) plus an optional one-hop graph boost. Procedural writes take a parallel FSM path. The STM↔LTM trans￾former runs as an async background task. An optional governance plane (UI + append-only audit log) inter￾cepts writes that require human review and…

Figures are the authors', reproduced from the paper.

Cited by 1 Pith paper
How the literature uses it

1 arXiv paper cite this in 1 sentence

Each citing sentence is taken from the citing paper's LaTeX source and typed by Pith's classifier. A label appears at probability 0.8 or more (0.95 for support), a contest at 0.7 or more; the quoted words are the citing authors'. How each label was checked · JSON

Papers citing it

Cites it as background 1 paper
  • TRUSTMEM [ref] focuses on trustworthy memory consolidation, emphasizing that write, revise, and delete operations can themselves introduce omission, corruption, or hallucinated persistent state. memorywire [ref] standardizes memory operations such as remember, recall, forget, merge, and expire as an interface-level concern for agent memory systems.

    Spatial Memory Agent: Experience-Grounded Procedural Memory for Spatial Intelligence · Long-Term Memory Maintenance · 0.96

Challenges and discussion

Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.

No comments yet.

Sign in to comment