Memory Design Considerations

Retrieval is five-channel parallel + Reciprocal Rank Fusion (RRF) — not a single vector lookup.

Why it matters Concrete, shipped instance of the multi-channel+fusion pattern; copy the channel decomposition. Connects directly to [precision-belief-state] on why channel fusion still needs retrieval-quality measurement.

Confirms five-channel parallel retrieval with RRF and structured-memory extraction.

Why it matters Independent confirmation of the architecture in [cf-agent-memory-blog].

Argues memory systems lean too hard on semantic similarity (misses user-centric evidence) and store related experiences as isolated fragments. Proposes adaptive, user-centric retrieval.

Why it matters Direct critique of cosine-similarity-as-relevance — the case for ranking on user state/goals, not just embedding distance. Connects to AdaMem's fragmentation point and [cast-episodic]'s coherence argument.

RAG-at-every-step is a rigid brute-force strategy that wastes compute and can degrade performance. Proposes an agent that decides when to retrieve vs reason from current context.

Why it matters Reframes retrieval as a policy decision, not a reflex — the cost/quality lever most retrieval designs ignore. Bridges Retrieval and Working-Memory categories.

Memory retrieval depends on the embedding model; existing training ignores the hierarchical difficulty of negatives (close distractors vs easy negatives) in human–agent interaction. HiNS trains on that hierarchy.

Why it matters The under-discussed layer beneath retrieval design: the embedding model itself decides what 'similar' means. Improving it is orthogonal to channel/fusion choices.

Observes that returning the entire belief store yields recall 1.0 and passes answer-quality evals — so answer-correctness can't validate a retrieval system. Introduces a precision-aware retrieval benchmark over a structured belief state.

Why it matters The cleanest statement of the retrieval-vs-answer-correctness gap (the 'unit test vs integration test' framing). A north star for evaluating any multi-channel retriever. Bridges Retrieval and Evaluation.

Opens on the paradox: coding agents have vast parametric knowledge yet can't remember an hour ago. Critiques single-channel vector retrieval that needs cloud LLMs and implements no cognitive processes. Adds biologically-inspired forgetting, cognitive quantization, and multi-channel retrieval — all local/zero-LLM.

Why it matters Bundles forgetting + multi-channel retrieval + local-first into one system; the indie counterpart to Cloudflare's managed multi-channel approach. Connects to [yourmemory] (zero-LLM, local) and [git-s3-memory] (local-first ethos).

'ChatDB' — a self-hosted conversation archive across multiple AI apps, with a proper hybrid keyword + semantic search interface, deployable free on Cloudflare.

Why it matters Demonstrates the storage+search split: keep transcripts, layer hybrid retrieval on top. The hybrid (lexical+semantic) retrieval choice connects to the Retrieval category.

Plain-language abstract Engram is an open-source long-term memory engine for LLM agents. Instead of replaying an entire conversation history into the prompt, it stores the past as a bi-temporal knowledge graph and retrieves a small, precisely-targeted slice at answer time. On a standard 500-question memory benchmark that lean ~9.6k-token slice answers more accurately than feeding the model the full ~79k-token history, turning memory from a cost optimization into an accuracy improvement.

Motivation Stateless LLM agents forget across sessions, and the usual fix — concatenating the whole history — grows token cost and latency linearly and loses accuracy as distractors crowd the window ('lost in the middle'). Two gaps stay open: most memory systems are cheaper or faster but not more accurate than full-context, and memory benchmarks run on inconsistent harnesses where one system reports wildly different scores across sources. Engram targets both — beating full-context on accuracy, and shipping a neutral, re-runnable harness.

Methodology A dual-process design. A System-1 hot write path appends lossless episodes with no LLM (sub-50ms) and enqueues them. A System-2 async path extracts atomic (subject,predicate,object) facts, builds a bi-temporal knowledge graph (valid time vs transaction time on every fact and edge), detects conflicts, and resolves them cheap-then-escalate: exact slot match, embedding similarity, and content subsumption handle the common case with no LLM call, invalidating (never deleting) a superseded fact and recording a supersedes chain and provenance, with only ambiguous cases escalated to an LLM adjudicator. The hybrid read path retrieves through four channels (dense, BM25, graph n-hop, recency/salience), fuses them with Reciprocal Rank Fusion, applies an 'as-of' temporal filter and an abstention gate, and assembles a deduplicated, provenance-tagged, token-budgeted context of facts plus raw chunks.

Results On the full 500-question LongMemEval_S under the official category-specific judge, Engram's lean configuration scores 83.6% vs 73.2% for full-context (+10.4 points, McNemar exact p<10^-6) at ~8x fewer tokens (9.6k vs 79k), 0/500 errored. The gain is load-bearing on the read path being hybrid: facts alone lose recall, while facts plus retrieved chunks recover detail. Bi-temporal modeling pays off most on knowledge-update (87.5%) and temporal (81.1%) categories, while multi-session aggregation and preference remain headroom. The paper documents measurement-integrity pitfalls (truncation, home-grown judges, full-history leaks) and ships a neutral in-repo harness with the official judge baked in and raw per-question logs, every number reproducible by command.

Plain-language abstract Infini Memory is a long-term memory architecture for LLM agents that stores memory as a library of plain-text 'topic documents' rather than vectors or a knowledge graph. Each document gathers related evidence under a subject and is maintained over time by splitting, merging, and rewriting. At answer time the agent reads memory through iterative tool calls, expanding context around matches instead of taking a single retrieval shot.

Motivation External memory systems that store observations as isolated records, summaries, or indexed fragments hit four recurring failure modes: fragmentation (evidence about one subject scattered across records), conflict (old and new versions of a fact coexisting), compression loss (summaries dropping temporal and source cues), and insufficient retrieval (single-shot top-k returning fragments without enough local context for multi-hop reasoning). Infini Memory reframes persistent memory as a lifecycle maintenance problem — write, maintain, read — and aims for an inspectable, editable state without a mandatory vector or graph backend.

Methodology Memory is a library of topic documents, each a maintenance scope with a summary, body, and entry-level metadata signatures (<seq,time,source>) that preserve order and provenance as content is rewritten. Writes are decoupled from structure: new candidates append to a buffer document, then periodic consolidation rewrites, splits, updates, and merges them into coherent topic documents. Retrieval can run over plaintext via lexical indexing rather than embeddings. At inference an agentic read procedure lets the LLM iteratively choose memory tools, inspect intermediate results, expand local context, and assemble evidence before answering.

Results On MemoryAgentBench the agentic-retrieval variant scores 64.7% overall and 81.2% on Accurate Retrieval, with gains on Factual Recall, Test-Time Learning, and Selective Forgetting. Ablations on LongMemEval_S isolate two complementary sources: holding the hybrid reader fixed, removing structural split-and-merge maintenance drops accuracy 76.0%->69.3% (-6.7, concentrated on knowledge-update and multi-session questions), while upgrading the reader from hybrid to agentic adds 3.3 points (76.0->79.3) — so maintenance matters more than the retrieval upgrade and neither is sufficient alone. A split-threshold sweep shows over-fragmentation is recoverable, but oversized documents that mix subtopics are costly.

Plain-language abstract T-Mem is a long-term conversational-memory architecture for LLM agents that aims to make every stored memory reachable two ways: by surface similarity (descriptive recall) and by latent semantic/causal link (associative recall). It precomputes, at write time, four families of retrieval cues ('triggers'), one per quadrant of a granularity (item vs scene) x orientation (descriptive vs associative) design space, and retrieves via a topic -> scene -> item cascade fused with RRF over lexical and dense indices. It reaches state-of-the-art on LoCoMo (80.26%) and LoCoMo-Plus (74.81%).

Motivation Existing LLM memory systems (flat RAG, graph/temporal-KG, hierarchical, OS-style) all retrieve by projecting query and memory into one similarity space and taking top-K, so they are reachability-bounded by lexical/dense similarity. In long-running dialogue users rarely re-raise old topics with the same wording; they revisit them through indirect situational cues, so the target's surface form has drifted and can never be reached from the same neighbourhood. This associative half of the query-memory relation is a structural blind spot.

Methodology M is a typed tuple of scenes, items, topic labels, four trigger families, and per-speaker Persona, built by a load-bearing four-stage offline pipeline: event-closure scene segmentation, incremental data-grown topic labelling, dual-granularity item extraction (atomic + connected, one LLM call per topic), and trigger instantiation (Entity+Bridge jointly per item; Scene+Horizon per scene). Memory-construction LLM is GPT-4.1-mini, dense encoder bge-m3. Retrieval is a top-down topic -> scene -> item cascade scored by RRF over BM25 + per-type dense rankings; multi-view trigger indices surface host nodes via nan-aware max cosine, and associative triggers bypass the topic prefilter so cues outside the similarity neighbourhood still hit. Triggers stay off the QA evidence path; Persona is ambient context appended after retrieval.

Results On LoCoMo, T-Mem reaches 80.26% LLM-as-judge accuracy (51.96 token-F1), 3.25 pp above the strongest baseline HyperMem and the maximum on five of six columns. On LoCoMo-Plus it scores 74.81%, narrowing the LoCoMo-to-LoCoMo-Plus drop to 5.45 pp, about 5x tighter than HyperMem (28.38 pp) and near an order of magnitude tighter than the Mem0/SeCom/A-Mem cluster (~49 pp). Ablations confirm the scene-level associative triggers drive the associative gain: removing Scene+Horizon collapses LoCoMo-Plus by 22.19 pp (Horizon alone -12.47 pp) while moving LoCoMo by under 0.4 pp. T-Mem also reaches higher accuracy than HyperMem at a lower input-token budget.

Plain-language abstract MemStrata is a memory system for AI agents that keeps track of when facts become outdated. Instead of just retrieving whatever text looks most similar to a query, which fails when an old and a new fact look nearly identical, it uses a deterministic rule to detect when a new fact supersedes an old one and retires the stale version.

Motivation Retrieval-augmented memory has no concept of time: when a fact changes (a renamed function, an updated config value, a new port number), both the old and new versions sit in the store with near-identical embeddings, and the agent can't tell which is current. The authors show this isn't a tuning problem: on a calibrated dataset, cosine similarity separates contradictions from duplicates at only 0.59 AUROC (near chance), because a value-flip edit sits textually closer to the original than a genuine rephrasing does.

Methodology MemStrata's write path first tries a deterministic (subject, relation, object) triple match: if an incoming fact shares a key with a stored one but asserts a different value, the old fact is retired (not deleted) in a bi-temporal ledger and the new one is stored as current. Non-triple prose falls back to a similarity-plus-LLM-judge gate. The system is evaluated on six local, deterministic benchmarks (two static, four marker-free evolving: code mutation, config migration, dependency bumps, API evolution) with a 7B model on consumer hardware.

Results MemStrata matches RAG on static recall (no cost) and reaches 0.95-1.00 accuracy on evolving-knowledge benchmarks where RAG reaches only 0.20-0.47. When forced to answer, plain RAG serves the superseded value 15-40% of the time; MemStrata drives this to ~0%. It also runs at ~2.1s retrieval latency versus ~16-18s for LLM-reranking/verification baselines, since no LLM sits on the read path.

Newsletter roundup that flagged the agent-memory survey wave and frameworks like MemVerse (fast parametric recall + hierarchical retrieval) and WorldMM (multimodal experience consolidation).

Why it matters Good lay-of-the-land pulse on what the research community foregrounded as memory went mainstream. Lighter signal than the survey itself.

Slack engineering moved away from accumulating chat logs toward structured memory, validation, and 'distilled truth' to keep long-running agents coherent and accurate.

Why it matters Production validation of the consolidation thesis — and crucially, they *validate* the distilled memory rather than trusting LLM rewrites. Read alongside [useful-memories-faulty], which explains why that validation step is necessary.

Distinguishes episodic traces (raw trajectories) from consolidated abstractions (schema-like lessons). Shows that when an LLM repeatedly rewrites a textual memory bank, the consolidated memory degrades over time.

Why it matters The strongest research caution against LLM-driven consolidation as your primary store. Direct argument to keep raw traces (see Substrate) as ground truth and treat distillation as lossy. Pairs with Slack's validation step.

Critiques 'eager' consolidation (invoke an LLM on every incoming interaction to extract memory) as a major token-cost driver. Proposes recurrence-based consolidation that batches/defers the work.

Why it matters The cost knob for consolidation. Connects to [memfly] and [simplemem] as the efficiency cluster; the tradeoff is staleness vs token spend.

Frames the dilemma: retain full history (redundancy) vs iterative reasoning to filter noise (token cost). Proposes an efficient middle path for lifelong memory.

Why it matters Clean statement of the consolidation cost/coverage tradeoff that recurs across the category. Sits with [recmem]/[memfly] on efficiency.

