acceptodds
Under review as a conference paper at ICLR 2027

Recursive Experiential–Working Memory Evolution for Long-Horizon Agent Harnesses

Abstract

Recursive self-improvement (RSI) remains hard in long-horizon tasks, where growing histories obscure the task state and misalign skill invocation, while failures are difficult to trace to specific harness components, hindering effective evolution. We introduce Recuris, a recursive Experiential–Working Memory architecture for long-horizon agent harnesses, in which Working Memory tracks task progress and guides skill selection from Experiential Memory, grounding skill use in current needs rather than the full history. This coupling also turns execution into structured evidence that localizes failures to specific memory components. Across tasks, a fixed Meta-Agent uses this evidence to make localized, validation-gated updates to the memory system. These updates reshape execution and yield new evidence, forming a bounded recursive memory-evolution loop. Across four challenging long-horizon benchmarks and ten models, substantially improves task success for both frontier and open-source models: on -Bench Retail it adds points to GPT-5.6 Sol and to Claude Opus 5, taking Opus 5 to , and / points on Qwen3.6-27B/35B on SkillFlow. The advantage widens as the interaction horizon grows, to points on the longest tasks, and common long-horizon failures fall by up to . These results position recursively evolving memory as a scalable foundation for RSI, enabling agents to continuously transform accumulated experience into increasingly effective long-horizon behavior.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Recursive Self-Improvement, Agent, Memory

Reviews

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

This paper introduces Recuris, a recursive Memory architecture for long-horizon agent harnesses. This harness tracks task progress and guides skill selection from Experiential Memory, grounding skill use in current needs rather than the full history. This coupling also turns execution into structured evidence that localizes failures to specific memory components. Across tasks, a fixed Meta-Agent uses this evidence to make localized, validationgated updates to the memory system. Across four benchmarks and ten models, Recuris reports improvements in most model–benchmark pairs.

Critical strengths
  1. Recuris connects task-state tracking, skill retrieval, and evidence-based completion checks, while using the resulting structured traces to identify which memory component needs repair.

  2. Experiments span four benchmarks and ten models, reporting improvements in 38 of 40 model–benchmark pairs.

Critical weaknesses
  1. Figure 3(b) compare against other baseline methods, but only with the Doubao-2.0-Pro worker across three benchmarks. Extending these comparisons to other models and Terminal-Bench would better establish the method’s general advantage.

  2. Figure 5(c) reports tokens per success, but explicitly excludes memory evolution, including Meta-Agent calls and repeated candidate validation.

  3. Although structured traces improve fault localization, the paper does not clearly isolate the methodological novelty beyond combining state tracking, diagnostic logging, and memory edits.

  4. The appendices provide component descriptions and examples, but do not present the full prompts for Meta-Agent diagnosis and patch generation or working-memory updates.

Questions for authors
  1. Can you report the total token usage and cost of evolution?

  2. What distinguishes the proposed failure-localization mechanism from standard structured logging followed by LLM diagnosis?

7 comments
AuthorsOpenReview ↗

[1/4] Response to Reviewer qnwC

We sincerely thank you for the careful review and valuable feedback. We are glad that you found our paper clear and easy to follow, interesting and useful, with only minor or fixable concerns about its soundness. Please see below for our responses to your comments.

Weakness 1: Comparison with the Baselines on Other Models and on Terminal-Bench.

In response to your concern about comparisons on other models, we extend the comparison of Figure 3(b) to four further workers on all three benchmarks. Each baseline is re-adapted on the worker's own rollouts with the budget of Figure 3(b). Recuris uses the frozen memory evolved with Doubao-2.0-Pro, without any adaptation on the new workers. The tables report success (%) on the tasks of Figure 3(b), with the gain of Recuris over the base agent in parentheses; we have added these results to the revised paper (Appendix C.5, Table 7, with a pointer in Section 4.3).

τ2\tau^2-Retail (86 tasks × 4):

MethodDeepSeek-V4.1-FlashGPT-6.1-TerraClaude Sonnet 5.5Gemini 3.8 Flash
Base agent67.253.265.474.4
ACE [1]73.361.068.972.1
SkillX [2]73.855.569.274.7
Ratchet [3]72.157.366.071.2
SkillOpt [4]69.257.364.873.5
Evo-Harness [5]72.756.167.269.8
Recuris84.0 (+16.9)76.5 (+23.3)77.9 (+12.5)84.9 (+10.5)

τ2\tau^2-Airline (29 tasks × 4):

MethodDeepSeek-V4.1-FlashGPT-6.1-TerraClaude Sonnet 5.5Gemini 3.8 Flash
Base agent82.882.881.983.6
ACE81.080.281.984.5
SkillX81.982.880.284.5
Ratchet84.581.984.580.2
SkillOpt84.580.284.581.9
Evo-Harness81.081.981.986.2
Recuris87.9 (+5.2)85.3 (+2.6)86.2 (+4.3)87.1 (+3.5)

SkillFlow (114 tasks × 3):

