acceptodds
Under review as a conference paper at ICLR 2027

MemPilot: Learning to Organize and Navigate Latent Memory

Abstract

Large language models (LLMs) are increasingly capable of using long and complex histories, but processing the full history for every query remains expensive. Latent memory stores past information in reusable states, but repeatedly updating a single state can make earlier information difficult to recover as history grows. Storing history in multiple states can preserve earlier information, but introduces a new problem of retrieving the states relevant to each query. To this end, we propose MemPilot, a framework for organizing and navigating growing latent memory. First, we store history as independently written and restorable memory states, preventing later writes from modifying earlier ones. Each state is paired with a compact semantic key that supports candidate selection and briefly describes its content. Second, we retrieve evidence sequentially from memory: evidence from each read guides the next state selection, read instruction, and decision to stop. We supervise state readouts with page-local evidence to support navigation and train the access policy through RL post-training, using same-history counterfactual comparisons for more local credit assignment. Together, these components make growing latent memory easier to preserve and navigate adaptively. We evaluate MemPilot on five QA and long-term-memory benchmarks under two distinct latent-memory backends. Across both backends, MemPilot substantially improves over the corresponding native memory baselines. The five-task average improves from 13.51 to 39.99 with Metis and from 15.14 to 33.10 with -Mem.

Primary area:
reinforcement learning
Keywords:
Large Language Models, Long-Term Memory, Latent Memory, Reinforcement Learning, Reinforcement Fine-Tuning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_jf5pOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes MemPilot, a framework for organizing and accessing latent memory through independently restorable states and learned sequential navigation. Each source page is encoded into a separate state and paired with a textual semantic key. A navigation policy selects states and decides when to stop, while acquired evidence guides subsequent read instructions. The authors adapt memory readers using page-local evidence supervision and train navigation with same-history counterfactual continuations. Experiments instantiate the framework with Metis and δ-Mem across five benchmarks, supplemented by controls examining memory organization, navigation, semantic keys, state payloads, and query-time efficiency.

Critical strengths
  1. Independent state organization addresses a practical limitation of cumulative latent memory. Demonstrating the framework with two backends supports its applicability beyond one memory representation.

  2. The experiments include useful controls, particularly matched-storage retention, fixed-route payload interventions, key-only access, and comparisons between static and learned navigation.

  3. Training on HotpotQA and evaluating on four additional benchmarks provides meaningful transfer evidence. The measured query-time advantages on the longest histories are also practically relevant.

Critical weaknesses
  1. The framework combines established ideas: independently stored latent memories, semantic-key retrieval, evidence-conditioned access, and actor–critic training. Related work already includes latent-memory banks with learned access, such as ElasticMem and M+, and iterative retrieval such as IRCoT. The paper explains implementation differences, but does not sufficiently establish a distinctive algorithmic advance. Comparisons against closer learned-memory systems and a textual navigator with the same keys, policy, and read budget would better demonstrate what specifically requires the proposed latent interface.

  2. Semantic keys contain source-derived facts and account for substantial performance. Key-only retrieval reaches 35.50 average score, versus 39.99 for the full system; on HotpotQA, replacing latent payloads with zero states still achieves 60.09 F1 versus 65.77. These controls establish some payload contribution, but leave unclear whether latent storage provides sufficient benefit over compact textual summaries. The raw-source RAG baseline lacks the learned selection and query-conditioned evidence extraction used by MemPilot, so it does not resolve this question.

  3. Counterfactual training improves the five-task average over GRPO by 2.11 points, but the comparison simultaneously introduces a learned critic, alternative continuations, and a paired difference loss. Without a standard PPO/critic baseline and separate ablations of these additions, the gain cannot be attributed specifically to counterfactual credit assignment. Multiple training seeds and confidence intervals are also needed, especially since HotpotQA and 2Wiki each use only 200 evaluation questions.

  4. The efficiency advantage depends strongly on workload. Table 13 shows lower query latency on BEAM and LongMemEval-S, but higher latency on the other three benchmarks, while excluding offline state construction and key generation. Each Metis page additionally requires approximately 16.8 MB uncompressed or 2.1 MB at rank 64. Reporting construction costs, total persistent storage, and the query volume needed to amortize preprocessing would clarify when the added system complexity is worthwhile.

Questions for authors

How much does candidate coverage limit performance on long histories, and does learned sequential navigation retain its advantage over a matched textual navigator?

11 comments
AuthorsOpenReview ↗

Response 1/7 to Reviewer jf5p

We thank the reviewer for the insightful and useful feedback. These comments have helped us improve the manuscript. We have addressed each weakness and question below and revised the main paper and appendix accordingly, with all changes marked in red.

R1. Contributions and related work

W1: Contributions and related work.

R1: MemPilot addresses how to preserve earlier latent information and obtain sufficient evidence from stored states as history grows. Below we explain why this problem matters, what prior methods leave unresolved, and the evidence for our contribution.

Why latent memory?

Latent memory stores history in learned internal states that LLMs can use, allowing the memory to be optimized for later tasks. Prior studies [10,11] show that these states can be trained to retain useful information, helping models answer questions and generate text from past information at a much lower inference cost. Motivated by these findings, we focus on two challenges in latent memory: cumulative updates can interfere with earlier information, and relevant evidence can be spread across multiple stored states. MemPilot preserves states independently and uses the evidence read from each selected state to decide what to read next and when enough information has been gathered to answer the question. Compared with full-context answering, peak GPU memory decreases from 37.94 to 9.57 GiB on BEAM and from 35.75 to 9.63 GiB on LME (paper Table 13).

A relevant state may provide only part of the answer. The access policy must use that partial evidence to decide what to read next and whether further reading is needed before answering.

What MemPilot adds to latent memory

M+ [3] retrieves and injects tokens from MemoryLLM’s layer-wise pools. MemDefrag [8] traces and reorganizes memory fragments through middle-layer attention. These methods organize access around their internal representations. MemPilot organizes access to independently saved states through the backend’s save, restore, and read operations. This lets the same organization and access design work with different state representations, as demonstrated with Metis [1] and δ-Mem [2]. Each backend still uses its own trained components.

ElasticMem [4] selects memories and latent capacity before generation. MemPilot makes further access decisions after reading evidence from a selected state: it can choose another state, revise the next read instruction, or stop. IRCoT [5] and Search-R1 [9] already use intermediate results for iterative text retrieval. MemPilot applies evidence-driven access to separately preserved neural states, where the system must restore a state and read out useful evidence before choosing its next action. Table R3.1 summarizes these differences.

