acceptodds
Under review as a conference paper at ICLR 2027

Understanding and Mitigating Inference-Time Overreliance Using Agentic Memory

Abstract

Agentic memory allows LLM agents to reuse past experience, yet retrieved memories can also distort inference even when they are benign, correctly stored, and appropriately retrieved. We study this failure mode, which we call memory overreliance. Across benchmarks and memory architectures, we find that memory is useful when past experience transfers to the current task, but can become misleading when only part of the evidence transfers. Failures are strongest under partial query-memory overlap, a pattern further confirmed by controlled experiments that vary the amount of overlapping evidence. Motivated by this finding, we propose MemTrim, a plug-and-play framework that indexes memory evidence at write time and controls its reuse at read time. MemTrim removes repeated or conflicting evidence while preserving useful memory-specific information, requires no retraining, and applies to both embedding-based and structured memory systems. Experiments show that MemTrim reduces memory overreliance while preserving the benefits of useful memory across models and memory settings.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Agentic Memory, Memory Overreliance, LLM Agents, Evidence Duplication, Inference-Time Robustness

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_bwd3OpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates the issue of "overreliance" in LLM agents utilizing long-term memory. Even when historical memories are accurate and retrieved appropriately, they can still mislead the model’s reasoning if they are only partially relevant to the current task. Through experimental analysis, the authors identify that a partial overlap of evidence between the query and the retrieved memory is a primary driver of this phenomenon. To address this, the paper introduces the MEMTRIM framework. During the memory-writing phase, it parses historical information into structured "evidence" and organizes it using a Trie index. During the reasoning phase, it identifies and filters out redundant or conflicting evidence, while also determining whether to reuse past answers based on task shifts and answer dependencies. Experiments conducted across various LLM backbones, memory frameworks, and benchmarks demonstrate that this approach effectively mitigates memory overreliance—preserving the performance gains derived from useful memories—while incurring only minimal computational overhead.

Critical strengths

This paper addresses the issue of over-reliance on agent memory during the reasoning process. The research motivation is clear, and the work holds practical application value.

The authors conducted experiments across various LLM backbones, memory frameworks, and benchmarks, while also providing ablation studies and safety evaluations. The results demonstrate that the proposed method effectively mitigates the negative impact of erroneous historical memories while preserving those that are useful.

Critical weaknesses
  1. Insufficient methodological innovation. The proposed MEMTRIM framework primarily functions by parsing historical memories into structured "evidence," then utilizing a Trie index and rule-based matching to filter out redundant, conflicting, or irrelevant information. This approach largely mirrors existing concepts in memory deduplication, conflict resolution, and RAG context filtering; it essentially combines and applies established techniques rather than introducing significant algorithmic innovation. Furthermore, the paper fails to clearly articulate the fundamental distinctions between MEMTRIM and existing memory management methods.

  2. Lack of comprehensive comparison with mainstream memory methods. While the current experiments include frameworks such as Mem0, A-Mem, MemGPT, and Graphiti—alongside various retrieval-filtering and context-compression techniques—they omit systematic comparisons with other representative agent-memory methods, such as MemoryBank, LightMem, MemoryOS, MemP, and LangMem. Additionally, recent approaches that optimize memory based on task feedback (e.g., MemSkill, MemRL) ​​or employ query-aware memory routing (e.g., BudgetMem) warrant inclusion or further discussion. It is recommended that the authors incorporate these baselines using a unified benchmark, backbone model, and experimental setup to more robustly demonstrate the effectiveness and novelty of their approach.

  3. Absence of validation in realistic long-term memory scenarios. The evaluation is primarily based on task pairs derived from RippleEdits, CounterLogic, and CLADDER—datasets that align well with the specific mechanisms MEMTRIM employs for handling evidence conflicts and reusing historical answers. To better assess the framework's generalization capabilities in complex, multi-turn interactions and dynamic memory environments, the authors should conduct further evaluations using more realistic long-term memory benchmarks, such as LoCoMo or MemoryAgentBench.

  4. Heavy reliance on structured information extraction, with inadequate analysis of errors and costs. The effectiveness of MEMTRIM hinges on the parser’s ability to accurately extract "evidence units," "task signatures," and "answer support sets"; however, the paper lacks a systematic assessment of the accuracy of these critical components. Moreover, the authors should provide details regarding the parser’s model configuration, additional computational/API costs, and end-to-end latency. Analyzing how parsing errors impact final performance is also essential to verify the reliability and efficiency of the method for practical deployment.

Questions for authors

Please see above.

9 comments

We thank the reviewer for recognizing the practical motivation of memory overreliance and the effectiveness of MEMTRIM across different models, memory systems, and evaluation settings. We appreciate the opportunity to further clarify our methodological contribution, experimental design, evaluation scope, and implementation details.


Weakness 1: Insufficient Methodological Innovation

Insufficient methodological innovation. The proposed MEMTRIM framework primarily functions by parsing historical memories into structured "evidence," then utilizing a Trie index and rule-based matching to filter out redundant, conflicting, or irrelevant information. This approach largely mirrors existing concepts in memory deduplication, conflict resolution, and RAG context filtering; it essentially combines and applies established techniques rather than introducing significant algorithmic innovation. Furthermore, the paper fails to clearly articulate the fundamental distinctions between MEMTRIM and existing memory management methods.

Thank you for raising this important point and giving us the opportunity to clarify the methodological contribution of MEMTRIM. We would like to emphasize that our main contribution is not trie indexing or evidence deduplication alone, but a support-aware and task-aware mechanism that determines how historical evidence and previous answers should be reused during inference.

First, MEMTRIM addresses a different problem from conventional memory filtering. Existing memory systems primarily focus on storing, organizing, updating, and retrieving historical information. However, retrieving a relevant memory does not necessarily mean that its previous answer remains applicable to the current query. A historical interaction can be entirely correct when stored, yet its conclusion may become inappropriate for a new task even when much of its evidence remains useful. This is the specific failure mode studied in our paper.

Second, MEMTRIM distinguishes historical evidence from the outcome supported by that evidence. As defined in Section 3.1, each memory is represented using evidence units, a task signature, a historical outcome, and an answer-support set. Rather than treating all information in a retrieved memory as equally relevant to its previous answer, MEMTRIM explicitly models which evidence supports that outcome.