MethodDeepSeek-V4.1-FlashGPT-6.1-TerraClaude Sonnet 5.5Gemini 3.8 Flash
Base agent56.155.653.855.0
ACE60.862.355.955.0
SkillX57.053.554.455.6
Ratchet54.459.452.355.6
Evo-Harness55.657.352.653.2
Recuris67.5 (+11.4)68.1 (+12.6)65.2 (+11.4)65.5 (+10.5)
  1. Recuris is the best method on every new worker and every benchmark. It leads the strongest re-adapted baseline by 8.7 to 15.4 points on Retail, 0.9 to 3.4 on Airline and 5.8 to 9.9 on SkillFlow. The strongest baseline changes from one worker to another, whereas Recuris leads on all of them, which shows that its advantage is general and does not depend on the worker.

  2. The frozen memory improves every new worker, whereas the re-adapted baselines often do not. Without any adaptation, Recuris raises the base agent in all twelve cases, by 10.5 to 23.3 points on Retail, 2.6 to 5.2 on Airline and 10.5 to 12.6 on SkillFlow. The baselines adapt to each worker with its own rollouts and still fall below the base agent in 21 of their 56 cases. What Recuris learns in one evolution run transfers to new models, which shows the generalizability of the evolved memory.

  3. On Terminal-Bench, Recuris is evaluated under test-time adaptation, a different setting from Figure 3(b). Each Terminal-Bench task has its own environment, toolchain and goal (Section 3.4), and the benchmark provides no training split. For this reason, we do not run cross-task evolution there: Recuris keeps the same Skill Memory and the same Meta-Agent, but updates memory only between attempts on the same task, and tasks are isolated from one another. The five baselines of Figure 3(b) accumulate memory across tasks: they learn on training tasks and are evaluated, frozen, on unseen ones. This differs from test-time adaptation (TTA) within a task, so placing the two side by side would not be an aligned comparison. The aligned comparison is pass@4 with fixed memory under the same attempt limit: with Doubao-2.0-Pro, TTA solves 53 of the 87 tasks against 51 for pass@4 (Appendix C.1), and it improves all ten models over the base agent by 2.5 to 3.8 points (Table 1). Cross-task accumulation on Terminal-Bench, and a comparison with these methods under one protocol, is a direction we will explore in future work.

AuthorsOpenReview ↗

[2/4] Response to Reviewer qnwC

Weakness 2 & Question 1: Total Token Usage and Cost of Evolution.

  1. Most of the evolution budget goes to candidate validation, and the Meta-Agent takes a quarter. One evolution run of Recuris uses 107.0M tokens, about 37 USD at list prices; this is the evolution cost that Figure 5(c) excludes. The Meta-Agent uses 27.5M tokens over four rounds, 88% of them cached re-reads of the same session context. The remaining 79.4M are rollouts, about four fifths of which serve candidate validation at the gate, and only a change that passes is kept. Every change that Recuris keeps has been validated, which makes its updates reliable and robust.

  2. One evolution run is reused across models, giving larger gains at a smaller budget. The table compares the adaptation budgets of all six methods on τ2\tau^2-Retail, summed over four workers (Doubao-2.0-Pro, GPT-6.1-Terra, Claude Sonnet 5.5 and Gemini 3.8 Flash); it is added to the revised paper as Table 5 (Appendix C.3), together with the budgets per worker, which are also given in our response to Reviewer XifB (Weakness 2 & Question 2). Each baseline is re-adapted on every worker, whereas Recuris evolves once. ACE, SkillX and Evo-Harness learn offline from one shared set of base-agent rollouts, so their rollout tokens are the same.

MethodOptimizer / Meta-Agent tokensRollout tokensTotal tokensApprox. cost (USD)Mean test-split gainTokens per point of gain
ACE3.9M34.6M (shared)38.5M21+1.428M
SkillX6.2M34.6M (shared)40.8M23+1.724M
Ratchet21.4M256.6M278.1M130-0.4no gain
SkillOpt8.1M239.2M247.3M110+2.3110M
Evo-Harness0.2M34.6M (shared)34.8M17-0.7no gain
Recuris27.5M79.4M107.0M37+16.96.3M

Recuris uses 107.0M tokens (about 37 USD) for a mean gain of +16.9 points, whereas SkillOpt and Ratchet, which like Recuris optimize while running, use 247.3M and 278.1M (about 110 and 130 USD) for +2.3 and -0.4; per point of gain, Recuris needs 6.3M tokens against 110M for SkillOpt. A single evolution run brings large gains to different downstream models, demonstrating the effectiveness and generalizability of Recuris.

AuthorsOpenReview ↗

[3/4] Response to Reviewer qnwC

Weakness 3 & Question 2: How Our Failure Localization Differs from Standard Structured Logging Followed by LLM Diagnosis.

