Regularized Recursive Self-Improvement of Agent Harnesses

• Regularized Recursive Self-Improvement of Agent Harnesses (RRSI) is a class of recursive optimization procedures where an agent repeatedly modifies its interaction scaffolding with tasks, tools, memory, and environments, while enforcing constraints on regressions, resource use, and behavioral drift.
• It distinguishes harness improvement from general self-improvement by focusing on context construction, tool routing, memory retrieval, and workflow control without necessarily changing the underlying model, accompanied by examples like harness-level examination in a task for algorithmic code consistency.
• RRSI systems use explicit regularization mechanisms to ensure safe and controlled improvements, with concrete examples such as bounded edit spaces, independent evaluation, and complexity budgets.

Regularized Recursive Self-Improvement of Agent Harnesses (RRSI) denotes a class of recursive optimization procedures in which an agent repeatedly modifies the scaffolding that mediates a fixed or evolving model’s interaction with tasks, tools, memory, evaluators, and environments, while constraining regressions, evaluator manipulation, resource use, and uncontrolled behavioral drift. The term is an extrapolation from research on harness evolution, verifier-grounded optimization, persistent memory, model–harness co-evolution, and recursive self-improvement; it is not introduced as a formal framework by any single cited paper. Its defining object is the agent harness: prompts, tools, memory stores, skill libraries, retrieval indices, planners, evaluators, orchestration code, stopping rules, permissions, and deployment policies.

1. Conceptual scope and terminology

RRSI distinguishes harness improvement from broader forms of recursive self-improvement. A harness can improve the behavior of a fixed foundation model without changing its weights, or it can participate in a larger model–harness co-evolution loop in which execution traces subsequently influence model training. The distinction is important because an agent may become more effective through improved context construction, tool routing, memory retrieval, or workflow control without acquiring a new computational model.

A harness is commonly defined as everything around a model that turns it into an agent, including system prompts, tool definitions, memory stores, skill libraries, retrieval indices, orchestration code, and stopping rules (Chen et al., 8 Jul 2026). RRSI broadens this object to include evaluators, permissions, runtime and environment models, training procedures, and governance controls.

The term “recursive” has several uses:

• Self-modification: the system changes code, prompts, memory, weights, or workflow without necessarily improving.
• Weak recursive self-improvement: the system optimizes performance within a relatively fixed algorithmic framework.
• Strong recursive self-improvement: the system improves the mechanism by which it improves, potentially creating a positive feedback loop.

Most current agent systems are classified as Level 2 in this terminology. They can modify prompts, memories, skills, LoRA weights, workflows, or orchestration code while retaining externally designed evaluators and improvement procedures (Zhang et al., 5 Jul 2026).

RRSI is therefore narrower than unrestricted RSI and broader than ordinary prompt optimization. Its central concern is repeated improvement of the agent’s execution substrate under explicit regularization. The regularization may be mathematical, as in a complexity or cost penalty, or procedural, as in immutable evaluators, bounded edit surfaces, held-out validation, rollback, and independent verification.

Introspection and self-reference

A system is computationally introspective when it can:

1. construct an internal model of its own computational process;
2. execute that model on hypothetical inputs;
3. compare predicted and actual outcomes;
4. modify its operation in response to discrepancies.

This definition is operational rather than phenomenological. Textual self-description, confidence reporting, or self-critique does not by itself constitute introspection. Current LLM behaviors are commonly characterized as quasi-introspection: calibrated confidence, self-recognition, self-critique, behavioral prediction, textual self-cards, and reports of latent policies without complete, causally grounded access to the execution substrate (Zhang et al., 5 Jul 2026).

RRSI does not necessarily require exact access to every model weight. A harness may instead expose a sufficiently complete functional model of the components it is authorized to modify, including prompts, tools, memory, planning, orchestration, evaluation, runtime assumptions, and safety constraints. This functional self-model may be executable or simulatable and may be approximate, provided its prediction error is measured for the relevant modification class.

2. Formal foundations and boundaries

The theoretical basis for self-reference comes from computability theory rather than from empirical demonstrations of autonomous improvement. Kleene’s Second Recursion Theorem states:

$$\forall f:\mathbb N\to\mathbb N \text{ total computable},\quad \exists e\in\mathbb N \text{ such that } \varphi_e \simeq \varphi_{f(e)}.$$

Here, $e$ is a program index, $f$ is a total computable transformation, $\varphi_e$ is the partial recursive function computed by program $e$, and $\simeq$ denotes computational equivalence. The theorem establishes the theoretical existence of programs that can behave as though they have supplied their own index to a computable transformation (Zhang et al., 5 Jul 2026).

For bounded self-simulation, a transformation $f_T$ simulates a program for at most a finite horizon $T$. Because the simulation is bounded, $f_T$ is total computable, and a fixed point $e^*$ exists such that:

$e$0

An introspective self-improvement construction can be described by:

$e$1

where $e$2 simulates candidate source code, $e$3 evaluates the result, and $e$4 modifies the source code. Kleene’s theorem then yields a fixed point $e$5 satisfying:

$e$6

The intended sequence is self-reconstruction, bounded simulation, evaluation, modification, and execution. These constructions demonstrate the existence of bounded self-referential programs, not useful or safe recursive improvement.

Several limitations follow directly:

• Rice’s theorem prevents a general evaluator from deciding all nontrivial semantic properties of arbitrary programs.
• Bounded evaluation can compare finite traces but cannot establish unrestricted lifelong superiority.
• Löbian limitations constrain unrestricted self-certification by sufficiently expressive consistent formal systems.
• A fixed point does not imply utility improvement, monotonicity, global optimality, safety, or indefinite continuation.
• Internal self-modification does not automatically create a qualitative computational jump.

The analogy between RRSI and von Neumann’s self-reproducing automata is therefore suggestive rather than theorem-level. A von Neumann automaton combines a constructor, copier, controller, and blueprint. The proposed AI analogue replaces a complete structural blueprint with a sufficiently complete functional self-model. However, policy improvement, tool selection, and workflow optimization do not require physical reproduction or an exact description of every parameter (Zhang et al., 5 Jul 2026).

Generalized Agent Iteration (GAI) provides a separate conceptual formalism for comparing classical generalized policy iteration and RSI. It defines an agent as a configuration of modifiable components and models learning as a cycle of agent evaluation and agent improvement. Two axes distinguish cases: whether the improving mechanism belongs to the agent and whether the evaluation standard is grounded outside it (Tang et al., 11 Sep 2026). RRSI occupies the region in which the harness or improvement mechanism is at least partly modifiable while evaluation remains externally anchored or procedurally protected.

3. Harness representations and improvement operators

A central design requirement of RRSI is an explicit representation of the modification surface. Several systems instantiate this principle at different levels of granularity.

Prompt-level harnesses

Recursive Harness Self-Improvement (RHI) represents the harness as a textual specification of an agent loop around a fixed LLM. Its components include agent roles, instructions, expected outputs, workflow contracts, interaction hops, acceptance gates, termination conditions, failure fallbacks, evidence-triggered recall, and communication rules (Lee et al., 17 Jul 2026).

The RHI update cycle is:

1. execute a task with the current harness;
2. produce a repository and execution trace;
3. compare the current output with the predecessor output;
4. append the preference to a revision history;
5. ask a harness-optimizer LLM to rewrite the harness.

RHI uses predecessor-local pairwise comparisons rather than a global population objective. This reduces computational cost: one new trace and one pairwise evaluator call are required per task and iteration, rather than quadratic comparisons among candidate populations. Its implicit regularizers include a limited update budget, trajectory locality, a prompt-level feasible set, pairwise preference filtering, history dependence, and emphasis on contracts and hops.

The reported experiments use 30 synthetic machine-learning research tasks across quantitative finance, robotics, and pharmacy. A few iterations raise the performance ceiling of low-reasoning-effort agents, with reported reductions in inference cost of up to 60% in the tested settings. The evidence suggests that improvements arise primarily from task-specific context management and inter-agent information flow rather than uniformly longer reasoning traces, although the Opus 4.7 token analysis is inconclusive (Lee et al., 17 Jul 2026).