This distinction directly affects inference-time decisions. Section 3.3 defines the support-aware condition$D_m(q) \cap H_m \neq \emptyset$. A conflict involving unrelated historical information does not necessarily invalidate the stored answer. In contrast, when the conflict affects the evidence supporting that answer, MEMTRIM suppresses the previous outcome. Therefore, MEMTRIM does more than detect or remove conflicting facts: it considers whether those conflicts actually invalidate the historical conclusion.

Third, MEMTRIM explicitly handles task changes. Even when the historical evidence remains consistent, the current query may ask a different question. In such cases, MEMTRIM can convert an applicable previous outcome into task-labeled contextual evidence instead of presenting it as the answer to the new question. This prevents the model from confusing a previously correct answer with the answer required by the current task.

These components jointly address a problem that cannot be resolved by simple deduplication. The trie provides an efficient structure for indexing and matching evidence, while the main methodological contribution lies in deciding which historical information and outcomes should influence the current inference.

Our empirical results further support the effectiveness of this combined mechanism. Table 2 reports the following results with Qwen3.8-27B and Mem0:

DatasetMem0 TD-DupMEMTRIM TD-DupMem0 TAMEMTRIM TA
RippleEdits62.674.585.388.4
CounterLogic80.087.993.194.6
CLADDER-Derived46.663.579.683.9

All values are accuracy percentages reported in Table 2.

These results show that MEMTRIM substantially improves performance when historical conclusions are no longer transferable, while preserving or improving performance when they remain applicable. Figure 5 provides complementary ablation evidence showing that duplicated evidence, conflicting information, outdated outcomes, and task changes affect memory overreliance in different ways.

We have also clarified the role of answer-support sets and the distinction between evidence-level filtering and outcome-level reuse in Sections 3.1 and 3.3. We further emphasize this contribution in the Method and Related Work discussions to distinguish our proposed inference-time memory-reuse mechanism from conventional memory deduplication and context filtering.

Weakness 2: Lack of Comprehensive Comparison With Mainstream Memory Methods

Lack of comprehensive comparison with mainstream memory methods. While the current experiments include frameworks such as Mem0, A-Mem, MemGPT, and Graphiti—alongside various retrieval-filtering and context-compression techniques—they omit systematic comparisons with other representative agent-memory methods, such as MemoryBank, LightMem, MemoryOS, MemP, and LangMem. Additionally, recent approaches that optimize memory based on task feedback (e.g., MemSkill, MemRL) or employ query-aware memory routing (e.g., BudgetMem) warrant inclusion or further discussion. It is recommended that the authors incorporate these baselines using a unified benchmark, backbone model, and experimental setup to more robustly demonstrate the effectiveness and novelty of their approach.

Thank you for these valuable suggestions and for highlighting additional developments in agent memory. We agree that these methods are relevant to the broader research landscape. However, we would like to clarify an important distinction in our experimental design: we evaluate memory backbones and inference-time mitigation strategies at two different levels, because they serve different purposes.

First, our four memory systems are used as underlying memory backbones. Mem0, A-Mem, MemGPT, and Graphiti employ different approaches to memory storage, representation, organization, and retrieval. MEMTRIM does not aim to replace their memory architectures. Instead, it operates after their original retrieval process and transforms the retrieved evidence before it is provided to the answering model.

Evaluating MEMTRIM across these four systems therefore directly examines whether the same inference-time mechanism can work with different underlying memory architectures. This is important for our plug-and-play objective because MEMTRIM is intended to complement existing memory systems rather than introduce another independent memory architecture.

Second, our nine mitigation baselines directly compare how retrieved memory is used during inference. These baselines cover different strategies, including:

  • Memory selection: Top-1 and MMR.
  • Similarity-based filtering: Similarity Filter.
  • Context compression: RECOMP and LLMLingua-2.
  • Historical-answer removal: Facts-only.
  • Conflict-aware and answer-oriented reasoning: Context-faithful, Answer-first, and Micro-Act.

Within each memory backbone, these methods operate on the same underlying retrieved candidates. This allows us to examine how different inference-time strategies affect the model's predictions without mixing their effects with changes in memory storage or retrieval.

The two levels of comparison therefore address complementary research questions.

The comparison across memory backbones examines whether MEMTRIM can be applied consistently to different memory architectures. The comparison across mitigation strategies examines whether MEMTRIM provides an effective way to process the same retrieved information.

Table 2 presents the main mitigation comparison using Mem0, while Appendix B.3 extends the evaluation to A-Mem, MemGPT, and Graphiti. Together, these experiments demonstrate that the effectiveness of MEMTRIM is not restricted to one particular underlying memory system.

Regarding the additional methods suggested by the reviewer, MemoryBank, LightMem, MemoryOS, MemP, and LangMem provide relevant perspectives on memory organization, maintenance, and retrieval. Similarly, MemSkill, MemRL, and BudgetMem are important related approaches to memory learning, optimization, and query-aware memory use.

We agree that these methods deserve clearer discussion in our paper. We expanded Section 5 to position them more explicitly according to their objectives and intervention points.

At the same time, comparing different complete memory architectures is not equivalent to comparing different inference-time memory mitigation strategies under the same retrieval conditions. Our evaluation primarily focuses on the latter, while testing the proposed mechanism across four representative memory backbones.

We have clarified this baseline-selection rationale in Section 4 and strengthen the Related Work discussion. This makes the scope of our comparison more explicit without conflating memory-system design with inference-time memory-reuse decisions.

Weakness 3: Absence of Validation in Realistic Long-Term Memory Scenarios

Absence of validation in realistic long-term memory scenarios. The evaluation is primarily based on task pairs derived from RippleEdits, CounterLogic, and CLADDER—datasets that align well with the specific mechanisms MEMTRIM employs for handling evidence conflicts and reusing historical answers. To better assess the framework's generalization capabilities in complex, multi-turn interactions and dynamic memory environments, the authors should conduct further evaluations using more realistic long-term memory benchmarks, such as LoCoMo or MemoryAgentBench.

Thank you for this constructive suggestion. We agree that realistic long-horizon memory benchmarks are valuable for evaluating deployed memory-augmented agents. We would like to clarify that our current benchmarks are deliberately designed as controlled diagnostic settings to investigate a specific inference-time failure, rather than to evaluate every capability required for long-term conversational memory.

