acceptodds
Under review as a conference paper at ICLR 2027

CuratorMem: Metadata-Grounded Curation of Accumulating Agent Memory

Abstract

Large language model (LLM) agents act in environments that keep changing, where tools, code and user goals move on between encounters, so their memory fills with successive attempts at related problems that overlap. To deal with this situation, patch-based memory is introduced to manage these attempts: each attempt is recorded as a patch, and the state it supersedes is kept as history, enabling cross-patch retrieval. However, a store built to persist is written once and never revised, so it decays as it grows: redundant entries accumulate and split the retriever’s focus. In a patch-based system, superseded attempts and the ones that replaced them sit side by side, and there is no record to evaluate their worth. For this reason, we propose CuratorMem, a memory layer over an append-only, patch-based store: a manifest carries version lineage and per-entry statistics, an additive curation operator refines and enriches what is stored based on these heuristics, and retrieval is scoped to a task chain and ordered by that lineage. The key idea is to decouple evidence from opinion: curated content is written by a model, but an entry may be endorsed only on a recorded outcome, grounded outside the model that wrote it. Across GAIA, GAIA2, LoCoMo and τ²-bench with multiple backbones, CuratorMem improves on an uncurated patch store and two external memory baselines (A-Mem, Mem0). Every experiment in this paper is backed by full trajectories, and the system will be released as a memory-layer SDK.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, agent memory, memory curation, retrieval, large language models

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_Ax56OpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes an append-only memory method that never deletes memories.

It organizes memories through three steps: record, curate, and store.

One distinctive feature is its endorsement mechanism, which assigns each memory a confidence-like score. This score is then used during subsequent memory retrieval

Critical strengths
  1. The overall design is simple and intuitively‑structured, yielding substantial performance improvements over competing methods in the main experiments.

  2. The component‑wise ablation presented in Table 8 is well‑organized, with confidence intervals provided to back its statistical findings.

Critical weaknesses
  1. CuratorMem’s core performance gains hinge on memory ranking driven by ground-truth labels or environmental feedback, as demonstrated in Table 8. Such objective labels are largely unavailable in most real-world applications, and disabling this feedback eliminates the reported 7.41-point performance uplift. This renders the main-experiment comparison somewhat unfair: unlike CuratorMem, the A-Mem and Mem0 baselines have no access to ground-truth signals for memory construction.

  2. Token consumption results are only partially reported. Given that LLM inference costs constitute a key practical deployment consideration, a full side-by-side comparison of input and output token usage across all memory approaches would facilitate a more thorough evaluation of their respective engineering trade-offs in the main experiment.

Questions for authors

Could authors also report the results for CuratorMem’s self-assessment and no-certificate variants in the main experiments, so they can be compared side by side with the other methods?

1 comment

Here is a point-by-point response. Q:core performance gains hinge on memory ranking driven by ground-truth labels or environmental feedback.

True. This was a fatal flaw in both the experiments and the code that produced them, and there was no way to repair it without substantial rework, since label-driven ranking was a mechanism the earlier pipeline was built around. We therefore spent the week rebuilding those parts. Ranking is now driven exclusively by an outcome recorded by an independent, memory-free run of the same task; the benchmark's official scorer is consulted only to compute the final number and never enters the memory path; each chain is split so that the first 30% of tasks build the store and the remaining 70% are scored, with no label crossing the divide. Components that consulted the label were removed rather than disabled, and every number they had produced was discarded and re-run.

Q:main-experiment comparison somewhat unfair

True. The original submission offered a broad comparison across models, baselines and benchmarks, and attempted to show an advantage on every one of them. Where the effect was marginal, we followed it with a lengthy statistical analysis arguing that it was significant. We now narrow the claim. The method is no longer presented as superior everywhere; it is presented as no worse than the baselines in most settings, and as clearly better in the circumstances where the versioned lineage will take effect—namely, situations involving conflict resolution and temporal evolution. That advantage is bought with tokens, and we state the exchange rate rather than leave it implicit (§5.3). We believe the present version establishes our true contribution and novelty.

Q:self-assessment and no-certificate variants in the main experiments, so they can be compared side by side with the other methods

We agree, and we find the original choice of benchmarks faulty. GAIA is a single-passage lookup benchmark: each question is answered from one retrieved document, and no two answers are versions of one another. GAIA2 introduces asynchronous environment changes, but its tasks are independent and the change lives in the environment rather than in the stored answer. τ²-bench has episodes that are self-contained. None of the three contains the structure the design addresses—two statements about the same fact, of which only the later one still holds. We could inject synthetic version drift into these benchmarks, but the intervention would replace their official scoring protocol, which would make our numbers incomparable with the published ones and would measure our own perturbation rather than the benchmark. We therefore report those runs as a boundary (Appendix G) and evaluate where the structure is native: LoCoMo for the static case, and MAB, whose Test-Time Learning and Conflict Resolution splits are exactly the case in which a later statement overrides an earlier one.

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