Executable context constructors

VideoHarness-RSI searches over executable programs that construct bounded multimodal contexts for a frozen vision-LLM. A harness maps a video $e$7 and question $e$8 to a context $e$9 subject to a fixed visual budget $f$0:

$f$1

The searchable components include frame sampling, caption generation and retrieval, image-embedding indexes, temporal navigation, question-conditioned range selection, density and diversity sampling, memory construction, and final context packing (Xu et al., 25 Aug 2026).

The system freezes the answering model, decoding configuration, evaluator, final visual budget, auxiliary services, and held-out set. Candidate programs are proposed, smoke-tested, executed on a development set, evaluated, and archived. Strict development improvements replace the incumbent, while rejected programs remain available for analysis.

Starting from uniform sampling, the search improved held-out LVBench accuracy from 36.3% to 45.4%. Starting from the stronger AKS baseline, it discovered Timestamped-AKS, increasing held-out accuracy from 46.5% to 50.3%. The selected hybrid also transferred without further search to Video-MME and MLVU. These results establish executable context construction as an independently optimizable layer, but the search objective was accuracy-only; complexity, latency, auxiliary calls, instability, and overfitting were reported rather than directly regularized.

Five-slot harness genomes

MetaRSI formalizes a harness as a five-slot genome:

$f$2

where $f$3 is the system prompt, $f$4 is memory, $f$5 is the built-in tool set, $f$6 is the skill library, and $f$7 is the MCP-mounted tool and resource set (Tan et al., 6 Sep 2026).

A HarnessPatch contains a repair hypothesis, patch operations, expected effects, and risk statements. Each operation identifies a slot, mutation type, and new value. Deterministic validation enforces slot validity, schema correctness, interface compatibility, declared modification, freshness, provenance, and complexity bounds. The model provider, target weights, evaluator, sandbox, release rule, runtime, artifact schemas, and sealed task text are protected from modification.

The five-slot genome converts arbitrary self-rewriting into typed, enumerable intervention. Its complexity budget limits active context, memory count, and serialized genome size. Strict incumbent comparison prevents non-improving candidates from being installed. The framework explicitly treats these controls as hard constraints rather than as a soft edit-distance penalty.

Typed executable harnesses

HELIX decomposes agent systems into typed ports, reusable atoms, recipes, product shells, and runtime policies. Its recipe spaces contain 1,024 or 4,096 possible coupled configurations, depending on whether acceptance is coupled with the turn loop (Fan et al., 14 Aug 2026).

This representation supports:

• source-traceable interventions;
• typed compatibility checks;
• deterministic recipe compilation;
• lockfiles;
• runtime policy enforcement;
• workspace and test evidence;
• candidate-level provenance;
• distinction between deployable fixed-harness performance and post-hoc portfolio coverage.

In a 65-candidate portfolio, the best fixed harness improved coverage from 50/100 to 52/100 on a LiveCodeBench-derived task set, while the post-hoc portfolio covered 79/100 tasks. The latter is complementary portfolio coverage, not the performance of one deployable harness. A selected harness also reached 46/55 tasks with at least one successful run on SWE-bench Verified, compared with 44/55 for Pi Mono.

Population-based harness evolution

DarwinX treats harnesses as a population of variants with a frozen underlying model. Its editable layers include prompts, memory, skills, tools, control flow, verification routines, and executable agent code (Zhang et al., 31 Jul 2026).

The central preserve-and-extend contract defines per-task changes $f$8, net gain $f$9, and regression $\varphi_e$0:

$\varphi_e$1

$\varphi_e$2

A candidate is eligible when:

$\varphi_e$3

The archive retains alternative lineages, including specialists and globally weaker variants that may contain unique capabilities. Recombination is accepted only if the child covers the union of its parents’ solved-task sets:

$\varphi_e$4