We first clarify that the novelty of Recuris lies in two contributions, not in a combination of existing parts:

  • EM-WM coupling. Existing methods typically rely on one kind of memory: they retrieve skills from the instruction or the interaction history, or they track progress without using it to select experience. Recuris couples the two, so that a verified working state decides which experience is invoked and when. Experience stays aligned with the current state of the task, however long the interaction grows. This improves the accuracy of skill invocation and makes long-horizon problem solving efficient, reliable and stable.
  • Recursive self-improvement driven by structured traces. Existing self-evolving methods update memory from the final outcome or the agent's trajectory, which show that a task failed but not which part of the memory to repair. In Recuris, every step leaves a record of the memory system's decisions, and a fixed Meta-Agent uses these records to repair the component that caused each failure. Each repair is targeted, and the next round builds on it. This makes self-improvement directed, adaptive to different models and tasks, and more effective.

Difference from standard structured logging followed by LLM diagnosis. Our failure localization belongs to the second contribution and differs in three respects.

  1. It records different evidence. A raw trajectory, which is what standard structured logging provides, records what the agent did: its actions, observations and outcome. It shows that a task failed and at which step, but not why. Our structured trace Γ\Gamma records what the memory system decided at every step: the open goals, the invoked skill and the state that invoked it, the proposed and committed state update, and the checker's decision (Section 3.2). These records exist only because of the EM-WM coupling, so finer logging of a plain agent cannot produce them.

  2. It attributes a failure to a memory component, which a raw trajectory cannot do. In the exchange of Figure 2, the agent reuses the original item ID. The raw trajectory is identical whether the skill lacks the variant rule, the goal was never pending, no rule fired at the draft, or the checker accepted the wrong receipt. These are four causes in four components, each needing a different edit. The structured trace separates them, because it records each component's decision at that step. With the same LLM diagnoser, fault-localization accuracy is 64.8% with the structured trace against 37.0% with the raw trajectory (Figure 6).

  3. It leads to effective repair, as a new experiment with the same LLM diagnoser shows. The same Meta-Agent evolves memory on τ2\tau^2-Retail from four kinds of evidence, with the same initial memory, evolution rounds, gate and patch interface. Each setting adds to the one above it, and the last one is the structured trace defined in Section 3.2, which is the method of the paper; the third keeps the memory-system events only as counts per episode, to test whether the step-level record matters. Each setting is run twice, and the final memories are evaluated on the 86 test-split tasks × 4 (added to the revised paper as Table 6, Appendix C.4):

Evidence read by the Meta-AgentWhat it containsTest-split success, % (run 1 / run 2)Mean
Outcome onlywhether each trial succeeded77.6 / 78.277.9
Raw trajectory+ the agent's messages, tool calls and tool results68.9 / 68.968.9
Transcript + episode-level counts+ how often each memory event occurred in the episode65.1 / 82.373.7
Per-step structured trace Γ\Gamma (Recuris, Section 3.2)+ at every step: open goals, invoked skill, proposed and committed state update, checker decision85.5 / 83.184.3

With raw trajectories, that is, with standard structured logging, the Meta-Agent still produces edits that pass the gate on the evolution tasks, but they are aimed at the wrong component and do not hold on the test split (68.9%). With episode-level counts, it knows how often skills were invoked and the checker intervened, but not at which step or under which state, and its two runs differ by 17 points. With the per-step structured trace, each edit repairs the component that actually failed, and the evolved memory is the best in both runs, 84.3% on average: +15.4 [+10.0, +20.8] over the raw trajectory and +10.6 [+6.5, +14.8] over the episode-level counts. The difference comes from the evidence alone: the step-level record of the memory system's decisions, not more logging. A raw trajectory tells that a step failed; our trace tells which memory component to edit, and this is what turns diagnosis into effective repair.

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

This paper proposes Recuris, a recursive Experiential-Working Memory architecture for improving long-horizon LLM agents without modifying the underlying model. The framework couples Working Memory (WM), which maintains a verified task state, with Experiential Memory (EM), which provides relevant skills based on the agent's current execution needs. It further introduces a Meta-Agent that analyzes structured execution traces, localizes failures to specific memory components, and performs targeted updates through a validation-gated recursive evolution process.

Critical strengths

S1. I find the motivation convincing. Long-horizon agents often struggle to maintain accurate task states and reuse relevant experiences as interactions become longer. The proposed EM-WM coupling provides a reasonable solution by explicitly tracking unresolved goals and invoking skills according to the current execution state. I also appreciate the separation between proposed and verified state updates, which can help prevent incorrect completion claims. Extending this architecture to structured failure diagnosis and targeted memory evolution is an interesting contribution.

S2. The paper provides a relatively comprehensive evaluation across ten models and four benchmarks, covering both frontier and open-source models. I appreciate the comparisons with several recent self-evolving memory approaches. The improvements on long-horizon tasks are encouraging, and the additional analyses of memory coupling, failure localization, and recursive evolution help explain the effectiveness of the framework.

Critical weaknesses

