acceptodds
Under review as a conference paper at ICLR 2027

CaseMem: Closing the Loop from Agent Outcomes to Memory Reuse

Abstract

Long-term memory lets an agent retain knowledge from a growing interaction history. Most memory systems focus on what to store and how to retrieve it. However, a relevant memory is not necessarily one that should be applied to the current decision, nor one that actually helped when it was used. We introduce , which separates reusable knowledge from task-specific application and evidence from later use. Each CaseMem record assigns a stable identity to a piece of knowledge, along with its retrieval address, conditions of use, and supporting sources. Before the agent acts, a grounding step binds reusable procedures to the observable task state. When feedback is enabled, a lightweight ledger records exposure and outcome against supplied records to guide later selection without rewriting memory or retraining the agent. On static memory benchmarks, CaseMem is competitive with recent systems without generative construction calls. On agentic benchmark MemoryArena, retrieved experience and task grounding make complementary contributions under two different model family. Their combination improves string reward over retrieval alone by 24% with Qwen3-32B and 12% with GPT-4.1-mini. Separate controlled experiments on a fixed store show that outcome feedback can recover an overlooked procedure and demote a harmful one; replacing current feedback with earlier outcomes reduces the gains. Together, these findings show that agent memory can improve through how knowledge is applied and selected, alongside how it is stored.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Agent Memory, LLM Agents, Memory Retrieval, Outcome Feedback

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 4 reviews, above 68% of the others.
Reviewer_Dy4JOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The central question discussed in this paper is, agent not only needs to remember prior experiences, but "when" to use these experiences, and how to improve future memory selection based on the actual utilities of existing memories.

The paper proposes CaseMem that includes the memory construction & retrieval using structured records, task grounding of memories to current tasks, and outcome-driven memory reuse.

On the MemoryArena shopping benchmark, CaseMem with qwen3-32b outperforms baselines and the authors also evaluated on Locomo, longmemeval-S and AMA-bench, showing that CaseMem is competitive with relatively low memory-construction cost.

Critical strengths
  1. Sound setup and the system design is a practical approach. the paper makes it clear that memory retrieval doesn't necessarily mean that this particular memory fits the current task, and this is an important insight for real-world agentic systems.

  2. this approach shows a method that could maintain competitive performance on memory benchmarks while keeping a low memory construction cost.

  3. solid experiments with task grounding and controlled baseline comparisons.

Critical weaknesses
  1. The paper argues that retrieval -> task grounding -> outcome feedback -> improved reuse could be a closed loop, as it says in Section 4.1 “Grounding experiments disable ledger updates, and feedback experiments disable grounding.”However, grounding uses a fixed predefined compatibility procedure, but this procedure doesn't participate in ledger learning. So it is still unclear whether the compatibility procedure could really be learned from historical experiences, and be used in future task solving. This weakens some of the claims in this work.

  2. There might be a credit assignment problem: one task could use multiple pieces of memory but only produce a single final reward. The credit assignment in this paper is done by "behavioral similarity", but Appendix E4 shows that the AUC for this behavioral proxy is only 0.36. This is not very significant.

Questions for authors

See Weaknesses.

4 comments
AuthorsOpenReview ↗

Response to Reviewer Dy4J

We thank the reviewer for the detailed review and focusing on whether a procedure learned from experience can influence later decisions. We now show the relevant steps and have removed the dependence on the behavioural credit proxy.

W1. Can a procedure be learned from experience and reused?

Experience-derived procedures can change future selection. In a naturalized store of 120 LLM-distilled records, n43 was written from a failed episode (source reward 0.40). Its failure stays as provenance, not a negative starting utility. Outcome feedback promotes it from outside the static pair to the first retrieval slot at round 8, and it is then supplied on 114 of 120 rounds; in that development stream the adaptive selector scores 0.217 versus 0.152 for static retrieval (Appendix H). Separately, two distilled natural records score 0.249 and 0.242 when supplied individually on a disjoint-source store, close to a hand-written procedure at 0.252.

Selection and grounding also run together. In a new joint experiment, the compatibility procedure is one of six selectable records and is grounded whenever supplied:

UnboundGrounded
Static retrieval0.1880.230
Outcome-aware ledger0.2230.235

Under the released MemoryArena setting, the binder uses the agent's own recalled purchase, and binding still improves over an unbound reminder with Qwen (+0.018 [+0.005, +0.032]).

These studies establish experience-derived promotion, grounding from remembered state, and joint execution. They do not yet demonstrate automatic typed-slot induction and outcome-driven discovery of that newly written grounded procedure in a single run.

W2. Does the conclusion depend on unreliable behavioural credit?

No. Our uptake audit finds that the behavioural similarity proxy is a poor indicator of which supplied memory the agent follows (AUC 0.36). A direct equal-exposure control gives similar reward (0.193 vs. 0.196), so we recommend the simpler rule and report which credit rule each original experiment used. The positive result relies on linking the supplied set to its current outcome: substituting earlier-round outcomes reduces reward by 0.044 [0.003, 0.086] and 0.053 [0.019, 0.086] in the two controlled variants. This establishes outcome-associated preference learning, not causal attribution to each record.