This population-level structure regularizes against single-lineage path dependence, local optimization, and destructive capability tradeoffs. Reported results include gains on Terminal-Bench 2.1, held-out TerminalWorld, WebArena-Infinity, and transfer to SWE-bench Verified. The evidence supports harness-level improvement under a frozen model, although component-level ablations and formal statistical acceptance theory remain incomplete.

4. Evaluation, verification, and causal attribution

RRSI systems rely on an improvement signal. The central principle of the recursive-improvement literature is that every self-improvement loop substitutes some signal for human judgment; the loop’s ceiling is determined by the quality of that substitute (Chen et al., 8 Jul 2026).

Verification hierarchy

The verification hierarchy commonly ranges from stronger external anchors to weaker intrinsic signals:

1. formal verifiers, proof checkers, and type systems;
2. execution feedback, tests, compilers, and deterministic environment outcomes;
3. learned judges, reward models, process reward models, and rubrics;
4. intrinsic confidence, likelihood, self-consistency, and self-assessment;
5. human research judgment for direction-setting.

Formal verifiers can be sound within their domain but incomplete. Execution feedback is reliable but limited by test coverage. Learned judges are vulnerable to shared biases and optimization. Intrinsic self-assessment is inexpensive but particularly susceptible to self-confirming errors.

RRSI therefore generally uses intrinsic signals for proposal generation or prioritization rather than persistent authorization. High-impact harness changes should rely on independent evaluators, held-out tasks, adversarial tests, formal checks where possible, and human or external control-plane approval.

Mechanism-aware evaluation

PAST-Bench separates later-task gains from evidence that retained experience caused those gains through the intended save–retrieve–apply–update pathway (Xue et al., 4 Aug 2026). Its matched persistence-on/off evaluation uses ordered fresh-session task families and records memory writes, reads, skill operations, artifact diffs, and update correctness.

The benchmark reports task completion, robustness, safety, and mechanism evidence. It distinguishes:

• writing the relevant artifact;
• retrieving it later;
• applying it correctly;
• replacing stale state;
• retaining useful information over distance;
• avoiding irrelevant pollution.

This structure is directly relevant to RRSI because outcome gains alone cannot establish that a modified memory or harness component produced the improvement. Counterfactual deletion, corruption, distractor replacement, and stale-artifact conditions provide stronger attribution than self-reports.

Reference-guided credit assignment

HarnessEvolve addresses credit-assignment failure by generating verified reference trajectories using ground-truth answers offline, aligning failed executions against them, identifying first action divergences, clustering errors, and producing targeted harness modifications (Jiang et al., 1 Sep 2026).

Its four-module architecture separates execution, evaluation, optimization, and gating. The quality gate rejects data leakage and prompt bloat. The performance gate accepts an update if it improves the current batch without excessive degradation on recent batches. Accepted snapshots form a pool, and epoch-end validation selects the best snapshot.

The ablation on CloudCoreNetwork-QA reports 86.9% for the complete system, 68.6% without error clustering, and 57.8% without reference trajectories. The difference supports the importance of reference-guided causal diagnosis, although the alignment procedure remains agent-mediated rather than formally specified.

Cross-instance diagnosis

Ecdysis argues that failures should be aggregated across task instances before modifying the harness (Yue et al., 10 Sep 2026). Its Failure-Driven Collaborative Refinement uses Analyst, Critic, Engineer, and Moderator roles to distinguish recurring harness deficiencies from model-specific accommodation.

The method prioritizes failure patterns covering at least two distinct task identifiers. This creates an implicit regularization prior:

isolated failure is weaker evidence than a recurring cross-task mechanism.

The reported aggregate accuracy rises from 46.67% for serial Self-Evolution to 59.33% for Ecdysis with FDCR. Training-time speedups reach 1.84x for the full method in the reported settings. The model-accommodation ratio falls from 60.0% for Self-Evolution to 45.5% for Ecdysis, according to the paper’s manual analysis.

Persistent memory and state verification

Recuris separates Experiential Memory, Working Memory, the skill-invocation policy, and a checker set (Yu et al., 25 Aug 2026). The task state is updated only when environmental evidence supports the proposed transition. A verbal claim of completion or attempted tool call does not establish completion.