The paper introduces several related mechanisms, including verified working-state tracking, state-grounded skill invocation, structured failure diagnosis, and targeted recursive memory updates. Although the ablation studies provide useful evidence, I am not fully convinced that the specific benefits of these mechanisms have been sufficiently distinguished. For example, Figure 5 shows that WM only already improves Retail performance by 23.9 points, compared with 25.4 points for the complete Recuris framework. This suggests that explicit working-state tracking alone accounts for a substantial portion of the improvement in this setting. It would be helpful to better understand what additional benefits the complete coupling provides beyond a strong working-memory mechanism. Similarly, Figure 6 demonstrates that structured traces improve failure-localization accuracy, but this experiment relies on injected faults and does not directly establish how much structured diagnosis contributes to downstream memory evolution. The recursive-versus-reset comparison in Figure 7 demonstrates the benefit of retaining previous updates, but a comparison with memory evolution using raw trajectories or outcome-based feedback under the same update budget would provide stronger evidence for the proposed targeted evolution mechanism.

Questions for authors

Q1. Could the authors provide a more systematic summary of held-out test performance across the evaluated models, preferably with uncertainty estimates? In particular, I would appreciate some discussion of the negative transfer observed in Appendix C.2, such as Qwen3.5-4B on Retail and Qwen3.6-27B on Airline. What characteristics of the evolved memory or target models might explain these regressions?

Q2. Could the authors further isolate the contribution of structured failure diagnosis to recursive memory evolution? For example, how would the final task success change if the Meta-Agent performed memory updates using raw trajectories or outcome-only feedback instead of structured traces, while keeping the same evolution rounds and validation budget? This would help establish whether improved failure localization directly translates into better memory evolution.

Q3. I would appreciate further clarification regarding computational overhead. In addition to execution-token consumption, Recuris introduces working-memory updates, skill invocation, verification, and Meta-Agent calls during evolution. Could the authors report the overall computational cost or token consumption of the evolution process? This seems particularly relevant to Terminal-Bench, where the matched-attempt experiment reports a relatively small improvement of 2.3 percentage points while requiring additional Meta-Agent computation.

6 comments
AuthorsOpenReview ↗

[1/4] Response to Reviewer NErk

We sincerely thank you for the positive evaluation and valuable feedback. We are glad that you found our paper clear and easy to follow, interesting and useful, with a convincing motivation and encouraging improvements on long-horizon tasks. We especially appreciate your recognition of our separation between proposed and verified state updates, as well as of structured failure diagnosis with targeted memory evolution as an interesting contribution. Please see below for our responses to your comments.

Weakness 1: Benefit of the Complete Coupling beyond a Strong Working Memory.

The table gives the gain over the base agent when parts of one evolved memory are removed (Figure 5):

VariantRetailAirline
EM only (skills, no working state)+2.0+1.5
WM only (working state, no skills)+23.9+4.0
State plus the whole skill library at every turn+7.5+2.4
Recuris (the state invokes skills)+25.4+8.5
  1. On Retail the coupling adds little because the task relies mainly on working memory. Most Retail failures are requests that are recorded but never executed, which a verified working state resolves. WM alone already gains 23.9 points, and adding EM brings the gain to 25.4. Tasks differ in which memory they need: Retail needs WM strongly and EM little.

  2. On tasks that rely on both memories, the coupling yields a clear synergy. Airline tasks turn on policy rules: they need the working state to keep the current goal and the experiential memory to supply the matching rule. WM alone gains 4.0 points, EM alone gains 1.5, and the coupling gains 8.5, which exceeds the sum of the two individual gains. The coupling is also what allows EM to work: without a state, skills barely help, and with a state but the whole library shown without selection, success falls below WM alone. Only when the working state invokes the matching skill does EM take full effect, demonstrating the synergy of the EM-WM coupling.

  3. On Retail, the coupling improves the efficiency of problem solving. Retail relies little on EM, so the coupling does not bring the synergy seen on Airline; what it does is reduce the errors made along the way. We ran Recuris and the WM-only variant on all 114 Retail tasks × 4 and compared them task by task; overall success is 79.8% against 77.9%. Invoking the matching skill before a write cuts the write calls rejected by the tool from 67 to 8. With fewer failed calls to repair, Recuris completes the tasks in fewer interaction turns on average, and fewer turns mean fewer tokens: in Figure 5(c), Recuris uses the fewest tokens per success. The coupling improves not only accuracy but also the efficiency of problem solving.

  4. The coupling lets Recuris optimize both memories adaptively, according to what each task needs. Tasks differ in how much they need EM and WM, and this cannot be known in advance. With EM and WM coupled, the trace records the decisions of both the state and the skills, so the Meta-Agent can tell whether a task lacks EM, WM or both, optimize the corresponding part, and keep the two working together. On Retail, by round 2 it has added 13 skills, three invocation rules and two checkers. By contrast, the five baselines of Figure 3(b) optimize only one of these parts, and all fall below the base agent on Airline. Recuris offers a more complete set of optimization targets and adapts better to different tasks and models, which shows its adaptivity and generality.

AuthorsOpenReview ↗

[2/4] Response to Reviewer NErk