We also test individual memories from identical saved task states: the second-ranked record beats the first on 16 of 33 bundles (4 losses, 13 ties). These counterfactual comparisons suggest a way to improve credit assignment, rather than a component of the reported ledger.

We believe the joint experiment, the experience-derived procedure trace and the equal-credit control directly strengthen the two points raised in the review, and we would welcome reconsideration of the assessment.

AuthorsOpenReview ↗

Follow-up to Reviewer Dy4J

Thank you for raising the questions about experience-derived procedures and credit assignment. We wanted to highlight two new findings directly relevant to them.

Procedure n43 was distilled from a failed episode and later promoted through outcome feedback, appearing on 114 of 120 rounds without rewriting its content. We also evaluated the compatibility procedure as a selectable record in the joint grounding–ledger experiment.

For credit assignment, our equal-exposure control achieves comparable reward to behavioral credit (0.193 vs. 0.196), showing that the main controlled-store result does not depend on the behavioral similarity proxy.

We would appreciate your feedback on whether these on whether these results address the two concerns raised in your review. Thank you!

Reviewer_Dy4JOpenReview ↗

Updated my score

I appreciate the response. I've raised my score.

Thank you for taking the time to consider our responses and additional experiments. We really appreciate your feedback!

Reviewer_GTGbOpenReview ↗
Rating
3
Confidence
4
Informativeness
3(+1)
Presentation
3
Soundness
3(+1)
Read review
Paper summary

The paper proposes CaseMem, an agent-memory framework that stores each memory as a record with a stable identity. A record holds content, a retrieval address, a scope, and source evidence, and is kept separate from task-specific bindings and reuse statistics. A deterministic binder instantiates a reusable procedure into a decision card for the current task. A lightweight ledger then adjusts later selection based on outcomes, without rewriting memory content or training the model. The experiments cover three static memory benchmarks, MemoryArena shopping, and outcome-driven selection over a fixed store. I read the paper primarily as an engineering system with an empirical analysis.

Critical strengths
  1. Clear separation of responsibilities. Source outcome, applicability, exposure, and later outcome are recorded separately. This makes content construction, current application, and later selection individually inspectable.
  2. Low cost with quantitative support. Static stores are built without generative calls, yet their accuracy remains competitive. The paper reports construction calls, reader tokens, and runtime across read depths and readers.
  3. Solid grounding controls. On all 150 bundles and with both readers, the grounded card outperforms a generic reminder, and retrieval plus the card outperforms the card alone, with intervals above zero (Table 17).
  4. Valuable negative results and diagnostics. Experiments on natural stores, held-out categories, repeated executions, and the credit audit candidly show where outcome-driven selection fails.
Critical weaknesses

W1. The static gains are not attributed to specific design choices. Record granularity, date handling, and retrieval configuration differ across adapters, but they are not ablated individually. On LongMemEval-S, for example, the reported CaseMem uses dense-only retrieval, and multichannel retrieval lowers accuracy from 0.618 to 0.478 (Table 14). Of the gain over dense RAG, date handling accounts for about 5 points, and the remaining 4 points or so are unexplained. It is therefore hard to tell which choices other systems should adopt. The organizational value of the four-field interface should also be separated from the implementation choices that actually drive accuracy.

W2. The agentic comparisons with external baselines are not matched. CaseMem+ receives the grounded card, whereas the external baselines do not. Without the card, CaseMem's point estimate falls below LightMem's in Table 19. The only comparison under an identical card, dense retrieval plus the card, covers just 30 bundles, and its interval includes zero (Table 21). The results therefore support the value of the card and its complementarity with retrieval, but not an advantage of CASE over other retrievers. If CASE's main benefit under identical grounding is lower reading cost (about 29% fewer tokens in Table 21), the contribution should be framed that way.

W3. The evidence for grounding is narrow. The experiments use a single fixed procedure, and the binder is written specifically for MemoryArena's feedback format. An earlier version of the binder was corrected after it failed (Appendix F). The binder reads only information available to all methods, so leakage is not a concern. However, the paper does not state where the procedure and its slots come from, how much manual effort a new task would require, or whether binder development and evaluation used separate bundles. The results show effectiveness in one task rather than a general mechanism.

W4. Neither the ledger's reliable benefit nor the necessity of its design is established. The clearest positive results occur only with the header query, which is identical for every subtask, and only in development categories. The ledger brings no gain with task-specific queries (Table 26), on held-out categories (Table 25), or on the full benchmark (Table 22). As for the design, the repaired MemRL adapter and simple equal exposure credit perform no worse than the authors' configuration (Appendix C, Table 29). The current evidence does not show when the ledger should be enabled, or what its statistics add over a simple utility rule.

Questions for authors
  1. (W1) What explains the remaining 4 points or so on LongMemEval-S: the extra user-turn records, the full-text keys, or the larger read budget? Could you ablate these, or give the dense baseline the same records and date information?
  2. (W2) Could you add the same card to at least one external baseline (e.g., LightMem) on the 50-bundle subset, and enlarge the comparison between CaseMem+ and dense retrieval plus the card? Do you claim a performance gain or a cost advantage for CASE?
  3. (W3) How were the procedure and its slots obtained? How much manual effort would a new task need? Were binder development and evaluation performed on separate bundles?
  4. (W4) Under what conditions should the ledger be enabled? Please explain why MemRL is no worse than the pooled learner in Appendix C, and whether the planted-store gains hold with task-specific queries.
  5. Please check the following numbers:
    • In Table 1, mem0's 555k tokens on LongMemEval-S exceed the full history of about 115k tokens per question.
    • In Table 19, CaseMem+ − A-MEM is reported as +0.041, but the means give 0.034.
    • The AMA-Bench score of 0.492 is a multi-run mean (Appendix D.1), which is inconsistent with the single-run label in Table 6 and with the 0.474 in Table 8.
    • The single-object results in Appendices C and G disagree.
