NapMem: From Passive Retrieval to Active Memory Navigation

The Paper

"From Passive Retrieval to Active Memory Navigation: Learning to Use Memory as a Structured Action Space" is authored by Yue Xu, Yutao Sun, Yihao Liu, Mengyu Zhou, Jiayi Qiao, Lu Ma, Kai Tang, Wenjie Wang, Xiaoxi Jiang, and Guanjun Jiang, posted to arXiv in July 2026. The paper introduces NapMem, a framework that reframes long-term memory in personalized conversational agents from a passive retrieval interface into a structured action space that the agent actively navigates. Rather than consuming pre-selected context injected by an external retrieval system, a NapMem agent issues memory tool calls at different granularity levels and learns - via reinforcement learning - which level to inspect and when.

The Problem Before This Paper

Standard approaches to long-term memory in conversational agents follow the same basic pattern: encode user history into a retrieval index, fetch the top-k most similar chunks at inference time, and inject them into the model's context window. This design has a fundamental structural flaw - the retrieval system selects evidence before the model has a chance to reason about what it needs. The model receives a fixed slice of memory and must answer from it, regardless of whether the retrieved context is at the right level of abstraction. A user asking about a recurring preference needs a high-level profile, not raw conversation transcripts. A user asking for a specific detail from a past exchange needs the inverse. Flat retrieval collapses these cases into a single lookup, leading to noisy context injection and, frequently, the wrong granularity for the query at hand. Prior personalized dialogue systems - including those built on MemoryBank, ReadAgent, and similar architectures - did not give the agent any mechanism to choose its own memory access pattern. The retrieval system decided; the model consumed.

What They Built

NapMem organizes user history into a linked multi-granularity memory pyramid with four levels connected via provenance relations. At the base are raw conversations - verbatim exchange logs across all sessions. The second level holds typed memory records: structured extractions of facts, events, and entities pulled from those conversations (think: "user prefers morning appointments", "mentioned dog named Mochi"). The third level groups these records into topic tracks - thematic threads that cluster related records across sessions, e.g. a "health goals" track or a "work project" track. At the apex sits a user profile: a high-level summary of the user's persistent traits, preferences, and long-term state.

NapMem 4-level memory pyramid. Each level is a callable tool; provenance links enable single-hop traversal between levels.

Each level is exposed to the agent as a separate callable memory tool. The agent does not receive any memory passively - it decides which tool to call, processes the result, and either answers from that level or issues another tool call to navigate to a different granularity. The training approach is memory-tool reinforcement learning: the agent is trained end-to-end with a reward signal that incentivizes correct answers while penalizing unnecessary navigation steps, teaching it to select the minimum sufficient granularity for each query. A query about a user's general dietary preference should resolve at L4; a query about what they ordered at a specific dinner two months ago should resolve at L1. The policy learns to route without explicit heuristics.

NapMem agent navigation policy:
  pi(a | q, m_t) - given query q and current memory observation m_t
  select action a in {call_tool(level_k) | k in 1..4} union {answer}

  Reward R:
    +correct answer
    -unnecessary navigation steps (penalizes over-querying)
    objective: maximize E[R] via GRPO-style policy gradient

Provenance relation (cross-level linking):
  record r in L2 has provenance pointer to source conversation c in L1
  topic track t in L3 aggregates records {r1, r2, ...} from L2
  user profile P in L4 is derived from topic tracks {t1, t2, ...}
  drill-down: t -> {r1, r2} -> {c1, c2} in at most 2 hops
  zoom-out: c -> r -> t -> P in at most 3 hops

Key Findings

• Active navigation outperforms passive retrieval on memory-intensive benchmarks. NapMem shows competitive performance across PersonaMem-v2, LongMemEval, and LoCoMo - three benchmarks that specifically stress long-term personalization and multi-session recall.
• The learned navigation policy generalizes across query types. The agent correctly routes preference queries to the user profile level and specific-recall queries to raw conversations, without explicit per-query heuristics - the policy is learned from reward, not hand-engineered routing rules.
• Memory-tool RL training is necessary. Ablations removing the RL training component and replacing it with supervised fine-tuning on fixed navigation traces significantly degraded performance, confirming that the policy needs a feedback loop to learn adaptive granularity selection.
• General reasoning and tool-use abilities are preserved. NapMem does not exhibit catastrophic forgetting on non-memory tasks - the model retains its base capabilities after memory-tool RL training, a common failure mode in continual learning setups.
• Provenance links reduce navigation steps. The explicit connections between pyramid levels allow single-hop drill-down rather than multi-step traversal, keeping inference overhead manageable relative to the accuracy gains from active navigation.