Structured traces include the current state, retrieved skills, actions, observations, proposed next state, checker decisions, and committed state. Fault localization based on these traces achieves macro accuracy of 64.8%, compared with 13.0% from outcome alone and 37.0% from raw trajectories.

This architecture treats state tracking and skill invocation as distinct failure surfaces. It reduces the risk that a failed action, stale memory, or unsupported completion claim becomes an accepted state transition.

5. Regularization mechanisms and control architecture

RRSI regularization is usually procedural and architectural rather than a single differentiable penalty. The principal mechanisms are bounded edit spaces, independent evaluation, complexity and compute budgets, non-regression gates, versioning, rollback, provenance, diversity preservation, and immutable governance.

Bounded modification surfaces

A harness should expose a manifest of modifiable components, for example:

$\varphi_e$5

where $\varphi_e$6 is the policy and prompt set, $\varphi_e$7 the tool and permission configuration, $\varphi_e$8 memory, $\varphi_e$9 orchestration code, $e$0 the model or model adapters, $e$1 the runtime and environment interface, and $e$2 safety constraints.

The harness need not expose every model weight. It should instead expose a sufficiently complete functional self-model of components within its modification authority. Modifications outside the declared surface should be rejected deterministically.

External grounding and evaluator independence

The optimizer and evaluator should be separated. If the agent can modify the evaluator as easily as the policy, it can optimize the score rather than the task. Evaluator infrastructure should therefore be frozen, independently hosted, cryptographically protected, hardware-protected, or administratively outside the agent’s authority.

HELIX explicitly treats policy, execution, test, workspace, and verifier evidence as part of the evaluation record (Fan et al., 14 Aug 2026). DarwinX uses benchmark verifiers, repeated trials, preservation probes, and adjudication. SBCO requires verifier precision of at least 0.80 and recall of at least 0.55 before a verifier enters its bank (Kulkarni et al., 10 Aug 2026). HarnessEvolve uses an independent quality and performance gate (Jiang et al., 1 Sep 2026).

Non-regression and preservation

A candidate should not be accepted merely because its aggregate score improves. RRSI systems employ several preservation schemes:

• DarwinX bounds task-wise regression through $e$3.
• HarnessEvolve evaluates the current batch and recent batches.
• Recuris tests source failures and held-out development anchors.
• HELIX supplements target tests with regression tests and patch inspection.
• VideoHarness-RSI uses strict development improvement but lacks a formal held-out non-regression constraint.
• PAST-Bench compares persistence-on and persistence-off conditions while separately scoring pathway evidence.

A stronger design uses a protected regression suite containing previously solved tasks, rare failures, safety cases, cross-model probes, adversarial cases, and distribution-shifted tasks.

Complexity, cost, and resource budgets

Regularization must account for inference-time and evolution-time resources. Relevant costs include:

• tokens;
• wall-clock time;
• GPU and energy consumption;
• tool-call count;
• memory growth;
• evaluator calls;
• context length;
• number of agents and workflow hops;
• candidate-generation and validation cost;
• human review.

SBCO obtains reported compute savings of approximately 4–5.5 times relative to customized self-modifying baselines in planning tasks, although its budget is defined in plan generations rather than total tokens, energy, or wall-clock cost (Kulkarni et al., 10 Aug 2026). RHI reports up to 60% inference-cost reduction in its tested machine-learning research tasks (Lee et al., 17 Jul 2026). Recuris reduces execution-time context relative to injecting the entire skill library but does not provide a complete evolution-time cost accounting (Yu et al., 25 Aug 2026).

Diversity and archives

Single-lineage optimization is vulnerable to path dependence and local maxima. DarwinX retains alternative lineages and specialists. Its TerminalWorld results show that four specialists solved between 24 and 27 of 41 held-out tasks, while a merged harness solved 28. This demonstrates complementarity but not a guarantee of generalization.

Portfolio systems must distinguish post-hoc union coverage from deployable fixed-harness performance. HELIX’s 79/100 portfolio coverage is not equivalent to one harness solving 79 tasks. A deployable system requires routing, staged execution, or pre-outcome selection.

