MemReader: Active Memory Extraction

• MemReader is a family of memory extraction models that actively manage long-term agent memory by evaluating information value, ambiguity, and completeness before writing.
• It formalizes memory extraction as a sequential decision process with a think–act–observe cycle, using specialized actions like add, buffer, search, and ignore to update memory.
• Empirical results show that MemReader’s active decision-making improves temporal reasoning, reduces hallucinations, and achieves high performance across diverse memory benchmarks.

Searching arXiv for recent and related papers on MemReader and adjacent memory-reader systems. MemReader is a family of memory extraction models for long-term agent memory that reframes memory population from passive transcription to active, decision-driven state maintenance. In this usage, introduced in "MemReader: From Passive to Active Extraction for Long-Term Agent Memory" (Kang et al., 9 Apr 2026), the system evaluates whether information should be written at all, whether it is complete enough to write now, whether historical retrieval is required for disambiguation, and whether new content should update existing memory. The name has also appeared earlier in other research contexts, including as an alias for Episodic Memory Reader in streaming question answering and for the Reinforced Mnemonic Reader in extractive machine reading comprehension (Han et al., 2019, Hu et al., 2017).

1. Conceptual shift from extraction to memory management

MemReader is motivated by a specific failure mode in long-horizon agent systems: existing memory modules often treat extraction as a one-shot JSON-generation problem. The 2026 MemReader paper argues that this conflates semantic extraction with memory management. In noisy dialogue with missing references and cross-turn dependencies, passive extraction tends to produce memory pollution, low-value writes, and inconsistency. MemReader therefore treats long-term memory not as a transcript of surface content but as an actively maintained state that can be written, deferred, queried, or left unchanged (Kang et al., 9 Apr 2026).

The central diagnostic questions are explicit. Before acting, MemReader reasons about information value, reference ambiguity, and completeness. Information value asks whether content is a preference, constraint, important decision, or merely low-value chatter. Reference ambiguity asks whether pronouns or cross-session links require retrieval to resolve. Completeness asks whether the available information is sufficient to form memory now or should instead be buffered. This design directly targets knowledge updating, temporal reasoning, and hallucination reduction, rather than maximizing write volume.

A common misconception is that long-term memory quality is primarily a schema-design problem. MemReader instead treats schema consistency as necessary but insufficient. The paper’s position is that reliable memory requires action selection over memory state, not only structured extraction. This is why the system includes explicit operations for deferral and retrieval, rather than only a write tool.

2. Formalization as a sequential decision process

MemReader formalizes memory extraction at turn $t$ as a sequential decision problem over the state

$s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$

where $x_t$ is the current user utterance, $\mathcal{M}_{t-1}$ is the long-term memory state, and $\mathcal{B}_{t-1}$ is the temporary buffer state (Kang et al., 9 Apr 2026). The model produces a ReAct-style trajectory

$$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$

with internal reasoning $z_t^{(k)}$, selected action $a_t^{(k)}$, and resulting observation $o_t^{(k)}$.

The specialized action space is

$$\mathcal{A} = \{add\_memory,\ buffer\_memory,\ search\_memory,\ ignore\_memory\}.$$

The trajectory updates memory via

$s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$0

Here, add_memory writes or updates structured entries in $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$1; buffer_memory stores incomplete but valuable hypotheses in $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$2; search_memory retrieves supporting evidence; and ignore_memory leaves state unchanged.

The policy objective is stated as

$s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$3

where the reward captures correct decision-making, high-quality content, and efficient reasoning. This formulation places memory writing, retrieval, and deferral inside the same control loop. A plausible implication is that MemReader treats memory quality as a sequential control problem rather than as a purely generative extraction task.

3. Model family and operational loop

The MemReader family contains two complementary designs (Kang et al., 9 Apr 2026).

Variant	Base model	Primary role
MemReader-0.6B	Qwen3-0.6B	Compact, cost-efficient passive extractor trained by distillation
MemReader-4B	Qwen3-4B	Active extractor using a ReAct loop with tool-calling and GRPO

MemReader-0.6B is a compact, cost-efficient structured extractor trained by distillation. It targets settings that require schema-consistent outputs at low cost and latency. Training uses bilingual Chinese/English conversation and document extraction data, together with JSON validation, field completeness checks, and date-parsing accuracy checks. Its outputs conform to a fixed schema with decoding constraints enforced by validators.

MemReader-4B is the active variant. It follows a think–act–observe cycle in which the model reasons about value, ambiguity, and completeness, invokes one of the four memory-state tools, integrates the tool result, and then either continues or finalizes. The loop favors retrieval-first disambiguation when encountering pronouns or implicit references; buffer_memory is used only when search cannot resolve ambiguity and the user has not finished; add_memory requires both value and completeness; ignore_memory is used for pleasantries or generic content.