Weakness 1 & Question 2: Contribution of Structured Failure Diagnosis to Memory Evolution.

As you suggest, we ran an end-to-end evolution comparison on τ2\tau^2-Retail. The Meta-Agent updates memory from outcome-only feedback, raw trajectories or structured traces, with the same evolution rounds and validation budget; the initial memory, the Meta-Agent, the gate and the patch interface are also the same. We add one intermediate setting, which keeps the memory-system events only as counts per episode, to test whether the step-level record matters. Each setting adds to the one above it, and the last one is the structured trace defined in Section 3.2, which is the method of the paper. Each setting is run twice, and the final memories are evaluated on the 86 test-split tasks × 4. This experiment is added to the revised paper (Appendix C.4, Table 6, with a pointer in Section 4.5):

Evidence read by the Meta-AgentWhat it containsTest-split success, % (run 1 / run 2)Mean
Outcome onlywhether each trial succeeded77.6 / 78.277.9
Raw trajectory+ the agent's messages, tool calls and tool results68.9 / 68.968.9
Transcript + episode-level counts+ how often each memory event occurred in the episode65.1 / 82.373.7
Per-step structured trace Γ\Gamma (Recuris)+ at every step: open goals, invoked skill, proposed and committed state update, checker decision85.5 / 83.184.3
  1. The structured trace evolves the best memory in both runs. With the same rounds and validation budget, Γ\Gamma reaches 84.3%, which is 6.4 points above outcome-only evidence [+2.6, +10.3] and 15.4 points above the raw trajectory [+10.0, +20.8].

  2. The reason is that only the structured trace records the decisions of the memory system itself. The raw-trajectory setting is not short of updates: two rounds of edits pass the gate in each of its runs. But a raw trajectory records what the agent did, not which memory decision led to the failure, so these edits are not aimed at the component that actually failed; they pass on the evolution tasks and do not hold on the test split. Γ\Gamma records, at every step, the open goals, the skill that was invoked and the checker's decision, so the Meta-Agent can localize a failure to a specific component and repair it locally. This agrees with Figure 6, where fault-localization accuracy is 64.8% with the structured trace and 37.0% with the raw trajectory. Better localization translates directly into a better memory, which confirms the effectiveness and necessity of structured diagnosis.

  3. The step-level record is what makes the trace effective. The third setting tells the Meta-Agent how often skills were invoked and how often the checker intervened in an episode, but not at which step or under which state. Its two runs differ by 17 points (65.1% and 82.3%), and Γ\Gamma is 10.6 points higher [+6.5, +14.8]. Knowing that memory events occurred is not enough; the trace has to record the decision made at each step, as defined in Section 3.2.

AuthorsOpenReview ↗

[3/4] Response to Reviewer NErk

Question 1: Held-out Performance with Uncertainty, and Negative Transfer.

We report every frozen-memory comparison of Table 1 on the held-out test split only, as the change from the base agent with its 95% interval (10,000 paired, task-clustered bootstrap resamples). Bold marks strict gains, whose interval lies entirely above zero. The table is added to the revised paper as Table 4 (Appendix C.2).

ModelRetail test split, Δ [95% CI]Airline test split, Δ [95% CI]
Granite-4.1-3B+0.58 [-6.10, +6.98]+2.34 [-1.56, +7.03]
Qwen3.5-4B-2.64 [-7.78, +2.22]+3.02 [-3.45, +10.34]
Qwen3.5-9B+1.99 [-5.62, +7.26]+2.72 [+0.54, +5.43]
GPT-OSS-20B+15.41 [+4.37, +23.85]+3.88 [+0.86, +7.33]
Qwen3.6-27B+16.28 [+10.61, +22.24]-5.60 [-13.79, +1.72]
Qwen3.6-35B+0.29 [-4.38, +6.24]-0.43 [-6.03, +5.17]
Doubao-2.0-Pro+21.51 [+13.66, +29.36]+1.6 [-2.34, +5.73]
Gemini 3.7 Flash+3.49 [-1.74, +8.72]+0.86 [-1.72, +4.31]
GPT-5.6 Sol+14.53 [+7.85, +21.51]+1.72 [-3.45, +8.62]
Claude Opus 5+15.12 [+9.88, +20.64]+1.72 [+0.00, +4.31]
  1. The frozen memory remains effective on new tasks. On the test split, Recuris improves 17 of the 20 model-domain pairs, seven of them strictly and by up to +21.5 points. These gains come from generalizable in-domain knowledge and experience accumulated during memory evolution, rather than from patches fitted to the evolution tasks.

  2. The decreases reflect how a model's failures are distributed between the evolution and test splits, not a limitation of the framework. For the two cases you name, success on the three task splits is (without memory → with memory):

Evolution tasksDev tasksTest tasks
Qwen3.5-4B, Retail30.2 → 70.858.3 → 66.774.3 → 71.7
Qwen3.6-27B, Airline75.0 → 85.268.8 → 78.884.1 → 78.4

