Artificial Intelligence · arXiv:2608.22533 v2 · submitted 23 Aug 2026
CONTRAMEM: Learning Self-Evolving Procedural Memory from Contrasting Multi-Model Trajectories
The paper says
“Autonomous computer-use agents are increasingly applied to long-horizon tasks requiring coordinated application calls, persistent state tracking, and verifier-sensitive writes, yet they remain prone to procedural failures: misreading application state, tool semantics, or task progress.”
more of the abstract
Procedural memory promises more consistent decisions and less redundant exploration, but constructing high-quality memory without model training remains challenging. We introduce CONTRAMEM, a source-flexible, training-free framework for self-evolving procedural memory that treats same-task outcome variation as supervision: differences in correctness, efficiency, recovery, and failure modes expose outcome-relevant procedural distinctions, distilled into a compact bank of app-level Function Cards and task-level Skill Cards that evolves through localized curation rather than append-only accumulation or whole-bank rewriting. On held-out GAIA2/ARE computer-use tasks, CONTRAMEM more than doubles the success rate across the three source-model targets (26.2% to 55.3%), with consistent per-model gains (GPT-5.5: 27.5 to 61.0; Claude Sonnet 4.6: 28.0 to 52.5; DeepSeek V4 Pro: 23.0 to 52.5). The same bank transfers unchanged to the unseen Qwen3.7 Plus (18.5 to 35.5), indicating transferable procedural knowledge rather than model-specific behavior. The same construction carries over unchanged to AppWorld, beating both no memory and its own single-source self-memory variant for all three mid-tier agents on both public test splits. Under a matched trajectory budget, heterogeneous multi-model trajectories yield stronger memory than self- or same-model multi-rollout memory: the margin comes from contrastive behavioral diversity, not stronger source agents or more sampling.
from the abstract
Pith says
Machine review · deepseek-v4-flash · 27 Aug 2026 · of version 1 of the paper; version 2 is newer · what was read was not recorded · not checked by a person
It can be wrong. Challenge this review or reply to it.
Holds up, with conditions. A serious, well-validated paper on training-free procedural memory; the headline result survives scrutiny, but the causal-attribution mechanism is only supported end-to-end, and the paper deserves peer review with an eye on code release and a direct attribution probe. This line is wrong
3 major objections · 4 minor
How often objections from reviews like this one are right: not yet measured
Not checked: figures, code, what the references say.
The paper says, at Methodology, 'Contrastive Skill Memory' (Reflector and Curator paragraphs; Appendix B.4–B.5)
The review did not quote this passage.
Pith says: Objection 1 of 3 · major
The load-bearing assumption is that the Reflector can correctly locate the causal decision boundary separating success from failure in a contrast packet and that the Curator preserves this boundary under semantic-closure edits. This assumption is never directly evaluated. The existing controls vary trajectory inputs (self memory vs. multi-model), the construction model (GPT-4.1-mini on AppWorld), and the memory type (Table 3), but none measures whether a card's core_rule corresponds to the actual causal contrast in the packet.
more of objection 1
The alternative account that the pipeline distills useful but generic advice ('verify before destructive writes', 'ask before ambiguous writes') is consistent with the data, because such advice would also improve held-out success. I recommend one of: (a) a sampled oracle evaluation of Reflector attribution against an independently annotated decision boundary; (b) a card-level flip analysis showing which cards drive the failure-to-pass and pass-to-fail transitions; or (c) rewording the mechanistic claims from 'the causal decision boundary' to 'transferable procedural guidance' wherever they appear in the abstract and methodology. As written, the causal-attribution half of the central claim is supported only end-to-end.
The paper says, at Appendix A.8, Eq. (1); Table A1
The review did not quote this passage.
Pith says: Objection 2 of 3 · major
The retrieval configuration contains several free parameters — the BM25 soft app-family prior weight lambda_1, the retrieval caps (top-3 Skill Cards, top-2 Function Cards), and the AppWorld task-start memory budget — but the paper provides no sensitivity analysis and does not state how these values were selected.
more of objection 2
If these parameters were chosen after inspecting held-out performance, the reported gains could be inflated; if they were fixed a priori, that should be stated explicitly. Please report the selection procedure and provide a small sensitivity sweep (e.g., lambda_1 in {0, 0.1, 0.5}, Skill/Function caps in {1, 2, 3, 5}) on at least one ability or benchmark to show that the main conclusion is robust to reasonable variation in these settings.
The paper says, at Figure 3; Appendices A.6–A.7
The review did not quote this passage.
Pith says: Objection 3 of 3 · major
The headline comparison to AWM and ACE is against evidence-matched adaptations of those systems, not against the original published implementations or their original benchmark scores. The appendices document the adaptations carefully and honestly, but the main text's claim of being '30.0 points above the strongest prior memory system' (Introduction, repeated in the Abstract and Conclusion) and the Figure 3 label do not carry this caveat.
more of objection 3
This is important because a reader could reasonably interpret the number as a direct comparison to the published systems' results. Please qualify the claim in the main text, for example by writing 'strongest prior memory system under our evidence-matched adaptation' or by moving the exact comparison to the appendices and using a more hedged phrase in the abstract.
4 minor objections
The paper says, at Table 1, Claude Sonnet Time row
Pith says: minor objection 1 of 4
ContraMem's Time success (2.5%) is below the self-memory control (10.0%) for Claude Sonnet, and the three source targets' Time aggregate is essentially flat. The experimental discussion is honest about this, but the abstract's unqualified 'beats ... self memory' formulation and Figure 1's 'beats self memory on every metric' should be qualified to macro-level metrics or explicitly note per-cell Time regressions.
The paper says, at Abstract and Experiments, AppWorld validation
Pith says: minor objection 2 of 4
The phrase 'the same construction carries over unchanged to AppWorld' overstates the actual transfer: the AppWorld instantiation uses a deterministic task signature instead of an ability label, a doc-delta rule for API cards, a different Reflector focus block, a different construction model (GPT-4.1-mini), and a different injection budget (Appendices B.7–B.11). The algorithmic recipe is the same, but the instantiation is benchmark-aware; please rephrase to 'the same algorithmic recipe' or state the adapters explicitly where the claim first appears.
show 2 more
The paper says, at General reproducibility
Pith says: minor objection 3 of 4
No code release is mentioned. Releasing the bank construction pipeline, retrieval scoring, and frozen-bank configuration would substantially improve reproducibility, especially given the number of prompt templates and benchmark-specific adapters in Appendices A and B.
The paper says, at Table 1
Pith says: minor objection 4 of 4
The table formatting appears corrupted in several cells: for Claude Sonnet, '52.552.5' should presumably be '52.5' (self) and '57.5' (ContraMem), and '10.051.0' should be '10.0' and '51.0'; for DeepSeek V4 Pro, '77.532.5' should be '77.5' and '32.5'. Please regenerate the table to ensure each cell contains a single value.
What would settle it
Run a synthetic attribution probe on 50 GAIA2-style tasks where, for each task, the success/failure trajectories are scripted to differ in exactly one known procedural decision (e.g., completing the safe branch vs asking immediately; enumerating the full target set vs skipping one write), with verifier outcomes assigned deterministically from that decision. Feed these packets through the exact Reflector and Curator prompts in Appendices B.4–B.5 and measure how often the emitted Skill Card's core_rule and completion_condition match the manipulated boundary (precision/recall against known ground truth) and how often it introduces rules not supported by the packet. High recall with few spurious rules would resolve the concern; low recall would mean the end-to-end gains need a different mechanistic explanation.
from the skeptic's reading
How the review went
4 readings by deepseek-v4-flash · 27 Aug 2026
- Reader holds up, with conditions
- Skeptic agrees
- Editor wrote the verdict above
- Referee major revision: 3 major objections, 4 minor
Not run on this paper: the simulated authors' defence.
Pith did not check this review's objections against the paper.
The review in full
The review in brief, machine-written
You should know one thing up front: this is a serious empirical paper, not a flashy sketch. The core idea—treating same-task outcome variation across models as supervision, then distilling it into typed Function/Skill Cards through a local curator—is genuinely new as a combination, and the evaluation is considerably more careful than the field's average. The headline results (26.2% to 55.3% held-out on GAIA2/ARE, transfer to unseen Qwen3.7 Plus, consistent gains on AppWorld) come with matched multi-rollout controls, a self-memory control inside the same architecture, McNemar tests, and honest reporting of the Time limitation. The appendix is a real attempt at reproducibility: full prompts, schemas, baseline adaptation details with fidelity caveats, runtime accounting. The AppWorld construction using GPT-4.1-mini as Reflector/Curator is a nice control against the objection that a stronger model is doing the work.
The soft spots are real but mostly in the interpretation, not the headline. The stress-test concern lands: the Reflector/Curator attribution accuracy is never measured directly. The paper does not show that the emitted cards encode the actual causal decision boundary rather than useful generic advice ('verify before destructive writes', 'ask before ambiguous writes'). The existing controls—self-memory still helps, multi-rollout trails contrastive—do rule out source-strength and sample-count explanations, but they do not rule out the possibility that the bank is a better collection of generic heuristics. If attribution is often wrong, the explanation of why ContraMem works would need revision, even though the success rates might hold. To me this is a moderate concern about the mechanism paper, not a fatal flaw in the method.
Two smaller items: no code or data release, which matters for a system like this; and no direct comparison with MemCollab, the closest prior work, although the difference in goals is stated clearly. The retrieval hyperparameters (BM25 prior, caps) are fixed without sensitivity analysis—minor.
Who is this for? Anyone working on agent memory, self-improving agents, or computer-use evaluation. It deserves a serious referee: a good reviewer will push for an attribution probe (e.g., hand-label a sample of cards as causal vs. generic) and for code release, but the paper's central empirical claim is supported. I would cite it and would bring it up in a reading group focused on agent memory.
The strongest objection
The central claim is that same-task outcome variation is procedural supervision and that the Reflector/Curator (Appendix B.4–B.5) distills the causal decision boundary between success and failure into Skill Cards. The load-bearing, unverified step is attribution reliability: the Reflector is prompted to 'locate the decision boundary' and 'attribute the outcome,' and the Curator is constrained by semantic closure, but the correctness of the extracted boundary is never measured against an oracle. Because the bank is built once and reused for every target, any systematic misattribution is inherited by all downstream evaluations. The existing controls (self memory, matched multi-rollout in Table 3, GPT-4.1-mini construction on AppWorld) vary trajectory inputs or construction model, but they do not test whether emitted cards encode the actual causal contrast rather than useful generic procedure. An alternative account is consistent with the data: the LLM distiller may produce helpful transferable advice ('verify before destructive writes', 'ask before ambiguous writes') that improves agents even when the specific attributed boundary is spurious. Table 1's Time results, where Claude Sonnet's self memory is 10.0% but ContraMem is 2.5% and contrastive memory does not beat self memory overall on Time, show the method's limits but do not address attribution quality. Thus the mechanistic half of the strongest claim is supported only end-to-end, not directly; if attribution accuracy is low, the explanation of why ContraMem works would need substantial revision even though the success rates might stand.
I reviewed the strongest claim against the evidence. The empirical results are internally consistent: paired held-out evaluations, a matched multi-rollout control (Table 3), a weaker construction model on AppWorld (GPT-4.1-mini), explicit privacy and leakage validations, and honest reporting of the Time limitation all support the headline success rates. The weakest link is not the evaluation itself but the interpretive mechanism: the paper asserts that same-task contrast exposes the causal decision boundary, yet the only enforcement is prompt-level constraint in the Reflector/Curator, with no direct measurement of attribution accuracy. Because the bank is built once and reused, a systematic misattribution would be inherited everywhere. The self-memory and multi-rollout controls vary trajectory inputs, not attribution correctness, so they cannot rule out an alternative explanation: the distiller may be producing useful generic procedural guidance that helps regardless of whether the specific attributed boundary is causal. End-to-end transfer provides indirect evidence, but a strong LLM distiller with generic prior knowledge could yield helpful text even from spurious attributions, so the end-to-end result conflates attribution quality with generic helpfulness. This does not overturn the empirical claim; it narrows what is proven. The reader's weakest assumption identifies the same issue, and the proposed synthetic probe would settle it by measuring attribution precision and recall against known decision boundaries. The verdict remains conditional: accept the empirical results as credible, but require the attribution probe (and ideally code/data release) before the mechanistic claim is fully verified.
The referee's report
If the empirical results hold, this is a substantial contribution to training-free procedural memory for computer-use agents. The idea of using cross-model disagreement as a supervision signal is clean, and the evaluation is unusually careful: matched-budget multi-rollout controls, self-memory controls, unseen-model transfer, frozen-bank runtime, cross-benchmark validation, and transparent construction-cost accounting are all present. The AppWorld construction using GPT-4.1-mini as the Reflector/Curator is a good control against the concern that gains come from a stronger construction model. The paper also reports its main limitation honestly: text-injected memory does not resolve time-sensitive failures, and Time results show only small or mixed gains. The principal weakness is that the mechanistic claim about distilling the causal decision boundary is supported only end-to-end; the experiments do not directly measure whether emitted cards encode the true causal contrast rather than useful generic heuristics. This is a load-bearing gap for the paper's framing, though not for the more modest claim that the memory bank improves held-out performance.
Pith's reading of the paper (a machine's summary, not the authors')
The paper tries to establish that an autonomous computer-use agent can build reusable procedural memory without retraining by treating the differences between several models attempting the same task as supervision. It claims that distilling the boundary between success and failure into compact cards—global Function Cards describing how tools behave and ability-level Skill Cards describing decision rules—and maintaining the bank through small local edits raises held-out success on GAIA2/ARE tasks from 26.2% to 55.3% on average across three source models, and that the same untouched bank lifts an unseen model from 18.5% to 35.5%. The construction also beats both no-memory and single-source self-memory on AppWorld for three mid-tier agents, which points to contrastive behavioral diversity rather than extra sampling as the source of the gain.
What carries the argument. The load-bearing object is the task contrast packet: one reference task's trajectories from multiple source models, normalized into a common event sequence and grouped so that outcome, action spans, writes, and verifier feedback can be compared side by side. Around it sit the two memory representations—Function Cards, which record observed callable-function contracts, side effects, and misuse guards, and Skill Cards, which record the distilled decision boundary with a trigger, core rule, and completion condition. The Reflector reads packets to locate the boundary and emits at most three candidate deltas; the Curator edits the existing bank through localized ADD, PATCH, MERGE, NARROW, or NOOP operations, and a deterministic retriever injects a small task-relevant subset at runtime.
Core claim. The central claim is that same-task outcome variation is a supervision signal: when several models attempt one reference task, their differences in correctness, efficiency, recovery, and failure modes expose the procedural decision boundary that explains why some runs succeed and others fail. ContraMem encodes those boundaries as typed memory rather than raw traces: Function Cards capture evidence-grounded tool contracts, Skill Cards capture transferable rules with explicit completion conditions, and a Curator applies the smallest valid edit (Add, Patch, Merge, Narrow, No-op) so the bank stays compact. The paper reports that this bank more than doubles source-target macro success on held-out GAIA2/ARE tasks (26.2% to 55.3%), transfers unchanged to an unseen target, and beats no-memory and self-memory baselines on both AppWorld public test splits; controlled ablations attribute the gain to heterogeneous contrast rather than sampling volume or source strength.
The premise it rests on. The whole pipeline rests on the assumption that the reflecting model can reliably identify which actual decision separated success from failure in a batch of same-task runs, and that the curator's edits do not introduce spurious rules; if attribution is wrong, the cards encode correlations rather than causes.
If the paper is right (Pith's inferences, not the authors')
Held-out success on GAIA2/ARE more than doubles from 26.2% to 55.3% averaged across the three source targets, with every target gaining (GPT-5.5 +33.5, Claude Sonnet 4.6 +24.5, DeepSeek V4 Pro +29.5).
The shared bank transfers unchanged to Qwen3.7 Plus, a target that contributed no trajectories, raising its success from 18.5% to 35.5%.
On AppWorld, the same construction beats both no memory and target-specific self-memory for all three mid-tier agents on both public test splits, with the largest margins in scenario completion (60.1% vs 44.6% for self-memory on Test-Normal).
Under a matched trajectory budget, three heterogeneous models' trajectories outperform three same-model rollouts (77.5% vs 70.0% macro), indicating contrastive behavioral diversity is the active ingredient.
Localized curation removes 24.9% of the skill cards while raising GPT-5.5 held-out success from 65.0% to 71.9%, so the gain comes from sharper cards, not more memory.
A testable consequence the paper leaves implicit: if attribution is sound, then contrast packets are a free self-supervision signal, and a direct probe would be to hold out outcome labels from the Reflector and measure how much of the gain remains.
The paper's own Time-ability result (self and contrastive memory within 10/120 vs 9/120) suggests a boundary: text-injected memory repairs failures it has encoded but not asynchronous state tracking, pointing to a hybrid of curated memory with a runtime obligation controller.
Transfer to an unseen model could be pushed further by evaluating open-ended deployment with the ability label removed, letting retrieval select across all banks and testing whether app-independent rules survive cross-family transfer.
One could falsify the causal claim by reversing an extracted decision rule in a card (e.g., ask-then-write instead of write-then-ask) and checking whether the target agent flips its behavior as predicted; if it does not, the card is not what drives the outcome.
Check this review
Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.
How often reviews like this one are right
Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.
How often objections from reviews like this one are right: not yet measured
Reviews by people
This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.
The paper
Abstract
Autonomous computer-use agents are increasingly applied to long-horizon tasks requiring coordinated application calls, persistent state tracking, and verifier-sensitive writes, yet they remain prone to procedural failures: misreading application state, tool semantics, or task progress. Procedural memory promises more consistent decisions and less redundant exploration, but constructing high-quality memory without model training remains challenging. We introduce CONTRAMEM, a source-flexible, training-free framework for self-evolving procedural memory that treats same-task outcome variation as supervision: differences in correctness, efficiency, recovery, and failure modes expose outcome-relevant procedural distinctions, distilled into a compact bank of app-level Function Cards and task-level Skill Cards that evolves through localized curation rather than append-only accumulation or whole-bank rewriting. On held-out GAIA2/ARE computer-use tasks, CONTRAMEM more than doubles the success rate across the three source-model targets (26.2% to 55.3%), with consistent per-model gains (GPT-5.5: 27.5 to 61.0; Claude Sonnet 4.6: 28.0 to 52.5; DeepSeek V4 Pro: 23.0 to 52.5). The same bank transfers unchanged to the unseen Qwen3.7 Plus (18.5 to 35.5), indicating transferable procedural knowledge rather than model-specific behavior. The same construction carries over unchanged to AppWorld, beating both no memory and its own single-source self-memory variant for all three mid-tier agents on both public test splits. Under a matched trajectory budget, heterogeneous multi-model trajectories yield stronger memory than self- or same-model multi-rollout memory: the margin comes from contrastive behavioral diversity, not stronger source agents or more sampling.
The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.
abstract compiled · 2026-09-23
The authors' main claim, as the classifier picked it out 0.55
“On held-out GAIA2/ARE computer-use tasks, CONTRAMEM more than doubles the success rate across the three source-model targets (26.2% to 55.3%), with consistent per-model gains (GPT-5.5: 27.5 to 61.0; Claude Sonnet 4.6: 28.0 to 52.5; DeepSeek V4 Pro: 23.0 to 52.5).”
How the main claim is stated: asserted 1.00
What the abstract itself states, as probabilities: claims first 0.07 · states limitation 0.20 · human participants 0.03 · controlled comparison 0.96 · randomized assignment 0.02 · states quantitative result 0.99 · compares with prior results 0.96 · mentions code or data availability 0.04
The abstract, sentence by sentence
This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.
| Sentence | Role | The authors' own work | States the main conclusion | Strength |
|---|---|---|---|---|
| Autonomous computer-use agents are increasingly applied to long-horizon tasks requiring coordinated application calls, persistent state tracking, and verifier-sensitive writes, yet they remain prone to procedural failures: misreading application state, tool semantics, or task progress. | background 0.97 | 0.05 | 0.02 | asserted 1.00 |
| Procedural memory promises more consistent decisions and less redundant exploration, but constructing high-quality memory without model training remains challenging. | gap 0.70 | 0.04 | 0.03 | asserted 0.87 |
| We introduce CONTRAMEM, a source-flexible, training-free framework for self-evolving procedural memory that treats same-task outcome variation as supervision: differences in correctness, efficiency, recovery, and failure modes expose outcome-relevant procedural distinctions, distilled into a compact bank of app-level Function Cards and task-level Skill Cards that evolves through localized curation rather than append-only accumulation or whole-bank rewriting. | contribution 0.69 | 0.91 | 0.26 | asserted 1.00 |
| On held-out GAIA2/ARE computer-use tasks, CONTRAMEM more than doubles the success rate across the three source-model targets (26.2% to 55.3%), with consistent per-model gains (GPT-5.5: 27.5 to 61.0; Claude Sonnet 4.6: 28.0 to 52.5; DeepSeek V4 Pro: 23.0 to 52.5). | result 1.00 | 0.96 | 0.40 | asserted 1.00 |
| The same bank transfers unchanged to the unseen Qwen3.7 Plus (18.5 to 35.5), indicating transferable procedural knowledge rather than model-specific behavior. | result 0.77 | 0.95 | 0.11 | hedged possibility 0.78 |
| The same construction carries over unchanged to AppWorld, beating both no memory and its own single-source self-memory variant for all three mid-tier agents on both public test splits. | result 1.00 | 0.95 | 0.09 | asserted 1.00 |
| Under a matched trajectory budget, heterogeneous multi-model trajectories yield stronger memory than self- or same-model multi-rollout memory: the margin comes from contrastive behavioral diversity, not stronger source agents or more sampling. | result 0.55 | 0.93 | 0.26 | asserted 1.00 |
What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.97
What was examined, and what was not
Sources read
- arXiv listing abstract v1
Not examined
- full text
- figures and tables
- references and citing sentences
- relations to other papers
Levels run
- P abstract
Not run
- S sections
- T body sentences
- C citations
- R cross-paper relations
How the labels were made
Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 6,031 input tokens.
Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON
Figures (3)
Figures are the authors', reproduced from the paper.
Cited by 3 Pith papers
Reviewed papers on Pith that cite this one. The full citation record
- RSI-PDEbench: A Benchmark for Self-Improving Agents in PDE Solving cs.AI · Nov 2026
- RSI-Opt: Recursive Self-Improvement Optimizer Agents For Model Training cs.AI · Oct 2026
- Mining Agent Skills from Production Traces cs.AI · Oct 2026
How the literature uses it
What this paper does with the arXiv papers it cites
What it cites · 10 sentences without a confident label
Uses the method or tool of 2 papers
-
We evaluate on /, the benchmark executed in the Agents Research Environments () runtime [ref] , across five abilities (Execution, Search, Ambiguity, Adaptability, Time), with 40 reference and 40 held-out tasks per ability.
2509.17158 · Experimental Setup · 0.88
-
We evaluate on /, the benchmark executed in the Agents Research Environments () runtime [ref] , across five abilities (Execution, Search, Ambiguity, Adaptability, Time), with 40 reference and 40 held-out tasks per ability.
2602.11964 · Experimental Setup · 0.88
Compares with 3 papers
-
To compare against published agent-memory baselines, we evaluate offline Agent Workflow Memory (AWM) [ref] , ACE [ref] , and raw trajectory retrieval on GPT-5.5 over Execution, Search, and Ambiguity, testing whether the gains reduce to trajectory replay, induced workflows, or an evolving playbook.
Agent Workflow Memory · Experimental Setup · 0.98
-
To compare against published agent-memory baselines, we evaluate offline Agent Workflow Memory (AWM) [ref] , ACE [ref] , and raw trajectory retrieval on GPT-5.5 over Execution, Search, and Ambiguity, testing whether the gains reduce to trajectory replay, induced workflows, or an evolving playbook.
Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models · Experimental Setup · 0.98
-
Most directly related is MemCollab, which likewise contrasts trajectories from different models on the same task [ref] —but toward transferability, distilling agent-invariant constraints so one memory can be shared across backbones. uses the same disagreement for a different end: rather than normalizing model differences away, it exploits them to raise memory quality among frontier sources under a matched budget.
MemCollab: Cross-Model Memory Collaboration via Contrastive Trajectory Distillation · Related Work · 0.95
Cites as support 7 papers
-
Append-only accumulation compounds this with redundancy and drift: agents over-follow retrieved experience, propagate stale errors, and degrade as continuously updated memories accumulate faults [ref] .
Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models · Introduction · 0.99
-
Append-only accumulation compounds this with redundancy and drift: agents over-follow retrieved experience, propagate stale errors, and degrade as continuously updated memories accumulate faults [ref] .
2505.16067 · Introduction · 0.99
-
Append-only accumulation compounds this with redundancy and drift: agents over-follow retrieved experience, propagate stale errors, and degrade as continuously updated memories accumulate faults [ref] .
2603.10600 · Introduction · 0.99
Cites as background 6 papers
-
Recent benchmarks stress long-horizon, stateful app-agent behavior—conversational tool use in ToolSandbox, cross-application coding agents in AppWorld, and dynamic asynchronous tasks with ambiguity, time obligations, and action-level write verification in / [ref] —exposing a gap targets.
2602.11964 · Related Work · 0.80
-
Closer to our setting, Trajectory-Informed Memory Generation produces strategy and recovery tips for future AppWorld tasks [ref] , and Contextual Experience Replay keeps a dynamic buffer of environment dynamics for web agents [ref] .
2603.10600 · Related Work · 0.93
-
A large body of work converts past executions into reusable experience: verbal reflections (Reflexion), lessons (ExpeL), executable skills (Voyager), induced workflows (Agent Workflow Memory) [ref] , and distilled thought templates or procedural memories [ref] .
ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory · Related Work · 0.97
Challenges and discussion
Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.
Come back by email
A short list of the week's newly reviewed papers. Nothing is sent until you confirm from your inbox, and every email has a link that stops it. No account.
No comments yet.
Sign in to comment