5 comments
AuthorsOpenReview ↗

Response to Reviewer GTGb (Part 1/2)

We thank the reviewer for the detailed review and concrete suggestions and numerical checks. The new experiments test CASE against identical-card baselines, isolate important retrieval choices, and check grounding on shopping bundles not inspected during development. All four numerical inconsistencies are corrected.

W1/Q1. What accounts for the LongMemEval-S gap?

LongMemEval-S, 500 questions, Qwen readerAccuracyMedian reader tokens
CaseMem0.6141,762
without full-text keys0.6061,762
without user-turn records0.6023,074
without session dates0.5601,884
Dense, matched budget0.582~1,760
CaseMem, larger budget0.660~2,700
Dense, matched larger budget0.558~2,700

Date handling contributes 5.4 points (credited to Wu et al., 2025); user-turn records add 1.2 points and cut reading tokens by 43%. CaseMem remains 3.2 points ahead at a matched budget, and 10.2 points ahead at ~2,700 tokens, so the advantage is not a larger read. Matched median budgets do not give dense retrieval the same date or user-turn inputs, so this attribution is at the level of the retrieval configuration: we attribute the gain to retrieval and record-design choices, not to the four-field interface alone. Retrieval channels are set per benchmark (multichannel lowers LongMemEval-S, 0.478 vs. 0.618), and the revision lists every configuration in one table. The 0.630 in Table 1 and the 0.614 here come from two executions of the same configuration.

W2/Q2. Does CASE improve reward or cost with the same card?

Both, depending on the baseline and setting.

Same card, 150 bundles, history availableQwen reward / tokensGPT reward / tokens
CaseMem+0.232 / 13.8k (mem0 run); 0.227 / 13.9k (dense run)0.351 / 17.7k
mem0 + card0.212 / 15.4k—
Dense + card0.208 / 17.7k0.351 / 25.6k

CaseMem+ beats mem0 + card by +0.021 [+0.003, +0.038] and dense + card by +0.019 [+0.001, +0.036] with Qwen; with GPT it has comparable reward at 31% fewer tokens. Under the released default it again has comparable reward to dense + card at 25% (Qwen) and 37% (GPT) fewer tokens. LightMem with the identical card, as the reviewer suggested (same 50 bundles, Qwen): CaseMem+ scores 0.231 versus 0.213 for LightMem + card (paired Δ +0.018 [−0.009, +0.033]), with CaseMem+ reading 13.7k vs. 14.5k tokens and making no writer calls, while LightMem uses a generative writer whose calls we could not instrument. The card lifts LightMem by +0.034 [−0.000, +0.066], about as much as it lifts mem0 (+0.045). Together, these comparisons establish a Qwen reward advantage over mem0 and dense retrieval when history is available, and competitive reward with fewer reader tokens for LightMem and under the released default. The card also benefits other retrieval systems.

W3/Q3. Where does the procedure come from, and does it generalize beyond development examples?

The compatibility rule is specified for MemoryArena shopping. Its slots represent the earlier purchase, the requested compatibility relation, the avoid-list, and the current preference. Binder development examined electronics items 3–8 and the prompts of items 0–2 and 9–15; items 16–29 across all five categories (70 bundles) were not inspected.

Items 16–29, never inspectedQwen3-32BGPT-4.1-mini
CaseMem+ vs. CaseMem+0.061 [+0.035, +0.088]+0.017 [−0.017, +0.050]
CaseMem+ vs. card only+0.026 [+0.003, +0.048]+0.029 [+0.000, +0.057]
Card vs. unbound reminder+0.024 [+0.005, +0.046]+0.036 [+0.011, +0.062]

This tests uninspected shopping bundles, not transfer to a new domain. The shopping binder is about 1,100 lines of task-specific code: a 518-line slot grammar and 581 lines of runtime binding that parse the task state and render the card (tests are separate). Adapting it to another task means writing a new grammar for that task's relations and a parser for its observable state; the card format and the abstain-when-unresolved logic carry over. The released-default binder reused the grammar unchanged and added 238 lines to recall the earlier purchase from the agent's own memory.

We address the rest concerns in Part 2 below.

AuthorsOpenReview ↗

Response to Reviewer GTGb (Part 2/2)

W4/Q4. When does the ledger help, and what does it add over MemRL?

With a different task-specific query each round, the ledger still improves the controlled store by +0.043 (5 of 6 streams). Feedback also improves a 120-record LLM-distilled naturalized store from 0.152 to 0.217 under a lexical prior in one development stream (+0.001 under a dense prior). The disjoint-source natural store and the held-out categories remain harder: strong initial retrieval leaves less headroom, outcomes are noisy, useful and harmful records can be co-supplied, and early choices can lock in.