The central research question of our paper is whether a previously correct and appropriately retrieved memory can still mislead an LLM when the current task differs from the historical interaction.

Investigating this failure requires distinguishing incorrect historical-answer reuse from other sources of errors, such as retrieval failures, missing memories, or incorrect information stored during memory construction. In realistic multi-turn settings, these factors may change simultaneously, making it difficult to identify which component causes a particular prediction error.

Our benchmark construction addresses this challenge by using controlled historical and current query pairs. The three benchmark families examine complementary forms of task divergence.

RippleEdits considers changes in factual information, allowing us to study situations in which a previously correct answer becomes outdated.

CounterLogic examines changes in the question being asked. In particular, it distinguishes logical validity from real-world truth, allowing us to investigate whether a historical answer is incorrectly reused across different reasoning tasks.

CLADDER-Derived examines related causal scenarios in which answer-relevant evidence differs between the historical and current interactions.

These settings allow us to analyze memory behavior under task-aligned (TA) and task-divergent with duplicated evidence (TD-Dup) conditions. They also make it possible to measure memory-induced prediction changes, rather than relying only on overall task accuracy.

For example, Table 1 reports both correct-to-incorrect and incorrect-to-correct prediction changes after memory is introduced. Figures 2 and 3 further examine how query-memory evidence alignment relates to these outcomes, while Figure 5 evaluates the contributions of different MEMTRIM components.

These analyses are particularly useful because they provide a more direct understanding of when previously correct memory becomes harmful and which inference-time decisions help prevent its inappropriate reuse.

We agree that LoCoMo and MemoryAgentBench provide complementary settings for evaluating agents over longer interaction histories, where memory retrieval, updates, and user information may evolve across multiple turns.

However, such benchmarks examine a broader collection of memory capabilities than the particular inference-time failure studied here. Their value is complementary to, rather than a replacement for, controlled diagnostic evaluation.

Our current evaluation already spans two answering models, four memory architectures, three diagnostic benchmark families, nine mitigation strategies, and several ablation settings. This provides evidence of MEMTRIM's effectiveness across the tested conditions, although it does not establish performance in every possible long-horizon deployment scenario.

We have clarify this distinction in the Evaluation section and make the scope of our conclusions more explicit. We believe the controlled benchmark design is appropriate for identifying the failure mechanism and evaluating the proposed mitigation, while long-horizon benchmarks would provide an additional perspective on broader generalization.

Reviewer_o2SYOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies memory overreliance, where a previously correct memory misleads an agent after the task or relevant conditions change. It constructs memory-query pairs from RippleEdits, CounterLogic, and Cladder, and reports that failures concentrate at intermediate query-memory overlap. Their proposed method parses memories into evidence units, task signatures, and answer-support sets. It uses a trie to remove repeated or conflicting evidence and suppress or relabel previous answers. Evaluation covers two models and four memory systems, with mitigation baselines, component ablations, memory attacks, and runtime measurements.

Critical strengths
  1. The paper addresses a useful failure mode: historical correctness does not guarantee that a memory remains applicable. Reporting both memory-induced regressions and corrections is a useful way to examine this beyond aggregate accuracy.

  2. The reported mitigation gains are consistent across models and memory systems. The comparison with Facts-only and Context-faithful is particularly useful, since it tests whether the proposed method preserves useful memory while reducing harmful reuse.

Critical weaknesses
  1. The evaluation does not clearly establish selective use of useful memory. CounterLogic changes the task in both conditions, but labels a pair TA whenever the two gold answers agree; Cladder also uses answer agreement. Copying an old answer can therefore look like successful transfer. A test requiring valid memory-only evidence alongside an outdated conclusion is needed to support the claimed preservation of useful memory.

  2. The central overlap mechanism remains underidentified. RQ3 increases overlap while restoring the conditions that make the stored answer valid, so the recovery could reflect answer applicability rather than overlap itself. The keep-shared ablation supports an effect of duplication, but does not establish that intermediate overlap is the most harmful regime.

Questions for authors

Does the runtime measurement include all query-parsing and semantic-alignment calls?

3 comments

Weakness 1 · Selective Use of Useful Memory

The evaluation does not clearly establish selective use of useful memory. CounterLogic changes the task in both conditions, but labels a pair TA whenever the two gold answers agree; Cladder also uses answer agreement. Copying an old answer can therefore look like successful transfer. A test requiring valid memory-only evidence alongside an outdated conclusion is needed to support the claimed preservation of useful memory.

Thank you for this important comment. We agree that answer agreement alone does not establish whether useful evidence was transferred. To examine this distinction directly, we ran the test the reviewer suggests (Table B).

Clarifying TA. In CounterLogic and CLADDER-Derived, TA indicates that the historical answer remains correct for the current query, even when the task or underlying evidence changes. It measures answer applicability, not whether memory provides information that is necessary to solve the task. Because both benchmarks use binary answers, copying an invalid answer is also indistinguishable from an ordinary error. We therefore built the new test on RippleEdits, which our paper already includes and whose answers are open-ended entities. We clarified this distinction in Appendix C and the relevant table captions.

Additional evaluation. We constructed a diagnostic set of 200 compositional questions from the RippleEdits counterfactual subset. Each case tests two requirements at once. First, the historical outcome is no longer applicable, because its supporting evidence conflicts with the current query. Second, another valid fact from the historical memory is absent from the query and necessary for answering it. All edits are counterfactual, and the stored answer comes from an earlier edit that a later edit supersedes. The model therefore cannot recover either answer from parametric knowledge, so a match with the stored answer reflects reliance on memory rather than prior knowledge.

This setting tests whether MEMTRIM can suppress an outdated conclusion without discarding useful memory-only evidence. We independently annotated the required evidence and measured its contribution with a controlled ablation that removes it.

All methods use the same current queries and the same setting as Table A (Qwen3.8-27B + Mem0, top-k = 5). We report answer accuracy and the rate at which predictions match the invalid stored answer. The latter measures answer-string agreement; it does not prove that the model copied the memory.

Table B. Preservation of necessary memory-only evidence. Qwen3.8-27B + Mem0, top-k = 5; N = 200 compositional questions from the RippleEdits counterfactual subset; same queries in every condition. Accuracy and invalid stored-answer match rate (%); correct or matching counts in parentheses.