The evolved memory repairs the failures it was shown: success rises clearly on the evolution and dev tasks of both models. On the test split, however, both models already succeed on 74% and 84% of the tasks without memory, and the failures that remain there are not the ones exposed by the evolution tasks. Grouping the Retail test tasks by the model's success without memory shows where the memory acts:

Test tasks, by success without memoryQwen3.5-4B, Retail (-2.64 overall)Qwen3.6-27B, Retail (+16.28 overall)
Below 50%8 tasks, +17.217 tasks, +43.4
50% to 99%58 tasks, -2.645 tasks, +19.2
100%24 tasks, -9.424 tasks, -8.3

Even for Qwen3.5-4B, the memory raises the tasks that the model used to fail by 17.2 points. Tasks that a model already solves every time can only stay or drop, and they drop by a similar amount in the pair with the largest gain. The two pairs differ in how much is left to repair: Qwen3.6-27B gains 19 to 43 points on its 62 tasks below 100%, whereas Qwen3.5-4B has only 8 tasks below 50%, and its 58 mid-range tasks, which it fails only occasionally, do not change. For Qwen3.6-27B on Airline, three tasks account for the full net decrease.

The same model shows both outcomes: Qwen3.6-27B gains 16.28 points on the Retail test split and loses 5.60 on the Airline test split. The decreases come from whether, under a given split, the failures exposed by the evolution tasks match those on the test tasks, rather than from the framework itself. This behavior is expected: the memory improves a model on failures of the same type as those it has seen during evolution, and it can do little for failures of a type it has never seen. Thank you for raising this point. Covering the failure types that the evolution tasks do not expose is important for bringing gains on every task, and it is a main focus of our future work.

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

Recuris couples experiential skills with verified working memory to improve long-horizon agent execution. Task state guides skill invocation, while evidence-based checkers control progress updates. A fixed Meta-Agent uses structured execution traces to diagnose failures and update the external memory-control layer, keeping the underlying model frozen. Experiments across four benchmarks and ten models examine task success, component contributions, failure localization, and iterative memory improvement.

Critical strengths
  • The framework connects task-state tracking, timely skill invocation, and evidence-based completion checks in a coherent way.

  • The experiments provide evidence beyond improvements on the evolution tasks.

Critical weaknesses
  • The main table mixes evaluation scopes: most τ² results combine evolution, development, and test tasks, while some rows report test results only. Appendix C.2 provides the breakdown but also shows several held-out regressions. The broad improvement claims should therefore be based primarily on consistently reported held-out results.

  • The computational tradeoff remains incompletely characterized. Reported tokens per success exclude evolution, and optimization budgets for competing memory methods are unclear. Terminal-Bench matches worker attempts but adds Meta-Agent computation. This limits conclusions about the practical advantage over allocating more computation to existing approaches.

Questions for authors
  • Could you summarize the frozen-memory comparisons in Table 1 using held-out tasks only, with uncertainty estimates, and clarify how the overall “38/40” improvement claim changes?

  • What optimization budgets were used for Recuris and the five memory baselines? Please summarize Meta-Agent usage, validation-rollout costs, and which computational resources were matched.

4 comments
AuthorsOpenReview ↗

[1/3] Response to Reviewer XifB

We sincerely thank you for the positive evaluation and valuable feedback. We are glad that you found our paper clear and easy to follow, interesting and useful, with recognition of its soundness. We especially appreciate the comments that our framework connects task-state tracking, timely skill invocation and evidence-based completion checks in a coherent way, with experiments providing evidence beyond the evolution tasks. Please see below for our responses to your comments.

Weakness 1 & Question 1: Held-out Results with Uncertainty and the 38/40 Claim.

To address your concern, we report every frozen-memory comparison of Table 1 on the held-out test split only, as the change from the base agent with its 95% interval (10,000 paired, task-clustered bootstrap resamples). Bold marks strict gains, whose interval lies entirely above zero. The table is added to the revised paper as Table 4 (Appendix C.2).

ModelRetail test split, Δ [95% CI]Airline test split, Δ [95% CI]
Granite-4.1-3B+0.58 [-6.10, +6.98]+2.34 [-1.56, +7.03]
Qwen3.5-4B-2.64 [-7.78, +2.22]+3.02 [-3.45, +10.34]
Qwen3.5-9B+1.99 [-5.62, +7.26]+2.72 [+0.54, +5.43]
GPT-OSS-20B+15.41 [+4.37, +23.85]+3.88 [+0.86, +7.33]
Qwen3.6-27B+16.28 [+10.61, +22.24]-5.60 [-13.79, +1.72]
Qwen3.6-35B+0.29 [-4.38, +6.24]-0.43 [-6.03, +5.17]
Doubao-2.0-Pro+21.51 [+13.66, +29.36]+1.6 [-2.34, +5.73]
Gemini 3.7 Flash+3.49 [-1.74, +8.72]+0.86 [-1.72, +4.31]
GPT-5.6 Sol+14.53 [+7.85, +21.51]+1.72 [-3.45, +8.62]
Claude Opus 5+15.12 [+9.88, +20.64]+1.72 [+0.00, +4.31]
  1. Counting test splits only, 38/40 becomes 36/40. Recuris improves 17 of the 20 τ2\tau^2 model-domain pairs on the test split; with 9 of 10 SkillFlow pairs and 10 of 10 Terminal-Bench pairs, this gives 36 of 40, which the revised paper now states in the Introduction.

  2. The frozen memory remains effective on new tasks. On the test split, Recuris improves 17 of the 20 model-domain pairs, seven of them strictly and by up to +21.5 points. These gains come from generalizable in-domain knowledge and experience accumulated during memory evolution, rather than from patches fitted to the evolution tasks.

  3. The three decreases reflect how a model's failures are distributed between the evolution and test splits. In these three pairs, the models' failures are concentrated in the evolution tasks, where the memory repairs them: Qwen3.5-4B, for example, rises from 30.2% to 70.8% on its Retail evolution tasks. On the test split, these models already succeed 74% to 85% of the time without memory, and the failures that remain there are not the ones exposed by the evolution tasks.

