--- title: 'MemReader: Active Memory Extraction' url: https://www.emergentmind.com/topics/memreader type: topic --- # MemReader: Active Memory Extraction 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" [2604.07877], 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 [1903.06164, 1705.02798]. ## 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 [2604.07877]. 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 [2604.07877]. 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 \[ (\mathcal{M}_t, \mathcal{B}_t) = \mathcal{T}(\mathcal{M}_{t-1}, \mathcal{B}_{t-1}, \tau_t). \] Here, `add_memory` writes or updates structured entries in \(\mathcal{M}\); `buffer_memory` stores incomplete but valuable hypotheses in \(\mathcal{B}\); `search_memory` retrieves supporting evidence; and `ignore_memory` leaves state unchanged. The policy objective is stated as \[ J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}\left[\sum_{t=1}^{T} \gamma^{t-1} R(s_t, \tau_t)\right], \] 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 [2604.07877]. | 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 \[ \mathcal{L}_{\mathrm{SFT}}(\theta) = -\mathbb{E}_{(s,y)\sim\mathcal{D}_{\mathrm{SFT}}}\left[\sum_{\ell=1}^{|y|}\log \pi_\theta(y_\ell \mid s, y_{<\ell})\right]. \] This stage establishes protocol compliance and the semantics of the four memory operations [2604.07877]. 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 `` 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 \(-30\), 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 [2604.07877]. 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 \(1\times 10^{-5}\), cosine decay, 3 epochs, `cutoff_len=4096`, and DeepSpeed ZeRO-3 on \(8 \times\) A800 80GB GPUs. Stage-3 GRPO uses verl with `train_batch_size=8`, `rollout.n=8`, learning rate \(1\times 10^{-6}\), temperature \(0.7\), `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: ```json { "memory list": [ { "key": "", "memory_type": "", "value": "", "tags": [""] } ], "summary": "<120–200 word paragraph in conversation language>" } ``` 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 [2604.07877]. 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 \(\mathcal{M}\), 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 \(81.42\%\), with \(85.37\%\) Single Hop, \(81.44\%\) Multi Hop, \(75.80\%\) Temporal, and \(65.62\%\) Open Domain; its F1 is \(49.45\%\) and token consumption is 1950. MemReader-0.6B reaches Overall \(79.56\%\), with \(84.70\%\) Single Hop, \(76.95\%\) Multi Hop, \(76.22\%\) Temporal, \(53.40\%\) Open Domain, F1 \(52.54\%\), 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 \(62.15\%\) Open Domain and low token consumption of 784, highlighting the effect of GRPO on complex reasoning while maintaining efficiency [2604.07877]. On LongMemEval, MemReader-4B-GRPO matches the highest Overall score at \(83.00\%\) and leads in Knowledge Update at \(91.03\%\) and Temporal Reasoning at \(84.21\%\), with token consumption 922. MemReader-0.6B attains Overall \(80.20\%\), token consumption 1166, and the best Multi-Session score among MemReader variants at \(75.18\%\). Compared with baselines, MemOS reports Overall \(77.80\%\) and EverMemOS \(83.00\%\), 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 \(96.57\%\), Weighted Recall \(97.19\%\), T-P \(99.91\%\), and F1 \(98.21\%\), with Accuracy \(91.98\%\) and low FMR \(19.18\%\). MemReader-0.6B leads in Extraction Accuracy at \(95.66\%\). In Updating, MemReader-4B-GRPO achieves the best Correct Rate \(94.55\%\), the lowest Omission \(5.12\%\), and low Hallucination \(0.32\%\). In QA, however, MemReader-0.6B has the lowest QA Omission \(12.14\%\), 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 [2604.07877]. 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 [2604.07877]. 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 `` 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 [1903.06164]. In long-term retrieval control for LLM agents, MemR\(^3\) defines a closed-loop memory reader/controller with retrieve, reflect, and answer actions coordinated by a global evidence-gap tracker [2512.20237]. In reversible parametric memory, R\(^3\)Mem is explicitly positioned as a memory reader that reconstructs retained context by running a reversible model backward [2502.15957]. 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. Source: https://www.emergentmind.com/topics/memreader