Uses an information-bottleneck objective to balance compressing redundant info against keeping retrieval precise, optimizing memory on the fly.

Why it matters Gives the consolidation tradeoff a principled objective rather than a heuristic. Theoretical companion to [recmem]/[simplemem].

Argues current frameworks fragment conversations into isolated embeddings or graph nodes; proposes building a coherent narrative via agentic reasoning instead.

Why it matters Bridges consolidation and representation: the unit of memory should preserve narrative coherence, not just be a retrievable shard. Connects to [cast-episodic]'s who/when/where stance.

Shifts the question from memory *management* (retrieve/page within a budget) to memory *utility*: what experience is worth keeping, and how it should change agent behavior. 'Atlas' compiles accumulated experience into precise instructions.

Why it matters Reframes the goal of consolidation around behavior change, not storage. Strong complement to the cost cluster — efficiency is moot if you keep the wrong things.

Notes most memory systems store isolated records and retrieve fragments, limiting consolidation of evolving user state and conflict resolution. Proposes a self-organizing memory OS for structured long-horizon reasoning.

Why it matters 'Memory OS' framing that ties consolidation to conflict resolution (Temporality) and structure (Representation). Conceptual cousin of Letta/MemGPT-style OS metaphors.

Critiques incremental per-turn extraction/update; proposes a dual-process design (fast + slow paths) for high-fidelity memory access over long horizons.

Why it matters Dual-process (System-1/System-2) is a recurring shape; here applied to when to consolidate cheaply vs reason deeply. Connects to [retrieve-or-think]'s retrieve-vs-think policy.

Critiques the dominant extracted-fact paradigm: handcrafted static prompts compress raw dialogue into atomic facts that are stored, matched, and injected — losing the ability to reason deeply over history. Proposes going beyond atomic facts.

Why it matters The most on-the-nose challenge to atomic-facts-as-primitive. Read before committing to a fact-extraction pipeline; connects to [amory] (narrative) and [cast-episodic] (events) as richer alternatives.

Sliding-window and prompt-compression context management omit earlier structured info later steps rely on; retrieval-based memory surfaces relevant content but overlooks dependencies. Builds memory selectively with explicit dependency structure.

Why it matters Targets the failure where compression drops the one earlier fact a later step needs — a dependency-aware answer to context rot. Connects consolidation (what to keep) with context (what to show).

Context adaptation (modifying inputs vs updating weights) suffers two failure modes: brevity bias (concise summaries drop domain insight) and context collapse (iterative rewriting erodes detail).

Why it matters Names the exact degradation mode behind LLM-rewritten memory — the context-side mirror of [useful-memories-faulty]. Strong argument against over-summarizing either context or stored memory.

Plain-language abstract Infini Memory is a long-term memory architecture for LLM agents that stores memory as a library of plain-text 'topic documents' rather than vectors or a knowledge graph. Each document gathers related evidence under a subject and is maintained over time by splitting, merging, and rewriting. At answer time the agent reads memory through iterative tool calls, expanding context around matches instead of taking a single retrieval shot.

Motivation External memory systems that store observations as isolated records, summaries, or indexed fragments hit four recurring failure modes: fragmentation (evidence about one subject scattered across records), conflict (old and new versions of a fact coexisting), compression loss (summaries dropping temporal and source cues), and insufficient retrieval (single-shot top-k returning fragments without enough local context for multi-hop reasoning). Infini Memory reframes persistent memory as a lifecycle maintenance problem — write, maintain, read — and aims for an inspectable, editable state without a mandatory vector or graph backend.

Methodology Memory is a library of topic documents, each a maintenance scope with a summary, body, and entry-level metadata signatures (<seq,time,source>) that preserve order and provenance as content is rewritten. Writes are decoupled from structure: new candidates append to a buffer document, then periodic consolidation rewrites, splits, updates, and merges them into coherent topic documents. Retrieval can run over plaintext via lexical indexing rather than embeddings. At inference an agentic read procedure lets the LLM iteratively choose memory tools, inspect intermediate results, expand local context, and assemble evidence before answering.

Results On MemoryAgentBench the agentic-retrieval variant scores 64.7% overall and 81.2% on Accurate Retrieval, with gains on Factual Recall, Test-Time Learning, and Selective Forgetting. Ablations on LongMemEval_S isolate two complementary sources: holding the hybrid reader fixed, removing structural split-and-merge maintenance drops accuracy 76.0%->69.3% (-6.7, concentrated on knowledge-update and multi-session questions), while upgrading the reader from hybrid to agentic adds 3.3 points (76.0->79.3) — so maintenance matters more than the retrieval upgrade and neither is sufficient alone. A split-threshold sweep shows over-fragmentation is recoverable, but oversized documents that mix subtopics are costly.

Plain-language abstract T-Mem is a long-term conversational-memory architecture for LLM agents that aims to make every stored memory reachable two ways: by surface similarity (descriptive recall) and by latent semantic/causal link (associative recall). It precomputes, at write time, four families of retrieval cues ('triggers'), one per quadrant of a granularity (item vs scene) x orientation (descriptive vs associative) design space, and retrieves via a topic -> scene -> item cascade fused with RRF over lexical and dense indices. It reaches state-of-the-art on LoCoMo (80.26%) and LoCoMo-Plus (74.81%).

Motivation Existing LLM memory systems (flat RAG, graph/temporal-KG, hierarchical, OS-style) all retrieve by projecting query and memory into one similarity space and taking top-K, so they are reachability-bounded by lexical/dense similarity. In long-running dialogue users rarely re-raise old topics with the same wording; they revisit them through indirect situational cues, so the target's surface form has drifted and can never be reached from the same neighbourhood. This associative half of the query-memory relation is a structural blind spot.

Methodology M is a typed tuple of scenes, items, topic labels, four trigger families, and per-speaker Persona, built by a load-bearing four-stage offline pipeline: event-closure scene segmentation, incremental data-grown topic labelling, dual-granularity item extraction (atomic + connected, one LLM call per topic), and trigger instantiation (Entity+Bridge jointly per item; Scene+Horizon per scene). Memory-construction LLM is GPT-4.1-mini, dense encoder bge-m3. Retrieval is a top-down topic -> scene -> item cascade scored by RRF over BM25 + per-type dense rankings; multi-view trigger indices surface host nodes via nan-aware max cosine, and associative triggers bypass the topic prefilter so cues outside the similarity neighbourhood still hit. Triggers stay off the QA evidence path; Persona is ambient context appended after retrieval.

Results On LoCoMo, T-Mem reaches 80.26% LLM-as-judge accuracy (51.96 token-F1), 3.25 pp above the strongest baseline HyperMem and the maximum on five of six columns. On LoCoMo-Plus it scores 74.81%, narrowing the LoCoMo-to-LoCoMo-Plus drop to 5.45 pp, about 5x tighter than HyperMem (28.38 pp) and near an order of magnitude tighter than the Mem0/SeCom/A-Mem cluster (~49 pp). Ablations confirm the scene-level associative triggers drive the associative gain: removing Scene+Horizon collapses LoCoMo-Plus by 22.19 pp (Horizon alone -12.47 pp) while moving LoCoMo by under 0.4 pp. T-Mem also reaches higher accuracy than HyperMem at a lower input-token budget.

Plain-language abstract Long-running language agents accumulate more history than fits in working context, and the usual fix is retrieval — store past events outside the model and fetch a relevant subset at query time. This paper argues retrieval only answers what can be fetched (memory access) and not what should keep shaping behavior after the working context is unloaded (memory depth). It introduces the loop-drift protocol, a controlled stress test where the retrieval index stays intact but working context is cleared, so goal-conditioned behavior must persist through long-loop interference without the relevant text being reinserted. It evaluates EVAF, a surprise- and valence-gated LoRA consolidation mechanism that writes only behavior-relevant events into a small adapter. Across GPT-2, TinyLlama, and Mistral-7B, retrieval wins shallow factual recall while EVAF wins goal persistence and post-unload recovery with only 2–3 parametric writes per 200 events, and the paper shows selective consolidation factorizes into two separable controls — selection and actuation.

Motivation Memory access and memory depth are different problems. A shallow memory is one the system can retrieve or attend to; a deep memory changes future behavior — it persists through interference, survives context unload, and affects choices without being reinserted as text. Retrieval is indispensable for fetched facts, but a long-running assistant also needs durable goals, preferences, and constraints that are not merely fetched facts. Existing long-memory benchmarks (LongMemEval, LoCoMo) emphasize conversational recall, temporal access, and knowledge updates, and do not isolate the post-unload setting where retrieval remains available but behavior must continue without the relevant text in context. The paper's claim is narrow and explicit: memory depth can be probed by post-unload goal-conditioned behavior, and consolidation factorizes into selection and actuation — it does not claim universal memory accuracy, SOTA retrieval, or complete deletion/update validity.