Data and knowledge regularization

Knowledge-centric Self-Improvement retains a curated external knowledge base rather than modifying the agent or harness (Wang et al., 21 Jul 2026). It uses task-level and cross-task forums, evidence citations, explicit disagreement, scoped claims, confidence, rejected hypotheses, and typed distillation.

This provides an externalized regularization layer for RRSI:

• knowledge is inspectable and versionable;
• claims carry scope and counter-scope;
• disagreement remains visible;
• artifacts can transfer across models;
• bad claims can be rolled back without changing model weights.

However, knowledge-centric improvement is not itself recursive harness improvement. It changes what future agents know, not the execution substrate. A hybrid system can evolve both knowledge and harness.

State, memory, and update regularization

PAST-Bench and Recuris emphasize typed state, supersession, provenance, retrieval gates, synchronous persistence, and verified state transitions. A persistent artifact should include:

• source episode and timestamp;
• model and harness version;
• evidence references;
• scope;
• confidence;
• validity interval;
• superseded artifact identifiers;
• safety classification;
• update rationale.

Authoritative updates should replace or tombstone stale state rather than allowing contradictory records to coexist without priority.

6. Empirical status, limitations, and future directions

The empirical literature supports bounded, externally evaluated harness improvement but does not establish indefinite, monotonic, or globally safe RSI.

Established empirical patterns

Several patterns recur across systems:

• fixed models can improve substantially through harness evolution;
• execution-grounded evaluators outperform purely intrinsic self-assessment;
• task-specific context routing can reduce redundant reasoning and cost;
• structured memory and state tracking improve long-horizon execution;
• cross-task failure recurrence is more informative than isolated failures;
• preservation gates reduce capability regression;
• archives and diverse populations expose complementary capabilities;
• held-out and cross-model transfer provide stronger evidence than in-sample gains;
• evaluator quality is a principal bottleneck.

Reported results include:

• DarwinX improvements from 75.5% to 83.2% on matched GPT-5.5 Terminal-Bench 2.1 and from 43.5% to 93.0% audit-clean on WebArena-Infinity (Zhang et al., 31 Jul 2026).
• RHI surpassing corresponding higher-reasoning baselines in selected machine-learning research settings while reducing inference cost by up to 60% (Lee et al., 17 Jul 2026).
• Recuris improving task success in 35 of 37 completed model–benchmark pairs, with a reported +17.8 points for GPT-5.6 Sol on $e$4-Retail and +15.6 points for Claude Opus 5 (Yu et al., 25 Aug 2026).
• HarnessEvolve improving CloudCoreNetwork-QA from 43.4% to 86.9% with Qwen3.6-27B, while the no-reference ablation reaches 57.8% (Jiang et al., 1 Sep 2026).
• Ecdysis improving aggregate accuracy from 46.67% for Self-Evolution to 59.33% with FDCR and achieving a reported maximum full-method training speedup of 1.84x (Yue et al., 10 Sep 2026).
• NeoHorse-1 increasing macro-average performance from 58.94 to 64.87 at 4B and from 65.60 to 69.04 at 9B through routing-harness-mediated post-training (Team et al., 8 Sep 2026).
• MetaRSI reporting an average gain of +10.9 for the full composition of Data-RSI, Harness-RSI, and Model-RSI, compared with +6.6 for Harness-RSI alone (Tan et al., 6 Sep 2026).

These results are heterogeneous and should not be collapsed into a single scaling law. They use different models, benchmarks, evaluators, budgets, task distributions, and definitions of success.

Principal limitations

No demonstrated indefinite recursion: Most systems report one or a few rounds. NeoHorse-1 reports one completed evaluation–selection–update pass. HELIX proposes model updating and harness rebuilding but does not empirically close the multi-round loop. Recuris shows plateaus and reversals across rounds. MetaRSI reports several terms but does not establish indefinite monotonic improvement.