MethodAccuracy ↑Invalid stored-answer match ↓
No Memory26.0 (52)2.0 (4)
Empty MEMTRIM prompt26.0 (52)2.0 (4)
Raw Memory50.0 (100)35.0 (70)
Facts-only80.0 (160)5.0 (10)
MEMTRIM without Uₘ(q)27.5 (55)2.0 (4)
MEMTRIM86.0 (172)1.0 (2)

Results. First, MEMTRIM reaches 86.0% accuracy, compared with 26.0% without memory. The empty-prompt control matches No Memory exactly, so the improvement does not come from the prompt template itself.

Second, raw memory reaches only 50.0% accuracy, and 35.0% of its predictions match the invalid stored answer. MEMTRIM reduces this match rate to 1.0% while substantially improving accuracy.

Third, removing the memory-only evidence Uₘ(q) lowers MEMTRIM accuracy from 86.0% to 27.5%, a drop of 58.5 percentage points. This controlled ablation shows directly that the retained information is what enables the model to answer the current query.

Finally, MEMTRIM outperforms Facts-only in both accuracy (86.0% vs. 80.0%) and stored-answer match (1.0% vs. 5.0%). Removing historical answers while keeping all facts, including conflicting ones, is less effective than filtering evidence selectively.

Scope of the finding. This diagnostic set deliberately targets cases where valid memory-only evidence is required alongside an invalid historical conclusion. The observed improvement should therefore not be read as a benchmark-wide gain. It provides targeted evidence that MEMTRIM preserves useful historical information while reducing inappropriate answer reuse.

We have included Table B, the construction and annotation procedures, and the ablation details in the revised manuscript.

Weakness 2

The central overlap mechanism remains underidentified. RQ3 increases overlap while restoring the conditions that make the stored answer valid, so the recovery could reflect answer applicability rather than overlap itself. The keep-shared ablation supports an effect of duplication, but does not establish that intermediate overlap is the most harmful regime.

Author response:

Thank you for raising this point. We would like to clarify the interpretation of RQ3 in straightforward terms. Overlap describes how much evidence in a historical interaction is repeated in the current query. To change that quantity in a controlled example, some of the query's evidence must be changed. The LLM may then answer differently, because it is being asked under different information. We therefore do not use raw accuracy on those different queries as our measure of memory overreliance. At every overlap level, Figure 3 instead compares the model with retrieved memory against the same model without retrieved memory on the current query. The plotted difference captures the extra influence of the historical memory under that query condition.

This controlled sequence intentionally moves from an earlier answer that no longer applies toward an interaction where it becomes usable again. The increasing overlap and changing answer applicability describe that transition. The question we study is how the model's reliance on its retrieved history changes along the transition, and the U-shaped pattern is observed from model predictions, not inserted as a scoring rule. The reviewer’s suggested fixed-validity analysis is a distinct isolation question; the existing curve should be read as a transition between evidence conditions, not as a claim that restoring answer validity has no effect.

Our explanation also draws on evidence that does not depend on that transition. RQ2 reports different overlap patterns for successful and failed TD-Dup predictions, while the keep-shared ablation shows how retaining repeated facts affects the full filter. Together they help explain why evidence that looks familiar can still carry an inapplicable answer. We revised the Section 2 discussion and Figure 3 caption to make this distinction clear without overstating what any single experiment measures.

Question 1 · Runtime Measurement

Does the runtime measurement include all query-parsing and semantic-alignment calls?

Thank you for this important question. We appreciate the opportunity to clarify the runtime accounting of MEMTRIM, particularly the distinction between one-time memory preprocessing and online inference.

First, MEMTRIM separates write-time and inference-time operations. As described in Section 3.3 and Appendix A.1, historical interactions are parsed into structured evidence representations and organized using a trie during memory construction. These representations are cached and reused across subsequent queries. Therefore, historical memory parsing and trie construction are one-time preprocessing operations rather than costs repeated for every query.

Second, online inference involves additional processing. For each query, MEMTRIM retrieves relevant memories, parses the current query, performs semantic alignment when necessary, identifies shared and conflicting evidence, constructs the filtered context, and generates the final answer. Query parsing and semantic alignment are therefore part of the online computational workload and should be included when evaluating end-to-end inference latency.

Third, Figure 7 reports the net change in reasoning time after integrating MEMTRIM with different memory systems. As discussed in Section 4.4, the additional processing introduced by evidence matching can be partly offset by the shorter context provided to the answering model. This explains why the reported runtime changes are relatively small and can even be negative in some configurations.

We acknowledge that the current presentation does not explicitly separate individual parser and semantic-alignment calls, making the timing boundary insufficiently clear. We clarified the measurement procedure, including the treatment of online model calls and caching, and ensure that the runtime interpretation is consistent with the actual execution logs. We also distinguished recurring inference costs from one-time memory preprocessing more explicitly in Section 4.4 and the caption of Figure 7.

We thank the reviewer again for this constructive suggestion. We believe these clarifications make the computational overhead and practical efficiency of MEMTRIM easier to assess.

Best,

The author team

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

The paper studies harmful reuse of previously correct memories when the current task or its supporting conditions change. It proposes MEMTRIM, which represents memories as evidence, task signatures, and answer-support sets, then removes repeated or conflicting information and controls the reuse of previous answers. Experiments across three benchmark families, two models, and four memory systems show consistent improvements on task-divergent cases while preserving task-aligned accuracy.

Critical strengths
  1. The paper addresses a relevant problem in memory-augmented agents. A memory can be correct when stored and still mislead a later decision. The evaluation makes this failure measurable by separating task-aligned and task-divergent cases and tracking both memory-induced regressions and corrections. The focus on retaining useful information while preventing harmful reuse is practically valuable.

  2. The empirical results support the proposed methods.

Critical weaknesses
  1. The empirical gains are encouraging, but the methodological contribution needs a sharper test. MEMTRIM’s most distinctive component is its use of support sets to decide whether to reuse an old answer. The ablations show that removing invalidated answers helps. They do not show whether identifying precise support sets improves on the simpler rule of removing an answer whenever any evidence conflicts. Comparing these rules on the same parsed inputs would clarify what support tracking adds beyond conventional conflict handling.

  2. RQ3 changes answer applicability along with overlap. As overlap increases, the experiment also restores the evidence needed for the old answer to be correct. The resulting curve cannot establish overlap as an independent cause of harmful reuse. Broader applicability remains uncertain for a separate reason: the method depends on correctly matching evidence, identifying tasks, and extracting answer dependencies, yet the accuracy of these judgments is not measured. Testing several memory architectures does not address this dependence. A missed conflict or support condition can still lead the system to retain an invalid answer.