AuthorsOpenReview ↗

[2/3] Response to Reviewer XifB

Weakness 2 & Question 2: Optimization Budgets, Meta-Agent Usage and Validation Cost.

In response to your concern about the optimization budgets, we report the full adaptation budget of all six methods on four workers (Doubao-2.0-Pro, GPT-6.1-Terra, Claude Sonnet 5.5 and Gemini 3.8 Flash): optimizer and Meta-Agent tokens, and all rollout tokens of the worker and the user simulator. Matched across methods are the worker, the user simulator, the adaptation tasks (the same 16 evolution and 12 dev tasks of τ2\tau^2-Retail) and the evaluation (the same 86 test-split tasks × 4). Each baseline is re-adapted on every worker. Recuris evolves its memory once, with Doubao-2.0-Pro, and the other workers use the frozen memory unchanged, so its budget is counted once. Both tables below are added to the revised paper as Table 5 (Appendix C.3).

Totals over the four workers:

MethodOptimizer / Meta-Agent tokensRollout tokensTotal tokensApprox. cost (USD)Mean test-split gainTokens per point of gain
ACE [1]3.9M34.6M (shared)38.5M21+1.428M
SkillX [2]6.2M34.6M (shared)40.8M23+1.724M
Ratchet [3]21.4M256.6M278.1M130-0.4no gain
SkillOpt [4]8.1M239.2M247.3M110+2.3110M
Evo-Harness [5]0.2M34.6M (shared)34.8M17-0.7no gain
Recuris27.5M79.4M107.0M37+16.96.3M

