First surfaced in Tandemly Briefing — 2026-07-14.
Stop retrieving.
Navigate.
Researchers at Alibaba and ShanghaiTech organized user memory into four connected layers and exposed each layer as a callable tool. An RL-trained agent learns to move between those layers based on what it has found so far, stopping once it has enough evidence. Better answers, fewer unnecessary tool calls.
A single query can't ask
what you don't know yet.
Most personalized agents still treat memory as a filing cabinet: submit a query, receive documents, proceed. That works until it doesn't.
Personalized conversational agents carry user history: preferences stated weeks ago, facts mentioned in passing, patterns that only emerge across sessions. The most common way to use this history is to embed the user's latest message, run a nearest-neighbor search, and inject whatever comes back into the prompt. It is fast, simple, and good enough for many queries.
The trouble is that the search is passive. The agent asks a question of its memory, takes what it gets, and moves on. There is no way for it to say "I found a preference record, but I want to verify it against the conversation where it came from" or "this topic track mentions something relevant; let me pull the detail." The model is a consumer of pre-selected evidence, not a navigator of a structured information space.
This matters because user memory is not a flat list of independent facts. It has natural structure. Raw conversation logs exist. Extracted factual records, typed by category, exist. Topic threads that connect related conversations across sessions exist. High-level user profiles that summarize patterns and preferences exist. Passive retrieval dumps a mix of these levels into context indiscriminately, and the agent has to sort out the signal on its own. That is work the retrieval layer could be doing.
What if the agent could choose which memory layer to inspect, and in what order, based on what it has found so far? Could that active navigation produce better answers than a single fixed retrieval pass?
A four-level pyramid
and an agent that climbs it.
NapMem introduces two ideas together: a structured memory pyramid and a trained policy for navigating it.
The first idea is the memory pyramid. NapMem organizes user history into four layers, linked by provenance pointers so that any claim at one level can be traced to the evidence at the level below it. The layers, from bottom to top, are: raw conversation transcripts, typed memory records (atomic facts organized by category), topic tracks (threads that connect related facts and conversations across time), and a user profile (a summary of stable preferences and behavioral patterns). The links between layers are bidirectional. The agent can start at the top and drill down, or start at the bottom and aggregate upward.
The second idea is exposing each layer as a callable tool rather than as a single retrieval endpoint. The agent can call "get user profile," then "get topic track for dietary preferences," then "get the specific conversation where the user mentioned a food allergy." Each call returns structured, typed output. The agent decides which call to make next based on what it has found so far. This turns memory access from a one-shot query into a multi-step decision process.
To teach the agent how to navigate this structure well, the researchers used reinforcement learning. The reward signal jointly optimizes two things: the quality of the final answer and the efficiency of the navigation path. An agent that reaches the correct answer in two tool calls is rewarded more than one that reached the same answer in eight. Over training, the model learns to stop exploring once it has gathered enough evidence, rather than calling every available tool by default.
Fewer calls.
Better answers.
Across three memory-intensive benchmarks and a battery of non-memory tasks, NapMem's trained navigators consistently beat passive retrieval baselines.
NapMem was evaluated on three memory-intensive benchmarks covering different angles of what it means to know a user: PersonaMem-v2 (multiple-choice questions about implicit preferences), LongMemEval (open-ended QA across five capabilities: information extraction, multi-session reasoning, temporal reasoning, knowledge updates, and abstention), and LoCoMo (open-ended QA on long-horizon conversational memory). The agent was also evaluated on standard non-memory reasoning and tool-use tasks to check whether the memory-specific training hurt general capability.
Across the memory benchmarks, NapMem was competitive with or better than passive retrieval baselines. The ablation results are the most informative part of the paper: all three components contributed independently. Active navigation alone (allowing multi-step tool calls without RL) improved over passive retrieval. Adding the memory pyramid (structured granularity) improved further. Adding RL training on top changed the navigation behavior: the trained model made fewer tool calls overall while reaching higher accuracy, indicating it learned to stop searching once sufficient evidence had accumulated.
On non-memory tasks, performance largely held. The RL training did not push the model toward over-relying on memory tools in contexts where they are not useful. That is a meaningful finding: it means the navigation policy learned by the model is selective, not compulsive.
The paper does not surface absolute accuracy numbers prominently in publicly available materials. The relative findings (active navigation beats passive, granularity contributes, RL improves selectivity) are clearly supported by the ablation structure, but direct comparison to specific external baselines requires reading the full paper at arxiv.org/abs/2607.05794.
What this means
for builders.
The core lesson is architectural: if memory has structure, expose that structure as callable tools rather than collapsing it into a single retrieval endpoint.