Contribution and current evidence

CSUPO supervises return differences between legal access actions from the same observed history, including different READ choices and READ versus STOP. Comparing actions at the same starting history trains the action-value critic to estimate which next choice has greater expected return. This gives the navigator feedback on both where to read and whether another read is worthwhile, beyond the final score of a completed answer.

With adaptation and access components matched, independent-state organization improves the five-task average over cumulative memory by 5.29 points (paper Appendix C.5). Across three seeds, CSUPO improves the five-task mean over PPO + GAE by 1.95 points and over Without Pair by 1.57 points, with a higher macro-average in each seed (Table R3.3(b-1)). R2 details key-free organization controls and fixed-route state interventions. R3 details ablations of the training components, results across three seeds, and reading behavior.

Table R3.1. Related-work focus and specific distinctions of MemPilot.

MethodExisting focusSpecific distinction of MemPilot
Native cumulative backendRepeatedly update one history statePreserve separate states; gather cross-state evidence at query time
M+ [3] / MemDefrag [8]Retrieve or reorganize internal memory representationsOrganize evidence access through backend state-saving, restoration, and reading interfaces
ElasticMem [4]Retrieval and latent-capacity allocation before generationAdjust state selection, read instructions, and stopping after actual readouts
IRCoT [5] / Search-R1 [9]Guide text retrieval using intermediate findingsRestore neural states and read partial page-supported evidence for subsequent access
MemPilotIndependent-state preservation, page-local evidence, and learned accessCSUPO supervises return differences between access actions from the same history

Related Revised Sections: §§1–3, 5; Appendices C.7, C.11.

AuthorsOpenReview ↗

Response 2/7 to Reviewer jf5p

R2. Keys, states, and raw-text access

W2 & W1: Keys, states, and raw-text access.

R2: The controls show that correct states contribute useful information beyond answer-side keys. Direct text reading provides a stronger quality reference in the current comparison. We first examine keys and state payloads, then give the text-reading configurations and results. The motivation for latent memory is addressed in R1.

The role of keys and key-free organization controls

Table R3.2(a) passes up to 16 BM25-retrieved keys directly to the answerer, without state restoration or sequential READ/STOP. The full system is higher on four tasks. Key-only is higher on LoCoMo. Keys describe pages at write time and can contain answer facts, while readouts respond to the current question. The next control removes semantic keys to test organization directly.

Storage-constrained Grouped remains higher than Cum. on all five tasks without semantic keys (Table R3.2(b)). Both retrieve top-16 candidates using source-page embeddings, share the adapted reader, trained answerer, and navigator, and allow eight accesses. Navigation, read instructions, and answering receive only neutral IDs and actual readouts. Cum. repeatedly reads one state for the full history. Grouped uses at most eight chronological groups and rank-63 compression, with state-plus-mapping storage no larger than Cum.

State contribution under fixed trajectories

Table R3.2(c) keeps questions, page order, read instructions, each variant’s readouts, and the answerer fixed, replacing semantic keys only in the final answer input with neutral IDs. Correct independent states lead on all three tasks, exceeding zero states by 5.04/5.55/8.20 points on LoCoMo/BEAM/LME. Useful state information remains beyond answer-side keys.

Text-reading controls: configuration and results

For the motivation for latent memory and its relation to text, see R1 above. Here, Table R3.2(d) addresses source-text replacement and text-navigation retraining.

Table R3.2(d) shares keys, navigator weights, answerer, and B=8 in original policy + text, substituting source pages and expanding the window from 4K to 32K. Text retraining matches initialization, data, four main trajectories plus one critic-only branch per question, and 900 actor updates. Frozen Qwen3-4B extracts up to 256 evidence tokens/page. RL and access budgets match. Total compute differs.

Retrained text navigation leads on all five tasks. Against original policy + text, it improves 2Wiki/LoCoMo, ties LME, and lowers HotpotQA/BEAM. Text preserves factual detail that latent encoding or readout may lose. Matched latent controls establish organization and access gains; text controls show the current quality tradeoff.

Table R3.2(a). MemPilot versus Key-only.

DatasetMetis + MemPilotKey-only
HotpotQA65.7759.62
2Wiki57.8945.31
LoCoMo26.3227.99
BEAM-128K23.1621.40
LongMemEval-S26.8023.20

Table R3.2(b). Key-free organization under a storage cap.

2,840 questions and 5,680 answers. BEAM/LME use Flash evaluation. Some cumulative answers reuse same-configuration outputs.

DatasetCum.Grouped
HotpotQA25.7745.19
2Wiki33.4738.84
LoCoMo8.7210.26
BEAM-128K14.1717.53
LongMemEval-S8.2011.00

Table R3.2(c). Fixed routes/readouts with final-answer keys removed.

DatasetInd.Cum.ZeroForeign
LoCoMo18.8510.3813.819.40
BEAM-128K16.628.5811.079.89
LongMemEval-S19.0011.4010.809.00

Ind.: independent states. Cum.: cumulative. Zero: zero states. Foreign: another history. LoCoMo/BEAM/LME: 1,540/400/500 questions.

Table R3.2(d). Latent reading and the two text controls.

DatasetMemPilotOriginal policy + text readingRetrained text navigator
HotpotQA65.7766.6766.18
2Wiki57.8956.2159.51
LoCoMo26.3241.5943.37
BEAM-128K23.1625.6823.21
LongMemEval-S26.8036.0036.00

The MemPilot column uses the original paper’s Table 2 results. The text variants are additional experiments.

Related Revised Sections: §4.5; Appendices C.3, C.5–C.7 (Tables 15–16, 19).

AuthorsOpenReview ↗

Response 3/7 to Reviewer jf5p

R3. Training components, seeds, and behavior

W3: Training components, seeds, and behavior.

R3: The ablations distinguish the benefit of the paired loss from the overall comparison with PPO. We report those controls first, then the means and sample standard deviations across three training seeds, and finally evidence-gathering behavior from one seed.

Training design and component ablations

Table R3.3(a) compares seed-42 CSUPO with PPO + GAE and two ablations. Without Pair retains alternative branches but removes pairwise return-difference loss. Main-only removes both and trains its critic on main trajectories. PPO uses a standard state-value critic. Alternative branching changes rollout volume.

CSUPO averages 39.99: +1.50 over PPO and +1.07 over Without Pair. Differences precede mean rounding. It exceeds Main-only on all tasks and PPO on all four transfer tasks. PPO leads on HotpotQA. Without Pair retains alternative branches, testing the added return-difference loss.

