Recuris: A New Memory Paradigm That Boosts Performance from 3B Models to Claude Opus 5

Recent large‑language‑model (LLM) agents have shown strong potential on long‑horizon tasks, but existing frameworks struggle with how memory is used and iterated. Traditional approaches retrieve memory once at task start or rely on expanding dialogue context, which quickly becomes stale, noisy, and unreliable because there is no compact, trustworthy task‑state to keep experience aligned with current execution needs.

Recursive self‑improvement (RSI) faces the same problem: memory updates are driven only by downstream task scores, making them coarse‑grained and unable to pinpoint the exact component that caused a failure. Growing context length further hampers the agent’s ability to identify effective improvement strategies.

To address these issues, research teams from NUS, Princeton, Stanford, Oxford and others proposed Recuris (Recursive Experiential–Working Memory Evolution) . Recuris applies RSI inside the memory‑control layer without additional training and achieves a full‑scale performance jump from a 3B model to Claude Opus 5.

How memory is used: Existing agents inject or retrieve memory from an ever‑growing dialogue history, often causing hallucinations and skill‑selection mismatches. Recuris instead selects skills based on verified state updates produced by a checker, rather than trusting a single “completed” utterance.

How memory is iterated: Conventional frameworks rewrite the entire memory after a task succeeds or fails. Recuris reads a structured trajectory, locates the failing component, modifies only that component, and accepts the change only after a validation‑gate confirms it does not degrade performance on a held‑out set.

Performance

The authors evaluated Recuris on four long‑horizon benchmarks (τ²‑Retail, τ²‑Airline, SkillFlow, Terminal‑Bench 2.1) across ten models. From a 3B open‑source model up to frontier models such as Claude Opus 5 and GPT‑5.6‑Sol, Recuris consistently delivered large gains that did not decay with more interaction rounds, and it markedly reduced common long‑horizon failure modes.

When tasks are split by inherent length into four quantiles, Recuris outperforms baselines on every quantile with improvements ranging from +17.0 to +44.7 points, showing no monotonic decline as tasks become longer.

Structured Trajectories Enable Precise Failure Localization

Recursive improvement requires knowing where to fix. The authors inject known faults into memory and let a fixed judge evaluate three evidence sources: final success/failure, the raw trajectory, or Recuris’s structured trajectory. The fault pool is balanced across categories, giving a naïve “always‑same‑component” judge a 33.3 % accuracy.

Using only final outcomes yields a 13.0 % localization accuracy (worse than baseline). Raw trajectories improve this to 37.0 %. Structured trajectories achieve 64.8 %, nearly double the baseline, demonstrating the value of explicit, component‑level evidence.

Memory Evolves Across Tasks and Models

Cross‑task transfer: Memory distilled from 16 failing tasks provides +9.01 to +17.44 points on 86 unseen tasks, confirming that structured failure trajectories contain transferable information.

Cross‑model transfer: A memory evolved on one model can be directly applied to a never‑seen frontier model, still yielding noticeable performance gains, indicating strong generalization.

Key Technical Contributions

The paper argues that the bottleneck in long‑horizon scenarios is not a lack of experience but the absence of a compact, reliable task‑state that continuously aligns accumulated experience with current execution demands. Recuris’s three core techniques revolve around this insight.

Experience‑Memory ↔ Working‑Memory Coupling (EM‑WM): Working memory (WM) acts as the missing task‑state, continuously tracking progress and pending goals. It selects the most suitable skill from experience memory (EM), receives tool receipts after execution, validates progress, and updates the task‑state, forming a closed loop: task state → skill selection → execution feedback → updated task state .

Skill calls occur at execution events (state‑change attempts or interaction‑round boundaries) rather than via similarity matching over an expanding context. The checker validates state changes only when supported by tool receipts; mere skill invocation or attempted tool calls do not count as completion.

Structured Trajectories & Component‑Level Failure Localization: Prior methods learn only from final success/failure, which signals that “something went wrong” but not which component (skill, state, call mechanism, validator) is at fault. EM‑WM coupling explicitly links task state, invoked skill, action, and observation, turning the execution trace into evidence about “how memory influences behavior”. This enables the pipeline: EM‑WM coupling → structured evidence → failure localization → targeted memory evolution , allowing local patches without rewriting the whole memory.

Bounded, Gated Recursive Evolution: A fixed meta‑agent reads structured trajectories, attributes each diagnosed failure to a specific memory component, and modifies only that component. A gate admits the patch only if it fixes the target task and does not cause regression on the held‑out set. Accepted updates alter future execution patterns, generate new optimization signals, and support the next recursion round.

The work is authored by Yuzhao Yu (NUS PhD), Ling Yang (Princeton postdoc), Mengdi Wang (Princeton professor), and Shuicheng Yan (NUS professor), with collaborators from Stanford and Oxford.