The paper addresses memory that decays as it grows: in a patch-based store, a superseded attempt and its replacement sit side by side with no record for choosing between them. CuratorMem keeps the append-only write and adds a metadata manifest, additive refine/critique/enrich curation, chain-partitioned lineage-ordered retrieval, and an endorsement gate that permits a “successful” presentation only when the outcome’s provenance is not the acting model. Validation covers 12 benchmark–backbone cells, a second LoCoMo protocol with distinct questions, read/write cost, and component ablations.

Critical strengths

Strength1: Eq. 5's separation of authorship from certification is cleanly isolated, and the negative result it yields is the paper's most transferable finding. In Table 7a, letting the agent certify its own attempt puts the system below the memory-free arm on both backbones — the store does not merely fail to help, it harms. Table 8's certification panel varies only π_c, and the grounded-outcome row is the only one in that table whose interval excludes zero, with the highest certainty reported there. "A model may write an entry but not grade it" is adoptable independently of this architecture.

Strength2: The standing objection to never deleting is measured rather than argued. In Tables 5–6, read latency tracks the length of the queried chain and is essentially flat in total store size, because a read selects its partition before ranking; index construction and footprint are reported as the costs that do grow. This is what makes the append-only premise practical rather than merely principled.

Critical weaknesses

Weakness1: Table 8's two panels cannot carry the comparative conclusion §4.3 draws from them. The read-policy and certification panels run on different benchmarks with different sample sizes, and the caption states each panel is its own concurrent sweep. §4.3 nonetheless concludes the evidence is "stronger for certification than for any individual read-policy choice" — a comparison across sweeps rather than within one. Inside its own panel, the curated-text estimate sits near zero with certainty close to chance, so the accuracy case for the three curation stages is neither supported nor refuted. Its defensible payoff in the main text is the shorter injected block (§4.2, Cost Analysis), a narrower claim than the title's.

Weakness2: The headline is calibrated above what §4.2's own analysis delivers. Table 2's per-cell claim is unadjusted (footnote 2), and in two cells CuratorMem and Patched are effectively level, including the tie the caption notes. In the drift-corrected comparison, the margin over Patched — the control that isolates curation and the gate from the store itself — excludes zero on GAIA alone; the intervals on the other three benchmarks cross it. Direction over Patched is consistent across every pooled comparison, but magnitude on any single benchmark other than GAIA is not established.

Questions for authors

Question1: Could the curated-text arm — raw patch text served under the gate and lineage ordering — be run inside the certification panel's window, so both mechanisms are estimated in one sweep? That is the comparison §4.3's conclusion requires, and the cheapest way to settle whether the curation stages earn their LLM calls.

Question2: Of the four benchmarks, only GAIA's vs-Patched interval excludes zero. Is there a second condition — the full τ²-bench rerun described in J.1, for instance — where that margin clears the variance floor reported there? One such result would firm up §4.2 considerably.

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

This paper proposes CuratorMem, an agent memory framework that preserves historical experiences through append-only storage, refines them using LLM-based curation, and prioritizes verified experiences based on external execution outcomes. Experiments on four benchmarks show improvements over existing memory approaches.

The system has three main components: Store, Retrieval and Curation. The core of CuratorMem is a versioned memory system, where the memory is never deleted, and new memory is attached to old memories in a chain, and new memory is prioritized over the old ones during retrieval. CuratorMem is empirically validated on four datasets (GAIA, GAIA2, LoCoMo and tau-2 bench) using three different language models, demonstrating strong performance over baselines such as A-mem and Mem0.

Critical strengths
  1. The paper proposes a reasonable framework for managing evolving agent memories. In particular, separating LLM-generated memory content from externally verified execution outcomes is useful for improving memory reliability.
  2. The experiments cover multiple benchmarks and backbone models. The authors also provide ablation studies and statistical analyses to support their findings. The overall results are good and show consistent improvements over existing memory approaches in the main evaluation.
  • The paper studies a practical problem: agents face evolving tools, databases and the memory layer needs to support these challenges.
  • The design of the chained/versioned memory is reasonable and intuitive for addressing the challenges in the motivation.
  • Comprehensive experimentation with 4 benchmarks and 3 large language models.