Questions for authors
  1. Does support-aware filtering outperform a rule that removes the old answer whenever any evidence conflicts, with evidence extraction, task handling, and the reader held fixed?

  2. Does Figure 3 contain an interval where overlap changes while the decisive evidence and validity of the stored answer remain fixed? If so, does the decline in performance occur within that interval?

  3. Which parser model and prompts are used, and what validation is available for evidence matching, task identification, and support extraction? Have you measured how often errors in these judgments cause invalid answers to be retained or valid answers to be discarded?

6 comments

Weakness 1

The empirical gains are encouraging, but the methodological contribution needs a sharper test. MEMTRIM’s most distinctive component is its use of support sets to decide whether to reuse an old answer. The ablations show that removing invalidated answers helps. They do not show whether identifying precise support sets improves on the simpler rule of removing an answer whenever any evidence conflicts. Comparing these rules on the same parsed inputs would clarify what support tracking adds beyond conventional conflict handling.

We thank the reviewer for focusing on support sets, as they capture a central distinction between MEMTRIM and conventional conflict filtering. Detecting that two facts disagree is not the same as determining whether a previously correct answer is still usable. A retrieved interaction may contain many facts, but only a subset actually supports the answer it produced. Treating every disagreement as grounds for discarding that answer ignores this dependency and may remove useful information unnecessarily.

This distinction is formalized in Sections 3.1 and 3.3. For each stored interaction, MEMTRIM represents the historical outcome together with its task signature τₘ and a support set Hₘ. At inference time, it identifies evidence Dₘ(q) that conflicts with the current query, but suppresses the stored outcome only when Dₘ(q) ∩ Hₘ ≠ ∅. Importantly, conflicting memory evidence is removed from the current context regardless; the support-set condition determines whether the historical answer must also be discarded. In this way, the same retrieved memory can be corrected at the fact level without automatically losing a still-applicable answer.

Consider a historical interaction that answers “When was Northstar Robotics founded?” with “2016,” and also mentions that its headquarters was in Seattle. A new query states that the company has moved to Boston but still asks for its founding year. The headquarters conflict does not affect the support for “2016.” An any-conflict rule would discard the historical answer because some memory fact changed; MEMTRIM removes the outdated location while preserving the founding-year answer. If the founding-year evidence itself changes, the conflict intersects Hₘ and MEMTRIM suppresses “2016.” The difference is therefore a precise decision about the relevance of the conflict to the answer, rather than a different way of counting conflicts.

The existing results are also consistent with the importance of selective reuse. Table 2 shows that discarding historical answers indiscriminately can substantially reduce performance on task-aligned (TA) cases, even when it helps on task-divergent (TD-Dup) cases. The following values are from the reported Qwen3.8-27B + Mem0 experiments:

DatasetConditionRaw Mem0Facts-onlyMEMTRIM
RippleEditsTA85.371.688.4
RippleEditsTD-Dup62.672.474.5
CounterLogicTA93.187.094.6
CounterLogicTD-Dup80.086.787.9
CLADDER-DerivedTA79.664.183.9
CLADDER-DerivedTD-Dup46.661.063.5

For example, on RippleEdits, Facts-only obtains 71.6% TA accuracy, compared with 88.4% for MEMTRIM; on CLADDER-Derived, the respective numbers are 64.1% and 83.9%. At the same time, MEMTRIM achieves 74.5% and 63.5% TD-Dup accuracy on these datasets, exceeding Facts-only (72.4% and 61.0%). The key point is the two-sided trade-off: preserving applicable historical information while reducing the influence of outdated conclusions. Figure 5 provides complementary ablation evidence: retaining conflicting evidence or a historical answer after its supporting evidence has changed reduces TD-Dup performance, while ignoring task changes introduces another source of error. Together, these experiments support the importance of both evidence-level conflict handling and conditional outcome reuse. We made this connection explicit in Sections 3.3 and 4.2.

Weakness 2 · RQ3 design and parser reliability

RQ3 changes answer applicability along with overlap. As overlap increases, the experiment also restores the evidence needed for the old answer to be correct. The resulting curve cannot establish overlap as an independent cause of harmful reuse. Broader applicability remains uncertain for a separate reason: the method depends on correctly matching evidence, identifying tasks, and extracting answer dependencies, yet the accuracy of these judgments is not measured. Testing several memory architectures does not address this dependence. A missed conflict or support condition can still lead the system to retain an invalid answer.

We thank the reviewer for the comments and constructive suggestions. Please see below regarding the point-wise explanations and revisions: We would like to clarify the purpose of RQ3 in straightforward terms. The experiment asks what happens when a current question becomes increasingly similar, in its evidence, to a previously stored interaction. To create this progression, we change which facts are presented in the current query. Some are background facts also present in memory; others directly determine whether the earlier answer remains valid. Naturally, when the query evidence changes, both its overlap with memory and the applicability of the old answer can change. This is part of the scenario we deliberately construct: a past experience gradually becomes more relevant to the new task.

The performance pattern in Figure 3 is not predetermined by that construction. We decide which evidence appears at each stage, but we do not prescribe the LLM’s answer or the resulting ΔAccuracy. Those values come from running the models under the corresponding query and memory conditions. Indeed, different backbones could respond differently to the same sequence. Figure 3 therefore measures how memory influence evolves along a controlled evidence-alignment transition, rather than claiming that overlap has been varied independently while answer validity is fixed.

This interpretation is supported by two other parts of the study. RQ2 reports an association between observed overlap and memory-induced failures among naturally occurring TD-Dup cases, where the old answer is not applicable. Figure 5 then directly ablates duplicate-evidence removal: keeping shared evidence lowers TD-Dup accuracy relative to the full MEMTRIM transformation. These observations address different questions, but together explain why repeated evidence deserves special treatment when an earlier conclusion does not fully transfer. We made this three-part reading of RQ2, RQ3, and the ablation more explicit, and adjust language that could be read as a claim of an overlap-only causal intervention.