At seed 42, removing Pair lowers 2Wiki/BEAM by 4.54/2.82, with slight gains elsewhere. CSUPO selects a higher proportion of evidence pages with fewer reads than PPO and both ablations. Per-question proportions are averaged over 200/200/1,527/470 questions (HotpotQA/2Wiki/LoCoMo/LME). LME labels identify supporting sessions. This single-seed diagnostic measures selected-page relevance, not complete coverage, which is not uniformly highest. Three-seed answer scores assess overall quality.

Table R3.3(a). Training methods and ablations (seed 42). The last four rows report evidence-page proportion (%) / mean reads.

DatasetCSUPOw/o PairMain-onlyPPO + GAE
HotpotQA65.7766.2765.3166.89
2Wiki57.8953.3554.4254.39
LoCoMo26.3227.4125.0024.96
BEAM-128K23.1620.3420.0720.78
LongMemEval-S26.8027.2026.0025.40
Five-task average39.9938.9138.1638.48
HotpotQA (hit % / mean reads)83.83 / 1.7579.41 / 2.3877.48 / 2.3175.21 / 2.08
2Wiki (hit % / mean reads)84.65 / 2.3377.12 / 3.2975.98 / 2.8878.31 / 2.54
LoCoMo (hit % / mean reads)43.08 / 1.9940.29 / 2.8235.16 / 2.7135.55 / 2.37
LME-S (hit % / mean reads)80.45 / 1.8675.62 / 2.6474.50 / 2.4076.95 / 2.24

Related Revised Sections: §4.6 (Table 3); Appendices B.5, C.9 (Tables 23–25; Figures 9–10).

Reviewer_7wENOpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes MemPilot, a layer on top of an existing latent-memory backend (Metis-4B or δ\delta-Mem). The history is split into pages (paragraphs for HotpotQA and 2Wiki, blocks of at most 512 tokens for the long histories), and each page is written from a reset state into its own memory state. A frozen Qwen3-4B writes a text key of up to 40 words for each page from its full content. At query time, BM25 over the keys picks N=16N=16 candidates, and a Qwen3-4B navigator reads up to B=8B=8 states one at a time and decides when to stop. The first read uses the question; later reads use an instruction that a frozen generator writes from the question, the selected key and the earlier readouts. A fine-tuned Qwen3-4B answerer gets the selected keys and readouts. Training first supervises the backend reader with page-local evidence, then trains the navigator with PPO, using a baseline from a critic fitted on the returns of rollouts that branch from the same history.

Everything is trained on HotpotQA and evaluated on HotpotQA, 2Wiki, LoCoMo, BEAM-128K and LongMemEval-S. The five-task average goes from 13.51 to 39.99 over the native cumulative Metis interface and from 15.14 to 33.10 over δ\delta-Mem. Further experiments compare independent and cumulative states, static BM25 access, keys and readouts, RAG top-2 and full context, and the counterfactual training against GRPO and GiGPO.

Critical strengths
  1. The interface is clean. MemPilot treats the backend state as opaque and needs only write, restore and read, and the same pipeline improves both Metis and δ\delta-Mem on all five tasks. The problem is also stated well: one cumulative state suffers from interference, and separate states turn that into an access problem. If the latent payload proved its worth, the access layer could be reused as backends improve, though δ\delta-Mem still needed its own adapter and policy.

  2. The saved-route interventions are well designed and reported honestly. Replaying fixed routes while removing keys or readouts from the answer context (Table 2a), swapping in a zeroed or foreign state (Table 12), and the policy-first controls (Table 10) separate what the route contributes from what the payload contributes. They let a reader judge the latent memory directly, and my main concern below comes from them.

  3. The system is trained only on HotpotQA and still improves on four other benchmarks, including long conversational histories, with no target-domain training. Counterfactual training beats GRPO on all four transfer sets with the same five rollouts per source. Reproducibility is good: prompts, seeds and hyperparameters are given, along with a compression trade-off (rank 64 cuts storage 7.9x for a 0.63-point drop) and query time with peak memory. I recomputed the averages in Tables 1, 2, 3 and 9 and they are consistent.

Critical weaknesses
  1. The gains come mostly from the text keys, and Table 1 does not isolate the latent memory. With keys only and no state read at all, the average is 35.50 (Table 2a), which is 22.0 of the 26.5-point gain over cumulative Metis. On LoCoMo, keys only (27.99) and dropping readouts from the answer context (28.07) both score above the full system (26.32). Under fixed routes a zeroed state still reaches 60.09 F1 on HotpotQA against 65.77 (Table 12), so on the training domain the latent payload is worth about 5.7 F1. The keys are LLM summaries of each full page listing its entities, relations, dates and events, so they are a textual memory. The answerer never sees a source passage, yet most of what it uses reaches it as text through the keys.

The cumulative baseline in Table 1 is a floor. It has no retrieval and no keys, and it stores one 16.8 MB state for the whole history, where MemPilot stores one per page (a median of 247 pages, about 4 GB uncompressed, for a LongMemEval-S history). It also does not get the page-evidence adaptation. Appendix C.1 shows that this adaptation alone moves 2Wiki from 23.63 to 30.24 and LoCoMo from 8.76 to 14.18 under the cumulative interface, and Fig. 3a shows the cumulative state falling to about 2 F1 after 16 HotpotQA bundles. The baseline's answerer is not specified either. The paper never runs the control that would show whether latent states are worth having: the same navigator and answerer reading the raw page text instead of the state.

  1. The textual baselines are too weak or underspecified to support the claim that latent memory is competitive with textual access. The paper runs RAG only at top-2, while MemPilot sees 16 keys and can read 8 states, and RAG top-2 still beats MemPilot on LongMemEval-S (33.20 vs 26.80). It also feeds the raw pages to the answerer that was fine-tuned on 6,472 MemPilot routes of keys and readouts, so the RAG inputs are out of distribution for it. I could not find the full-context baseline described anywhere (context window, truncation, answerer). Its LongMemEval-S score of 16.20 is half that of RAG top-2 with the same answerer, which points to a configuration problem. There is no iterative text retrieval baseline, although IRCoT is cited and RL-trained search agents such as Search-R1 are the obvious comparison for the navigator. No textual memory system is compared either, and SHINE sees only the last 40K tokens, 34 to 36% of the history.