Critical weaknesses
  1. The method mainly combines existing techniques, including append-only storage, LLM-based refinement, and outcome-guided retrieval, with limited technical novelty. Table 8 shows only marginal improvement from curated text, while most gains appear to come from outcome-grounded certification. It remains unclear whether Refine, Critique, and Enrich are necessary, or if a simpler approach could achieve similar results.
  2. Most experiments repeatedly evaluate the same tasks with different paraphrases, rather than testing whether the agent can transfer learned experiences to new but related tasks. This is particularly important since the proposed curation pipeline aims to extract reusable and generalizable knowledge. Moreover, the certification mechanism relies on benchmark labels or official evaluators in several experiments, which may not be available in real-world applications. Although the authors include some label-free experiments, these are relatively limited and do not provide sufficient evidence of the method's effectiveness in more realistic and continuously evolving environments.
  • The motivation of the paper and the empirical experimentation of the paper doesn't match. The motivation is to address the challenges of evolving tools, codebases and user questions presented to the agent, but the experiments are done with repeated-task reuse.
  • The paper organization and writing is very confusing. For example, the first few sentences are extremely hard to parse, and therefore the motivation of CuratorMem is unclear. In line 101, the paragraph seems to be misplaced. It appears abruptly in the context. In Eq. 3 and Eq. 4, what these two equations are trying to convey are easily explained in plain language. Using equations unnecessarily increases the cognitive load to understand the paper.
  • The empirical experiments are designed for a very limited setting: using memory for repeated task reuse, i.e., "overfitting to one task". This could be a useful diagnostic setting, but raises concerns regarding the potential application of the method. This also raises concerns regarding evaluation, e.g., the "raw" evaluation should report pass@k to be fair with the other compared methods.
  • Lack of qualitative analysis of the produced memory. While the empirical results in Table 2 are impressive, the paper could be strengthened much by showcasing the quality of the memory produced by CuratorMem vs. Patched (and/or other baselines).
Questions for authors
  1. Could the authors compare against a simpler baseline using raw experiences with outcome-based ranking, without the curation pipeline?
  2. Could the authors provide separate ablations for Refine, Critique, and Enrich to demonstrate their individual contributions?
  • Line 13: "Each attempt is recorded as a patch" -> are you referring to each trajectory or textual memory of an attempt?
  • Line 15: "A store built to persist" -> what store? in the previous sentence the memory is patched, but here the store is never revised, which seems conflicting.
  • Line 173: How is the "store" implemented? Is it a raw text file, a database of trajectories, or something else?
  • Line 181: What is the relationship between updater U and the Read/Write operation defined earlier. It is also confusing that the updater only takes x_t (the task description) as the input, without the trajectory.
  • Line 181: Why do you focus on non-additive change here? The later sections says the store is "append-only", so it's conflicting here.
  • Line 286: What's the reason for introducing the avoidance group? Are you instructing the model to avoid the mistakes in the content? Also why are entries ranked k..2k-1 considered bad and needs to be avoided?
1 comment

Q:The motivation of the paper and the empirical experimentation of the paper doesn't match. limited technical novelty. marginal improvement.

True. This was a fatal flaw in both the experiments and the code that produced them, and there was no way to repair it without substantial rework, since label-driven ranking was a mechanism the earlier pipeline was built around. We therefore spent the week rebuilding those parts. The true novelty of this paper lies within its versioned lineage, and the current version is centered around this, the improvements this structure can leads to, and the cost and burden this structure would incur.

Q:Repeated task reuse and empirical experiments are designed for a very limited setting

Fixed. Ranking is now driven exclusively by an outcome recorded by an independent, memory-free run of the same task; the benchmark's official scorer is consulted only to compute the final number and never enters the memory path; each chain is split so that the first 30% of tasks build the store and the remaining 70% are scored, with no label crossing the divide. Components that consulted the label were removed rather than disabled, and every number they had produced was discarded and re-run.

Q:the paper could be strengthened much by showcasing the quality of the memory produced by CuratorMem vs. Patched.

We now give a representative example before the conclusion, and its difference is now apparent with the fellow baseline methods.

Q: How is the "store" implemented

The store is a metadata manifest: we add extra information to the original memory text, and uses these extra information for better retrieval and better weight ranking. Just like rounds of model training, you get the query, compute kv pairs, calcute a softmax, and then adjust the weight. However, the current system is not at all this sophisticated, we have only a simple "weight update" intuition, which we name it "curation".

Q: Could the authors provide separate ablations for Refine, Critique, and Enrich.

This is another major problem. In the main figure our components are name "store, retrieve and curate", but somehow in different places "Refine, Critique, and Enrich" are used to describe our methods. There is nothing new to these. Store, retrieve and curate, based on lineaged version patch, should be what truly differentiates our work from others. Ablations and detailed analysis are offered to claim the now unified terms and methods.