Compared with MemRL, which keeps one running utility per memory, CaseMem keeps the source episode's outcome separate from later-use evidence and records family-specific exposure and credited outcomes. Shrinkage and exposure-based exploration act on those statistics; the matched controlled-store comparison gives 0.202 for our ledger, 0.173 for repaired MemRL and 0.177 for static retrieval (ours higher on 5 of 6 streams). This is a system-level comparison, not an ablation of each statistic. Equal exposure credit performs similarly to behavioural credit (0.193 vs. 0.196), so the latter is not needed for the main controlled-store result.

Number corrections. We separate reader tokens from repeated pipeline calls (mem0's 555k is a sum over a median 51 calls per question); correct Table 19's pairwise differences (LightMem +0.021, A-MEM +0.034, ReasoningBank +0.064); label AMA-Bench 0.492 as a four-run mean versus 0.474 for a single run (dense 0.444); and name every learner and execution behind the App. C/G single-record results in Appendix G. None changes the main conclusions.

These experiments directly address the requested grounding controls and attribution checks, and we hope the reviewer will consider them in the assessment.

AuthorsOpenReview ↗

Follow-up to Reviewer GTGb

Thank you again for the specific experimental suggestions. We have now completed the requested matched-card comparisons, including LightMem + card on the same 50 bundles (0.231 vs. 0.213 for CaseMem+, with fewer reader tokens), and expanded the dense + card comparison to all 150 bundles.

We also added the LongMemEval-S attribution ablations and clarified the binder's implementation effort and development/evaluation separation. The revised paper reports these results in Appendix I.

We would appreciate your feedback on whether these additions address your main concerns about fair comparisons, retrieval attribution, and grounding generality. Thank you!

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

The paper introduces CaseMem, a lightweight memory framework for LLM agents that aims to improve not only how past experiences are stored and retrieved, but also how they are applied to current tasks and reused based on subsequent outcomes. Its central insight is that relevant memories are not necessarily useful memories, and effective memory systems should distinguish knowledge storage, task-specific application, and outcome-driven selection. Main Contributions

  1. Efficient memory construction: Introduces structured CASE records containing Content, Address, Scope, and Evidence, enabling reusable memory storage and retrieval without generative construction calls for static histories.

  2. Task-grounded memory application: Proposes CaseMem+, which uses deterministic binding to instantiate reusable procedures with task-specific information from observable states, avoiding ambiguous or inappropriate applications.

  3. Outcome-driven memory reuse: Introduces a lightweight feedback ledger that tracks memory exposure and outcomes, combining relevance, estimated utility, and exploration to improve future memory selection without modifying stored knowledge or retraining the agent.

Experimental Validation The paper evaluates these contributions through three sets of experiments:

  • Static memory retrieval: On LoCoMo, LongMemEval-S, and AMA-Bench, CaseMem achieves competitive performance against established memory systems, including Mem0 and retrieval baselines, while avoiding generative memory-construction calls.

  • Agentic task performance: On MemoryArena shopping tasks, CaseMem+ improves mean string reward over retrieval-only CaseMem from 0.201 to 0.249 with Qwen3-32B (24% relative improvement) and from 0.318 to 0.355 with GPT-4.1-mini (12% relative improvement). Ablations demonstrate complementary benefits from retrieval and grounding, with grounding outperforming generic procedural reminders.

  • Feedback-based adaptation: Controlled experiments with fixed memory stores demonstrate that outcome-driven selection can recover overlooked useful procedures and reduce the reuse of harmful ones. Additional controls show that correctly associated feedback is more effective than stale feedback.

Overall, the results support the claim that memory effectiveness can be improved through task-aware application and adaptive selection without expensive memory reconstruction. However, the feedback mechanism's benefits are primarily demonstrated in controlled settings and do not consistently generalize to natural memory stores or held-out categories. Furthermore, grounding and feedback are evaluated separately rather than as a fully integrated adaptive system.

Critical strengths
  1. Strong empirical evidence for task-grounded memory reuse. The paper demonstrates that retrieval and task-specific grounding provide complementary benefits, with CaseMem+ improving string reward by 24% over retrieval alone on Qwen3-32B and 12% on GPT-4.1-mini. The controlled ablations further show that grounding provides benefits beyond simply including generic procedural instructions. These results provide convincing evidence that how retrieved memories are applied matters, making this the paper's strongest contribution.

  2. Practical and computationally efficient memory framework. CaseMem achieves competitive performance on three static memory benchmarks without generative memory-construction calls. Its design also enables outcome-driven adaptation without retraining the agent or rewriting stored knowledge. Controlled experiments demonstrate that feedback can recover overlooked useful memories and reduce harmful reuse. This offers a practical direction for building more efficient and adaptive agent memory systems, although the feedback results are not yet broadly generalizable.

Critical weaknesses
  1. Limited validation of outcome-driven memory adaptation. While the feedback-based selection mechanism is a central contribution, its improvements are primarily demonstrated in controlled experiments with predefined helpful and harmful procedures. The method does not consistently improve performance on natural memory stores or held-out categories. This raises concerns about whether the proposed feedback mechanism can generalize to realistic agent workloads, limiting the strength of the paper's central claims.

  2. Lack of end-to-end validation and limited methodological novelty. The paper presents task grounding and outcome-driven memory selection as parts of a unified framework, but evaluates them separately, with feedback disabled during grounding experiments and grounding disabled during feedback experiments. Consequently, it remains unclear whether the proposed components work effectively together in a fully adaptive system. Furthermore, the individual techniques, including deterministic slot binding and bandit-style utility-based retrieval, are relatively straightforward extensions of existing approaches. Stronger end-to-end evidence would be necessary to establish the significance of their integration.

Questions for authors
  1. Generalization of outcome-driven adaptation : The paper reports that feedback-based memory selection improves performance in controlled settings but does not consistently improve results on natural memory stores or held-out categories. Could the authors clarify the primary factors behind this gap? In particular, is the limitation primarily due to noisy credit assignment, insufficient exploration, or the quality and diversity of stored procedures? Understanding this would materially affect the assessment of the method's practical applicability.

  2. End-to-end effectiveness of the proposed framework : The grounding and feedback mechanisms are evaluated separately, although their integration is presented as a central contribution. Have the authors evaluated CaseMem+ with both grounding and outcome-driven updates enabled? If so, do the improvements remain complementary, or are there interactions that limit their combined effectiveness? This is important for assessing whether the proposed framework delivers benefits beyond its individual components.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 1S2r

We thank the reviewer for the detailed review and highlighting grounded reuse as the strongest part of the paper. We have now run grounding and outcome updates together, and the new diagnostics explain why feedback helps in some retrieval settings but not others.

Q1/W1. Why does feedback work in some settings but not on disjoint natural stores or held-out categories?

The ledger can also improve an LLM-distilled store. On a 120-record naturalized store with lexical retrieval, it raises reward from 0.152 to 0.217 in a development stream and promotes n43, a procedure distilled from a failed episode, to 114 of 120 selections (Appendix H). This uses a shared-header query and a store distilled from the evaluation episodes, so it does not replace the disjoint-source evaluation. In that separate 69-record store, two distilled natural records score 0.249 and 0.242 when supplied alone, versus 0.226 for static retrieval with two records. Useful content exists; learning to choose and combine it remains difficult.

Our diagnostics point to three constraints: weak reward signals (SD ~0.27 and small observed gaps), co-exposure (a harmful record accompanies a useful one on 118 of 120 held-out home rounds), and early lock-in (at k=1 the learner can switch away from an already useful static choice, 0.192 vs. 0.272). Fixed-partner tests also show that a second record can reduce reward even with selection held fixed.

SettingLedger − staticScope
Planted, shared query+0.0496 streams
Planted, task-specific queries+0.0436 streams; 5 improve
Naturalized, lexical prior, shared query+0.0651 development stream
Naturalized, dense prior, shared query+0.0011 development stream
Disjoint natural, task-specific queries−0.0193 streams
Held-out categories−0.0136 streams

For a rough sense of scale, distinguishing a 0.03 reward gap at SD ~0.27 needs about 1,270 independent exposures per candidate under a simple two-sample approximation, far beyond the 120 rounds available. This does not prove the cause of the natural-store failures, but it suggests that feedback is most useful when a recurring retrieval mistake creates a clear signal and records can be evaluated separately (§4.4).

Q2/W2. Do grounding and feedback work together?

Yes. The compatibility procedure is now one of six selectable records. The ledger chooses which records to supply, and the binder grounds the procedure whenever it is selected (released setting, three development categories, six 120-subtask streams).

Unbound procedureGrounded procedure
Static retrieval0.1880.230
Outcome-aware ledger0.2230.235

The full system has the highest observed mean (0.235), grounding adds +0.042 under static retrieval (5 of 6 streams), and the ledger supplies the grounded procedure on every round. Static retrieval already picks the useful procedure, however, and the ledger chooses the same pair on 93–96% of rounds, so its additional gain over grounded static retrieval is small (+0.005). The joint test establishes that both stages operate in one loop; the selection logs suggest that the additional value of learned selection depends on whether static retrieval makes a selection error. Across all 150 released-default bundles, a post-hoc split shows binding helps by +0.085 [+0.014, +0.155] when the recalled purchase is largely correct and not when it is wrong.

W2 (novelty). What is new about the framework?

The contribution is the persistent separation of what a memory says, when it applies, and what later outcomes say about reusing it. Source provenance and task scope remain attached to a stable record, while a separate ledger updates reuse preferences without rewriting the record or training the LLM. This architecture lets us measure grounding against an unbound reminder, retrieval against systems given the same card, and learned selection against static retrieval and MemRL. The matched-card study finds a Qwen reward benefit over mem0 (+0.021 [+0.003, +0.038]) and dense retrieval (+0.019 [+0.001, +0.036]) with history available, alongside lower reader-token use. The individual operations are deliberately simple; the contribution is how they are connected and evaluated.

We believe these experiments address the two questions the reviewer identified as central to the assessment, and we would appreciate reconsideration in light of the new joint evaluation and failure analysis.

AuthorsOpenReview ↗

Follow-up to Reviewer 1S2r

Thank you for the constructive feedback. We wanted to follow up on the two questions you identified as important to your assessment.

We have now evaluated grounding and outcome-driven selection jointly. The full configuration achieves the highest mean reward (0.235), compared with 0.230 for grounded static retrieval, 0.223 for the unbound ledger, and 0.188 for unbound static retrieval. The selection logs also help explain the interaction: static retrieval already supplies the useful procedure, leaving little selection error for the ledger to correct.

We additionally analyzed the natural-store failures and identified weak reward signals, co-exposure, and early lock-in as contributing factors.

We would appreciate your feedback on whether the joint experiment and these diagnostics address your two main concerns. Thank you!

AuthorsOpenReview ↗

Additional analysis

We wanted to share one additional analysis directly addressing your Q1 on why feedback does not consistently improve natural-store performance. We traced the selection logs on the 69-record disjoint-source store to examine the three factors you raised:

1. Memory quality. Yes, multiple useful procedures are present. For example, two procedures distilled from failed episodes achieve 0.249 ± 0.032 (n39) and 0.242 ± 0.003 when supplied individually, comparable to a hand-written procedure (0.252). Thus, the negative result is not simply due to a lack of useful knowledge.

2. Selection and exploration. Static retrieval supplies n39 on only 14/120 rounds in the examined stream, while the ledger increases its exposure to 101/120 and 85/120 rounds in two learning streams. This shows that outcome feedback can identify and promote useful experience-derived procedures beyond the planted store, even when aggregate reward does not improve.

3. Application and credit. The ledger also repeatedly pairs n39 with n34 (128 co-exposures across streams). In a separate fixed-selection experiment, adding n34 reduces reward from 0.249 to 0.216 (and to 0.192 with another partner, n49). This shows that co-supplied memories can interfere with execution, while shared task outcomes make their individual contributions difficult to distinguish.

Together, these diagnostics show that useful natural procedures can be retained and promoted through feedback, while co-exposure and shared credit help explain why these gains do not always translate into higher reward. This pattern is supported by multiple useful procedures, two fixed-selection partner comparisons, and repeated co-exposure across streams. CaseMem's separation of stored knowledge, selection, and outcome evidence makes these stages directly inspectable without rewriting memory.

For Q2, our joint experiment further demonstrates that grounding and ledger updates operate together, achieving the highest observed mean reward (0.235). The selection logs explain the small additional ledger gain in this setting: static retrieval already selects the useful procedure, leaving little selection error to correct.

We believe these additional experiments directly address your two main questions: when outcome-driven selection helps or is limited, and how grounding and feedback operate together in a unified system. We hope this evidence helps resolve your remaining concerns and would appreciate your reconsideration. Thank you again for your constructive feedback!

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

CaseMem separates stored knowledge, its task-specific application, and evidence from later use. Records keep content, a retrieval address, an applicability scope, and provenance under stable identities, and static stores are built without generative calls. CaseMem+ also binds a fixed procedure to the observable task state, and a separate ledger reranks retrieval from downstream outcomes without rewriting memories or training the agent. The paper reports that CaseMem is competitive on LoCoMo, LongMemEval-S, and AMA-Bench at low construction cost. On MemoryArena shopping, combining retrieval with grounding improves string reward over retrieval alone by 24% (Qwen3-32B) and 12% (GPT-4.1-mini). On a planted store of five procedures, outcome feedback surfaces an overlooked procedure or demotes a harmful one.

Critical strengths
  1. Clear decomposition and transparent reporting. Separating memory storage, task grounding, and outcome-driven selection provides a useful framework. The generic-reminder, unresolved-procedure, and dense-retrieval-plus-card controls help isolate the contribution of grounding (Tables 16, 21), and the generic-reminder control replicates across two reader models. The detailed reporting of negative results, corrected-query reruns, and execution variability makes the evidence and its limitations assessable.
  2. Practical efficiency of static memory construction. CaseMem builds LoCoMo stores in 113 seconds without generative-model calls, compared with hours and thousands of calls for several baselines (Table 11), while maintaining competitive accuracy on LoCoMo and AMA-Bench. This supports the useful finding that effective memory retrieval need not require expensive generative construction.
Critical weaknesses
  1. The main agentic gains come from benchmark-specific grounding, not from memory. CaseMem+ uses one fixed compatibility procedure and a deterministic binder that reads corrective feedback identifying previous ground-truth products (Sec. 3.1; App. F). The released MemoryArena shopping configurations (He et al., 2026) turn off both corrective feedback and history injection, so the protocol departs from the benchmark’s released setting and the results are not comparable with published MemoryArena numbers. Memory itself contributes little: with Qwen, CaseMem retrieval alone adds +0.002 [−0.016, +0.021] over no memory (Table 16), and none of the compared baselines receives the card. Under identical grounding, CaseMem’s advantage over dense retrieval is inconclusive (+0.047 [−0.003, +0.095]), and the retrieval-over-card increment is +0.034, −0.031, 0.000, and +0.051 across four executions on the same bundles (Tables 20–21). GPT exact-target success also does not improve over retrieval alone: 130 versus 132 out of 900 steps (Table 18). Only shopping, one of MemoryArena’s four domains, is evaluated. The headline 24% and 12% gains therefore reflect a hand-written, benchmark-specific scaffold rather than better use of memory.

  2. Outcome-driven selection does not help under realistic retrieval. The positive results use five planted procedures and a shared-header query that makes static retrieval select the same pair on every round. With task-specific queries on a disjoint-source natural store, both learners underperform static retrieval in all three streams: 0.205/0.207 versus 0.226 (Table 26). The frozen configuration also underperforms on held-out categories: 0.245 versus 0.257 (Table 25). With a single injected record, the utility learner falls below static retrieval in all six streams (0.192 versus 0.272; App. G), and on the full benchmark the ledger changes mean reward from 0.179 to 0.178 (Table 22). The abstract’s claim that feedback recovers useful procedures and demotes harmful ones therefore holds only in a constructed setting. Grounding and feedback are also evaluated separately, so the proposed integrated loop is never validated.

  3. Novelty over existing memory systems is limited. MemRL (Zhang et al., 2026) already combines relevance with a feedback-derived per-memory utility while keeping the agent fixed. CaseMem’s additional statistics, shrinkage, and exploration show no demonstrated advantage over MemRL, and the only repaired MemRL comparison does not favor CaseMem (baking 0.225 versus 0.197; electronics 0.229 versus 0.225; App. C). Behavioral credit nearly matches equal credit, and the plain-content ablation establishes no representation advantage (App. G). Static gains mix indexing, date handling, and reading-budget changes. On LongMemEval-S, they come largely from turn-level records and time-aware query expansion, both proposed in the LongMemEval paper itself (Wu et al., 2025). The distinctive contribution of the CASE abstraction therefore remains unestablished.

Questions for authors
  1. Does the shopping setup enable ground-truth feedback or history injection that is disabled in MemoryArena’s released configurations? How much of CaseMem+’s advantage remains when conventional retrieval receives the identical grounded card across all 150 bundles?
  2. Both learners underperform static retrieval with task-specific queries and disjoint-source memories (Table 26), and the frozen configuration underperforms on held-out categories (Table 25). What evidence supports reliable feedback-driven improvement beyond constructed retrieval failures, and how do these results limit the central claim?
  3. Under matched stores, queries, candidate sets, and evaluation budgets, how does CaseMem compare with MemRL (Zhang et al., 2026) and equal-credit utility updates? Which distinctive ledger design choices provide a measurable advantage?
6 comments
AuthorsOpenReview ↗

Response to Reviewer Wfh2 (Part 1/2)

We thank the reviewer for the detailed review and critique. The new experiments address three central concerns: CASE retains reward or reading-cost advantages under matched grounding, binding helps without injected purchase history, and feedback gains persist with task-specific queries.

W1/Q1. Protocol, matched grounding, and the role of memory

Protocol. The original grounding comparisons used include_history=true for every arm, while MemoryArena's released default disables it. We repeated the shopping study under the released default. An audit of 761 configurations verified matched settings across arms, no access to the current answer, and that all other experiments already used the released default. We now report the two protocols separately; the original 24%/12% CaseMem+-over-CaseMem gains belong to the history-available setting.

Matched cards. The original dense + card comparison covered 30 bundles and was inconclusive. The expanded 150-bundle comparison now shows a positive Qwen advantage:

Same grounded card, history availableΔ reward [95% CI]Reader tokens
CaseMem+ − mem0 + card, Qwen+0.021 [+0.003, +0.038]13.8k vs. 15.4k
CaseMem+ − dense + card, Qwen+0.019 [+0.001, +0.036]13.9k vs. 17.7k
CaseMem+ − dense + card, GPT−0.001 [−0.022, +0.021]17.7k vs. 25.6k

Under the released default, CaseMem+ and dense + card have comparable reward while CaseMem+ reads far fewer tokens: +0.000 [−0.020, +0.019] at 11.3k vs. 15.1k with Qwen, and +0.018 [−0.007, +0.044] at 11.6k vs. 18.3k with GPT. The equal-card comparison therefore supports a Qwen reward advantage with history available and a reading-cost advantage under the released default.

Grounding without injected history.

Card vs. unbound reminderQwen3-32BGPT-4.1-mini
History available, 150 bundles+0.023 [+0.010, +0.038]+0.034 [+0.012, +0.057]
History available, 70 never-inspected bundles+0.024 [+0.005, +0.046]+0.036 [+0.011, +0.062]
Released default, 150 bundles+0.018 [+0.005, +0.032]+0.008 [−0.012, +0.027]

Using the agent's own recalled purchase, grounding still improves on the same unbound rule with Qwen. Its increment over CaseMem retrieval is smaller in this setting (+0.008 [−0.009, +0.024]), as the revision states. A post-hoc split offers a possible explanation: grounding beats the reminder by +0.085 [+0.014, +0.155] when the recalled purchase is largely correct, versus −0.004 when it is wrong. This pattern suggests that the benefit of grounding depends on the reliability of the recalled state.

Memory and repeatability. With GPT, CASE retrieval alone improves over no memory in both settings (+0.030 with history; +0.019 [+0.001, +0.035] under the released default). With history available, retrieval raises exact-target successes from 102 to 132 of 900 steps; the card mainly improves attribute satisfaction. The four 30-bundle executions cited in the review measure run variation: hosted agents are not seedable, and the test–retest SD of bundle-mean reward is 0.092, which is why small effects fluctuate on subsets. On the full 150 bundles, CaseMem+ exceeds card-only with both Qwen (+0.025 [+0.009, +0.042]) and GPT (+0.038 [+0.018, +0.056]), and two full Qwen executions give a pooled +0.037 [+0.019, +0.054] over CaseMem retrieval. These comparisons use the history-available protocol. Grounding is evaluated on shopping; a group-travel pilot remained at floor.

We address feedback generalization, MemRL, and representation in Part 2 below.

AuthorsOpenReview ↗

Response to Reviewer Wfh2 (Part 2/2)

W2/Q2. Does feedback work beyond a fixed query and planted memories?

The gain is not restricted to the five-record planted store. On a 120-record store distilled by an LLM from the evaluation episodes (so source and evaluation tasks overlap), with lexical retrieval and the shared-header query, utility-based selection raises reward from 0.152 to 0.217 in one development stream, and it promotes procedure n43, distilled from a failed episode, to 114 of 120 rounds (Appendix H). Under a stronger dense prior on the same store, where retrieval already does well, the gain is +0.001. This shows that outcome feedback can change the reuse of real distilled procedures when the prior errs; it is not a replicated test on disjoint-source tasks.

To test the fixed-query concern directly, we reran the controlled store with a different task-specific query every round:

Controlled store, 6 streamsShared queryTask-specific query
Static0.1600.174
Utility + exploration0.1960.217 (+0.043, 5 of 6)

Correctly associated feedback also outperforms reassociated earlier outcomes by +0.044 [+0.003, +0.086] and +0.053 [+0.019, +0.086] in the two controlled variants.

Why some controls are negative. The reviewer is right that the ledger does not improve the 69-record disjoint-source store with task-specific queries (0.207 vs. 0.226 static), nor the held-out categories (0.245 vs. 0.257). The single-record k=1 control tests a different failure mode: static retrieval already supplies the known useful procedure on every round (0.272), while the learner can explore away from it and lock onto a harmful record (0.192). With k=2, by contrast, the static pair contains a harmful record that feedback can demote (+0.049 with a shared query). These results identify selection headroom, outcome noise, co-exposure and early lock-in as constraints, rather than showing a universal benefit. On the natural store, the best single record is only 0.023 above the static two-record mean; with reward SD ~0.27, an illustrative independent-sample calculation needs roughly 1,270 exposures per candidate for a 0.03 difference, versus at most 120 in a stream. This is a diagnostic, not a sample-complexity guarantee.

The new joint experiment also puts the compatibility procedure inside ledger selection and grounds it whenever selected (reply to 1S2r).

W3/Q3. MemRL, credit, and representation

What differs from MemRL. Both methods keep the LLM frozen and learn retrieval preferences from reward. MemRL maintains a scalar utility for each episodic memory and uses relevance-based ranking with exploration. CaseMem instead keeps source evidence distinct from later use, and separately tracks exposure, credited outcome and task-family preference. A procedure distilled from a failed episode therefore starts with no positive or negative reuse evidence; n43 is promoted through its actual use (Appendix H). Our selection rule also uses family-centred shrinkage and exposure-decayed exploration. These are design differences, not a claim that each one individually explains the gain.

Under matched controlled-store conditions (same store, shared-header queries, dense prior, top-8 candidate shortlist and budget), our ledger achieves 0.217 versus 0.173 for the repaired MemRL adapter and 0.169 for static retrieval across 12 streams. The paired improvement over MemRL is +0.044 [+0.001, +0.087], with our ledger higher in 10 of 12 streams. The separate task-specific-query experiment also shows an improvement over static retrieval (+0.043, 5 of 6 streams). The Appendix C comparison concerns a natural single-record store where differences from static are small relative to run variation. CaseMem additionally connects reuse evidence to explicit scope and task grounding; we do not claim a new bandit algorithm.

Credit and representation. Equal exposure credit performs similarly to behavioural credit (0.193 vs. 0.196), so we recommend the simpler update while preserving the rule actually used in each run. Exposure-based exploration finds an overlooked procedure on 5 of 6 streams (Table 23). The five-record plain-content ablation is too small to establish the value of the indexing fields. On full static benchmarks, CaseMem improves over dense retrieval on identical LoCoMo chunks (0.749 vs. 0.666) and on AMA-Bench at matched depth (0.474 vs. 0.444). On LongMemEval-S it remains ahead at a comparable reader-token budget (0.614 vs. 0.582), though date handling, record granularity and other retrieval choices all contribute; we attribute the gain to the retrieval implementation, not the four-field schema alone.

We believe the expanded equal-card controls, the released-default rerun and the task-specific-query experiments materially address the review's main concerns, and we would appreciate reconsideration of the assessment.

AuthorsOpenReview ↗

Follow-up to Reviewer Wfh2

Thank you again for the detailed review. We wanted to highlight that the revised experiments directly address two central concerns in the original assessment.

First, the expanded 150-bundle identical-card comparisons show a Qwen reward advantage over mem0 (+0.021) and dense retrieval (+0.019), with both paired confidence intervals above zero. Under the released MemoryArena configuration, grounding still improves over an unbound reminder (+0.018), and CASE achieves comparable observed reward to dense + card with 25–37% fewer reader tokens.

Second, outcome-driven selection improves the controlled store even with task-specific queries (+0.043), rather than relying on a fixed query.

We would appreciate your feedback on whether these new controls address the main attribution and protocol concerns. Thank you!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.