The paper’s qualitative examples make the operational semantics concrete. In one trace, search_memory resolves a user’s business background before add_memory writes a structured “Dance studio startup plan” entry. In another, incomplete trip timing leads to buffer_memory until a later turn provides the date. In a third, ambiguous social pleasantries are resolved to an already recorded recommendation, after which ignore_memory prevents duplicate, low-value writes. These examples establish that MemReader is not merely extracting content from the current turn; it is adjudicating the memory state transition.

4. Training pipeline, rewards, and GRPO optimization

MemReader-4B is trained with supervised fine-tuning followed by Group Relative Policy Optimization. The supervised warm start teaches ReAct-format trajectories, including > traces, tool calls, and structured arguments, using the objective

$s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$4

This stage establishes protocol compliance and the semantics of the four memory operations (Kang et al., 9 Apr 2026).

The reward for GRPO training is multi-level and shaped across four components: format reward, action-align reward, LLM-judge reward, and efficiency reward. Format reward enforces strict protocol compliance, including valid tags, structurally complete tool blocks, and parseable tool arguments. Action-align reward provides hierarchical credit assignment over turn-level alignment, final-decision correctness, and action-distribution consistency, with incorrect terminal add_memory receiving the strongest penalty to discourage memory pollution. LLM-judge reward scores correctness, completeness, and hallucination avoidance for add_memory payloads. Efficiency reward penalizes overly long outputs, especially excessively long <think> traces.

GRPO is used instead of a separate critic-based PPO variant. For a group of sampled trajectories, rewards are normalized into a group-relative advantage, and the model is optimized with a clipped PPO-style objective plus KL regularization against a reference policy. The paper reports that a DPO alignment attempt was unstable: loss decreased, but rewards for both chosen and rejected outputs also fell, the rejected reward dropped below $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$5, and gradients vanished. The stated explanation is that memory extraction outputs under the same state often differ subtly in completeness, hallucination, and compression, making pairwise preference learning fragile. GRPO, by ranking multiple sampled trajectories per state, provided more informative and stable signals (Kang et al., 9 Apr 2026).

The training data are correspondingly structured around decision paths rather than isolated outputs. Teacher trajectories generated by Gemini-3-Flash-Preview use real retrieval via Milvus and cover direct add_memory, search_memory \rightarrow add_memory, buffer_memory, and ignore_memory. The final datasets contain 7k SFT samples and 3k GRPO samples, unified in ShareGPT format with chained multi-turn composition and max_chain_len=10. Stage-1 SFT uses LlamaFactory with learning rate $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$6, cosine decay, 3 epochs, cutoff_len=4096, and DeepSpeed ZeRO-3 on $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$7 A800 80GB GPUs. Stage-3 GRPO uses verl with train_batch_size=8, rollout.n=8, learning rate $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$8, temperature $s_t = (x_t, \mathcal{M}_{t-1}, \mathcal{B}_{t-1}),$9, max_assistant_turns=16, max_user_turns=15, and max_response_length=768.

5. Memory schema, retrieval, and write-time constraints

MemReader’s add_memory tool writes a strict schema: $$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$4 The schema is paired with explicit writing rules. Entries must use third-person perspective, referring to the user as “The user” or by name rather than “I” or “me.” Key, value, tags, and summary must follow the conversation’s language, while memory_type remains in English. Time expressions such as “yesterday” or “next Friday” are normalized to absolute dates using session time, and the system is instructed to distinguish event time from message time, include locations, resolve aliases and identities, and explicitly mark uncertainty (Kang et al., 9 Apr 2026).

Retrieval is integral to this schema discipline. Prompts instruct the model to prioritize search_memory when encountering ambiguous information such as “he” or “that thing,” and not to be hasty in calling add_memory when background information is needed. During teacher data generation, retrieval is backed by a real vector database, Milvus, so that search_memory produces realistic observations for subsequent reasoning. The paper’s claim is that retrieval-first disambiguation and buffering reduce speculative writes and support a consistent, updatable memory state.

Cross-turn dependencies are handled through interaction between buffer_memory and later add_memory calls. Buffering stores incomplete but valuable hypotheses until sufficient details arrive. This allows knowledge updating and multi-turn fusion rather than forcing premature memory writes. The paper also states that add_memory writes or updates $x_t$0, so the mechanism is explicitly designed for evolving memory rather than append-only logging.

6. Empirical performance and benchmark profile