Per worker (adaptation tokens / gain over the worker's base agent on the test split):

MethodDoubao-2.0-ProGPT-6.1-TerraClaude Sonnet 5.5Gemini 3.8 Flash
ACE8.6M / -3.57.4M / +7.810.8M / +3.511.8M / -2.3
SkillX9.1M / +0.37.9M / +2.311.4M / +3.812.4M / +0.3
Ratchet58.3M / -2.950.6M / +4.171.3M / +0.697.9M / -3.2
SkillOpt49.5M / +6.449.2M / +4.166.9M / -0.681.7M / -0.9
Evo-Harness7.6M / -2.96.5M / +2.99.9M / +1.710.9M / -4.7
Recuris107.0M / +21.50 / +23.30 / +12.50 / +10.5
  1. The budgets differ because the methods adapt in different ways. ACE, SkillX and Evo-Harness learn offline: they read one fixed set of base-agent rollouts and never run the agent again, so their rollout cost is identical and their total over the four workers stays between 35M and 41M tokens. SkillOpt and Ratchet, like Recuris, optimize while running: every change is validated by running the adaptation tasks again, and more than 90% of their budget goes to these rollouts, 247M and 278M tokens in total. SkillOpt and Ratchet work in the same way as Recuris, which makes them the most comparable baselines.

  2. One evolution run is reused across models, giving larger gains at a smaller budget. The memory evolved by Recuris adapts directly to different models, whereas the baselines are adapted separately on each model. Over the same four workers, Recuris evolves once and uses 107.0M tokens (about 37 USD) for a mean gain of +16.9 points; SkillOpt and Ratchet use 247.3M and 278.1M (about 110 and 130 USD) for +2.3 and -0.4. GPT-6.1-Terra, Claude Sonnet 5.5 and Gemini 3.8 Flash are new workers that are not in the paper: the same frozen memory gains +23.3, +12.5 and +10.5 points on them without any adaptation token, and we have added these results to the revised paper (Appendix C.5, Table 7). A single evolution run brings large gains to different downstream models, demonstrating the effectiveness and generalizability of Recuris.

  3. Recuris makes the most efficient use of its budget. Dividing the total budget by the mean gain, Recuris needs 6.3M tokens per point of gain, SkillOpt needs 110M, and the two offline methods that gain need 24M and 28M. This also addresses your concern about allocating more computation to existing approaches: SkillOpt and Ratchet spend about seven times the budget of the offline methods, yet their mean gain is at most 0.6 points higher, so the advantage of Recuris does not come from a larger budget. Each point of gain costs Recuris between a quarter and a seventeenth of what it costs the other methods, which shows its efficiency and scalability.

AuthorsOpenReview ↗

[3/3] Response to Reviewer XifB

  1. Most of the evolution budget goes to candidate validation, and the Meta-Agent takes a quarter. One evolution run of Recuris uses 107.0M tokens, about 37 USD at list prices; this is the evolution cost that the tokens per success of Figure 5(c) leave out. The Meta-Agent uses 27.5M tokens over four rounds, 88% of them cached re-reads of the same session context. The remaining 79.4M are rollouts, about four fifths of which serve candidate validation at the gate: in each gated round, the candidate and the current memory are both run on all evolution and dev tasks, and only a change that passes is kept. Every change that Recuris keeps has been validated, which makes its updates reliable and robust.

  2. On Terminal-Bench, adaptation adds only 1.5% of computation at the same attempt limit. As you note, our control matches worker attempts while adaptation also spends Meta-Agent computation. We measured this cost:

12 tasksWorkerMeta-Agent
Calls30 attempts13 diagnoses
Tokens20.9M0.31M (1.5%)

The Meta-Agent runs only after an unsuccessful attempt and uses about 26k tokens per task, under 4% of a single worker attempt (about 0.7M tokens). The two settings of the matched-attempt experiment, test-time adaptation (TTA) and pass@4 with fixed memory, differ by about 1.5% in computation, and giving this budget to pass@4 would not buy it one more attempt. At the same attempt limit, TTA solves 53 of the 87 tasks against 51 for pass@4 (Appendix C.1, where this measurement is now reported). The additional tasks solved come from the memory update rather than from additional computation, which confirms the effectiveness of test-time adaptation.

Thank you for these suggestions, which have improved the paper; all the additions above are in the revised paper. We hope our responses address your concerns, and we are happy to discuss any further questions.

[1] Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models. ICLR 2026.

[2] SkillX: Automatically Constructing Skill Knowledge Bases for Agents. arXiv 2026.

[3] Ratchet: A Minimal Hygiene Recipe for Self-Evolving LLM Agents. arXiv 2026.

[4] SkillOpt: Executive Strategy for Self-Evolving Agent Skills. arXiv 2026.

[5] Evo-Harness: Context-to-Harness Skill Compilation for Self-Evolving Agents. arXiv 2026.

AuthorsOpenReview ↗

Gentle Reminder

Dear Reviewer XifB,

We sincerely appreciate the time and effort you dedicated to reviewing our paper. Your thoughtful questions and insightful feedback have been extremely beneficial to our work.

In response to your concerns, we have reported the held-out results of all ten models with confidence intervals and summarized the optimization cost of Recuris and the five self-evolving memory methods.

Should there be any further points that require clarification or improvement, please know that we are fully committed to addressing them promptly.

Thank you once again for your invaluable contribution to our research.

Warm Regards, The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the Discussion

Dear Area Chair and Reviewers,

As the discussion period comes to a close, we sincerely thank all reviewers and the Area Chair for the time and effort devoted to our paper. We have responded to every comment with new experiments and clarifications, and revised the paper accordingly. A brief summary of the discussion follows.

  1. The frozen memory remains effective on new tasks (held-out results with uncertainty; Reviewers XifB, NErk). Counting τ2\tau^2 on held-out tasks only, Recuris improves 36 of the 40 model-benchmark pairs.
  2. One evolution run brings large gains at a small budget (cost of evolution; Reviewers XifB, NErk, qnwC). On τ2\tau^2-Retail, it uses 107.0M tokens, about 37 USD, for a mean gain of +16.9 points over four workers, the fewest tokens per point of gain among all six methods.
  3. Structured failure diagnosis leads to a better memory (its contribution to memory evolution; Reviewers NErk, qnwC). With the same Meta-Agent, evolution rounds and validation budget, memory evolved from our structured trace reaches 84.3% on the test split, against 68.9% from raw trajectories.
  4. The advantage of Recuris is general (comparison on other models; Reviewer qnwC). On four further workers and all three benchmarks, Recuris is the best method in every case, without any adaptation.
  5. The EM-WM coupling yields a clear synergy (benefit of each mechanism; Reviewer NErk). On Airline, the coupling gains 8.5 points, more than WM alone (4.0) and EM alone (1.5) combined.

All new results, together with the full prompts requested by Reviewer qnwC, are in the revised paper (Tables 4 to 7, Appendix E).

We sincerely thank Reviewers XifB and NErk for their positive evaluation. Reviewer NErk has confirmed the positive score based on our response. We also sincerely thank Reviewer qnwC for raising the score and for acknowledging that our additional controlled experiments and implementation clarifications addressed concerns raised in the original review.

We are encouraged by this recognition and remain glad to address any further questions.

Thank you once again for your time and your valuable feedback.

Warm Regards, The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.