Evaluator dependence: A learned judge, benchmark verifier, or hidden test can be incomplete, biased, or exploitable. SBCO’s shopping policy exploited a metric that did not penalize extra products. VideoHarness-RSI’s development-selected candidates show a search–evaluation gap. DarwinX’s audit reduced invalid WebArena trajectories but did not constitute a formal sandbox guarantee.

Benchmark overfitting: Development-set selection, repeated candidate evaluation, task-template regularities, and benchmark-specific interfaces can produce apparent gains without broad capability improvement. TerminalWorld training-proxy performance rose to 1.000 while held-out performance reached only 68.3%.

Model-specific accommodation: A harness may compensate for idiosyncrasies of the current model rather than repair a general execution deficiency. Ecdysis explicitly measures this issue, while cross-model transfer is used as evidence against narrow accommodation.

Insufficient causal attribution: A successful candidate may benefit from stochasticity, altered context length, extra computation, or hidden environmental factors. Mechanism scores and trace evidence are informative but not causal proof. Counterfactual artifact deletion, controlled substitution, and factorial ablations are needed.

Memory and context growth: Repeated skill, memory, and knowledge accumulation can create redundancy, stale state, retrieval interference, and rising cost. Recuris added 51 skills across eight accepted patches and deprecated none in its reported evolution study, illustrating the need for pruning.

Resource escalation: RRSI can spend more compute, tool calls, evaluator calls, and human attention than the apparent capability gain justifies. Cost must be measured at both deployment and evolution time.

Governance and objective drift: Research direction-setting, acceptable risk, benchmark legitimacy, and value conflicts remain difficult to verify automatically. Current systems can increasingly execute experiments and modify local scaffolding, but the choice of what to optimize remains comparatively under-automated (Chen et al., 8 Jul 2026).

Recommended RRSI architecture

A conservative RRSI system should contain five separated planes:

1. Execution plane: model, tools, memory, skills, workflow, and deployment policy.
2. Modeling plane: traces, causal state, simulators, self-models, and predicted outcomes.
3. Improvement plane: candidate generation, mutation, search, and synthesis.
4. Evaluation plane: formal checks, execution tests, independent judges, regression suites, and human audits.
5. Governance plane: immutable constraints, permissions, resource ceilings, rollback, monitoring, and approval.

The improvement plane should not control the governance plane. Persistent harness changes should proceed through sandboxing, static validation, hidden tests, independent verification, shadow deployment, canary evaluation, staged rollout, and rollback.

A generic constrained acceptance rule is:

$e$5

subject to:

$e$6

$e$7

and an explicit regression budget. Here $e$8 may penalize edit magnitude, complexity, context cost, resource use, policy drift, evaluator dependence, or distribution shift. Such a formulation is a proposed RRSI abstraction rather than an objective uniformly implemented in the cited work.

Open research questions

Important unresolved problems include:

• What self-model fidelity is sufficient for each harness modification class?
• How can model-specific accommodation be distinguished automatically from general harness repair?
• What evaluation architecture remains independent when the agent can improve its own workflow?
• How should evaluator uncertainty and disagreement affect acceptance?
• Can held-out, adversarial, and cross-domain tests provide statistically reliable non-regression guarantees?
• How can RRSI preserve rare capabilities while optimizing average performance?
• What mechanisms prevent reward hacking, benchmark overfitting, and evaluator co-adaptation?
• How should memory, skills, and tools be retired when their marginal benefit becomes negative?
• Can model–harness co-evolution be made stable across many generations?
• What forms of human oversight remain necessary for objective selection and research direction?
• Can a complete self-improver safely modify the mechanisms that enforce its own invariants?
• How should recursive systems distinguish imported knowledge from capability generated solely by scaffold rearrangement?

RRSI is therefore best understood as a research program for constrained, evidence-grounded evolution of agent scaffolding. Its strongest defensible form is bounded, externally anchored, human-on-the-loop improvement: the system proposes changes to prompts, tools, memory, skills, planning, evaluation, or orchestration; independent mechanisms test those changes; and only validated, reversible, resource-bounded improvements are retained. The framework supports recursive improvement of agent behavior without implying consciousness, unrestricted introspection, global optimality, indefinite capability growth, or safety by construction.