Q: what consists of a patch

what consists of a patch is now described clearly in the prose: it is the raw text, along with the metadata with it. Together, they build a lineage tree, just like how modern big data systems need lineage to manage their data, we believe that as memories become more complex, it will gradually evolve to the form similar to database systems.

Q: compare against a simpler baseline using raw experiences

The comparsion is reworked. we find the original choice of benchmarks faulty. GAIA is a single-passage lookup benchmark: each question is answered from one retrieved document, and no two answers are versions of one another. GAIA2 introduces asynchronous environment changes, but its tasks are independent and the change lives in the environment rather than in the stored answer. τ²-bench has episodes that are self-contained. None of the three contains the structure the design addresses—two statements about the same fact, of which only the later one still holds. We could inject synthetic version drift into these benchmarks, but the intervention would replace their official scoring protocol, which would make our numbers incomparable with the published ones and would measure our own perturbation rather than the benchmark. We therefore report those runs as a boundary (Appendix G) .

Q: Why do you focus on non-additive change here?

The Git analogy is apt: if an entry can be edited in place, there is no displacement to record, and rollback—along with any method that reasons over versions—has nothing to operate on. A non-additive store therefore removes the object that version-based methods are defined over, which is why we fix additivity as a property of the substrate rather than vary it as a factor. However, it is not a life-or-death design principle, but only a trivial implementation detail. Additivity is no longer emphasized in the main prose, but instead only occurs rarely in implementation details.

Q: avoidance group

One interesting thing we found is that including past failures within memory does not necessarity improves scores, but it does save tokens because models will know what not to try. We thought it was worth reporting, but we did the experimental report poorly. No we are NOT instructing the model to avoid the mistakes in the content, we reworked those parts so now it seems clear. Entries ranked k..2k-1 are too much for simple top k-retrieval and introduces extra token cost, that was all we were trying to say.

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

This paper presents CuratorMem, a memory layer for LLM agents that preserves successive task attempts in an append-only patch store. It combines version lineage, outcome metadata, and a refinement, critique, and enrichment pipeline. Retrieval operates within task chains and prioritizes entries endorsed by independently recorded outcomes. Experiments on GAIA, GAIA2, LoCoMo, and τ2-bench report improvements over an uncurated patch store, A-Mem, and Mem0, primarily under repeated-task reuse.

Critical strengths
  1. Preserving earlier versions while separating model-generated guidance from recorded outcomes is a sensible design for maintaining auditable agent memory.
  2. The evaluation covers four benchmarks and several backbones. The native LoCoMo evaluation, chain-key ablations, and label-free pilot experiments provide useful evidence about the method’s scope and limitations.
Critical weaknesses
  1. The comparisons do not adequately separate memory design from access to evaluation feedback. Table 11 confirms that CuratorMem uses gold-derived outcomes on GAIA and LoCoMo and the official evaluator on GAIA2, while A-Mem and Mem0 do not use this signal. GAIA2 curation also receives failure information derived from oracle events. The label-free experiments partially address this concern, but their limited scale and inconsistent certification quality leave the practical advantage uncertain.
  2. The evaluation only partially tests the problem motivating the paper. Most experiments repeat tasks with unchanged facts and expected answers, which primarily measures reuse of previous solutions. This does not establish adaptation to changing APIs, outdated knowledge, or rollbacks. The native LoCoMo evaluation is a useful addition, but covers only three conversations. Controlled experiments involving actual state changes and recovery of the appropriate historical version are still needed.
  3. The external baselines are limited to A-Mem and Mem0. More recent and closely related systems, such as Memento 2 and ChronoMem, are discussed but not evaluated. The capability comparison does not establish an empirical advantage over these methods, particularly when preserving and retrieving version history is a central contribution.
  4. The benefit of the main curation and retrieval components remains unclear. In Table 8, curated text improves performance by only 0.63 points and lineage ordering by 1.41 points, with both confidence intervals crossing zero. The reuse-based ranking statistic has a negative point estimate. These results support outcome-based endorsement more clearly than the additional refinement, critique, enrichment, and ranking machinery.
  5. The statistical evidence for broader superiority is uneven. In Table 10, the confidence intervals for improvements over Patched and Mem0 include zero on both GAIA2 and τ2-bench. The corrected LoCoMo comparison covers only 100 questions from one conversation and one backbone. Alongside the reported run-to-run variation, these results warrant more qualified claims and further repeated evaluation of the complete systems.
Questions for authors

Please refer to the summary of weaknesses.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.