The parser question concerns a separate implementation layer. Appendix A.1 describes source-grounded evidence extraction, canonicalization, conservative semantic alignment, task-signature identification, support estimation, and output validation/retry. This processing is performed on historical interactions and current queries; the method does not receive benchmark TA/TD-Dup labels or gold support sets at inference time. We evaluate the downstream pipeline across four memory architectures to test its applicability to different retrieval formats. That result should be distinguished from a manually labeled extraction-accuracy benchmark, which is not reported in the main experiments. We state the parser configuration and the scope of the available validation explicitly so that readers can assess what is directly measured.

Question 1

Does support-aware filtering outperform a rule that removes the old answer whenever any evidence conflicts, with evidence extraction, task handling, and the reader held fixed?

Thank you for this important question. Following the reviewer's suggestion, we conducted a controlled comparison between MEMTRIM and an any-conflict baseline, with 200 cases in each of three conflict categories. Both methods use the same retrieved memories, parsed evidence, task-handling procedure, prompt template, and answering model. The only difference is the rule used to suppress a historical answer: any-conflict removes the answer whenever conflicting evidence is detected, whereas MEMTRIM removes it only when the conflict affects the evidence supporting that answer (Dₘ(q) ∩ Hₘ ≠ ∅). Task compatibility is handled separately and identically in both methods.

Table A. Support-aware versus any-conflict filtering. Qwen3.8-27B + Mem0, retrieval top-k = 5, with 200 cases per category. Values are accuracy (%) followed by the number of correct predictions in parentheses.

MethodC1: No conflictC2: Non-support conflictC3: Support conflict
No Memory70.0 (140)70.0 (140)75.0 (150)
Raw Memory88.0 (176)80.0 (160)57.0 (114)
Facts-only72.0 (144)71.0 (142)79.0 (158)
Any-conflict91.0 (182)74.0 (148)82.0 (164)
MEMTRIM91.0 (182)87.0 (174)82.0 (164)

The results show that the advantage of support-aware filtering is concentrated in cases where the two rules make different decisions.

C1 (No conflict): Both methods achieve 91.0% accuracy. Neither rule needs to suppress the historical answer, so their identical aggregate performance is consistent with the expected behavior.

C2 (Non-supporting conflict): MEMTRIM achieves 87.0% accuracy, compared with 74.0% for any-conflict, an improvement of 13.0 percentage points (174 versus 148 correct predictions out of 200). This is the key difference between the two approaches. Any-conflict discards a historical answer even when the conflicting information is unrelated to that answer. In contrast, MEMTRIM removes the conflicting evidence while preserving the historical answer when its supporting evidence remains valid. MEMTRIM also outperforms raw memory (80.0%) and Facts-only (71.0%) in this setting.

C3 (Supporting conflict): Both methods achieve 82.0% accuracy, compared with 57.0% for raw memory. When the conflicting evidence directly supports the historical answer, both rules suppress the outdated conclusion. Their identical aggregate performance is therefore consistent with the intended decision rule.

These findings directly support the value of answer-support tracking beyond general conflict detection. A change in a contextual fact, such as an organization's headquarters, should not invalidate a still-correct answer about its founding year. However, if the founding-year evidence itself changes, the previous answer should be removed. MEMTRIM makes this distinction by checking whether the conflict affects the evidence supporting the historical outcome, rather than treating all conflicts equally.

The results also complement our existing ablation studies. While the original ablations examine the effects of shared evidence, conflicting evidence, historical-answer retention, and task changes, this new experiment specifically isolates the difference between support-aware filtering and the simpler any-conflict rule. The 13.0-point improvement in C2, together with the matching aggregate results in C1 and C3, provides additional empirical support for the selective memory-reuse mechanism in MEMTRIM.

Reviewer_FuMTOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary
  • The paper studies "memory overreliance", where a memory that was correct when stored and is retrieved properly still leads the model to a wrong answer, because the new question shares most of its details with the memory while the old answer no longer applies
  • Memory and question pairs are built from three existing benchmarks (RippleEdits, CounterLogic and CLADDER), and a pair is labelled task-aligned when the stored answer is still correct and task-divergent otherwise, with four memory systems and two LLMs tested
  • The obtained results suggest that memory helps on task-aligned pairs, hurts on task-divergent ones, and lowers accuracy the most when the question and memory only partly overlap
  • To address this, the authors propose MEMTRIM, which uses a parser to split memories and questions into key-value facts. When a question comes in, repeated and conflicting facts are dropped, and the old answer is either removed or relabelled
Critical strengths
  • The paper describes a practical failure mode and clearly illustrates it with case studies. In one, a stored answer saying that Messi's club is in France misleads the model even though the question says he moved to Inter Miami
  • Across four memory systems and two models, the same pattern appears. On CLADDER-Derived with Qwen, accuracy on task-divergent pairs drops from 61.2 without memory to 43.9-49.8 with memory, and memory-caused errors of 14-19% far outnumber memory-caused fixes of about 2-3%
  • MEMTRIM is compared against nine mitigation methods covering filtering, compression and conflict-aware prompting, each tested with the four memory systems. It has the best task-divergent accuracy in every reported configuration while maintaining or improving accuracy on task-aligned pairs
