- 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
-
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.
-
Experiments span four benchmarks and ten models, reporting improvements in 38 of 40 model–benchmark pairs.
Critical weaknesses
-
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.
-
Figure 5(c) reports tokens per success, but explicitly excludes memory evolution, including Meta-Agent calls and repeated candidate validation.
-
Although structured traces improve fault localization, the paper does not clearly isolate the methodological novelty beyond combining state tracking, diagnostic logging, and memory edits.
-
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
-
Can you report the total token usage and cost of evolution?
-
What distinguishes the proposed failure-localization mechanism from standard structured logging followed by LLM diagnosis?
7 comments
[2/4] Response to Reviewer qnwC
Weakness 2 & Question 1: Total Token Usage and Cost of Evolution.
-
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.
-
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 -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.
| Method | Optimizer / Meta-Agent tokens | Rollout tokens | Total tokens | Approx. cost (USD) | Mean test-split gain | Tokens per point of gain |
|---|---|---|---|---|---|---|
| ACE | 3.9M | 34.6M (shared) | 38.5M | 21 | +1.4 | 28M |
| SkillX | 6.2M | 34.6M (shared) | 40.8M | 23 | +1.7 | 24M |
| Ratchet | 21.4M | 256.6M | 278.1M | 130 | -0.4 | no gain |
| SkillOpt | 8.1M | 239.2M | 247.3M | 110 | +2.3 | 110M |
| Evo-Harness | 0.2M | 34.6M (shared) | 34.8M | 17 | -0.7 | no gain |
| Recuris | 27.5M | 79.4M | 107.0M | 37 | +16.9 | 6.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.
[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.
-
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 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.
-
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).
-
It leads to effective repair, as a new experiment with the same LLM diagnoser shows. The same Meta-Agent evolves memory on -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-Agent | What it contains | Test-split success, % (run 1 / run 2) | Mean |
|---|---|---|---|
| Outcome only | whether each trial succeeded | 77.6 / 78.2 | 77.9 |
| Raw trajectory | + the agent's messages, tool calls and tool results | 68.9 / 68.9 | 68.9 |
| Transcript + episode-level counts | + how often each memory event occurred in the episode | 65.1 / 82.3 | 73.7 |
| Per-step structured trace (Recuris, Section 3.2) | + at every step: open goals, invoked skill, proposed and committed state update, checker decision | 85.5 / 83.1 | 84.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.
[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-Retail (86 tasks × 4):
τ2-Airline (29 tasks × 4):
SkillFlow (114 tasks × 3):
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.
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.
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.