One-sentence Summary

Researchers from NUS, Stanford, Oxford, and Princeton introduce Recuris, a recursive Experiential–Working Memory architecture that tracks task progress to guide skill selection, localizes failures via structured evidence, and enables validation-gated memory updates; across four benchmarks and ten models, it improves task success in 35 of 37 model–benchmark pairs, adding $+17.8$+17.8 points to GPT-5.6 Sol on $\tau ^ { 2 } .$τ2. -Bench and $+32.2$+32.2 points on the longest tasks.

Key Contributions

• Introduces Recuris, a recursive Experiential–Working Memory architecture that externalizes self-improvement to a memory-control layer, where Working Memory tracks verified task progress, guides skill selection from Experiential Memory, and a fixed Meta-Agent attributes failures to specific memory components before patching only those implicated behind a validation gate.
• Separates state proposal from state commitment by updating progress entries only when supported by actual tool results, grounding both action decisions and skill invocation in verified task state, and emitting a structured trace that links task states, invoked skills, actions, and outcomes for localized diagnosis.
• Across four long-horizon benchmarks and ten models, improves task success in 35 of 37 model–benchmark pairs, including +17.8 points for GPT-5.6 Sol and +15.6 for Claude Opus 5 on τ²-Bench (reaching 87.9%), +16.6/+13.5 points for Qwen3.6-27B/35B on SkillFlow, up to +32.2 points on the longest tasks, and a 64.8% fault-localization rate versus 13.0% from task outcomes alone.

Introduction

LLM agents increasingly rely on an external harness to coordinate memory, tool use, and task tracking, yet long-horizon tasks expose a key weakness: as interaction histories grow, agents lose track of unresolved goals and invoke outdated skills. Existing experiential-memory methods retrieve skills from the initial instruction or full history, but this becomes unreliable as the task evolves, and memory updates are often coarse, driven only by final success or failure without pinpointing which component caused the issue.

The authors propose Recuris, a recursive Experiential-Working Memory architecture that couples a verified task state (Working Memory) with reusable experience (Experiential Memory). Working Memory tracks progress and unresolved goals, grounds skill selection, and updates only from verified tool feedback, creating a closed loop of state, action, and outcome. Across tasks, a fixed Meta-Agent analyzes structured traces to localize failures to specific memory components and applies validation-gated updates, keeping the base model unchanged. Evaluated on four long-horizon benchmarks and ten models, Recuris improves success in 35 of 37 pairs, with gains growing over longer horizons and failure localization accuracy at 64.8% versus 13.0% from outcomes alone.

Method

The authors propose Recuris, an agent harness built around a frozen large language model (LLM) $\pi_\theta$πθ​ and a tool set $\mathcal{T}$T. The system mediates task-state tracking, experiential-memory access, skill invocation, tool interaction, and execution verification. At each evolution round $k$k, Recuris maintains an evolving Skill Memory represented as $\mathcal{M}_k = (\mathcal{E}_k, \mathcal{W}_k, \rho_k, \mathcal{C}_k)$Mk​=(Ek​,Wk​,ρk​,Ck​). Here, $\mathcal{E}_k$Ek​ stores reusable skills in an agent-skill format, $\mathcal{W}_k$Wk​ defines the state schema and update proposal for the task-specific working state $w_t$wt​, $\rho_k$ρk​ is the invocation policy determining when and which skills to retrieve, and $\mathcal{C}_k$Ck​ is a set of checkers that verify if observations support proposed state changes.

As illustrated in the framework diagram, Recuris operates through two interconnected loops: a task-level execution loop and a cross-task evolution loop. Within a task, the current working state guides skill invocation, and execution evidence controls the subsequent state update. Across tasks, a fixed Meta-Agent utilizes failed runs to localize an effective repair target, proposes a component-specific memory patch, and relies on a fixed validation gate to admit the candidate patch. To connect these loops, the system records a structured execution trace $\Gamma_k$Γk​ at round $k$k, which links each action and observation to the state that triggered skill invocation, the proposed state update, and the evidence used to accept or reject that update.