Critical weaknesses
  1. Appendix C.1 states that "we keep the entity, relation, and current query fixed", so without memory the task-aligned and task-divergent RippleEdits pairs are the same questions and should have the same accuracy. Table 1 instead reports 68.0 vs 71.3 for Qwen and 65.4 vs 68.9 for GPT-5.6 Luna, which are sizeable gaps of about 4-8 times the reported standard deviations. It is unclear what happens there

  2. The pair labels seem to largely mirror MEMTRIM's own decision rule. A pair is task-divergent when a fact the stored answer depends on differs in the new question, and MEMTRIM removes the stored answer exactly when "any supporting evidence conflicts with the current query". The baselines do not receive this signal, which makes the comparison rather unfair

  3. In every CounterLogic pair labelled task-aligned, the question also changes from logical validity to real-world truth, and the pair counts as aligned only because the two labels happen to agree

  4. In RQ3, overlap is not varied on its own. The paper states that "as overlap increases, the answer-relevant evidence is gradually restored", so overlap and the correctness of the stored answer change together, and the U-shaped curve seems largely built into the design

  5. The description of MEMTRIM does not really explain where its gains come from. On task-divergent pairs it only removes content, so its accuracy should be about the same as without memory. With GPT-5.6 Luna and Mem0 it instead outperforms the no-memory baseline by 6.4 points on RippleEdits and 6.5 on CLADDER-Derived, and its rate of memory-caused fixes is about twice that on the other memory systems, which is surprising

  6. Most of the processing happens in the parser, but the paper neither specifies nor evaluates it. Appendix A.1 describes a "fixed parser prompt" that extracts facts, decides which facts an answer depends on and judges whether two keys mean the same thing, but the paper does not say which model it uses, what it costs or how accurate it is. The released code does not include it either and expects facts that are already parsed

  7. Some case studies do not match the stated pipeline. Case 3 pairs observational with interventional probabilities, although pairs are supposed to share a causal level, and its stored answer "Yes" is drawn from confounded data, contrary to the rule that stored answers are correct. Case 1 outputs "(position, forward)", but this fact does not appear in the stored memory

  8. The statistical reporting seems quite incomplete. The number of runs and the temperature are not stated, and the tables report different standard deviations for the same rows. Several gains over the strongest baseline are only 1-2 points with at most 500 items per condition, which raises the question of how much of the difference is noise

  9. The released code is a small reference implementation of about 250 lines and does not reproduce the experiments. Its README says the examples "are not paper results and are not intended to reproduce Table 1", and it contains no parser, prompts, benchmark construction, memory-system integration or baselines. This contradicts the Reproducibility Statement, which says the released code supports "reproduction of the reported experiments". The trie, for instance, is a plain key-to-value dictionary that the read-time code never uses, as matching is done directly against the query. When a query names one of two founders, the code also marks the other founder as conflicting and drops it

  10. Related work on stale agent memory that would make sense to discuss is missing, for instance STALE (2026) and The Trap of Trajectory (2026)

Questions for authors
  1. Why do the no-memory accuracies differ between task-aligned and task-divergent RippleEdits pairs if the question is fixed?

  2. What explains MEMTRIM outperforming the no-memory baseline on task-divergent pairs when it only removes content? Putting the question without any memory into MEMTRIM's prompt template would show whether formatting alone explains that part of the gain

  3. Which model does the parser use, and how accurately does it extract facts and dependencies on a few hundred manually checked memories? Results for a baseline given the parsed facts without filtering would show how much of the value comes from parsing and how much from the filtering step

  4. Would it be possible to repeat the RQ3 experiment with the stored answer kept wrong throughout, varying only the amount of shared information that does not affect the answer? This would test whether overlap alone causes the overreliance

  5. In the released code, a query naming one of two founders causes the other founder to be dropped as conflicting. Is this the intended behavior for keys with several valid values, and what happens if the facts have changed but the question does not state the new value?

6 comments

Weakness 1 — No Memory Accuracy in RippleEdits

Appendix C.1 states that "we keep the entity, relation, and current query fixed", so without memory the task-aligned and task-divergent RippleEdits pairs are the same questions and should have the same accuracy. Table 1 instead reports 68.0 vs 71.3 for Qwen and 65.4 vs 68.9 for GPT-5.6 Luna, which are sizeable gaps of about 4-8 times the reported standard deviations. It is unclear what happens there

Thank you for carefully examining the RippleEdits evaluation. We would like to clarify the distinction between the construction of memory-query pairs and the grouping used to report evaluation results.

Appendix C.1 describes how TA and TD-Dup memory conditions are constructed from the same underlying factual edits. However, the No Memory results in Table 1 are aggregated over the corresponding evaluated query subsets rather than necessarily over identical query instances.

The No Memory baseline does not receive any historical memory. Therefore, the difference between TA and TD-Dup accuracy does not indicate that the model behaves differently because of a memory label. Instead, the reported values reflect the accuracy of the same backbone model on the respective evaluation subsets.

For Qwen3.8-27B, these values are 68.0% and 71.3%, while GPT-5.6 Luna obtains 65.4% and 68.9%. These differences should be understood in the context of the evaluation grouping, rather than as memory-induced changes in prediction behavior.

We clarified the distinction between source-level pair construction and evaluation-level aggregation in Appendix C.1 and the caption of Table 1 to avoid this misunderstanding.

Weakness 2

The pair labels seem to largely mirror MEMTRIM's own decision rule. A pair is task-divergent when a fact the stored answer depends on differs in the new question, and MEMTRIM removes the stored answer exactly when "any supporting evidence conflicts with the current query". The baselines do not receive this signal, which makes the comparison rather unfair

Thank you for raising this point. We would like to distinguish an evaluation label from the information actually available to a tested method. Appendix C constructs TA and TD-Dup pairs using source benchmark annotations and fixed rules. These annotations are used only to define and score the diagnostic conditions. They are not passed to MEMTRIM as an answer-applicability flag, a conflict label, or a gold support set. During inference, MEMTRIM must infer evidence units, task signatures, and answer-support dependencies from the stored interaction and current query.

The similarity between the data construction and our rule is intentional at the research-question level: the paper studies what happens when a previously correct experience is partially transferable. A useful diagnostic benchmark must contain both transferable and nontransferable prior experience. This does not mean that MEMTRIM receives the target condition. The same retrieved memory candidates and current query are available to all mitigation strategies; methods differ in how they process that information. We additionally compare with Facts-only and Context-faithful, which are particularly relevant because they also address answer reuse or conflicting context, rather than relying only on retrieval similarity.

We emphasized in Section 4 that the support sets used by MEMTRIM are estimated online, whereas evaluation labels are assigned offline from benchmark metadata. This is the key distinction relevant to possible label leakage. A same-parser, different-filter comparison would isolate the incremental contribution of the support rule more narrowly, but its absence should not be conflated with the method having access to benchmark ground truth.

Weakness 3

In every CounterLogic pair labelled task-aligned, the question also changes from logical validity to real-world truth, and the pair counts as aligned only because the two labels happen to agree

Thank you for this careful observation. The reviewer correctly observes that CounterLogic changes the question type in both conditions; this is the controlled feature of the benchmark, not an unintended mismatch. As detailed in Appendix C.2, the stored interaction asks whether an argument is logically valid, and the current interaction asks whether its conclusion agrees with real-world knowledge. Both conditions retain the same premises and conclusion, while the original benchmark provides two separate gold judgments.