On LOCOMO, MemReader-4B-GRPO achieves the best Overall score at $x_t$1, with $x_t$2 Single Hop, $x_t$3 Multi Hop, $x_t$4 Temporal, and $x_t$5 Open Domain; its F1 is $x_t$6 and token consumption is 1950. MemReader-0.6B reaches Overall $x_t$7, with $x_t$8 Single Hop, $x_t$9 Multi Hop, $\mathcal{M}_{t-1}$0 Temporal, $\mathcal{M}_{t-1}$1 Open Domain, F1 $\mathcal{M}_{t-1}$2, and token consumption 1976. The paper identifies MemReader-0.6B as the best Temporal performer and the highest-F1 MemReader variant on this benchmark, while MemReader-4B-SFT records $\mathcal{M}_{t-1}$3 Open Domain and low token consumption of 784, highlighting the effect of GRPO on complex reasoning while maintaining efficiency (Kang et al., 9 Apr 2026).

On LongMemEval, MemReader-4B-GRPO matches the highest Overall score at $\mathcal{M}_{t-1}$4 and leads in Knowledge Update at $\mathcal{M}_{t-1}$5 and Temporal Reasoning at $\mathcal{M}_{t-1}$6, with token consumption 922. MemReader-0.6B attains Overall $\mathcal{M}_{t-1}$7, token consumption 1166, and the best Multi-Session score among MemReader variants at $\mathcal{M}_{t-1}$8. Compared with baselines, MemOS reports Overall $\mathcal{M}_{t-1}$9 and EverMemOS $\mathcal{B}_{t-1}$0, so MemReader-4B-GRPO’s advantages are concentrated on dynamic, time-sensitive dimensions rather than on a blanket improvement over every system on every subtask.

On HaluMem-Medium, the benchmark picture is more differentiated. In Extraction, MemReader-4B-GRPO leads in Recall $\mathcal{B}_{t-1}$1, Weighted Recall $\mathcal{B}_{t-1}$2, T-P $\mathcal{B}_{t-1}$3, and F1 $\mathcal{B}_{t-1}$4, with Accuracy $\mathcal{B}_{t-1}$5 and low FMR $\mathcal{B}_{t-1}$6. MemReader-0.6B leads in Extraction Accuracy at $\mathcal{B}_{t-1}$7. In Updating, MemReader-4B-GRPO achieves the best Correct Rate $\mathcal{B}_{t-1}$8, the lowest Omission $\mathcal{B}_{t-1}$9, and low Hallucination $$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$0. In QA, however, MemReader-0.6B has the lowest QA Omission $$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$1, while MemOS retains the best QA correctness and hallucination rate. This is an important qualification: downstream answering depends on retrieval strategy and response model beyond extraction alone (Kang et al., 9 Apr 2026).

The paper’s interpretation is that explicit decision-making and tool use reduce memory noise, improve updating and temporal reasoning, and lower hallucinations. A plausible implication is that MemReader’s gains derive not only from better structured outputs but from selective non-writing: the capacity to defer or ignore is empirically valuable.

7. Deployment, limitations, and broader uses of the name

MemReader has been integrated into MemOS and is being deployed in real-world applications. Public resources include the MemReader-4B checkpoint, API documentation, and MemReader-0.6B usage endpoints. The recommended operational pattern is explicit: enable thinking mode for MemReader-4B, impose a max_response_length budget, trigger search_memory for pronouns and cross-session links, call add_memory only when content is valuable and complete, buffer incomplete but valuable information only when search cannot resolve it immediately, and enforce validators for JSON validity, parsable tool arguments, field completeness, and date normalization (Kang et al., 9 Apr 2026).

The paper also identifies open limitations. Future work includes extending the tool set to support memory editing, conflict detection, and hierarchical abstraction; evaluating stability and long-term gains in realistic online interactions; and jointly optimizing extraction, organization, and response generation. The training analysis further notes DPO instability and the risk that overlong <think> traces increase hallucinations, indicating unresolved questions in credit assignment and reasoning-length control.

The broader literature shows that “MemReader” is not a single, stable term across domains. In streaming QA, Episodic Memory Reader learns what to remember in a fixed-capacity external memory by reinforcement learning before a future unseen question arrives (Han et al., 2019). In long-term retrieval control for LLM agents, MemR$$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$2 defines a closed-loop memory reader/controller with retrieve, reflect, and answer actions coordinated by a global evidence-gap tracker (Du et al., 23 Dec 2025). In reversible parametric memory, R$$\tau_t = \{(z_t^{(k)}, a_t^{(k)}, o_t^{(k)})\}_{k=1}^{K_t}, \qquad a_t^{(k)} \in \mathcal{A},$$3Mem is explicitly positioned as a memory reader that reconstructs retained context by running a reversible model backward (Wang et al., 21 Feb 2025). This multiplicity of uses suggests that the contemporary MemReader family is best understood not as a generic synonym for “memory reader,” but as a specific proposal for active memory extraction in agent systems.