The cost argument is also selective. MemPilot is about 26x slower than full context on HotpotQA (6.19 vs 0.24 s) and 2.4x slower on LoCoMo (Table 13). The 3.6 to 3.7x speedup on BEAM and LongMemEval-S leaves out writing every page into a state and generating its key with an LLM. On HotpotQA, 2Wiki and LongMemEval-S each history has exactly one question (Table 4), so that offline cost is never amortized. One uncompressed state is about 8,000 times the size of the raw text of a 512-token page.

  1. The analyses of organization and navigation do not test growing memory, and Fig. 3b is confounded. The controlled analyses (Fig. 3b, Fig. 4a, Tables 10 and 12) all use Hotpot200, the training domain, where each history has at most 10 pages and all keys are visible with N=16N=16. The retention curve in Fig. 3a uses oracle access on 32 blocks built from HotpotQA training sources, which removes the very retrieval problem that the paper says independent states create. On the same saved routes, the cumulative payload gives 57.63 F1, lower than a zeroed state (60.09) or a state from another history (61.25). A reader trained on single pages seems to produce misleading readouts from the cumulative state, so Fig. 3b does not measure how much each organization retains. The static baseline in Fig. 4a is BM25 over 40-word keys, which is weak (one read gives 40.33 F1, against 61.33 for the policy's first pick), and no dense or reranker baseline over the keys is run.
Questions for authors
  1. Please run the same navigator and answerer with the raw page text in place of the latent readout, and with keys only, and report Tables 1 and 2 for both.

  2. Which answerer does the cumulative baseline use? Please rerun it with the same page-evidence adaptation, answerer and keys as MemPilot, and add a storage-matched variant that groups pages into a fixed number of states, as in Fig. 3a, evaluated end to end.

  3. Please report RAG at top-2, 4, 8 and 16 with an answerer trained in the same way on raw-page routes, and an iterative text retrieval baseline with the same RL budget. For the full-context baseline, what context window, truncation and answerer were used, and why does it score 16.20 on LongMemEval-S when RAG top-2 with the same answerer scores 33.20?

  4. For each benchmark, what is the offline cost of building the memory (state writes plus key generation), the storage per history, and the total cost per question including construction? This matters most for HotpotQA, 2Wiki and LongMemEval-S, where each history serves one question.

  5. Please repeat Fig. 3b and Tables 10 and 12 on LoCoMo, BEAM and LongMemEval-S, run Fig. 3a with learned access instead of oracle access, and add dense or reranker static baselines over the keys. Why does the cumulative payload score below a zeroed state on the same routes?

8 comments
AuthorsOpenReview ↗

Response 1/5 to Reviewer 7wEN

We thank the reviewer for the insightful and useful feedback. These comments have helped us improve the manuscript. We have addressed each weakness and question below and revised the main paper and appendix accordingly, with all changes marked in red.

R1. Keys, states, and raw-text access

W1 & Q1: Keys, states, and raw-text access.

R1: Both keys and state readouts supply useful facts. Key-only, controls without semantic keys, and fixed-route state swaps test their contributions. Text-reading controls compare the current quality of latent and source-text access.

The role of keys and key-free organization controls

Table R2.1(a) sends up to 16 BM25-retrieved keys directly to the answerer, without states or READ/STOP. The full system leads on four tasks; Key-only leads on LoCoMo. Keys can contain answer facts. Readouts respond to the current question. We therefore also test organization without semantic keys.

Storage-constrained Grouped remains higher than Cum. on all five tasks without semantic keys (Table R2.1(b)). Both retrieve top-16 candidates using source-page embeddings, share the adapted reader, trained answerer, and navigator, and allow eight accesses. Navigation, read instructions, and answering receive only neutral IDs and actual readouts. Cum. repeatedly reads one state for the full history. Grouped uses at most eight chronological groups and rank-63 compression, with state-plus-mapping storage no larger than Cum.

State contribution under fixed trajectories

With page order and read instructions fixed and semantic keys removed only from the final answering input, correct independent states outperform cumulative, zero, and foreign-history states on all three long-history tasks. For scores and intervention details, see R5, Table R2.5(a-2).

Why study latent memory, and how it relates to text

Latent memory stores history in learned internal states that LLMs can use, allowing the memory to be optimized for later tasks. Prior studies [10,11] show that these states can be trained to retain useful information, helping models answer questions and generate text from past information at a much lower inference cost. Motivated by these findings, we focus on two challenges in latent memory: cumulative updates can interfere with earlier information, and relevant evidence can be spread across multiple stored states. MemPilot preserves states independently and uses the evidence read from each selected state to decide what to read next and when enough information has been gathered to answer the question. Compared with full-context answering, peak GPU memory decreases from 37.94 to 9.57 GiB on BEAM and from 35.75 to 9.63 GiB on LME (paper Table 13).

Table R2.1(c) shares keys, navigator weights, answerer, and B=8 in original policy + text, substituting source pages and expanding the window from 4K to 32K. Text retraining matches initialization, data, four main trajectories plus one critic-only branch per question, and 900 actor updates. Frozen Qwen3-4B extracts up to 256 evidence tokens/page. RL and access budgets match. Total compute differs.

Retrained text navigation leads on all five tasks. Against original policy + text, it improves 2Wiki/LoCoMo, ties LME, and lowers HotpotQA/BEAM. Text preserves factual detail that latent encoding or readout may lose. Matched latent controls establish organization and access gains; text controls show the current quality tradeoff.

R2, Table R2.2 reports matched components and storage budgets.

Table R2.1(a). MemPilot versus Key-only.

DatasetMetis + MemPilotKey-only
HotpotQA65.7759.62
2Wiki57.8945.31
LoCoMo26.3227.99
BEAM-128K23.1621.40
LongMemEval-S26.8023.20

Table R2.1(b). Key-free organization under a storage cap.

2,840 questions and 5,680 answers. BEAM/LME use Flash evaluation. Some cumulative answers reuse same-configuration outputs.

DatasetCum.Grouped
HotpotQA25.7745.19
2Wiki33.4738.84
LoCoMo8.7210.26
BEAM-128K14.1717.53
LongMemEval-S8.2011.00

Table R2.1(c). Latent reading and the two text controls.

DatasetMemPilotOriginal policy + text readingRetrained text navigator
HotpotQA65.7766.6766.18
2Wiki57.8956.2159.51
LoCoMo26.3241.5943.37
BEAM-128K23.1625.6823.21
LongMemEval-S26.8036.0036.00

The MemPilot column uses the original paper’s Table 2 results. The text variants are additional experiments.

Related Revised Sections: §4.5; Appendices C.5–C.7 (Tables 15–16, 19).

AuthorsOpenReview ↗

Response 2/5 to Reviewer 7wEN

R2. Matched components and storage

W1 & Q2: Matched components and storage.

R2: Independent states retain an advantage after matching supervised adaptation, the answerer, keys, and navigation. Grouping also improves the average score when total storage is capped at the cumulative baseline’s budget. Below we specify the original answerer and these two controls.

Training and Access Configuration of the Cumulative-Memory Baseline

Native cumulative Metis [1] answers with public Metis-4B; δ-Mem [2] uses public Qwen3-4B with its adapter. Neither uses our trained answerer or semantic keys. Cum.+SFT shares our evidence adaptation and answerer but reads once. Cum.+Nav also shares keys and navigator weights. Every candidate maps to the cumulative state, and access follows its actual readouts.

Independent states exceed Cum.+Nav on all five tasks, raising the average from 34.70 to 39.99 (+5.29) after matching adaptation, answerer, keys, and navigation (Table R2.2). Adaptation and navigation also strengthen the cumulative baseline (paper Appendix C.5, Table 14). The remaining gain is then examined under a storage cap.

Storage Budget and Organization Granularity

Grouped partitions each history into at most eight chronological groups and compresses states so that states, keys, and access metadata occupy no more storage than Cum. Under this cap and shared components, the five-task average rises from 34.70 to 37.64 (+2.93). Four tasks improve. BEAM decreases by 0.08 points. For organization controls without semantic keys, see R1, Table R2.1(b).

Full independent states restore individual pages and score higher than both Cum. and Grouped on all five tasks. They also use more persistent storage (Table R2.4(b)). Grouped tests whether organization helps at a fixed storage budget. Full independent states show the additional quality obtained with finer pages and more storage. These comparisons answer different parts of the capacity question.

Table R2.2. Matched cumulative, grouped, and independent states.

The full independent states column retains the submitted version scores. Cum. and Grouped are additional results.

DatasetCum.GroupedMetis + MemPilot
HotpotQA58.5963.0765.77
2Wiki46.2055.1257.89
LoCoMo23.7324.2826.32
BEAM-128K21.5921.5123.16
LongMemEval-S23.4024.2026.80

Related Revised Sections: §4.3; Appendices A.3, C.5 (Tables 14–15).

R3. Text baselines and context length

W2 & Q3: Text baselines and context length.

R3: We add RAG top-2/4/8/16, a raw-page-trained answerer, retrained text navigation, and full-context and SHINE coverage checks. These address the requested retrieval, training, and input settings. IRCoT [8] and Search-R1 [9] establish iterative text retrieval. R1 reports our text navigator with matched RL budgets.

RAG Retrieval Depth and Answerer Adaptation

Table R2.3(a) retrieves source pages from the full history using Qwen3-Embedding-4B [3]. Raw-SFT uses the same 6,472 training trajectories and 809 updates as answerer training, retaining evidence pages and targets while adding same-history distractors. Both answerers receive identical rankings and pages at evaluation.

Increasing retrieval depth improves the original answerer on all five tasks. Top-16 exceeds current MemPilot on all five. Raw-SFT further improves top-16 on HotpotQA and LoCoMo, while lowering 2Wiki and BEAM. These results distinguish retrieval depth from answerer adaptation.

Retraining the Text Navigator

For the matched text-navigation configuration and retraining results, see R1, Table R2.1(c).

Table R2.3(a). RAG depth and answerer adaptation.

DatasetAnswerertop-2top-4top-8top-16
HotpotQAOriginal52.7761.2365.6869.00
HotpotQARaw-SFT56.3963.3967.5173.02
2WikiOriginal55.3863.7965.9065.67
2WikiRaw-SFT54.8555.3458.3361.05
LoCoMoOriginal25.5131.7937.8343.04
LoCoMoRaw-SFT26.2432.1638.4744.01
BEAM-128KOriginal21.2423.8925.1228.03
BEAM-128KRaw-SFT19.4723.6722.8424.06
LongMemEval-SOriginal33.2038.8042.6043.60
LongMemEval-SRaw-SFT35.2040.2043.0043.40

Related Revised Sections: §§4.5, 5; Appendices A.3, C.7 (Tables 18–20; Figure 6).

AuthorsOpenReview ↗

Response 3/5 to Reviewer 7wEN

R3 (continued)

Full-Context Configuration and Length Diagnostics

The trained full-context answerer allows 262,144 tokens. None of 2,840 executions overflows. The length diagnostic retains complete supporting evidence for the same 116 questions, placing it at the beginning, middle, and end of roughly 8K/32K/100K inputs: 348 answers per length.

Accuracy falls from 84.48% to 72.99% and 43.68% as input length grows, with supporting evidence retained at every tested position and length. This supports difficulty using long inputs as one contributor to the full-context result. Retrieval can shorten the input while retaining useful evidence.

SHINE Input Coverage and Implications of the Controls

SHINE [4] with YaRN [5] and full-history input scores below native 40K on all three tasks (Table R2.3(b)). Simply adding the omitted history does not resolve its performance gap in this control.

Our positioning relative to text methods is discussed in R1, matched organization controls in R2, and time, GPU memory, and persistent storage in R4.

Additional diagnostic: Input length and position-averaged answering performance when retaining supporting evidence.

Input lengthDistinct questionsCorrect answers / position testsPosition-averaged score (%)
~8K116294 / 34884.48
~32K116254 / 34872.99
~100K116152 / 34843.68

Table R2.3(b). SHINE context-extension controls.

DatasetNative 40KYaRN 40KYaRN Full History
LoCoMo17.6717.2017.20
BEAM-128K10.8110.119.93
LongMemEval-S12.2012.4010.80

Related Revised Sections: §§4.5, 5; Appendices A.3, C.7 (Tables 18–20; Figure 6).

R4. Construction, storage, and amortization

W1 & W2 & Q4: Construction, storage, and amortization.

R4: The cost advantage depends on the workload. Including construction, the reference total is lower than full context on BEAM but higher on the other tasks. We report state construction, key generation, online time, and persistent storage below, and distinguish time savings from answering GPU memory savings.

Construction Cost and Reference Per-Question Time

Table R2.4(a–b) includes state/key construction, online answering, persistent storage, and peak GPU memory. Metis construction includes states and keys. DeltaMem rows measure states only. Totals are reference sums of component timings measured on different servers.

Multi-query reuse amortizes construction time, while GPU memory savings hold per query. BEAM’s 20 questions/history yield 12.989 s vs. 38.546 s for full context. Unamortized single-question LME takes 35.741 s vs. 34.629 s.

State construction accounts for 51.8%–77.6% of offline time, and restoration/readout for 77.4%–86.5% of online time. These stages dominate the measured latency.

Table R2.4(a). Construction and per-question reference costs.

MethodMetricHotpotQA2WikiLoCoMoBEAM-128KLongMemEval-S
—Avg. questions / history11154201
Metis + MemPilotState construction (s / history)0.8500.9533.97532.23520.207
Key generation (s / history)0.2450.2953.69311.1056.249
Amortized construction (s / question)1.0951.2480.0502.16726.456
State restoration & readout (s / question)5.3106.4224.7238.5328.035
Sub-question generation (s / question)0.4720.7120.7491.2640.633
Answer generation (s / question)0.1740.1940.2030.6080.164
Retrieval, navigation & others (s / question)0.2350.2720.4280.4170.453
Online subtotal (s / question)6.1927.6006.10310.8229.285
Construction + online reference total (s / question)7.2878.8486.15312.98935.741
DeltaMem + MemPilotState construction (s / history)0.2350.1692.63414.58215.235
Amortized state construction (s / question)0.2350.1690.0170.72915.235
Full contextTotal (s / question)0.2400.2592.54338.54634.629

Related Revised Sections: §4.5; Appendix C.10 (Tables 26–27).

Reviewer_g38COpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

MemPilot addresses a key trade-off in latent memory for LLMs. Continually updating a single memory state can make older information harder to recover, while storing many separate states creates a retrieval problem. MemPilot stores each page as an independent latent state paired with a short semantic key. At query time, a learned policy navigates these states sequentially, using information from each read to choose the next state, formulate the next read instruction, and decide when to stop.

The system trains state readouts using page-level evidence supervision and trains the navigation policy with reinforcement learning augmented by counterfactual comparisons for finer-grained credit assignment. Across five QA and long-memory benchmarks and two memory backends, MemPilot improves the five-task average from 13.51 to 39.99 with Metis and from 15.14 to 33.10 with δ-Mem.

Critical strengths
  • Well-motivated problem and broadly applicable design. The paper clearly identifies the interference-versus-retrieval trade-off in latent memory and demonstrates consistent gains across two substantially different memory backends.

  • The development of the core navigation machinery (evidence-conditioned sequential and its counterfactual training) in Sections 3.2 and 3.3 is both intuitively and rigorously presented.

  • Strong evidence for the value of independent memory states. The fixed-route intervention in Figure 3(b) isolates memory organization from navigation, showing a drop from 65.77 to 57.63 F1 when independent states are replaced with cumulative-state payloads.

Critical weaknesses
  • Storage and preprocessing costs receive limited attention. Query-time comparisons exclude offline memory construction, and the paper does not quantify the total storage required for maintaining an independent state for every page.

  • The main baseline is relatively weak: the paper compares only against the original cumulative-memory interface.

  • The contribution of the learned RL component appears modest. Much of the gain is achieved through independent memory organization and retrieval. Counterfactual training improves the average score by only 2.11 points over GRPO, and results are reported for a single seed (minor).

Questions for authors
  • How does MemPilot compare against a cumulative-memory baseline that receives the same supervised adaptations (including page-level evidence supervision) and uses the same trained answerer?

  • What are the offline memory-construction time and storage costs per history?

5 comments
AuthorsOpenReview ↗

Response 1/4 to Reviewer g38C

We thank the reviewer for the insightful and useful feedback. These comments have helped us improve the manuscript. We have addressed each weakness and question below and revised the main paper and appendix accordingly, with all changes marked in red.

1. Memory Construction, Storage, and Cost Amortization

W1 & Q2 — Memory Construction, Storage, and Cost Amortization

R1: Tables R1.1(a–b) report state construction, key generation, and online answering latency for Metis [1] + MemPilot, together with per-history persistent storage and peak GPU memory during answering. They also include state construction latency for DeltaMem [2] + MemPilot and the full-context baseline. Construction costs are measured per history and online costs per question. The reference per-question total latency is defined as "online latency + construction latency / questions per history." The DeltaMem rows measure state construction only, and reference totals aggregate component measurements across different servers.

Sharing a history across questions reduces the construction cost per question, but a runtime gain also requires a fast online stage. LoCoMo and BEAM serve 154 and 20 questions per history, respectively. Including construction, BEAM is faster than full context in the reference costs, while LoCoMo remains slower. LME has one question per history and bears the full construction cost, making its reference total slightly higher than full context. HotpotQA and 2Wiki are also slower. Thus, history reuse helps amortize construction but does not by itself make the full pipeline faster.

State construction and readout account for the majority of latency: state construction takes 51.8%–77.6% of offline time, while state restoration and readout take 77.4%–86.5% of online time. DeltaMem shows lower state construction time in the table, where its rows measure state construction only.

On-demand restoration lowers GPU memory demand during long-history answering, independently of cost amortization across queries. Peak GPU memory on BEAM/LME is about 9.6 GiB, roughly three quarters below the 35–38 GiB used by full context. Historical states remain on the host, and only selected states are restored during answering. Persistent storage is a separate cost: training-free rank-64 compression shrinks uncompressed states by about 7.9× with a 0.63 drop in five-task average score, but compressed states still occupy more space than raw text. Storage figures include states, keys, and entry metadata, excluding shared model weights and optional indices. Raw text is measured in UTF-8 bytes. These GPU memory savings are relative to full-context answering. RAG also restricts the text processed online.

Table R1.1(a). History construction, online answering, and per-question reference costs.

MethodMetricHotpotQA2WikiLoCoMoBEAM-128KLongMemEval-S
—Avg. questions / history11154201
Metis + MemPilotState construction (s / history)0.8500.9533.97532.23520.207
Key generation (s / history)0.2450.2953.69311.1056.249
Amortized construction (s / question)1.0951.2480.0502.16726.456
State restoration & readout (s / question)5.3106.4224.7238.5328.035
Sub-question generation (s / question)0.4720.7120.7491.2640.633
Answer generation (s / question)0.1740.1940.2030.6080.164
Retrieval, navigation & others (s / question)0.2350.2720.4280.4170.453
Online subtotal (s / question)6.1927.6006.10310.8229.285
Construction + online reference total (s / question)7.2878.8486.15312.98935.741
DeltaMem + MemPilotState construction (s / history)0.2350.1692.63414.58215.235
Amortized construction (s / question)0.2350.1690.0170.72915.235
Full contextTotal (s / question)0.2400.2592.54338.54634.629

Table R1.1(b). Per-history persistent storage and peak GPU memory during answering.

MethodMetricHotpotQA2WikiLoCoMoBEAM-128KLongMemEval-S
Metis + MemPilotUncompressed history storage (GB / history)0.16550.16801.01626.88914.1503
Peak GPU memory during answering (GiB)9.239.419.759.579.63
Full contextRaw text storage (KB / history)5.493.8592.66541.72504.83
Peak GPU memory during answering (GiB)8.668.6014.3437.9435.75

Related Revised Sections: §4.5; Appendix C.10 (Tables 26–27).

AuthorsOpenReview ↗

Response 2/4 to Reviewer g38C

R2. Cumulative-memory controls

W2 & Q1: Cumulative-memory controls.

R2: Cum.+SFT shares page-local evidence adaptation and the trained answerer but reads the cumulative state once. Cum.+Nav also shares candidate keys and navigator weights. Every candidate maps to the cumulative state, and navigation follows its actual readouts.

Independent states outperform cumulative memory on all five tasks after matching adaptation and access (Table R1.2). These progressive controls separate gains from training and navigation from the additional benefit of independent organization.

The gains from state organization persist when total storage is capped at the cumulative level (paper Appendix C.5): grouped states score higher on four tasks, including 63.07 vs. 58.59 on HotpotQA and 55.12 vs. 46.20 on 2Wiki, while BEAM is close at 21.51 vs. 21.59. Organizational structure thus improves quality within a fixed storage budget. Full independent states add single-page restoration and achieve higher scores on all five tasks, with their storage costs reported in the cost tables.

Table R1.2. Cumulative-memory baseline and progressively enhanced variants on the Metis backend.

MethodHotpotQA2WikiLoCoMoBEAM-128KLongMemEval-S
Cum.12.7823.638.7610.9811.40
Cum.+SFT23.5530.2414.1810.5811.60
Cum.+Nav58.5946.2023.7321.5923.40
Metis + MemPilot65.7757.8926.3223.1626.80

Related Revised Sections: §4.3; Appendices A.3, C.5 (Tables 14–15).

R3. Navigation training and stability

W3: Navigation training and stability.

R3: Navigation training adds gains after the state organization, reader, and answerer are fixed. We first test this added benefit without navigation RL, then examine reading behavior, results across three training seeds, and the training components in Tables R1.3–R1.6.

No navigation RL: gains on the existing state bank

The no-RL control keeps organization, reader, and answerer fixed but omits REINFORCE initialization and later RL. Its HotpotQA score of 62.50 and the REINFORCE-initialized Initial Policy’s 62.15 in original Table 10 thus use different weights.

Navigation RL improves all five tasks, raising the average from 36.57 to 39.99 (Table R1.3). Gains span the training domain and all four transfer tasks under the same memory and answering pipeline.

Reading behavior: follow-up evidence and stopping

Table R1.4 analyzes saved trajectories from the submission’s single training seed without rerunning the models. Questions, BM25 top-16 candidates, and keys were verified to match per question across CSUPO, GRPO [3], and GiGPO [4]. LoCoMo includes 1,527 validly annotated questions evaluated at dialogue-turn level. LME includes 470 questions evaluated at the coarser supporting-session level. Coverage measures whether selected pages contain the annotated evidence.

CSUPO stops after one page less often and gathers more complete evidence. First-page hits are not consistently higher: GiGPO leads slightly on LoCoMo, and all methods are close on LME. CSUPO achieves the highest complete coverage on both tasks, exceeding GRPO by 13.16/13.40 percentage points (unrounded counts). The clearest behavioral gain lies in follow-up evidence gathering.

Higher coverage accompanies more reads and reflects selection and stopping jointly. Final answers also depend on readout and generation. These single-seed behavior statistics are separate from the three-seed answer results below.

Table R1.3. No navigation RL versus the full system.

DatasetWithout navigation RLMetis + MemPilotDifference (full system − without navigation RL)
HotpotQA62.5065.77+3.27
2Wiki53.2057.89+4.69
LoCoMo23.4526.32+2.87
BEAM-128K21.1123.16+2.05
LongMemEval-S22.6026.80+4.20
Five-task average36.5739.99+3.42

Table R1.4. Single-seed evidence coverage and reading behavior.

DatasetNavigatorFirst-page evidence hit rateComplete evidence coverage over the trajectoryMean pages readFraction of questions with one page read
LoCoMoGRPO42.24%34.77%1.1289.00%
LoCoMoGiGPO47.68%37.26%1.00100%
LoCoMoCSUPO47.22%47.94%1.9953.50%
LongMemEval-SGRPO82.55%34.26%1.1784.89%
LongMemEval-SGiGPO82.55%27.87%1.0099.79%
LongMemEval-SCSUPO82.98%47.66%1.8648.51%

Related Revised Sections: §§3.3, 4.6 (Table 3); Appendices B.5, C.9 (Tables 23–25; Figures 9–10).

AuthorsOpenReview ↗

Response 3/4 to Reviewer g38C

R3 (continued)

Three training seeds: mean gains and variability

Table R1.5(a) reports means and sample standard deviations over training seeds 42/43/44. The five-task average is computed within each seed before summarizing the three averages. Table R1.5(b) lists the per-seed scores used in these summaries. The GRPO runs in this three-seed evaluation are separate from the original single-run GRPO result retained in paper Table 3(a). That original result is not included in these statistics. The new component runs extend the seed-42 ablations to seeds 43 and 44.

CSUPO has higher across-seed means on all five tasks than GRPO and GiGPO. Its five-task average is 40.29 ± 0.26, ahead by 1.87 and 3.25 points, with a smaller macro-average sample standard deviation in this evaluation. CSUPO averages 40.29 ± 0.26 across three seeds, ahead of PPO/Without Pair/Main-only by 1.95/1.57/2.03 points. Its macro-average leads each control in every seed, and all five task means are higher. Pair gains are largest on 2Wiki/BEAM/LME. Without Pair exceeds Main-only by 0.46 on average, not in every seed, testing branches plus extra returns. Main-only has the smallest macro-average variability. Sample SDs describe seed variation, not per-task significance or test-sample uncertainty.

Table R1.5(a). Three-seed means ± sample standard deviations.

MethodHotpotQA2WikiLoCoMoBEAM-128KLongMemEval-SFive-task average
CSUPO66.03 ± 0.4657.75 ± 0.3226.26 ± 0.2523.66 ± 0.6527.73 ± 0.8340.29 ± 0.26
GRPO64.98 ± 0.6054.64 ± 1.6625.69 ± 0.7421.98 ± 0.6224.80 ± 0.3538.42 ± 0.31
GiGPO64.67 ± 0.4651.45 ± 0.9824.75 ± 0.3921.06 ± 0.7223.27 ± 1.3037.04 ± 0.47
Without Pair65.92 ± 0.3254.40 ± 1.7725.91 ± 1.5821.55 ± 1.1425.80 ± 1.4038.72 ± 0.75
Main-only critic65.29 ± 0.6353.88 ± 0.7424.75 ± 0.2221.66 ± 1.3925.73 ± 0.2338.26 ± 0.09
PPO + GAE65.08 ± 1.5854.27 ± 0.6426.00 ± 1.1021.13 ± 0.6025.20 ± 0.9238.34 ± 0.28

Table R1.5(b). Per-seed scores underlying the three-seed statistics.

MethodSeedHotpotQA2WikiLoCoMoBEAM-128KLME-SFive-task average
CSUPO4265.7757.8926.3223.1626.8039.99
CSUPO4365.7757.3926.4724.4028.0040.41
CSUPO4466.5657.9825.9923.4328.4040.47
GRPO4264.7755.7125.2822.5624.6038.58
GRPO4365.6552.7325.2522.0724.6038.06
GRPO4464.5155.4726.5421.3225.2038.61
GiGPO4265.1852.5224.8920.2324.6037.48
GiGPO4364.2950.6124.3121.5222.0036.55
GiGPO4464.5551.2225.0621.4423.2037.09
Without Pair4266.2753.3527.4120.3427.2038.91
Without Pair4365.6453.4124.2621.7324.4037.89
Without Pair4465.8656.4526.0622.5925.8039.35
Main-only critic4265.3154.4225.0020.0726.0038.16
Main-only critic4364.6554.1824.5922.6925.6038.34
Main-only critic4465.9153.0424.6622.2125.6038.28
PPO + GAE4266.8954.3924.9620.7825.4038.48
PPO + GAE4363.9753.5727.1521.8326.0038.50
PPO + GAE4464.3854.8425.8820.7924.2038.02

Related Revised Sections: §§3.3, 4.6 (Table 3); Appendices B.5, C.9 (Tables 23–25; Figures 9–10).

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank all reviewers for their careful evaluations and constructive feedback. We have addressed their concerns in the individual responses and revised the main paper and appendix, with changes marked in red. We particularly appreciate their recognition of:

  • The motivation and interface across backends. Reviewers g38C, 7wEN, and jf5p recognized the tension between interference in cumulative states and access to separate states, and the value of implementing the organization and access framework on two backends.
  • Controls that distinguish component contributions. Reviewers g38C, 7wEN, and jf5p valued the fixed-route interventions and related controls for separating state organization, access trajectories, and state information.
  • Transfer evaluation and reproducibility. Reviewers 7wEN and jf5p recognized evaluation on four transfer tasks after training only on HotpotQA; 7wEN also noted the disclosure of prompts, seeds, hyperparameters, and costs.

Preserving information in latent states does not by itself ensure that later questions receive sufficient evidence. MemPilot addresses this gap through independent-state organization and evidence-driven access, preserving earlier information while learning how to gather the evidence needed for answering.

1. Matched baselines, storage budgets, and state contributions

  • Matching adaptation, answerer, keys, and navigation leaves a five-task gain from 34.70 to 39.99. Storage-constrained grouping reaches 37.64, improving four tasks; without semantic keys, grouping improves all five under a storage cap. [Reviewer g38C, R2; Reviewer 7wEN, R1–R2; Reviewer jf5p, R2. Revised: §4.3; Appendix C.5, Tables 14–15.]

  • Long-history interventions separate state information from answer-side keys: after removing those keys, correct independent states outperform cumulative, zero, and foreign-history payloads on all three tasks. Reader controls also examine how cumulative-state scores depend on reader configuration. [Reviewer 7wEN, R1, R5; Reviewer jf5p, R2. Revised: §4.5; Appendix C.6, Tables 16–17.]

2. Method positioning and textual access

  • We clarify the contributions to organization and access training: independent-state preservation, page-local readout, and readout-guided access connect saved history to answering; CSUPO supervises return differences between legal access actions from the same history. Related-work comparisons distinguish internal memory access, retrieval and allocation before generation, and further evidence gathering after actual readouts. [Reviewer jf5p, R1. Revised: §§1–3, 5; Appendices C.7, C.11.]

  • Latent storage and text work together: states preserve history, while keys and readouts provide text. We distinguish full context, RAG, and text navigation, and report that RAG top-16 and retrained text navigation score higher on all five tasks under the evaluated configurations. Matched-backend controls test organization and access gains; cost conclusions remain specific to the measured settings. [Reviewer 7wEN, R1, R3; Reviewer jf5p, R2, R5. Revised: §§4.5, 5; Appendices A.3, C.7, Tables 18–20; Figure 6.]

3. Learned access, training gains, and evidence coverage

  • We add retention diagnostics for learned access as memory grows, alongside stronger-ranker controls. In eight of nine task–ranker combinations, MemPilot exceeds static eight-read access using 1.83–2.68 reads on average. Candidate coverage and omission analyses separate candidate recall from navigation within the pool. [Reviewer 7wEN, R5; Reviewer jf5p, R5. Revised: §§4.3–4.4; Appendices C.5, C.8, Tables 21–22; Figures 5, 7–8.]

  • No-navigation-RL, PPO, and component controls test learned access and its training. Across three seeds, CSUPO exceeds GRPO/GiGPO by 1.87/3.25 points and PPO/Without Pair by 1.95/1.57 points. Single-seed trajectories show fewer one-page stops and higher complete evidence coverage with more follow-up reads. [Reviewer g38C, R3; Reviewer jf5p, R3. Revised: §§3.3, 4.6; Appendices B.5, C.9, Tables 23–25; Figures 9–10.]

4. Complete costs and applicable workloads

  • We report per-history state construction, key generation, and persistent storage, alongside per-question online cost, peak answering GPU memory, and amortization conditions. Peak answering memory on BEAM and LME is about 9.6 GiB, roughly three quarters below full context. Time savings including construction depend on history reuse, with multi-query BEAM and single-query LME reported separately. [Reviewer g38C, R1; Reviewer 7wEN, R4; Reviewer jf5p, R4. Revised: §4.5; Appendix C.10, Tables 26–27.]

Detailed experimental settings, analyses, and revised-section references follow in the individual responses.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.