Results

NapMem is evaluated on PersonaMem-v2, LongMemEval, and LoCoMo - three benchmarks with distinct memory stress profiles. PersonaMem-v2 tests whether agents accurately recall and apply user-specific preferences across sessions. LongMemEval focuses on fine-grained recall of events and facts from extended conversation histories. LoCoMo evaluates localized contextual memory over long multi-turn exchanges. Across all three, NapMem's active navigation policy outperforms passive retrieval baselines, with the gains most pronounced on PersonaMem-v2 where query types most sharply bifurcate between coarse-preference and fine-detail access patterns. The ablation studies confirm that both the multi-granularity pyramid structure and the RL training component are load-bearing - removing either degrades performance toward the passive retrieval baseline. Inference overhead from navigation tool calls remains bounded because the provenance structure limits traversal depth, and storage costs scale linearly with the number of pyramid levels rather than quadratically.

Example navigation trace: agent routes to Topic Tracks, finds the "health" thread, drills to Typed Records for specifics, answers without touching raw logs.

Why This Matters for AI and Automation

• Passive memory retrieval is the bottleneck for long-term personalization. Any production agent that needs to maintain a coherent picture of a user across sessions - customer service bots, coaching assistants, legal intake systems - hits the same wall: flat retrieval returns the wrong granularity half the time. NapMem's framing gives a principled path out of that constraint.
• Memory as action space generalizes the tool-use paradigm. Most current agent frameworks treat external tools (APIs, calculators, search) as the primary action space and memory as a background read operation. NapMem treats memory access itself as a first-class decision - which is the right abstraction for agents with rich user history.
• The pyramid structure maps naturally to existing knowledge management patterns. Raw conversations, extracted facts, topic summaries, and user profiles are already the natural outputs of document processing pipelines, CRM systems, and note-taking tools. NapMem's architecture does not require a novel storage backend - it requires a navigation policy trained on top of what already exists.
• Connects directly to calibrated uncertainty work from Week 22. RLMF trains agents to express when they do not know something. NapMem trains agents to know where to look when they need to know something. Both are prerequisites for agents that behave reliably in production without constant human oversight.

From the Lab to My Projects

NapMem's memory pyramid isn't just an academic abstraction - the exact same structural problem shows up in every agent I've shipped. Here's where I've felt the pain directly and how NapMem's framing would change the architecture.

This is the pattern that separates a stateless voice bot from a genuinely personalized assistant. Flat retrieval or no retrieval works fine for one-shot tasks. The moment an agent needs to behave differently based on who it's talking to and what happened in past sessions, you need layered memory with a navigation policy - not a bigger context window or a longer system prompt.

My Take

The core insight - that retrieval granularity should be a model decision, not a retrieval-system decision - is the right reframing. The surprising part is that it took this long to arrive at it. The tool-use paradigm has been standard in agentic systems since 2023, yet memory access has remained stubbornly "call once, consume passively" in most deployed systems. The memory-tool RL training is the piece that makes this work in practice rather than in theory: it is easy to expose multiple memory levels as tools, but without a trained policy for when to use each, agents default to calling all of them or the wrong one. The open engineering questions are around memory update latency and staleness. The pyramid is built from past conversations, but user preferences drift over time. Whether the provenance links can support incremental updates without full recomputation of upper pyramid levels is not addressed in the abstract and will matter significantly for deployment at scale. The benchmark suite is also worth scrutinizing - PersonaMem-v2, LongMemEval, and LoCoMo are well-regarded but share a structural bias toward recall accuracy over behavioral fidelity. Whether a model that navigates memory correctly also behaves more consistently from a user's perspective is an open empirical question that requires a different evaluation design.

Discussion Question

NapMem's navigation policy is trained on historical conversation data with a reward signal tied to answer correctness. But user preferences are not static - they evolve over months and sessions in ways that make older profile data actively misleading. How would you design a memory update mechanism that keeps the pyramid fresh without requiring full retraining of the navigation policy every time the user's context changes?

Read the Paper on arXiv →