Methodology Loop-drift protocol: synthetic per-user streams of 200 events (10 users/run) mixing stable goal/preference reminders, off-topic distractors, transient opposite requests, conflicts, sibling-user contamination, and scheduled factual notes; four probe layers — shallow episodic (recent fact), noisy episodic (old fact after same-key interference), parametric tendency (does a stable goal still shape behavior after long interference), and post-unload recovery (re-probe the goal immediately after a context unload, with the retrieval index intact but working context cleared). The RAG baseline stores all events in a durable embedding index (top-3 cosine) that context unload does not clear, so any EVAF goal-layer advantage is not a trivial 'RAG forgot' artifact. EVAF mechanism: per-event surprise (token negative log-likelihood) and valence (embedding similarity to the user's durable goal/preferences) combine into an admission gate; events above threshold enter a buffer, and when the buffer fills a LoRA adapter is updated on the buffer plus replay from prior consolidated events, with an L2 anchor as a drift guard. Model controls: GPT-2 and TinyLlama (four-seed means) plus Mistral-7B. Selection is isolated with a matched-random gate (same write count and online write dynamics, random admitted events). Actuation is isolated with fixed-inner controllers (fixed-1/2/3 inner LoRA steps using the same gate). A routed EVAF+RAG variant routes factual probes to retrieval and goal probes to EVAF. Public Memora event streams serve as an external boundary diagnostic for stale-memory invalidation, tested with McNemar's test.

Results Depth flip: RAG is strongest on recent explicit facts (short-fact accuracy 0.956–0.973) and near-useless on goals; EVAF is near chance on short facts but much stronger on the goal layer — on GPT-2 EVAF reaches 0.904 goal / 0.900 post-unload vs RAG 0.398/0.394, and on TinyLlama 0.833/0.812 vs RAG 0.396/0.394 — at only 2.4–2.6 writes (L2 drift ~21–29) vs RAG's 0 writes. Writing everything is not enough: Naive-LoRA writes all 200 events at far higher drift (~67 TinyLlama, ~119 GPT-2) and still fails the goal layer; at 7B indiscriminate writing is actively harmful — Naive-LoRA goal persistence collapses to 0.333±0.047, below the 0.500 chance baseline. Selection is not sparsity: on GPT-2 EVAF beats a matched-random gate of equal write count on goal and post-unload in all four seeds (mean 0.790/0.763 vs 0.590/0.619); TinyLlama is weak/mixed, so the selection signal is not monotonic in model scale. Actuation is a separable, model-dependent factor: fixed-inner audits show smaller inner steps cut drift and improve goal/post (Mistral-7B five-step 0.354/0.306 -> Fixed-2 0.796/0.775 -> Fixed-1 0.919/0.938), but Fixed-1 contamination saturates at 1.000 on Mistral, so high actuation trades selectivity for goal strength. Asymmetric coupling: under a miscalibrated five-step actuation at 7B the matched-gate comparison reverses, yet EVAF still keeps lowest sibling contamination (0.787±0.041) — selection stays semantically active while its translation into goal behavior fails. Boundary: on Memora, EVAF improves forgetting-absence only 91/222 to 95/222 (p=0.57, not significant), so append-only selective consolidation does not solve stale-memory delete/update validity, which the paper leaves to validity-gating or reconsolidation.

Plain-language abstract ESAA-Conversational is a shared memory layer that lets several LLM coding agents — Codex, Claude Code, Grok — hand work off to one another without copying the conversation by hand. It watches each agent's visible turns through hooks or watchers, writes them into one append-only log (activity.jsonl), and deterministically projects compact files — a handoff contract, current state, recorded decisions, and an open-task list — that the next agent reads to pick up where the last left off.

Motivation Developers increasingly switch among multiple coding agents as context windows fill or a different tool suits a subtask, but each agent keeps its conversation in a private, vendor-specific log. The result is 'conversational state drift': goals, rejected alternatives, decisions already made, and open tasks established with one agent are not reliably available to the next. The usual fix — copy-pasting context — is manual, lossy, expensive in tokens, and conflates capturing evidence with interpreting it.

Methodology The system applies event sourcing and CQRS: visible turns are captured mechanically, with no LLM inference, into an append-only activity.jsonl that is the single source of truth, while state.md, handoff.md, decisions.md, and tasks.json are reconstructible read models that are never hand-edited. 'Inverted ingestion' means the runtime reads native agent logs, hooks, or watchers and normalizes them into conversation_turn events rather than requiring agents to share a protocol. A strict boundary separates mechanical capture (turns are evidence) from curation (durable decisions and tasks entered through explicit decide/task commands). A paginated context command serves filtered windows (--last, --around, --before, --topic) so a cold agent reads a slice, not the whole log; workspace_root isolates projects and a lockfile serializes writes. The v1.1.0 release is a local PowerShell CLI.

Results A self-referential case study recorded 570 events (562 conversation turns) in a single workspace on 21 June 2026, distributed across Codex (304), Claude (79), and Grok (67). The three heterogeneous agents co-designed and reviewed the tool through the shared log alone, with no direct agent-to-agent channel — e.g., Codex was given a focused view of recent Grok iterations via `context --agent grok --last 20`, and one concrete defect (incomplete filtering of legacy events under context --topic) was found, fixed, and closed as a task. The public release ships 51 tests in its main battery. Reported limitations: the implementation is Windows/PowerShell-only, sync depends on third-party hook surfaces outside the authors' control, retrieval is purely textual with no embeddings, and the system offers operational but not forensic auditability (no hash chains or signatures); validation covers one workspace and three agents.

Plain-language abstract AutoMem trains an agent to get better at managing its own memory, the way a person gets better at note-taking with practice. It gives the agent file-system operations (read, write, search, append) as memory actions on equal footing with its normal task actions, then uses a strong meta LLM to review whole episode traces (tens of thousands of steps) and improve both the memory scaffold the agent works within and, separately, the agent's own skill at making memory decisions.

Motivation Long-horizon tasks can run for 10^4-10^5 steps, far past what a human reviewer can practically read through to find where a memory decision went wrong; a single bad memory choice can stay hidden for thousands of steps before it matters. Existing memory systems treat memory as a fixed architectural module rather than a skill the agent can improve, so there's no natural way to optimize it beyond manual tuning.

Methodology Two outer loops wrap a shared inner-loop agent that treats a directory of files as its memory. Loop 1 (structure): a meta-LLM reads full episode traces, diagnoses memory-use failure patterns, and revises the agent's scaffold, prompts, file schema, action vocabulary. Loop 2 (proficiency): a meta-LLM selects the agent's own good memory decisions across many episodes as supervised training data and orchestrates LoRA fine-tuning of a dedicated memory-specialist model, while the task-action model stays frozen. Evaluated on three procedurally generated long-horizon games (Crafter, MiniHack, NetHack) with Qwen2.5-32B-Instruct as the base model.

Results Optimizing memory alone, without touching the model's task-action behavior, improves the base agent's performance roughly 2x-4x across the three games, and the optimized 32B model outperforms Qwen2.5-72B-Instruct on all three, becoming competitive with frontier systems like Claude Opus 4.5 and Gemini 3.1 Pro Thinking. The authors frame this as evidence that memory management is an independently learnable skill and a high-leverage optimization target for long-horizon agents.

Plain-language abstract SelfMem gives an AI agent a set of memory tools and feedback signals, instead of a fixed rule for what to remember and how, and lets the agent figure out its own memory strategy. The idea, as the authors put it, is teaching the agent to fish rather than giving it a fish: rather than forcing a predefined summarization format, the agent inspects the raw conversation, decides what's worth writing to its memory workspace, and can revise that memory when a self-check flags a problem.

Motivation Existing agent-memory systems (Mem0, MemGPT, MemoryBank, A-Mem) rely on manually specified strategies for what to store, update, and retrieve, which are rigid across tasks and need hand-tuning. Different tasks and conversation histories need different memory behaviors, and no fixed schema fits all of them; the authors argue this calls for letting the agent adapt its own strategy rather than hand-crafting one.

Methodology SelfMem keeps the raw transcript as an immutable source of truth, accessible only through read-only tools like a SQL-queryable turns table, and gives the agent a separate memory workspace plus a memory action space: read the transcript, read/write/revise memory, check memory quality, and even extend its own memory toolkit. The agent decides what to store, compress, update, or leave for transcript retrieval. Evaluated on BEAM across conversation scales from 100K to 1M tokens against retrieval, compression, and agent-memory baselines.

Results SelfMem gets the highest official score and Pass0.5 at all three tested scales (100K, 500K, 1M tokens), improving the official score over the strongest baseline by 0.165, 0.141, and 0.134 respectively, and Pass0.5 by 14.3-17.0 percentage points. It's the best performer on 9/10 question types at 100K tokens (8/10 at 500K, 7/10 at 1M), and a model-guided strategy-refinement study shows further gains are possible on top of the base approach.

Plain-language abstract A language model's memory can be worse than no memory at all. Give a model a memory that kept a wrong conclusion but dropped the work behind it and it re-emits the stale value as a confident answer; give the same model an empty memory and it abstains. The paper names this failure brittle memory, measures it with a reclaim-evaluation protocol that tests whether a correction can recover a known answer after compression, and shows a one-line fix (keep the recomputable source, drop the re-derivable conclusion) restores correctability at equal memory budget.

Motivation Memory systems carry information across sessions by compressing it, on the implicit assumption that a compression preserving the model's answer has preserved what matters. The paper shows the same compression decides whether the model can later be corrected: once the answer-determining source is gone, a correction has nothing to act on, and the resulting error compounds as deployed agents feed memory into memory.

Methodology Reclaim evaluation drifts a model into committing to a wrong answer via a planted premise, deepens the commitment over neutral turns, then issues a correction in a fresh session whose only inheritance is a memory written under one of three matched-budget policies: lossy (keep the salient conclusion, shed the source), source-first (keep the source, shed the conclusion), and lossy-padded (lossy plus neutral filler to at least source-first's length, controlling for budget). Success is exact recovery of the known answer, with no judge. Tasks are multi-step arithmetic and constraint-logic puzzles with objectively scorable answers; the pipeline runs end to end on llama-3.1-8b and grok-4.3 with a frontier replay on Claude models; headline cells are n=96, and three validators designed to fail against a deterministic fake all pass.

Results Within one conversation there is no wall, only anchoring: a directed correction holds far longer than a generic one (reclaim 0.79 to 0.50 over eight commitment turns) and pushing the error further back lifts reclaim rather than starving it. Across a session boundary the window becomes a wall: once the lossy note drops the source line items, even a directed correction dies, reclaim is 0.00 by measurement, and a lossy memory is worse than an empty one because models that abstain with nothing emit the confident wrong value with a source-less note. The wall sits in the same place from the 8B model to frontier systems. Source-first restores reclaim at equal budget (oracle 1.00; the deployable one-prompt distiller 0.49-0.88, concentrated on compact numeric sources), and the length-matched control rules out added text as the cause. Chained through a memory loop, one dropped-source error corrupts a growing span of downstream steps and stays uncorrectable however late it is caught, while source-first holds to a bounded budget horizon; the wall and the fix replicate on three deployed memory systems and on MultiWOZ, and past the budget where the source no longer fits, the fix fails silently unless the note records its own completeness.

Argues current frameworks fragment conversations into isolated embeddings or graph nodes; proposes building a coherent narrative via agentic reasoning instead.

Why it matters Bridges consolidation and representation: the unit of memory should preserve narrative coherence, not just be a retrievable shard. Connects to [cast-episodic]'s who/when/where stance.

Notes most memory systems store isolated records and retrieve fragments, limiting consolidation of evolving user state and conflict resolution. Proposes a self-organizing memory OS for structured long-horizon reasoning.

Why it matters 'Memory OS' framing that ties consolidation to conflict resolution (Temporality) and structure (Representation). Conceptual cousin of Letta/MemGPT-style OS metaphors.

Critiques incremental per-turn extraction/update; proposes a dual-process design (fast + slow paths) for high-fidelity memory access over long horizons.

Why it matters Dual-process (System-1/System-2) is a recurring shape; here applied to when to consolidate cheaply vs reason deeply. Connects to [retrieve-or-think]'s retrieve-vs-think policy.

The survey of graph-structured agent memory: why graphs (relational modeling, knowledge accumulation, self-evolution), the technique landscape, and applications across multi-turn dialogue, games, and scientific discovery.

Why it matters The map of the KG-memory design space — read before committing to or rejecting a graph. Read against [kg-wrong-abstraction] for the dissent.

Argues the field over-converged on entity–relationship graphs (Mem0, Zep, supermemory). Costs flagged: an extra entity-extraction LLM step (latency) and hallucinated edges that fabricate connections — when the real job is fast retrieval of the right past context.

Why it matters The sharpest practitioner counter-argument to KGs. Worth weighing before adopting a graph layer; [gaama] partially answers it (mega-hub fix), [graph-memory-survey] is the steelman.

Flat RAG loses structural relationships; entity-centric KGs suffer 'mega-hub' effects (a few nodes accrue too many edges). GAAMA proposes graph-augmented associative memory to keep structure without the hub blowup.

Why it matters A concrete fix for one of the KG failure modes [kg-wrong-abstraction] complains about. Useful if you want graph structure but fear scaling pathologies.

Systematically compares knowledge-graph storage/retrieval approaches for personalized agents, against the backdrop that RAG improves factual accuracy but lacks structured memory and doesn't scale in complex long-term settings.

Why it matters The closest thing to an apples-to-apples KG-design comparison; pairs with [mem0-vs-graphiti] (vector-vs-graph in distributed setting) for store-selection decisions.

Critiques the dominant extracted-fact paradigm: handcrafted static prompts compress raw dialogue into atomic facts that are stored, matched, and injected — losing the ability to reason deeply over history. Proposes going beyond atomic facts.

Why it matters The most on-the-nose challenge to atomic-facts-as-primitive. Read before committing to a fact-extraction pipeline; connects to [amory] (narrative) and [cast-episodic] (events) as richer alternatives.

Most agent memory emphasizes semantic recall and stores experience as key-value/vector/graph, which struggles to represent coherent events. CAST models episodic memory grounded in who/when/where (characters and scenes).

Why it matters The episodic-coherence counterpoint to fact/vector stores; aligns with [amory] (narrative) and [adamem] (fragmentation). Connects to Temporality via the 'when' grounding.

Practitioner build motivated by agents repeating mistakes (deploy → forget migrations → DB crash). Implements the cognitive-science triad — semantic (what you know), episodic (what happened), procedural (how to do things) — and open-sources it.

Why it matters Grassroots evidence that the semantic/episodic/procedural layering from research is being adopted by builders. Pairs with [cast-episodic] (episodic) and the procedural-skills theme of the academic explorer.

Agents in partially observable environments need persistent memory to integrate observations over time; KGs naturally represent evolving state. Introduces a benchmark where both world dynamics and the agent's memory are explicitly graph-shaped.

Why it matters Grounds temporal-KG memory in a controllable evaluation setting — rare for this topic. Connects temporality to representation: time is modeled as graph evolution.

Six cognitive mechanisms: sleep-phase consolidation, interference-based forgetting, engram maturation, reconsolidation upon retrieval, and entity knowledge graphs — a principled lifecycle rather than heuristic decay.

Why it matters The most complete bio-grounded lifecycle proposal; turns 'forgetting' from a TTL into a set of mechanisms. Unvalidated at scale, like most of this cluster — weigh against eval scarcity ([persistbench]).

Plain-language abstract Engram is an open-source long-term memory engine for LLM agents. Instead of replaying an entire conversation history into the prompt, it stores the past as a bi-temporal knowledge graph and retrieves a small, precisely-targeted slice at answer time. On a standard 500-question memory benchmark that lean ~9.6k-token slice answers more accurately than feeding the model the full ~79k-token history, turning memory from a cost optimization into an accuracy improvement.

Motivation Stateless LLM agents forget across sessions, and the usual fix — concatenating the whole history — grows token cost and latency linearly and loses accuracy as distractors crowd the window ('lost in the middle'). Two gaps stay open: most memory systems are cheaper or faster but not more accurate than full-context, and memory benchmarks run on inconsistent harnesses where one system reports wildly different scores across sources. Engram targets both — beating full-context on accuracy, and shipping a neutral, re-runnable harness.

Methodology A dual-process design. A System-1 hot write path appends lossless episodes with no LLM (sub-50ms) and enqueues them. A System-2 async path extracts atomic (subject,predicate,object) facts, builds a bi-temporal knowledge graph (valid time vs transaction time on every fact and edge), detects conflicts, and resolves them cheap-then-escalate: exact slot match, embedding similarity, and content subsumption handle the common case with no LLM call, invalidating (never deleting) a superseded fact and recording a supersedes chain and provenance, with only ambiguous cases escalated to an LLM adjudicator. The hybrid read path retrieves through four channels (dense, BM25, graph n-hop, recency/salience), fuses them with Reciprocal Rank Fusion, applies an 'as-of' temporal filter and an abstention gate, and assembles a deduplicated, provenance-tagged, token-budgeted context of facts plus raw chunks.

Results On the full 500-question LongMemEval_S under the official category-specific judge, Engram's lean configuration scores 83.6% vs 73.2% for full-context (+10.4 points, McNemar exact p<10^-6) at ~8x fewer tokens (9.6k vs 79k), 0/500 errored. The gain is load-bearing on the read path being hybrid: facts alone lose recall, while facts plus retrieved chunks recover detail. Bi-temporal modeling pays off most on knowledge-update (87.5%) and temporal (81.1%) categories, while multi-session aggregation and preference remain headroom. The paper documents measurement-integrity pitfalls (truncation, home-grown judges, full-history leaks) and ships a neutral in-repo harness with the official judge baked in and raw per-question logs, every number reproducible by command.

Plain-language abstract Infini Memory is a long-term memory architecture for LLM agents that stores memory as a library of plain-text 'topic documents' rather than vectors or a knowledge graph. Each document gathers related evidence under a subject and is maintained over time by splitting, merging, and rewriting. At answer time the agent reads memory through iterative tool calls, expanding context around matches instead of taking a single retrieval shot.

Motivation External memory systems that store observations as isolated records, summaries, or indexed fragments hit four recurring failure modes: fragmentation (evidence about one subject scattered across records), conflict (old and new versions of a fact coexisting), compression loss (summaries dropping temporal and source cues), and insufficient retrieval (single-shot top-k returning fragments without enough local context for multi-hop reasoning). Infini Memory reframes persistent memory as a lifecycle maintenance problem — write, maintain, read — and aims for an inspectable, editable state without a mandatory vector or graph backend.

Methodology Memory is a library of topic documents, each a maintenance scope with a summary, body, and entry-level metadata signatures (<seq,time,source>) that preserve order and provenance as content is rewritten. Writes are decoupled from structure: new candidates append to a buffer document, then periodic consolidation rewrites, splits, updates, and merges them into coherent topic documents. Retrieval can run over plaintext via lexical indexing rather than embeddings. At inference an agentic read procedure lets the LLM iteratively choose memory tools, inspect intermediate results, expand local context, and assemble evidence before answering.

Results On MemoryAgentBench the agentic-retrieval variant scores 64.7% overall and 81.2% on Accurate Retrieval, with gains on Factual Recall, Test-Time Learning, and Selective Forgetting. Ablations on LongMemEval_S isolate two complementary sources: holding the hybrid reader fixed, removing structural split-and-merge maintenance drops accuracy 76.0%->69.3% (-6.7, concentrated on knowledge-update and multi-session questions), while upgrading the reader from hybrid to agentic adds 3.3 points (76.0->79.3) — so maintenance matters more than the retrieval upgrade and neither is sufficient alone. A split-threshold sweep shows over-fragmentation is recoverable, but oversized documents that mix subtopics are costly.

Plain-language abstract ESAA-Conversational is a shared memory layer that lets several LLM coding agents — Codex, Claude Code, Grok — hand work off to one another without copying the conversation by hand. It watches each agent's visible turns through hooks or watchers, writes them into one append-only log (activity.jsonl), and deterministically projects compact files — a handoff contract, current state, recorded decisions, and an open-task list — that the next agent reads to pick up where the last left off.

Motivation Developers increasingly switch among multiple coding agents as context windows fill or a different tool suits a subtask, but each agent keeps its conversation in a private, vendor-specific log. The result is 'conversational state drift': goals, rejected alternatives, decisions already made, and open tasks established with one agent are not reliably available to the next. The usual fix — copy-pasting context — is manual, lossy, expensive in tokens, and conflates capturing evidence with interpreting it.

Methodology The system applies event sourcing and CQRS: visible turns are captured mechanically, with no LLM inference, into an append-only activity.jsonl that is the single source of truth, while state.md, handoff.md, decisions.md, and tasks.json are reconstructible read models that are never hand-edited. 'Inverted ingestion' means the runtime reads native agent logs, hooks, or watchers and normalizes them into conversation_turn events rather than requiring agents to share a protocol. A strict boundary separates mechanical capture (turns are evidence) from curation (durable decisions and tasks entered through explicit decide/task commands). A paginated context command serves filtered windows (--last, --around, --before, --topic) so a cold agent reads a slice, not the whole log; workspace_root isolates projects and a lockfile serializes writes. The v1.1.0 release is a local PowerShell CLI.

Results A self-referential case study recorded 570 events (562 conversation turns) in a single workspace on 21 June 2026, distributed across Codex (304), Claude (79), and Grok (67). The three heterogeneous agents co-designed and reviewed the tool through the shared log alone, with no direct agent-to-agent channel — e.g., Codex was given a focused view of recent Grok iterations via `context --agent grok --last 20`, and one concrete defect (incomplete filtering of legacy events under context --topic) was found, fixed, and closed as a task. The public release ships 51 tests in its main battery. Reported limitations: the implementation is Windows/PowerShell-only, sync depends on third-party hook surfaces outside the authors' control, retrieval is purely textual with no embeddings, and the system offers operational but not forensic auditability (no hash chains or signatures); validation covers one workspace and three agents.

Plain-language abstract The paper presents ActiveGraph, an open-source (Apache-2.0) agent runtime that inverts the usual framework design: instead of a conversation loop with logging bolted on, the append-only event log is the source of truth, the working graph is a deterministic projection of that log, and agent behavior is a population of reactions that fire on graph changes and emit new events. No component instructs another; coordination happens through the shared graph. This buys deterministic replay of any run, cheap forking at any event without re-executing the shared prefix, and total lineage from goal to each model call.

Motivation Conventional LLM agent stacks grow by accretion: chat loop, then tools, then rules, then logging, with memory as a lossy similarity-queried store, so the log is a byproduct and questions like 'why is this fact in context', 'what did the agent believe before rule R changed', or 'what if step 42 had gone differently' are awkward or impossible. For long-running agentic work such as diligence, compliance, and research, where the reasoning matters as much as the answer, the authors argue the recoverable causal chain is the actual product.

Methodology A systems and architecture contribution, explicitly not a task-performance benchmark. The runtime defines events (id, type, payload, actor, caused_by, timestamp), behaviors as subscriptions over event types plus Cypher-subset graph-shape patterns, and a determinism contract (no random, wall-clock, fresh UUIDs, or outside I/O in behavior bodies) policed dynamically by strict replay. Nondeterministic model calls are handled by recording responses in a content-addressed cache keyed on a hash of the full request, so replay and forks make no new model calls. A bundled investment-diligence pack runs fully offline against recorded fixtures on three companies, with no API key, completing in under thirty seconds.

Results The reproducible quickstart run produced 671 events yielding 93 objects (3 companies, 24 questions, 9 documents, 25 claims, 25 evidence items, 1 contradiction, 3 risks, 3 memos) and 76 relations via 103 model calls and 48 tool calls, with zero orchestration code; re-running produced byte-identical logs. Forking a 200-step run at step 150 pays only for steps from 150 onward. Named costs and limits: replay time grows with log length (no checkpointing or compaction yet), schema evolution is a real operational burden, side-effecting tools still mutate the world on first execution, multi-writer ordering is unresolved, and self-improving agents are discussed only as an affordance, not demonstrated.

Distinguishes episodic traces (raw trajectories) from consolidated abstractions (schema-like lessons). Shows that when an LLM repeatedly rewrites a textual memory bank, the consolidated memory degrades over time.

Why it matters The strongest research caution against LLM-driven consolidation as your primary store. Direct argument to keep raw traces (see Substrate) as ground truth and treat distillation as lossy. Pairs with Slack's validation step.

Agents in partially observable environments need persistent memory to integrate observations over time; KGs naturally represent evolving state. Introduces a benchmark where both world dynamics and the agent's memory are explicitly graph-shaped.

Why it matters Grounds temporal-KG memory in a controllable evaluation setting — rare for this topic. Connects temporality to representation: time is modeled as graph evolution.

A Mem0 user hits the classic wall: agents 'forget' the timeline of facts (amnesia when a user updates info). Tries Aurra's bi-temporal memory (tracks event time vs ingestion time) and reports it handles fact updates better.

Why it matters Field evidence that fact-update/timeline handling is the concrete weakness pushing people off vector-only stores — and that bi-temporal modeling is the differentiator. Connects to [useful-memories-faulty] (why naive updates fail).

Biologically-inspired decay plus temporal reasoning; a CLI to infer knowledge from stored memory with zero token/LLM cost, plus a dashboard that can double as an audit trail.

Why it matters Combines temporality with forgetting (decay) and nods at governance (audit trail). Representative of the 'zero-LLM, local, dashboarded' indie memory wave alongside [superlocalmemory].

Plain-language abstract Engram is an open-source long-term memory engine for LLM agents. Instead of replaying an entire conversation history into the prompt, it stores the past as a bi-temporal knowledge graph and retrieves a small, precisely-targeted slice at answer time. On a standard 500-question memory benchmark that lean ~9.6k-token slice answers more accurately than feeding the model the full ~79k-token history, turning memory from a cost optimization into an accuracy improvement.

Motivation Stateless LLM agents forget across sessions, and the usual fix — concatenating the whole history — grows token cost and latency linearly and loses accuracy as distractors crowd the window ('lost in the middle'). Two gaps stay open: most memory systems are cheaper or faster but not more accurate than full-context, and memory benchmarks run on inconsistent harnesses where one system reports wildly different scores across sources. Engram targets both — beating full-context on accuracy, and shipping a neutral, re-runnable harness.

Methodology A dual-process design. A System-1 hot write path appends lossless episodes with no LLM (sub-50ms) and enqueues them. A System-2 async path extracts atomic (subject,predicate,object) facts, builds a bi-temporal knowledge graph (valid time vs transaction time on every fact and edge), detects conflicts, and resolves them cheap-then-escalate: exact slot match, embedding similarity, and content subsumption handle the common case with no LLM call, invalidating (never deleting) a superseded fact and recording a supersedes chain and provenance, with only ambiguous cases escalated to an LLM adjudicator. The hybrid read path retrieves through four channels (dense, BM25, graph n-hop, recency/salience), fuses them with Reciprocal Rank Fusion, applies an 'as-of' temporal filter and an abstention gate, and assembles a deduplicated, provenance-tagged, token-budgeted context of facts plus raw chunks.

Results On the full 500-question LongMemEval_S under the official category-specific judge, Engram's lean configuration scores 83.6% vs 73.2% for full-context (+10.4 points, McNemar exact p<10^-6) at ~8x fewer tokens (9.6k vs 79k), 0/500 errored. The gain is load-bearing on the read path being hybrid: facts alone lose recall, while facts plus retrieved chunks recover detail. Bi-temporal modeling pays off most on knowledge-update (87.5%) and temporal (81.1%) categories, while multi-session aggregation and preference remain headroom. The paper documents measurement-integrity pitfalls (truncation, home-grown judges, full-history leaks) and ships a neutral in-repo harness with the official judge baked in and raw per-question logs, every number reproducible by command.

Plain-language abstract MemStrata is a memory system for AI agents that keeps track of when facts become outdated. Instead of just retrieving whatever text looks most similar to a query, which fails when an old and a new fact look nearly identical, it uses a deterministic rule to detect when a new fact supersedes an old one and retires the stale version.

Motivation Retrieval-augmented memory has no concept of time: when a fact changes (a renamed function, an updated config value, a new port number), both the old and new versions sit in the store with near-identical embeddings, and the agent can't tell which is current. The authors show this isn't a tuning problem: on a calibrated dataset, cosine similarity separates contradictions from duplicates at only 0.59 AUROC (near chance), because a value-flip edit sits textually closer to the original than a genuine rephrasing does.

Methodology MemStrata's write path first tries a deterministic (subject, relation, object) triple match: if an incoming fact shares a key with a stored one but asserts a different value, the old fact is retired (not deleted) in a bi-temporal ledger and the new one is stored as current. Non-triple prose falls back to a similarity-plus-LLM-judge gate. The system is evaluated on six local, deterministic benchmarks (two static, four marker-free evolving: code mutation, config migration, dependency bumps, API evolution) with a 7B model on consumer hardware.

Results MemStrata matches RAG on static recall (no cost) and reaches 0.95-1.00 accuracy on evolving-knowledge benchmarks where RAG reaches only 0.20-0.47. When forced to answer, plain RAG serves the superseded value 15-40% of the time; MemStrata drives this to ~0%. It also runs at ~2.1s retrieval latency versus ~16-18s for LLM-reranking/verification baselines, since no LLM sits on the read path.

Biologically-inspired decay plus temporal reasoning; a CLI to infer knowledge from stored memory with zero token/LLM cost, plus a dashboard that can double as an audit trail.

Why it matters Combines temporality with forgetting (decay) and nods at governance (audit trail). Representative of the 'zero-LLM, local, dashboarded' indie memory wave alongside [superlocalmemory].

Six cognitive mechanisms: sleep-phase consolidation, interference-based forgetting, engram maturation, reconsolidation upon retrieval, and entity knowledge graphs — a principled lifecycle rather than heuristic decay.

Why it matters The most complete bio-grounded lifecycle proposal; turns 'forgetting' from a TTL into a set of mechanisms. Unvalidated at scale, like most of this cluster — weigh against eval scarcity ([persistbench]).

Opens on the paradox: coding agents have vast parametric knowledge yet can't remember an hour ago. Critiques single-channel vector retrieval that needs cloud LLMs and implements no cognitive processes. Adds biologically-inspired forgetting, cognitive quantization, and multi-channel retrieval — all local/zero-LLM.

Why it matters Bundles forgetting + multi-channel retrieval + local-first into one system; the indie counterpart to Cloudflare's managed multi-channel approach. Connects to [yourmemory] (zero-LLM, local) and [git-s3-memory] (local-first ethos).

Persisting facts (e.g. 'user is vegetarian') aids personalization but also introduces safety risks that are largely overlooked. PersistBench measures when persistence becomes a liability and when memories *should* be forgotten.

Why it matters Reframes forgetting as a safety requirement, not just hygiene — and is one of the only benchmarks targeting forgetting at all. Bridges Forgetting and Evaluation; pairs with the 'forgetting is unmeasured' gap.

Plain-language abstract OSL-MR is a framework for deciding which memories a long-horizon language agent should keep when its storage budget is smaller than everything it has seen. It poses the choice as an optimization problem that weighs the future value of evidence against the cost of losing it, and learns the policy from logged interactions using only signals that would actually be available when the agent runs.

Motivation Long-horizon agents accumulate more observations, reasoning traces, and retrieved facts than fit in context, so retention is a resource-allocation problem. Prior systems score memories with heuristics, retrieval objectives, or learned compression, but treat each retention decision locally and never model its long-term consequences — and many depend on signals such as gold evidence or answer correctness that are only knowable after the fact and so would not exist at deployment.

Methodology Retention is cast as a constrained multi-step stochastic optimization: at each step the agent selects a subset of memories under a hard size budget, and a per-step reward credits covered evidence while charging storage, miss penalty, reacquisition delay, and stale-information use. A strict online/offline split separates online-observable inputs (query, memory metadata, interaction history) from offline-available supervision (gold evidence, answer text, freshness) used only for training. OSL-MR pairs a Mixed-Score heuristic — a deployable cold-start baseline and inductive prior — with an evidence learner trained offline on gold-evidence membership labels, then frozen and deployed on online features alone.

Results On LoCoMo and LongMemEval, OSL-MR beats recency, Generative-Agents-style scoring, behavior cloning, and the Mixed-Score heuristic across budgets, with the largest gains under tight budgets (LoCoMo budget 128: F1 0.302 and reward 305 vs 0.069/132 for Mixed-Score). It uses the budget more efficiently, running well below full occupancy while baselines saturate it, and reward rankings track precision and F1 exactly. Ablating the Mixed-Score prior cuts precision (0.529→0.421 on LongMemEval budget 256) while leaving recall nearly unchanged, showing the prior steers the learner away from low-utility memories.

Plain-language abstract Long-running language agents accumulate more history than fits in working context, and the usual fix is retrieval — store past events outside the model and fetch a relevant subset at query time. This paper argues retrieval only answers what can be fetched (memory access) and not what should keep shaping behavior after the working context is unloaded (memory depth). It introduces the loop-drift protocol, a controlled stress test where the retrieval index stays intact but working context is cleared, so goal-conditioned behavior must persist through long-loop interference without the relevant text being reinserted. It evaluates EVAF, a surprise- and valence-gated LoRA consolidation mechanism that writes only behavior-relevant events into a small adapter. Across GPT-2, TinyLlama, and Mistral-7B, retrieval wins shallow factual recall while EVAF wins goal persistence and post-unload recovery with only 2–3 parametric writes per 200 events, and the paper shows selective consolidation factorizes into two separable controls — selection and actuation.

Motivation Memory access and memory depth are different problems. A shallow memory is one the system can retrieve or attend to; a deep memory changes future behavior — it persists through interference, survives context unload, and affects choices without being reinserted as text. Retrieval is indispensable for fetched facts, but a long-running assistant also needs durable goals, preferences, and constraints that are not merely fetched facts. Existing long-memory benchmarks (LongMemEval, LoCoMo) emphasize conversational recall, temporal access, and knowledge updates, and do not isolate the post-unload setting where retrieval remains available but behavior must continue without the relevant text in context. The paper's claim is narrow and explicit: memory depth can be probed by post-unload goal-conditioned behavior, and consolidation factorizes into selection and actuation — it does not claim universal memory accuracy, SOTA retrieval, or complete deletion/update validity.

Methodology Loop-drift protocol: synthetic per-user streams of 200 events (10 users/run) mixing stable goal/preference reminders, off-topic distractors, transient opposite requests, conflicts, sibling-user contamination, and scheduled factual notes; four probe layers — shallow episodic (recent fact), noisy episodic (old fact after same-key interference), parametric tendency (does a stable goal still shape behavior after long interference), and post-unload recovery (re-probe the goal immediately after a context unload, with the retrieval index intact but working context cleared). The RAG baseline stores all events in a durable embedding index (top-3 cosine) that context unload does not clear, so any EVAF goal-layer advantage is not a trivial 'RAG forgot' artifact. EVAF mechanism: per-event surprise (token negative log-likelihood) and valence (embedding similarity to the user's durable goal/preferences) combine into an admission gate; events above threshold enter a buffer, and when the buffer fills a LoRA adapter is updated on the buffer plus replay from prior consolidated events, with an L2 anchor as a drift guard. Model controls: GPT-2 and TinyLlama (four-seed means) plus Mistral-7B. Selection is isolated with a matched-random gate (same write count and online write dynamics, random admitted events). Actuation is isolated with fixed-inner controllers (fixed-1/2/3 inner LoRA steps using the same gate). A routed EVAF+RAG variant routes factual probes to retrieval and goal probes to EVAF. Public Memora event streams serve as an external boundary diagnostic for stale-memory invalidation, tested with McNemar's test.

Results Depth flip: RAG is strongest on recent explicit facts (short-fact accuracy 0.956–0.973) and near-useless on goals; EVAF is near chance on short facts but much stronger on the goal layer — on GPT-2 EVAF reaches 0.904 goal / 0.900 post-unload vs RAG 0.398/0.394, and on TinyLlama 0.833/0.812 vs RAG 0.396/0.394 — at only 2.4–2.6 writes (L2 drift ~21–29) vs RAG's 0 writes. Writing everything is not enough: Naive-LoRA writes all 200 events at far higher drift (~67 TinyLlama, ~119 GPT-2) and still fails the goal layer; at 7B indiscriminate writing is actively harmful — Naive-LoRA goal persistence collapses to 0.333±0.047, below the 0.500 chance baseline. Selection is not sparsity: on GPT-2 EVAF beats a matched-random gate of equal write count on goal and post-unload in all four seeds (mean 0.790/0.763 vs 0.590/0.619); TinyLlama is weak/mixed, so the selection signal is not monotonic in model scale. Actuation is a separable, model-dependent factor: fixed-inner audits show smaller inner steps cut drift and improve goal/post (Mistral-7B five-step 0.354/0.306 -> Fixed-2 0.796/0.775 -> Fixed-1 0.919/0.938), but Fixed-1 contamination saturates at 1.000 on Mistral, so high actuation trades selectivity for goal strength. Asymmetric coupling: under a miscalibrated five-step actuation at 7B the matched-gate comparison reverses, yet EVAF still keeps lowest sibling contamination (0.787±0.041) — selection stays semantically active while its translation into goal behavior fails. Boundary: on Memora, EVAF improves forgetting-absence only 91/222 to 95/222 (p=0.57, not significant), so append-only selective consolidation does not solve stale-memory delete/update validity, which the paper leaves to validity-gating or reconsolidation.

Plain-language abstract MemStrata is a memory system for AI agents that keeps track of when facts become outdated. Instead of just retrieving whatever text looks most similar to a query, which fails when an old and a new fact look nearly identical, it uses a deterministic rule to detect when a new fact supersedes an old one and retires the stale version.

Motivation Retrieval-augmented memory has no concept of time: when a fact changes (a renamed function, an updated config value, a new port number), both the old and new versions sit in the store with near-identical embeddings, and the agent can't tell which is current. The authors show this isn't a tuning problem: on a calibrated dataset, cosine similarity separates contradictions from duplicates at only 0.59 AUROC (near chance), because a value-flip edit sits textually closer to the original than a genuine rephrasing does.

Methodology MemStrata's write path first tries a deterministic (subject, relation, object) triple match: if an incoming fact shares a key with a stored one but asserts a different value, the old fact is retired (not deleted) in a bi-temporal ledger and the new one is stored as current. Non-triple prose falls back to a similarity-plus-LLM-judge gate. The system is evaluated on six local, deterministic benchmarks (two static, four marker-free evolving: code mutation, config migration, dependency bumps, API evolution) with a 7B model on consumer hardware.

Results MemStrata matches RAG on static recall (no cost) and reaches 0.95-1.00 accuracy on evolving-knowledge benchmarks where RAG reaches only 0.20-0.47. When forced to answer, plain RAG serves the superseded value 15-40% of the time; MemStrata drives this to ~0%. It also runs at ~2.1s retrieval latency versus ~16-18s for LLM-reranking/verification baselines, since no LLM sits on the read path.

Proposes plain Git + S3 as the durable memory substrate for agents — versioned, cheap, auditable object storage rather than a bespoke memory service.

Why it matters The freshest signal in the 'deliberately boring substrate' movement: keep full history cheaply, derive memory downstream. Counterpoint to managed services; pairs with [chatdb] and [what-i-learned-coding-agent]. (Low vote count — early/thin.)

Managed session storage (preview) persists an agent's filesystem state — code, installed packages, generated artifacts — across stop/resume cycles, which was previously lost.

Why it matters A different memory layer than semantic memory: durable working state, not distilled knowledge. Important to keep distinct in a design — the runtime can own session durability while your store owns knowledge.

'ChatDB' — a self-hosted conversation archive across multiple AI apps, with a proper hybrid keyword + semantic search interface, deployable free on Cloudflare.

Why it matters Demonstrates the storage+search split: keep transcripts, layer hybrid retrieval on top. The hybrid (lexical+semantic) retrieval choice connects to the Retrieval category.

Argues many agents don't need a vector DB: SQLite + FTS5 full-text search covers a lot, with far less operational weight.

Why it matters The pragmatic floor of the substrate spectrum — strong reminder to not reach for pgvector/graph DBs by default. Echoes [kg-wrong-abstraction]'s 'simpler is fine' instinct.

Consumer-facing personal file/content store inside ChatGPT.

Why it matters Market signal that 'remember my stuff' is becoming a default consumer expectation, shaping what agents are assumed to retain. Low technical depth.

Local memory layer (Rust) motivated by memory being tool-locked (re-explaining things when switching tools/sessions) and by markdown-append memories that dump everything into context and rot.

Why it matters Cross-tool, local substrate aimed squarely at context rot and portability — connects to Interop ([memorywire], [unified-memory-stack]) and Working-Memory/context-rot.

DIY unification: Memori's interceptor architecture (zero code changes), Mem0's research-validated retrieval/consolidation, and Supermemory's structure — composed into one stack.

Why it matters Exactly the multi-store composition pattern that motivates a wire format. Real-world evidence builders are already gluing frameworks together by hand. Connects to [memorybank-rust] (cross-tool) and [memorywire] (the standard that would obviate the glue).

Notes that Mem0's OpenMemory MCP advertises local/private operation but still requires an OpenAI key (embeddings + gpt-4.1-nano) for extraction in the default Docker setup.

Why it matters Operational gotcha for anyone assuming a 'local' memory framework is self-contained — the LLM dependency leaks in via extraction/embeddings. Relevant to substrate/privacy and to the zero-LLM designs ([superlocalmemory], [yourmemory]) reacting to exactly this.

Plain-language abstract GitOfThoughts stores an LLM agent's reasoning tree as a git repository — every scored thought is a commit, scores are git notes, validation outcomes are tags, and retrieval is git log over the agent's own history — which makes reasoning replayable, auditable, diffable, and mergeable across agents. The paper then asks the harder question of whether memory, in any substrate, actually improves accuracy, and runs a pre-registered comparison of five substrates (none, markdown, vector, graph, git).

Motivation Reasoning is the last unversioned software process: chains of thought expire with the context window, pruned search branches leave no record, and memory buffers cannot be diffed, merged, or audited. The authors argue this ephemerality is a structural blocker — it prevents reproducibility ('what did the agent think at step 17?'), audit (detecting train–test leakage or gold-answer memorization), memory transfer between agents, and incident review. Code, infrastructure, datasets, and experiments are all version-controlled; reasoning is the remaining outlier.

Methodology A reasoning tree shares git's structural invariants, so the paper maps it one-to-one onto git primitives (node = commit, refinement = parent edge, score = note, outcome = tag, session vs. cross-session = branch, retrieval = git log --grep / -S). A pluggable MemoryBackend routes every read/write through one interface so the same agent can swap substrate with a one-line change. To isolate retrieval from write-path noise, all five backends ingest identical answer-free lessons, then solve held-out, domain-stratified problems read-only; benchmarks are GPQA-Diamond and MATH-500, scored with paired-bootstrap CIs, across two backbones and pre-registered replications, with a similarity sweep to locate when retrieval helps.

Results H-substrate is supported: git delivers auditability, line-level diffs over reasoning text, deterministic replay by SHA, and mergeable memory at accuracy parity, costing ~15 ms/write and ~48 ms/read. H-memory is rejected: across two benchmarks, two backbones, and up to n=500, no substrate reliably improves accuracy on novel problems, and a +15 pp git trend at n=40 collapsed under its pre-registered replication. Memory pays only above a 'copyability threshold' — a near-duplicate retrieved case (cosine ≳ 0.8) lifts accuracy +12 to +13.5 pp, and a 4.5× larger model steepens that step to +22.5–28.5 pp but still extracts no transferable method; the only general accuracy lever is test-time sampling (self-consistency, +3.4 pp at n=500). The authors deliberately document a measurement bug, a retracted result, and a refuted hypothesis as the evaluation standard.

Plain-language abstract The paper presents ActiveGraph, an open-source (Apache-2.0) agent runtime that inverts the usual framework design: instead of a conversation loop with logging bolted on, the append-only event log is the source of truth, the working graph is a deterministic projection of that log, and agent behavior is a population of reactions that fire on graph changes and emit new events. No component instructs another; coordination happens through the shared graph. This buys deterministic replay of any run, cheap forking at any event without re-executing the shared prefix, and total lineage from goal to each model call.

Motivation Conventional LLM agent stacks grow by accretion: chat loop, then tools, then rules, then logging, with memory as a lossy similarity-queried store, so the log is a byproduct and questions like 'why is this fact in context', 'what did the agent believe before rule R changed', or 'what if step 42 had gone differently' are awkward or impossible. For long-running agentic work such as diligence, compliance, and research, where the reasoning matters as much as the answer, the authors argue the recoverable causal chain is the actual product.

Methodology A systems and architecture contribution, explicitly not a task-performance benchmark. The runtime defines events (id, type, payload, actor, caused_by, timestamp), behaviors as subscriptions over event types plus Cypher-subset graph-shape patterns, and a determinism contract (no random, wall-clock, fresh UUIDs, or outside I/O in behavior bodies) policed dynamically by strict replay. Nondeterministic model calls are handled by recording responses in a content-addressed cache keyed on a hash of the full request, so replay and forks make no new model calls. A bundled investment-diligence pack runs fully offline against recorded fixtures on three companies, with no API key, completing in under thirty seconds.

Results The reproducible quickstart run produced 671 events yielding 93 objects (3 companies, 24 questions, 9 documents, 25 claims, 25 evidence items, 1 contradiction, 3 risks, 3 memos) and 76 relations via 103 model calls and 48 tool calls, with zero orchestration code; re-running produced byte-identical logs. Forking a 200-step run at step 150 pays only for steps from 150 onward. Named costs and limits: replay time grows with log length (no checkpointing or compaction yet), schema evolution is a real operational burden, side-effecting tools still mutate the world on first execution, multi-writer ordering is unresolved, and self-improving agents are discussed only as an affordance, not demonstrated.

Shared memory profiles let multiple agents access common knowledge.

Why it matters Productizes team/shared memory; pair with Slack's distilled-truth lesson for the coherence side.

Targets coherence across long-running multi-agent systems specifically.

Why it matters Pairs with Cloudflare shared profiles as the two main public takes on multi-agent memory.

Local memory layer (Rust) motivated by memory being tool-locked (re-explaining things when switching tools/sessions) and by markdown-append memories that dump everything into context and rot.

Why it matters Cross-tool, local substrate aimed squarely at context rot and portability — connects to Interop ([memorywire], [unified-memory-stack]) and Working-Memory/context-rot.

A testbed for long-term memory in distributed multi-agent systems (cloud+edge), directly comparing Mem0 (vector-based) vs Graphiti/Zep (graph-based) on system-level cost and accuracy — not just the tokens/latency that framework-published evals report.

Why it matters The single most decision-useful head-to-head for splitting work between a vector store and a graph store in a multi-agent setting. Bridges Multi-Agent and Evaluation; complements [personalai] (KG-internal comparison).

Lessons from ~10 production deployments (healthcare, fintech, consumer SaaS, dev tooling) on what actually matters vs the 'just add a vector DB' tutorials.

Why it matters The hard-won operational counterweight to research/product claims. Read with [what-using-production] as the practitioner reality layer of the Evaluation category.

Plain-language abstract DeLM (Decentralized Language Models) is a multi-agent framework that drops the central controller. Instead of a main agent assigning subtasks, waiting, and merging results, parallel agents asynchronously claim tasks from a shared queue and read/write a shared 'verified context' of accumulated progress. It targets two settings — parallel exploration in software engineering and concurrent evidence processing in long-context QA — and improves accuracy while roughly halving cost.

Motivation Most multi-agent systems use centralized scatter-gather orchestration, which parallelizes sub-agent execution but not the coordination around it. Every finding must return to the main agent to be merged and rebroadcast, so progress-sharing becomes a serialized bottleneck as agents grow, and the controller can dilute, omit, or distort details. In long-context reasoning the main agent must pre-assign evidence clusters before knowing what is relevant, triggering extra delegation rounds. DeLM removes the controller as the coordination chokepoint.

Methodology Coordination is state-based, not prompt-routed. Two global structures: a shared context C of compact verified gists and a task queue T of pending subtasks. The pipeline initializes the queue from the input, executes ready subtasks in parallel, then compresses-verifies-admits each result into the shared context, generates more subtasks when the context is insufficient, and finalizes once none remain. The shared context is compact, global, and 'unfoldable' — agents read coarse gists by default and expand to detailed summaries or raw evidence only when needed. Admission-time verification checks each update against its underlying evidence and reasoning trajectory before it enters shared state, rejecting or regenerating unsupported updates so errors cannot propagate as reusable problem state.

Results On SWE-bench Verified, DeLM is strongest across test-time-scaling metrics, reaching 77.4% pass@4 at ~$0.12/task — roughly half the baselines' cost — with trace-level examples showing agents reuse each other's discoveries through the compact shared context. On LongBench-v2 Multi-Doc QA it leads four frontier model families by up to 5.7 points, with both admission-time verification and hierarchical summarization contributing. On OOLONG, vanilla DeLM underperforms RLM (which needs exact row-level aggregation via code execution), but RLM combined with DeLM yields the best accuracy and lowest cost, showing DeLM works as a coordination layer for programmatic reasoning too.

Plain-language abstract ESAA-Conversational is a shared memory layer that lets several LLM coding agents — Codex, Claude Code, Grok — hand work off to one another without copying the conversation by hand. It watches each agent's visible turns through hooks or watchers, writes them into one append-only log (activity.jsonl), and deterministically projects compact files — a handoff contract, current state, recorded decisions, and an open-task list — that the next agent reads to pick up where the last left off.

Motivation Developers increasingly switch among multiple coding agents as context windows fill or a different tool suits a subtask, but each agent keeps its conversation in a private, vendor-specific log. The result is 'conversational state drift': goals, rejected alternatives, decisions already made, and open tasks established with one agent are not reliably available to the next. The usual fix — copy-pasting context — is manual, lossy, expensive in tokens, and conflates capturing evidence with interpreting it.

Methodology The system applies event sourcing and CQRS: visible turns are captured mechanically, with no LLM inference, into an append-only activity.jsonl that is the single source of truth, while state.md, handoff.md, decisions.md, and tasks.json are reconstructible read models that are never hand-edited. 'Inverted ingestion' means the runtime reads native agent logs, hooks, or watchers and normalizes them into conversation_turn events rather than requiring agents to share a protocol. A strict boundary separates mechanical capture (turns are evidence) from curation (durable decisions and tasks entered through explicit decide/task commands). A paginated context command serves filtered windows (--last, --around, --before, --topic) so a cold agent reads a slice, not the whole log; workspace_root isolates projects and a lockfile serializes writes. The v1.1.0 release is a local PowerShell CLI.

Results A self-referential case study recorded 570 events (562 conversation turns) in a single workspace on 21 June 2026, distributed across Codex (304), Claude (79), and Grok (67). The three heterogeneous agents co-designed and reviewed the tool through the shared log alone, with no direct agent-to-agent channel — e.g., Codex was given a focused view of recent Grok iterations via `context --agent grok --last 20`, and one concrete defect (incomplete filtering of legacy events under context --topic) was found, fixed, and closed as a task. The public release ships 51 tests in its main battery. Reported limitations: the implementation is Windows/PowerShell-only, sync depends on third-party hook surfaces outside the authors' control, retrieval is purely textual with no embeddings, and the system offers operational but not forensic auditability (no hash chains or signatures); validation covers one workspace and three agents.

RAG-at-every-step is a rigid brute-force strategy that wastes compute and can degrade performance. Proposes an agent that decides when to retrieve vs reason from current context.

Why it matters Reframes retrieval as a policy decision, not a reflex — the cost/quality lever most retrieval designs ignore. Bridges Retrieval and Working-Memory categories.

Production-grounded (LangGraph) deep dive on the seven things competing for the window — system prompts, user messages, conversation state, long-term memory, RAG, tool definitions, output schemas — with token ranges for each.

Why it matters Sets the budget frame: long-term memory is just one of seven consumers, so memory design is inseparable from context engineering. The practical entry point to this category.

Sliding-window and prompt-compression context management omit earlier structured info later steps rely on; retrieval-based memory surfaces relevant content but overlooks dependencies. Builds memory selectively with explicit dependency structure.

Why it matters Targets the failure where compression drops the one earlier fact a later step needs — a dependency-aware answer to context rot. Connects consolidation (what to keep) with context (what to show).

Names 'context rot' — performance degradation as interaction histories grow — as a failure to maintain coherent, task-relevant internal state. Proposes active + reflection-driven context management for deep-search/long-horizon agents.

Why it matters Canonical reference for the context-rot problem this category orbits. Pairs with [contextweaver] (structural fix) and [retrieve-or-think] (retrieve-vs-reason policy).

Context adaptation (modifying inputs vs updating weights) suffers two failure modes: brevity bias (concise summaries drop domain insight) and context collapse (iterative rewriting erodes detail).

Why it matters Names the exact degradation mode behind LLM-rewritten memory — the context-side mirror of [useful-memories-faulty]. Strong argument against over-summarizing either context or stored memory.

Plain-language abstract TokenPilot is a context-management framework for LLM agents in long-horizon sessions that reconciles cutting token count with preserving backend KV prompt-cache continuity. The authors observe that prior pruning, compaction, and memory-eviction methods mutate the prompt layout, which shatters prefix continuity and triggers cache-miss pre-fill penalties that override the financial savings from text reduction. TokenPilot operates at two granularities: a global Ingestion-Aware Compaction harness that stabilizes the prompt prefix and strips open-world tool-output noise at the ingestion gate, plus a local Lifecycle-Aware Eviction that defers purging context segments until their residual task utility expires, on a conservative batch-turn schedule.

Motivation Continuous multi-turn agent interactions accumulate verbose execution traces that inflate sequence length and per-turn inference cost. Existing content-reduction methods reduce tokens but constantly mutate input boundaries, causing prefix mismatches and KV cache invalidation; the resulting pre-fill penalties can exceed the text-reduction savings. The core insight is a trade-off between text sparsity and prompt-cache continuity that must be reconciled, by safeguarding physical prefix continuity during observation ingestion and deferring structural eviction until residual utility expires.

Methodology Messages are partitioned into internal intentional messages (high utility) and open-world environmental feedback (lower density unless content-hash access frequency exceeds a threshold). A canonicalization operator enforces a byte-identical prefix across turns; environmental messages are reduced to structural previews with full payloads stored in a content-hash-indexed artifact registry and recallable via a recovery tool. Lifecycle-Aware Eviction tracks segments through active/completed/evictable states using a zero-shot estimator run every B=3 turns over a compressed history view; only evictable segments (zero residual utility) are purged in a single pass. Evaluation is on PinchBench and Claw-Eval in isolated and continuous modes with GPT-5.4-mini as backbone, against compression baselines (LLMLingua-2, SelectiveContext, Keep-Last-N) and paging/summarization baselines (MemoBrain, MemOS, others); cache hit/miss token counts are read directly from provider API metadata.

Results TokenPilot achieves the lowest inference cost while maintaining competitive accuracy: isolated mode $3.22 on PinchBench and $2.27 on Claw-Eval (61% and 56% reductions vs Vanilla); continuous mode score 81.3 at $2.79 on PinchBench and $10.58 vs Vanilla's $81.52 on Claw-Eval (61% and 87% reductions). Ablation on continuous PinchBench: Ingestion-Aware Compaction cuts cost $7.24 -> $4.22 (cache-miss tokens 5.943M -> 1.589M); adding Lifecycle-Aware Eviction reaches $2.79 (cache-read tokens 26.716M -> 8.551M, a 65% drop). Prefix stabilization raises macro cache hit rate from 38.7% to 79.2% on PinchBench and 67.2% to 83.1% on Claw-Eval. Removing the recovery tool drops accuracy 80.9 -> 77.1; B=1 eviction is too aggressive, B=infinity bloats context, B=3 is the chosen balance.

Observes that returning the entire belief store yields recall 1.0 and passes answer-quality evals — so answer-correctness can't validate a retrieval system. Introduces a precision-aware retrieval benchmark over a structured belief state.

Why it matters The cleanest statement of the retrieval-vs-answer-correctness gap (the 'unit test vs integration test' framing). A north star for evaluating any multi-channel retriever. Bridges Retrieval and Evaluation.

Systematically compares knowledge-graph storage/retrieval approaches for personalized agents, against the backdrop that RAG improves factual accuracy but lacks structured memory and doesn't scale in complex long-term settings.

Why it matters The closest thing to an apples-to-apples KG-design comparison; pairs with [mem0-vs-graphiti] (vector-vs-graph in distributed setting) for store-selection decisions.

Persisting facts (e.g. 'user is vegetarian') aids personalization but also introduces safety risks that are largely overlooked. PersistBench measures when persistence becomes a liability and when memories *should* be forgotten.

Why it matters Reframes forgetting as a safety requirement, not just hygiene — and is one of the only benchmarks targeting forgetting at all. Bridges Forgetting and Evaluation; pairs with the 'forgetting is unmeasured' gap.

A testbed for long-term memory in distributed multi-agent systems (cloud+edge), directly comparing Mem0 (vector-based) vs Graphiti/Zep (graph-based) on system-level cost and accuracy — not just the tokens/latency that framework-published evals report.

Why it matters The single most decision-useful head-to-head for splitting work between a vector store and a graph store in a multi-agent setting. Bridges Multi-Agent and Evaluation; complements [personalai] (KG-internal comparison).

Existing benchmarks (LoCoMo foremost) focus on surface factual recall, but good responses often hinge on implicit constraints — user state, goals, values — never explicitly queried later. LoCoMo-Plus evaluates that 'beyond-factual' setting.

Why it matters Marks the benchmark frontier shifting from 'did it recall the fact' to 'did it honor implicit user context'. Pairs with [adamem] (user-centric retrieval) and [precision-belief-state] (retrieval precision).

Benchmark for multi-session memory: five personas, 100 multi-session conversations, 150 queries spanning factual recall, cross-space integration, and more.

Why it matters A concrete harness for evaluating cross-session retrieval quality. Use alongside [precision-belief-state] (precision) and [locomo-plus] (beyond-factual) to triangulate.

Field thread: chat-history-only, vector-DB RAG, and summary+embedding hybrids all 'work for demos' but break once the agent runs a while — preferences drift, the same mistakes recur, stale context gets pulled purely on semantic closeness.

Why it matters The blunt production reality check that motivates half this map (temporal updating, forgetting, beyond-similarity retrieval). The 'stale context on semantic closeness' complaint is exactly [adamem]'s thesis.

Lessons from ~10 production deployments (healthcare, fintech, consumer SaaS, dev tooling) on what actually matters vs the 'just add a vector DB' tutorials.

Why it matters The hard-won operational counterweight to research/product claims. Read with [what-using-production] as the practitioner reality layer of the Evaluation category.

Agent memory failures are silent — a fluent answer can hide a failure to extract, retain, or retrieve. Traces feature circuits across Qwen-3 (0.6B–14B) to map the write–manage–read loop to internal computations.

Why it matters A mechanistic-interpretability angle on *why* memory fails, complementing black-box benchmarks. Connects the write/manage/read framing used across consolidation, substrate, and retrieval.

Plain-language abstract Engram is an open-source long-term memory engine for LLM agents. Instead of replaying an entire conversation history into the prompt, it stores the past as a bi-temporal knowledge graph and retrieves a small, precisely-targeted slice at answer time. On a standard 500-question memory benchmark that lean ~9.6k-token slice answers more accurately than feeding the model the full ~79k-token history, turning memory from a cost optimization into an accuracy improvement.

Motivation Stateless LLM agents forget across sessions, and the usual fix — concatenating the whole history — grows token cost and latency linearly and loses accuracy as distractors crowd the window ('lost in the middle'). Two gaps stay open: most memory systems are cheaper or faster but not more accurate than full-context, and memory benchmarks run on inconsistent harnesses where one system reports wildly different scores across sources. Engram targets both — beating full-context on accuracy, and shipping a neutral, re-runnable harness.

Methodology A dual-process design. A System-1 hot write path appends lossless episodes with no LLM (sub-50ms) and enqueues them. A System-2 async path extracts atomic (subject,predicate,object) facts, builds a bi-temporal knowledge graph (valid time vs transaction time on every fact and edge), detects conflicts, and resolves them cheap-then-escalate: exact slot match, embedding similarity, and content subsumption handle the common case with no LLM call, invalidating (never deleting) a superseded fact and recording a supersedes chain and provenance, with only ambiguous cases escalated to an LLM adjudicator. The hybrid read path retrieves through four channels (dense, BM25, graph n-hop, recency/salience), fuses them with Reciprocal Rank Fusion, applies an 'as-of' temporal filter and an abstention gate, and assembles a deduplicated, provenance-tagged, token-budgeted context of facts plus raw chunks.

Results On the full 500-question LongMemEval_S under the official category-specific judge, Engram's lean configuration scores 83.6% vs 73.2% for full-context (+10.4 points, McNemar exact p<10^-6) at ~8x fewer tokens (9.6k vs 79k), 0/500 errored. The gain is load-bearing on the read path being hybrid: facts alone lose recall, while facts plus retrieved chunks recover detail. Bi-temporal modeling pays off most on knowledge-update (87.5%) and temporal (81.1%) categories, while multi-session aggregation and preference remain headroom. The paper documents measurement-integrity pitfalls (truncation, home-grown judges, full-history leaks) and ships a neutral in-repo harness with the official judge baked in and raw per-question logs, every number reproducible by command.

Plain-language abstract GitOfThoughts stores an LLM agent's reasoning tree as a git repository — every scored thought is a commit, scores are git notes, validation outcomes are tags, and retrieval is git log over the agent's own history — which makes reasoning replayable, auditable, diffable, and mergeable across agents. The paper then asks the harder question of whether memory, in any substrate, actually improves accuracy, and runs a pre-registered comparison of five substrates (none, markdown, vector, graph, git).

Motivation Reasoning is the last unversioned software process: chains of thought expire with the context window, pruned search branches leave no record, and memory buffers cannot be diffed, merged, or audited. The authors argue this ephemerality is a structural blocker — it prevents reproducibility ('what did the agent think at step 17?'), audit (detecting train–test leakage or gold-answer memorization), memory transfer between agents, and incident review. Code, infrastructure, datasets, and experiments are all version-controlled; reasoning is the remaining outlier.

Methodology A reasoning tree shares git's structural invariants, so the paper maps it one-to-one onto git primitives (node = commit, refinement = parent edge, score = note, outcome = tag, session vs. cross-session = branch, retrieval = git log --grep / -S). A pluggable MemoryBackend routes every read/write through one interface so the same agent can swap substrate with a one-line change. To isolate retrieval from write-path noise, all five backends ingest identical answer-free lessons, then solve held-out, domain-stratified problems read-only; benchmarks are GPQA-Diamond and MATH-500, scored with paired-bootstrap CIs, across two backbones and pre-registered replications, with a similarity sweep to locate when retrieval helps.

Results H-substrate is supported: git delivers auditability, line-level diffs over reasoning text, deterministic replay by SHA, and mergeable memory at accuracy parity, costing ~15 ms/write and ~48 ms/read. H-memory is rejected: across two benchmarks, two backbones, and up to n=500, no substrate reliably improves accuracy on novel problems, and a +15 pp git trend at n=40 collapsed under its pre-registered replication. Memory pays only above a 'copyability threshold' — a near-duplicate retrieved case (cosine ≳ 0.8) lifts accuracy +12 to +13.5 pp, and a 4.5× larger model steepens that step to +22.5–28.5 pp but still extracts no transferable method; the only general accuracy lever is test-time sampling (self-consistency, +3.4 pp at n=500). The authors deliberately document a measurement bug, a retracted result, and a refuted hypothesis as the evaluation standard.

Plain-language abstract StreamMemBench is a streaming benchmark that tests whether a personal-agent memory system can turn what it observes and how users interact with it into future-oriented assistance. Built on EgoLife egocentric lifelogs, it anchors each evaluation on a hidden piece of user-specific evidence and wraps a two-step task around it: an initial task that depends on the evidence, then a follow-up task that tests whether the agent reused both the evidence and the user's feedback. Four metrics diagnose evidence retention, feedback incorporation, initial evidence use, and follow-up reuse.

Motivation A central job of personal-agent memory is to carry stored observations and prior interactions forward into later, similar tasks, but existing memory benchmarks test dialogue recall or task improvement in isolation and usually rely on scripted or synthesized dialogues whose feedback is not tied to verifiable observations. That leaves the trajectory from streaming observations to later assistance largely untested — and even commercial assistants such as ChatGPT and Gemini store information that fails to help when it is actually needed.

Methodology In the construction stage an anchor agent processes five-minute EgoLife segments in stream order and extracts a user-specific evidence anchor plus two application-oriented queries, and a review agent retains a candidate only if both queries satisfy Leak=0 (the query does not reveal the evidence), Need=1 (ignoring the anchor yields a wrong or generic answer), and Natural=1 (it reads as a plausible request). In the evaluation stage the memory system ingests the lifelog chronologically, answers the initial task, receives confirming or correcting feedback from a user simulator, commits that interaction to memory, and then answers a follow-up task grounded in the same anchor; an evaluation agent scores Fidelity, Feedback Incorporation, Initial Evidence Use, and Follow-up Reuse against atom-level checklists, and the Fidelity−IEU / Fidelity−FUR gaps localize failures.

Results Across eight systems — two retrieval baselines (RAGraw, RAGext) and six memory systems (A-Mem, Mem0, EverMemOS, MemOS, MemoryOS, MemSkill) — on two backbones, current memory systems are not yet reliable for future-oriented assistance: they often fail to use evidence from egocentric observations in the initial task and to turn interaction feedback into reusable follow-up behavior. The failures are not explained by storage alone — systems frequently retain the evidence (with some Fidelity inflated by raw-text retention) yet do not use it — which motivates evaluation that traces each piece of evidence from its first appearance in the stream through initial use, feedback incorporation, and follow-up reuse.

Plain-language abstract MemTrace is a benchmark for testing how well an AI assistant remembers facts about a user across many conversations. Instead of scoring isolated questions, it tracks each individual fact—like a user's job title—and repeatedly asks about it under different conditions: long after it was mentioned, when it has since changed, or when the question contains false information. This reveals failures that a single overall accuracy score hides, such as a system that recalls a user's current role correctly but invents a false history of how they got there.

Motivation Long-term memory benchmarks usually aggregate accuracy over question rows or interaction episodes, treating questions that probe the same underlying fact as independent items. That makes it impossible to hold a fact fixed and ask how a system behaves as conditions around it change—whether it still recalls a fact after many sessions, whether it tracks how the fact evolved, and whether it behaves safely when evidence is missing or contradicted. Two systems with similar pooled scores can fail in entirely different ways, and aggregate scoring cannot show which.

Methodology MemTrace makes the knowledge point—a single typed fact about the user—the unit of measurement, and probes each fact along three controlled dimensions: memory age (how many sessions ago it appeared), question type (current state, an earlier state, or the trajectory of change), and evidence condition (present, missing, or contradicted by a false premise). It comprises 835 typed knowledge points from 20 users, expanded into 15,422 question rows and over 200,000 scored answers, and evaluates 13 memory-system configurations across four paradigms: long-context models, retrieval-augmented systems, external-memory stores, and agentic-memory architectures. A diagnostic step classifies each failure by whether the needed evidence was unreachable or reachable but unused.

Results Performance varies systematically across all three dimensions. Long-context systems answer recent facts well but lose accuracy as facts age, especially on trajectory questions; RAG systems, including graph-based retrieval, handle current and earlier-state questions better than questions about change over time; some external-memory systems decline almost all questions about facts that were never mentioned yet rarely correct a false premise. The dominant remaining bottleneck is evidence use, not retrieval: when systems fail, the evidence was already retrievable about 10× more often than it was missing, so improving memory depends on using reachable evidence rather than storing or retrieving more.

Plain-language abstract MemSyco-Bench is a benchmark that tests a specific failure mode in AI agents with long-term memory: sycophancy, where an agent trusts a memory of something the user said or believed before, even when that memory is outdated, out of scope, or contradicted by current evidence. Existing memory benchmarks mostly test whether an agent can retrieve the right memory; this one tests whether the agent uses a retrieved memory correctly once it has it.

Motivation The authors first show the problem is real: adding a plausible-but-wrong memory snippet before an objective factual question drops accuracy across all tested models and roughly doubles the rate at which the agent adopts the incorrect claim. They then show existing benchmarks (LongMemEval, LoCoMo, STALE, PersonaMem) can't isolate this: 47.4-66.1% of their errors come from failed retrieval, versus only 5.8-13.7% from correct-retrieval-but-wrong-use, so post-retrieval reasoning failures are essentially invisible in current scores.

Methodology MemSyco-Bench defines five task categories matched to the decisions an agent should make about a retrieved memory: reject it as factual evidence, respect its scope, resolve a conflict between memory and objective evidence, track that a memory has been updated, and use a genuinely valid memory for personalization. Multiple memory systems and backbone models are evaluated across these categories.

Results In the preliminary study, injecting a misleading memory cue drops factual accuracy on DeepSeek-V4-Flash from 56.1% to 40.2% and raises its sycophancy rate from 24.3% to 52.3%, with similar (smaller) effects on the other tested models. Full benchmark results show current memory systems generally increase sycophancy and struggle to balance personalization against factual reliability.

Plain-language abstract MemOps is a benchmark that reframes long-term conversational memory as a lifecycle of explicit operations (remembering, forgetting, updating, reflecting, and their compositions) rather than as static question answering. Each memory event is a structured trace specifying its trigger, target, scope, state transition, and supporting evidence. A controllable pipeline embeds these operations into long, task-oriented conversations, producing gold operation traces and six categories of operation-level probes evaluated under both adjacent-evidence and long-context settings. Across long-context, retrieval-based, parametric, and managed-memory systems, MemOps disentangles failure modes that final-answer accuracy alone conceals.

Motivation Existing long-term memory benchmarks such as LoCoMo, LongMemEval, MemBench, and others evaluate almost exclusively through downstream question answering, scoring only the correctness of a final answer. That black-box formulation conflates heterogeneous causes of failure (missing the introduction of a relevant fact, binding an operation to the wrong target, or relying on a stale value after a correction) and can credit a correct answer that rests on an inconsistent or unsafe memory state. This is most acute in dynamic long-horizon interaction, where memory functions as a lifecycle process: a user introduces a fact, corrects it, asks that part be forgotten, or implicitly signals a preference, each of which is a distinct operation with its own trigger, target, scope, state transition, and characteristic failure modes that downstream QA cannot diagnose.

Methodology Each instance is a tuple of a topic-specific user background, a set of evidence conversations, a gold operation trace, and evaluation probes. The trace is the evaluation anchor: each operation carries a type, target object, old and new value, and evidence spans quoted verbatim from user turns. Five operation types are defined, including TrajectoryOps that compose remember, update, forget, and reflect events across time so the benchmark can check intermediate states and their temporal order. A four-stage generation pipeline (background construction; evidence conversation and gold-trace generation; operation-level probe generation; long-context dialogue generation with distractor pools) produces natural conversations with explicit operation supervision, verified by local schema and span gates plus an LLM verifier. Six probe categories (operation trace, target binding, state transition, candidate disambiguation, operation application, state trajectory) score intermediate memory behavior, and representative systems from four paradigms are evaluated under adjacent-evidence and long-context settings.

Results Performance is strongest when evidence sits adjacent to the query and degrades consistently once it is dispersed into long, distractor-laden histories, for both answer accuracy and operation-level reliability. Session-level retrieval substantially outperforms turn-level retrieval, and managed-memory services that preserve longer, context-rich memory units outperform those storing short, isolated facts, indicating that surrounding context is critical for correctly executing lifecycle operations rather than merely retrieving relevant content. Parametric memory, which folds interaction history into model parameters, remains markedly unreliable across almost all diagnostic dimensions. Reconstructing an ordered memory-state trajectory across multiple composed operations is far more fragile than any single-step operation, and this weakness persists even for otherwise strong long-context models, exposing a failure mode that final-answer accuracy alone would not surface.

Plain-language abstract A language model's memory can be worse than no memory at all. Give a model a memory that kept a wrong conclusion but dropped the work behind it and it re-emits the stale value as a confident answer; give the same model an empty memory and it abstains. The paper names this failure brittle memory, measures it with a reclaim-evaluation protocol that tests whether a correction can recover a known answer after compression, and shows a one-line fix (keep the recomputable source, drop the re-derivable conclusion) restores correctability at equal memory budget.

Motivation Memory systems carry information across sessions by compressing it, on the implicit assumption that a compression preserving the model's answer has preserved what matters. The paper shows the same compression decides whether the model can later be corrected: once the answer-determining source is gone, a correction has nothing to act on, and the resulting error compounds as deployed agents feed memory into memory.

Methodology Reclaim evaluation drifts a model into committing to a wrong answer via a planted premise, deepens the commitment over neutral turns, then issues a correction in a fresh session whose only inheritance is a memory written under one of three matched-budget policies: lossy (keep the salient conclusion, shed the source), source-first (keep the source, shed the conclusion), and lossy-padded (lossy plus neutral filler to at least source-first's length, controlling for budget). Success is exact recovery of the known answer, with no judge. Tasks are multi-step arithmetic and constraint-logic puzzles with objectively scorable answers; the pipeline runs end to end on llama-3.1-8b and grok-4.3 with a frontier replay on Claude models; headline cells are n=96, and three validators designed to fail against a deterministic fake all pass.

Results Within one conversation there is no wall, only anchoring: a directed correction holds far longer than a generic one (reclaim 0.79 to 0.50 over eight commitment turns) and pushing the error further back lifts reclaim rather than starving it. Across a session boundary the window becomes a wall: once the lossy note drops the source line items, even a directed correction dies, reclaim is 0.00 by measurement, and a lossy memory is worse than an empty one because models that abstain with nothing emit the confident wrong value with a source-less note. The wall sits in the same place from the 8B model to frontier systems. Source-first restores reclaim at equal budget (oracle 1.00; the deployable one-prompt distiller 0.49-0.88, concentrated on compact numeric sources), and the length-matched control rules out added text as the cause. Chained through a memory loop, one dropped-source error corrupts a growing span of downstream steps and stays uncorrectable however late it is caught, while source-first holds to a bounded budget horizon; the wall and the fix replicate on three deployed memory systems and on MultiWOZ, and past the budget where the source no longer fits, the fix fails silently unless the note records its own completeness.

Plain-language abstract RECON (Reasoning over Extended Contexts with Obfuscated Narratives) is a benchmark that tests whether an agent's memory can maintain a coherent, evolving understanding over long contexts where facts do not just accumulate but interact, contradict, and cascade. It spans 24 investigative case files across criminal, medical, and financial domains, each 50k to 100k tokens, with 1,604 questions over six memory-intensive tasks, and reports that even the strongest non-Oracle system reaches only 22.4% accuracy.

Motivation Existing memory benchmarks model memory as a state machine: they check whether an agent can retrieve a scattered fact or detect that a fact changed. Real workflows demand more. When a lab result is revised on Day 9, a witness statement is contradicted on Day 5, or a flagged transaction is reversed, an agent must trace which downstream conclusions are affected, which survive on independent support, and how an alternative timeline would have unfolded. RECON targets what happens after a change, not just whether the current value is tracked.

Methodology A deterministic pipeline constructs each case from a provenance DAG, then a question generator traverses the DAG to synthesize questions per task category, with a fixed question matrix enforcing per-task and per-format quotas so the distribution does not drift between runs. The six tasks are chain reconstruction (order 5-15 evidence hops), cascade propagation (which conclusions break versus survive after an invalidation), source-conflict resolution, counterfactual reasoning, temporal-constraint satisfaction, and temporal fact retrieval as a control. Solvers - long-context, RAG, hybrid RAG, Supermemory, Mem0, Mem0-Graph, Hindsight, closed-book, and an Oracle handed the full structured ground truth - share one answering template; freeform answers are graded by two independent LLM judges from different model families and averaged, while other formats are scored deterministically with an explicit abstain option (+1 correct, -0.2 wrong, 0 abstain).

Results Even the Oracle given the ground-truth dependency graph reaches only 54.6% accuracy, and the best non-Oracle system 22.4%; RAG attains 20.6% on full-coverage retrieval hits. Decomposing failures shows roughly four in five persist even when retrieval succeeds, placing the bottleneck in reasoning rather than evidence selection. Human annotators reach 63.0% accuracy, exceeding the Oracle solver by 8.4 points and confirming reasoning, not retrieval, as the residual challenge across long-context, retrieval, and agentic-memory architectures.

Mem0, Letta/MemGPT, Cognee, Zep/Graphiti, MemoryOS, MemTensor each ship their own SDK, storage layout, and vocabulary — no shared wire format. Every integration is bespoke, every migration rebuilds from scratch, and none ships a governance surface to review writes. Proposes a neutral wire format.

Why it matters The interoperability + governance gap stated plainly — directly relevant if a service spans multiple stores (vector + graph + object storage). Pairs with [schema-quality] (schema discipline) and [unified-memory-stack] (DIY unification).

Deep dive on production-grade agent memory arguing memory quality is bounded by schema quality — get the schema wrong and retrieval/consolidation can't recover.

Why it matters Elevates schema design to a first-class concern; the human-readable companion to [memorywire]'s machine wire-format. Connects to Representation (the schema encodes the representation choice).

DIY unification: Memori's interceptor architecture (zero code changes), Mem0's research-validated retrieval/consolidation, and Supermemory's structure — composed into one stack.

Why it matters Exactly the multi-store composition pattern that motivates a wire format. Real-world evidence builders are already gluing frameworks together by hand. Connects to [memorybank-rust] (cross-tool) and [memorywire] (the standard that would obviate the glue).

Notes that Mem0's OpenMemory MCP advertises local/private operation but still requires an OpenAI key (embeddings + gpt-4.1-nano) for extraction in the default Docker setup.

Why it matters Operational gotcha for anyone assuming a 'local' memory framework is self-contained — the LLM dependency leaks in via extraction/embeddings. Relevant to substrate/privacy and to the zero-LLM designs ([superlocalmemory], [yourmemory]) reacting to exactly this.

Cloudflare's managed memory service: extracts structured memories from agent conversations and serves them on demand, with shared memory profiles so teams of agents read common knowledge. Framed around getting the right info into context even as windows pass 1M tokens.

Why it matters The most complete public blueprint for the shape of service described in many internal designs (sessions → turns → consolidated docs → multi-channel search). Build-vs-buy anchor for the whole map.

Third-party writeup of Cloudflare Agent Memory (private beta). Names the competitive set explicitly: Mem0, Zep, LangMem, Letta.

Why it matters Use this to scope the managed-memory market in one line. Takeaway: the named incumbents are exactly the frameworks the wire-format work [memorywire] says can't interoperate.

Large multi-institution survey formalizing agent memory as a core capability. Unifies a fragmented field into a taxonomy of memory forms (token-level logs vs parametric weights vs latent vectors) × functions (factual knowledge vs experiential learning vs working scratchpad).

Why it matters The canonical framing doc — read first to make the rest of the map legible. Its forms×functions grid is a good axis for any design review. Connects to every other category as the orienting vocabulary.

Newsletter roundup that flagged the agent-memory survey wave and frameworks like MemVerse (fast parametric recall + hierarchical retrieval) and WorldMM (multimodal experience consolidation).

Why it matters Good lay-of-the-land pulse on what the research community foregrounded as memory went mainstream. Lighter signal than the survey itself.

Productized 'memory across conversations' for Twilio's agent/CX stack.

Why it matters Data point that conversation memory is now table-stakes in vertical comms platforms, not just AI-infra vendors. Lower technical depth; useful as market evidence.