Within the task-level loop, the authors implement a verified Experiential Memory (EM) and Working Memory (WM) coupling. The execution harness initializes a structured working state $w_0$w0​ from the task, where each goal entry tracks its content, status (pending, done, or blocked), and supporting evidence. Skill invocation is state-grounded, meaning the policy $\rho_k$ρk​ decides which skills $\mathcal{E}_t \subseteq \mathcal{E}_k$Et​⊆Ek​ to retrieve based on the current progress $w_t$wt​ and specific execution events $e_t$et​, rather than searching the full interaction history. Following an action $a_t$at​ and environment observation $o_t$ot​, the working-memory specification proposes a next state $\widetilde{w}_{t+1} = U_{\mathcal{W}_k}(w_t, a_t, o_t)$wt+1​=UWk​​(wt​,at​,ot​). A checker set then evaluates this proposal against the observation, yielding decisions $c_t = \mathcal{C}_k(w_t, \widetilde{w}_{t+1}, a_t, o_t)$ct​=Ck​(wt​,wt+1​,at​,ot​). A fixed kernel commits only the supported changes to produce $w_{t+1} = K(w_t, \widetilde{w}_{t+1}, c_t)$wt+1​=K(wt​,wt+1​,ct​), ensuring the state accurately reflects verified progress.

For the cross-task evolution loop, Recuris employs bounded recursive skill memory evolution. When a task fails, the fixed localization stage of the Meta-Agent analyzes the structured trace to produce a diagnosis $D_k = \mathcal{A}_{\text{fixed}}(\Gamma_k, \mathcal{M}_k) = \{(f_j, z_j)\}_{j=1}^{J_k}$Dk​=Afixed​(Γk​,Mk​)={(fj​,zj​)}j=1Jk​​. Each diagnosed failure $f_j$fj​ is attributed to the component $z_j \in \{\mathcal{E}, \mathcal{W}, \rho, \mathcal{C}\}$zj​∈{E,W,ρ,C} where a localized intervention is most likely to help. The patching stage then proposes a specific edit $\Delta m_z = \mathcal{P}_{\text{fixed}}(\Gamma_k, \mathcal{M}_k, D_k, z)$Δmz​=Pfixed​(Γk​,Mk​,Dk​,z) for each implicated component, constructing a candidate memory $\mathcal{M}_k^+ = \mathcal{M}_k \oplus_{Z_k} \{\Delta m_z\}_{z \in Z_k}$Mk+​=Mk​⊕Zk​​{Δmz​}z∈Zk​​. This operator modifies only the implicated components while copying the rest unchanged. Finally, a validation gate $\mathcal{G}_{\text{fixed}}$Gfixed​ compares the candidate $\mathcal{M}_k^+$Mk+​ with the current memory $\mathcal{M}_k$Mk​ on the failed task and a held-out development set. The patch is admitted only if it repairs the target failure without causing regression on anchor tasks, completing the recursive update $\mathcal{M}_k \to \Gamma_k \to D_k \to \mathcal{M}_k^+ \to \mathcal{M}_{k+1}$Mk​→Γk​→Dk​→Mk+​→Mk+1​.

Experiment

The evaluation spans tool-use benchmarks (tau2-Retail, tau2-Airline), SkillFlow, and Terminal-Bench 2.1, using a frozen mid-sized deployment model to evolve a Skill Memory that is then transferred unchanged to other models. Recuris, which couples experiential memory with a verified working state, improves task success in 35 of 37 model-benchmark pairs, with the largest gains on Retail and SkillFlow; ablations show the working state and state-grounded skill invocation drive the gains, while simply injecting more skill text hurts. The critical memory component differs by domain (write review on Airline, status board on Retail), and recursive evolution, where a Meta-Agent patches memory from failed traces, yields consistent held-out gains that transfer across tasks and models, though transfer depends on whether the target still contains the repaired failure type. On isolated Terminal-Bench tasks, test-time adaptation adds modest per-attempt reliability gains, but most of the headline improvement comes from the retry budget itself rather than learning.

Recuris consistently improves task success across most model-benchmark pairs, with the largest gains on benchmarks that share structure across tasks, such as retail and skill discovery. The method's benefit does not scale with model size, and its value is tied to adaptive memory rather than additional context or compute. Recuris improves task success in 35 of 37 completed model-benchmark pairs. Largest gains appear on benchmarks with shared structure, with improvements of 23.3 and 16.8 points on retail and skill discovery tasks. The benefit is not tied to model scale; smaller models can see gains comparable to or larger than larger models. On isolated tasks without shared structure, Recuris provides little or no benefit, and extra context alone can hurt performance.