Our use of TA in this dataset means that the stored answer remains applicable to the current question, not that the two task signatures are identical. When the two judgments agree, the old answer is still a correct answer string; when they disagree, an agent that copies it will fail. Because the task switch is present in both groups, the contrast helps diagnose whether retrieved historical answers dominate current-task inference when the answer happens to remain valid versus when it no longer does.

This distinction also explains why MEMTRIM models task signatures separately from answer-support evidence. A historical answer to logical validity should not silently be presented as the answer to a real-world truth question, even if both happen to be “Yes.” When the task differs, Section 3.3 describes converting an earlier outcome into a statement explicitly labeled by its original task, where such a conversion is meaningful. We described CounterLogic as an answer-applicability under task change diagnostic and use “task-aligned” as shorthand only with that definition made explicit. We do not equate label agreement with proof that memory was necessary.

Weakness 4

In RQ3, overlap is not varied on its own. The paper states that "as overlap increases, the answer-relevant evidence is gradually restored", so overlap and the correctness of the stored answer change together, and the U-shaped curve seems largely built into the design

Thank you for this thoughtful comment. We appreciate the reviewer’s question and would like to explain the purpose of RQ3 more directly. In order to change how much evidence from a stored interaction overlaps with the current query, the query-side evidence must change. A language model can of course respond differently to a changed query, even without memory. This is why RQ3 evaluates the memory-induced difference at each overlap level, ΔAcc = Acc(with memory) − Acc(without memory), rather than interpreting raw accuracy across different queries as a memory effect. The question is how much the retrieved history helps or misleads the model as the current task becomes more similar to that history.

The controlled sequence in Section 2 deliberately reflects a realistic transition: initially the historical answer does not transfer; later, more of the previous evidence becomes relevant; finally the current task can again support the historical answer. The restoration of answer-relevant evidence is part of this transition, not a hidden change in the evaluation procedure. The sequence specifies what information the model sees, but it does not assign the model's predictions or guarantee a U-shaped response. Figure 3 reports those predictions after inference, using the same query-only comparison at each level. The resulting non-monotonic behavior therefore describes the observed effect of memory along a changing-evidence path.

We also do not rely on RQ3 alone. RQ1 establishes that otherwise benign memories can cause both harmful and helpful prediction flips; RQ2 shows that memory-induced failures are concentrated in different overlap regions from successful cases on naturally occurring TD-Dup examples; and the keep-shared ablation examines the practical effect of leaving duplicated evidence in the filtered context. Together these findings motivate evidence-aware treatment of historical experience. We explained in the text and Figure 3 caption that RQ3 characterizes the transition from TD-Dup toward TA, without presenting the plot as a fixed-answer-validity intervention in which every other query property is constant.

Weakness 5 + Question 2: Why MEMTRIM can outperform No Memory

Thank you for these closely related questions. The key clarification is that MEMTRIM does not simply remove memory. As explained in Section 3.3 of the revised manuscript, it separates shared evidence, conflicting evidence, and memory-only evidence Uₘ(q), while making a separate decision about whether the historical outcome can still be reused. Facts already in the query need not be repeated, and conflicting historical facts should not override current evidence. However, valid memory-only information can remain useful even when the historical answer itself is outdated.

This also explains why No Memory is a reference condition, not an upper bound. The query-only model does not have access to valid facts that may be retained by MEMTRIM. The reported GPT-5.6 Luna + Mem0 gains on TD-Dup—6.4 percentage points for RippleEdits and 6.5 for CLADDER-Derived—are consistent with selective evidence retention. Differences across Mem0, A-Mem, MemGPT, and Graphiti are also possible because their retrieval outputs differ. These aggregate results support the mechanism but do not, by themselves, show that each retained fact was necessary.

We have clarified this distinction in the Method and Evaluation discussions. We have also made the answer-generation prompt comparison explicit: the relevant control uses the same current query, answer template, model, and decoding settings, with no retrieved content. Any improvement over that control must be interpreted in relation to the information actually retained, rather than attributed to an unspecified prompt-formatting difference. The revised discussion distinguishes historical-answer suppression from preservation of useful memory-only evidence.

Weakness 7

Thank you for carefully examining the consistency between our case studies and the proposed methodology. We would like to clarify that the examples in Appendix B.4 are intended to illustrate the inference-time filtering mechanism, while the benchmark construction follows the explicit constraints described in Appendix C.

For Case 1, the additional evidence unit (position, forward) is not supported by the displayed historical interaction and is not needed to explain the filtering decision. We have removed this unnecessary unit from the revised example. The central mechanism remains unchanged: the historical answer is suppressed because its supporting club information conflicts with the current query.

For Case 3, we agree that observational and interventional probabilities represent different causal quantities. The original illustration did not clearly reflect the pairing constraints specified in Appendix C.3. We have replaced it with a source-grounded CLADDER-derived example that follows the same causal task and rung, with the historical answer verified against its original benchmark annotation.

Thank you again for this valuable feedback. We believe these corrections make the relationship between our method and the evaluation protocol clearer.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Thank you! And please see the point-wise response below as well as updated manuscript

Dear Reviewers, AC, SAC, and all editors,

We would like to take this opportunity to thanks for your time and efforts for organizing the review process. Please see below regarding our point-wise responses with intensive revision efforts. Besides:

  • we have uploaded revised manuscript, wherein Blue text indicates new updates or revised texts and Orange text indicates highlight to original contents to make it easier to be caught.

We would greatly appreciate the reviewer's further assessment of these improvements and warmly welcome any additional feedback or discussion. And we sincerely hope that our responses and revisions have adequately addressed the concerns raised and further improved the clarity and overall quality of the manuscript.

All the best,

The author team

Area_Chair_JDmwOpenReview ↗

Reminder: Please Read and Discuss the Author Rebutta

Dear Reviewers,

Thank you again for your valuable reviews and discussions. Also, thank the authors' for preparing the rebutall. As the author-reviewer discussion period will end on November 18 (AoE), I would kindly ask you to take another look at the authors’ rebuttal if you have not yet done so.

Please make use of this final opportunity to discuss any remaining questions or concerns with the authors, particularly if your current assessment is still borderline or uncertain. I hope the discussion can help clarify the key issues and lead to a fair and clear final assessment.

Thank you very much for your time and contribution.

AC, ICLR 2027

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.