Combining episodic and working memory yields the strongest performance in both retail and airline domains, with the largest gains over the base agent. Working memory alone provides substantial improvements in retail, while episodic memory alone adds only small, non-significant gains. The model-controlled invocation variant shows a significant but smaller improvement in retail only. The full memory combination outperforms all other variants in both domains, achieving the highest success rate and the largest confidence interval improvement over the base agent. Working memory alone delivers a large, significant gain in retail, whereas episodic memory alone yields only marginal, non-significant improvements in both domains. Model-controlled invocation, tested only in retail, provides a significant but smaller boost compared to working memory alone or the combined memory variant.

When the skill library is held fixed, the method of deciding when to invoke skills has a larger impact on performance than the skill content itself. Recuris, which supplies the one skill matched to each drafted state-changing call, outperforms a model-controlled variant that injects all skills into context on every turn, despite both using byte-identical skill bodies. The advantage is primarily in coverage, not speed, as the median turn of the first correct write is identical across configurations. Recuris achieves 82.4% required-write recall versus 61.1% under model control, and 83.6% task success versus 65.6%. Putting the entire skill library in context and letting the model decide when to use it scores below a configuration with no skills at all (65.6% vs 82.0% task success). The median turn of the first correct write is 18 in all configurations, indicating that invocation control affects whether writes are issued, not how quickly they occur. Recuris has the lowest rate of omitted required writes per episode (0.121) and the lowest agent tokens per success (101k), while model control is highest on both (0.417 and 147k).

Structured traces from the harness make component faults observable, with macro recall jumping from 13.0% with outcome only and 37.0% with raw trajectory to 64.8% with the structured trace. The gain is concentrated on faults that are invisible in the transcript, such as invocation and working-memory faults, while skill-content faults gain least because they already appear in the dialogue. Precision also improves substantially, indicating that the trace helps avoid misattributing faults to the wrong component. Outcome-only evidence scores below the constant-answer floor, while raw trajectory barely clears it, and structured trace nearly doubles the floor. Invocation faults are never detected without structured trace, but structured trace detects them 38.9% of the time. Working-memory fault recall rises from 50.0% with raw trajectory to 83.3% with structured trace. Skill-content faults gain the least, from 61.1% to 72.2%, consistent with the fault being visible in the transcript. Macro precision improves from 27.6% to 64.4%, showing the trace reduces false accusations against the skill component.

Recursive evolution of skill memory consistently improves held-out task performance over the shared starting memory, with gains ranging from about 9 to 17 points across multiple runs and implementations. A second evolution round compounds these gains, while a later round without admitted candidates shows no significant improvement. Transfer occurs only when held-out tasks contain the type of failures the memory repairs, as evidenced by near-universal invocation on held-out tasks for successful packages and no gain for airline-specific lineages where no such failures remain. All packages that reach held-out tasks outperform the starting memory by 9 to 17 points with confidence intervals excluding zero. A second round of evolution adds further gains, while a later round without in-loop candidate admission shows no significant improvement. Evolved memory is invoked on 78 to 86 of 86 held-out tasks for successful packages, indicating active retrieval rather than a generic prompting effect. The only package with zero held-out invocations fails to beat the starting memory, underscoring that transfer depends on actual skill use. Airline-specific lineages, evaluated on tasks lacking the repaired failure types, show no significant gains and lower invocation rates.

Recuris consistently improves task success across most model-benchmark pairs, with the largest gains on benchmarks that share structure across tasks, such as retail and skill discovery, while providing little benefit on isolated tasks. Combining episodic and working memory yields the strongest performance, with working memory alone contributing substantial gains and episodic memory alone adding only marginal improvements. When the skill library is fixed, the method of deciding when to invoke skills matters more than skill content, as Recuris outperforms a model-controlled variant that injects all skills into context on every turn. Structured traces from the harness make component faults observable, dramatically improving fault recall and precision, particularly for faults invisible in the transcript, and recursive evolution of skill memory consistently improves held-out task performance, with gains compounding over rounds and transfer depending on actual skill use.