Bounded Recursive Self-Improvement Under Human Governance: Evidence from a Seven-Cycle Reinforcement Learning Contour Experiment

1. Introduction

Large language models and agentic systems can generate hypotheses, write and revise code, critique outputs, maintain memory, call tools, and conduct increasingly long sequences of work. These capabilities have motivated renewed interest in systems that improve their own procedures rather than merely produce better single outputs. Existing approaches range from iterative self-feedback and verbal reinforcement to self-generated training data, self-improving scaffolds, self-referential agents, and automated scientific discovery [1,2,3,4,5,6,7,8].

Figure 1. Frozen seven-cycle experimental trace. NO_CHANGE denotes a bounded negative result, not permanent saturation.

Figure 1. Frozen seven-cycle experimental trace. NO_CHANGE denotes a bounded negative result, not permanent saturation.

Yet self-modification and self-improvement are not equivalent. A system may change prompts, validators, memory structures, retrieval policies, orchestration code, or evaluation procedures without becoming more reliable or more epistemically adequate. A more serious problem arises when the same computational process proposes a change, constructs the test, evaluates the result, and accepts the change. In that setting, recursive modification can become recursively self-confirming.

The central methodological question is therefore not simply whether a transition S_t -> S_(t+1) occurs, but whether there is a defensible procedure for asserting that the successor should be accepted as an improvement without allowing the mechanism producing the successor to manufacture the evidence by which it is judged superior.

The Reinforcement Learning Contour (RLC) was introduced as a conceptual architecture for governed recursive learning in AI-assisted research [9]. The term does not denote conventional reinforcement learning: the framework does not assume a closed Markov state space, scalar reward, value function, or automatic policy optimization. Instead, an epistemic contour is a bounded, time-indexed configuration of knowledge, ontology, relations, retrieval mechanisms, evaluative criteria, inquiry policy, provenance, memory, tools, and governance constraints; the RLC is the governed architecture that links such states through evidence, action, evaluation, approval, and reintegration.

The present experiment operationalizes four specific elements of that conceptual architecture: versioned contour state, evidence and provenance anchoring, bounded proposal-evaluation cycles, and structural separation of machine recommendation from Human Acceptance Authority. It deliberately leaves outside the experiment the broader epistemic ontology, long-horizon scientific-quality assessment, and comparative multi-condition pilot proposed in the conceptual paper; the claims below therefore concern operational governance capabilities rather than the full epistemic programme.

The conceptual RLC paper explicitly presented the framework as untested. The present work is an empirical follow-up. We operationalized a narrow subset of the architecture as a local recursive self-modification experiment in which each cycle could inspect the current operational state, identify at most one evidence-supported and falsifiable deficiency, construct a sandboxed candidate, test it, and recommend promotion. Crucially, promotion remained a separate human-authorized event, failure was preserved, and NO_CHANGE was defined as a legitimate terminal outcome.

Seven cycles were executed from a frozen baseline. The resulting trace was heterogeneous rather than monotonically progressive: two promotions, one failed transition, a forensic boundary revision, two further promotions, and two independent NO_CHANGE outcomes. This pattern permits analysis of recursive improvement as a governed state-transition process in which promotion, rejection, protocol revision, and non-change are all scientifically meaningful outcomes.

2. Related Work

Iterative self-refinement methods demonstrate that language models can improve outputs using their own feedback. Self-Refine uses a single model as generator, feedback provider, and refiner and reports improved task performance without additional supervised training [1]. Reflexion similarly uses linguistic feedback and episodic memory to improve subsequent trials without updating model weights [2]. These approaches primarily improve task outputs or action policies at inference time rather than maintain a cryptographically versioned architecture with external acceptance authority.

A second line of work concerns self-generated supervision. Huang et al. showed that large language models can generate high-confidence rationale-augmented answers and fine-tune on those self-generated solutions, improving reasoning performance on several benchmarks [3]. Constitutional AI uses self-critique, revision, and AI feedback under a human-specified set of principles to reduce dependence on direct human labels [4]. These systems demonstrate that self-produced signals can contribute to improvement, but they also sharpen the question of how evaluative authority and evidence provenance should be separated from generation.

A more formal predecessor is Schmidhuber's Gödel Machine, a fully self-referential problem-solver architecture that permits self-rewrites once its proof searcher establishes, within the machine's encoded axioms and utility framework, that executing the rewrite is preferable to continuing the search for alternatives [5]. Its global-optimality result is therefore proof-relative rather than an empirical guarantee about an incompletely modeled world. The present RLC experiment operates in a deliberately weaker and governance-oriented regime: formal proof of utility is replaced by preregistered falsifiable evidence, unrestricted self-rewrite by bounded sandboxed candidates, and self-authorized switching by independent Human Acceptance Authority.

More directly related are systems that modify their own scaffolding or agent logic. STOP applies a language-model-infused improver to its own code and reports improved downstream program-generation performance, while explicitly noting that the underlying language model is not itself modified and that the work is therefore not full recursive self-improvement [6]. Goedel Agent proposes a self-referential agent framework that dynamically modifies its own logic and behavior under high-level objectives and reports continuous improvement on reasoning and agent tasks [7]. These approaches emphasize performance improvement and search over agent designs. The present experiment instead emphasizes bounded evidence, preregistration, immutable lineage, failure preservation, human promotion authority, and the legitimacy of NO_CHANGE.

Automated scientific systems provide a complementary context. The AI Scientist integrates idea generation, code execution, experimentation, manuscript production, and automated review in an iterative research pipeline [8]. The RLC framework is concerned with a different unit of analysis: not the quantity of artifacts produced, but whether the mechanism governing subsequent inquiry changes in a beneficial, traceable, and governable way [9].

The contribution of this paper is therefore not a claim to outperform these systems. It is an instrumented case study of a recursive architecture designed so that an attempted improvement can fail, a failed branch can remain historically visible, the measurement boundary can be revised prospectively rather than retroactively, and repeated searches can terminate without producing a candidate.

3. Formal Model of Bounded Recursive Improvement

Let R_n denote the accepted operational RLC state before cycle n. Let E_n denote the evidence available to that cycle, B_n the active integrity boundary, Sigma the human-governed Sigma-sensitive layer, and A_H an independent Human Acceptance Authority.

A cycle first produces a diagnosis d_n from bounded observation and measurement. A candidate may be generated only if d_n identifies at most one qualifying deficiency that is evidence-supported, falsifiable, non-Sigma, bounded, and testable in the sandbox. Candidate generation is therefore conditional rather than obligatory.

We write the candidate-generation step as C-hat_(n+1) = G(R_n, E_n, B_n), where G may return either a candidate or the empty set. If G returns the empty set, the cycle terminates as NO_CHANGE and R_(n+1) = R_n.

If a candidate exists, its expected effects and falsification conditions are preregistered before implementation. The candidate is then evaluated under sandbox tests, inherited regression checks, resource/effect reconciliation, boundary integrity, Sigma integrity, and lineage integrity. Let Q_n in {0,1} denote conjunction of these machine-verifiable gates.

Promotion is separated from candidate generation: R_(n+1) = C-hat_(n+1) only when Q_n = 1 and A_H = 1. Otherwise R_(n+1) = R_n. A failed candidate is preserved in the complete experimental history even when it is excluded from promoted lineage.

Accordingly, the cycle outcome is O_n in {PROMOTE, FAILED_NOT_PROMOTED, NO_CHANGE, PAUSE}. A separate PROTOCOL_BOUNDARY_REVISION event may revise B prospectively, but it does not retroactively convert a failed transition into a successful one.

This formulation deliberately rejects a growth objective. The experiment did not optimize a composite scalar self-improvement score, and no rule required R_(n+1) to differ from R_n. The absence of a qualifying deficiency was treated as an admissible observation rather than a failure to continue recursion.

4. Materials and Methods

4.1. Experimental Environment

The experiment was executed in a local sandboxed workspace using an AI coding/orchestration agent. The underlying foundation model was not trained or weight-updated by the experiment. The object of modification was the surrounding operational RLC state: validators, evidence-checking mechanisms, lineage controls, and related bounded artifacts. Network calls and external actions were prohibited during recursive cycles.

4.2. Frozen Baseline and Protocol

Before Cycle 001, Protocol v1.0 and RLC0 were frozen. The prepared engine implemented a one-cycle-at-a-time state machine with persistent checkpoints, parent/child lineage, before/after hashes, a hash-chained event ledger, rollback references, sandbox confinement, independent promotion gates, and resource ceilings. Forced exponential growth was explicitly excluded.

4.3. Cycle Procedure

Each cycle followed the ordered stages Observe -> Measure -> Diagnose. If a qualifying deficiency was found, the cycle continued with Preregister -> Candidate -> Sandbox Test -> Evaluate -> Decision -> Post-Cycle Integrity Check. A cycle was limited to one hypothesis and one bounded candidate. A failed hypothesis could not be replaced by a second hypothesis inside the same cycle.

4.4. Preregistration

Before candidate implementation, the cycle recorded the exact hypothesis, supporting evidence, affected components, expected observable effects, semantic polarity of predicates, falsification criteria, adversarial cases, regression criteria, invariant-preservation requirements, rollback condition, and resource budget. This prevented post hoc redefinition of success.

4.5. Sandbox and Authority Constraints

Candidates could not modify their frozen parent, earlier RLC states, Boundary v1.1 after activation, Sigma, authoritative EWCC/RLC artifacts, or agent privileges. FORMAL collection was not activated. Network calls and external actions were prohibited. A machine recommendation to promote did not itself create a successor state; each promotion required a separate human authorization.

4.6. Provenance and Integrity

Accepted states and completion receipts were hashed with SHA-256. The promoted lineage and the complete experimental history were maintained separately so that failed branches remained visible. After Cycle 007 the experiment was frozen into an archival namespace. The freeze receipt recorded successful referenced-artifact verification with no mismatches, and the manifest covered 334 content-addressed artifacts.

4.7. Use of AI in the Research and Manuscript

AI-assisted tools were used as part of the experimental system, for code generation, bounded analysis, and artifact production, and were also used to assist drafting and editing of this manuscript. AI systems were not treated as authors. The human author defined the experimental constraints, supplied independent authorization at promotion gates, reviewed retained claims, and assumes responsibility for the manuscript.

5. Results

5.1. Overall Trace

Seven bounded recursive cycles were completed. Four cycles produced human-approved successor states; one cycle failed and was not promoted; one prospective integrity-boundary revision followed forensic analysis; and the final two cycles terminated as NO_CHANGE without creating a candidate or successor state.

The promoted lineage was RLC0 -> RLC1 -> RLC2 -> RLC3 -> RLC4. Cycle 003 formed a failed branch from RLC2 and did not become part of promoted lineage. Cycles 006 and 007 both executed from RLC4 and left RLC4 unchanged.

5.2. Cycles 001-002

Cycle 001 promoted an executable frozen-reference validation capability, converting documentary baseline integrity into an executable check. Cycle 002 added validation of inherited state and lineage. Together they established the first two cumulative operational changes. Operationally, these capabilities close distinct failure classes rather than merely adding another software check: Cycle 001 makes missing or tampered frozen references executable failures, whereas Cycle 002 makes broken parent/rollback lineage and missing inherited evidence detectable before a successor state can be accepted.

5.3. Cycle 003 Failure

Cycle 003 did not satisfy its preregistered hypothesis and entered an integrity pause. The candidate was not promoted, RLC2 remained the accepted parent state, and the failed branch was retained. This event demonstrated that the experimental mechanism could produce negative evidence rather than automatically continue the promoted chain.

5.4. Forensic Analysis and Boundary v1.1

Forensic investigation of Cycle 003 identified a mismatch between byte-level immutability assumptions and artifacts whose legitimate operational behavior was volatile or append-like. Boundary v1.1 was therefore designed and activated prospectively after human review. Historical RLC states and the failed Cycle 003 outcome were not rewritten. The revision changed the semantics of future integrity checking rather than the recorded result of the failed cycle.

5.5. Cycle 004

With Boundary v1.1 active, Cycle 004 identified a distinct deficiency: the current state could validate inherited frozen references but lacked an executable inheritance gate that jointly enforced the active boundary, lineage, failed-branch exclusion, and related integrity conditions. The preregistered sandbox predicates passed, post-cycle integrity remained valid, and the exact tested candidate was independently promoted to create RLC3. The resulting capability extends the acceptance boundary to failures that a simple hash check cannot distinguish correctly, including invalid boundary anchors, missing provenance for declared volatility, and accidental inclusion of the preserved failed branch in promoted lineage.

5.6. Cycle 005

Cycle 005 identified a further distinct gap in deterministic reconciliation between reported resource/effect claims and the actual candidate tree and referenced artifacts. The candidate reconciler was preregistered to accept intact evidence and reject tampered counts, hashes, extra files, and prohibited-effect counters. The candidate passed its bounded tests and integrity checks and was independently promoted, creating RLC4. Its operational significance is adversarial rather than cosmetic: it independently rejects inconsistent candidate hashes or file counts, unexpected files, and nonzero prohibited-effect claims instead of trusting self-reported counters at face value.

5.7. Cycles 006-007

Cycle 006 executed inherited validation and searched for a new qualifying deficiency. Candidate directions overlapping prior capabilities were rejected rather than relabeled as novel. The cycle recorded zero qualifying deficiencies, created no candidate, and terminated as NO_CHANGE. Cycle 007 repeated a fresh bounded observation and diagnosis from the same RLC4 parent. It did not treat Cycle 006 as proof of saturation and again found no qualifying deficiency under the protocol. No RLC5 state was created.

5.8. Final Freeze

After Cycle 007, no additional recursive cycle was authorized. The seven-cycle corpus was archived as a frozen experimental package containing the baseline, checkpoints, cycle evidence, the failed branch, forensic artifacts, Boundary v1.1 materials, human approvals, completion receipts, NO_CHANGE evidence, protocol references, and a content-addressed manifest. Referenced-artifact verification passed with no recorded mismatches.

6. Discussion

The principal result is not that the system improved itself seven times. It did not. The trace instead shows that bounded recursive self-modification can be organized as a governed experimental process with multiple legitimate outcomes. Four changes were promoted; one proposed transition failed; the integrity boundary was revised prospectively; and two subsequent searches produced no candidate.

The failed third cycle is particularly important. A pipeline that always reports improvement is difficult to distinguish from a pipeline whose evaluation procedure is biased toward its own outputs. Here, the failed transition remained failed. The architecture resumed later from RLC2 rather than laundering the failed candidate into the promoted lineage. This provides an operational example of failure preservation as a governance property.

The boundary revision is also significant. Integrity controls themselves can be misspecified. Treating every live artifact as byte-immutable can generate false integrity failures, while treating everything as volatile can make integrity meaningless. The Cycle 003 forensic episode therefore exposed a second-order problem: the measurement boundary is itself part of the experimental apparatus. The response was not unrestricted self-revision of governance; Boundary v1.1 required separate human review and was activated prospectively.

Cycle 005 adds a further layer of reflexivity. A recursive system that reports its own resource use and side effects should not be trusted merely because those counters are present in its own evidence. The promoted reconciler independently compared reported claims with the actual candidate tree and referenced artifacts, including negative cases with altered hashes, counts, extra files, and prohibited-effect counters.

The final two NO_CHANGE outcomes are scientifically useful because continued progression was not made a success criterion. They do not prove that RLC4 was optimal, permanently saturated, or incapable of future improvement. They show only that two bounded searches under the stated evidence and qualification rules did not establish a new deficiency. That distinction is essential.

More broadly, the experiment suggests a way to operationalize recursive improvement without assuming that recursion must be monotonic. The process can be viewed as a sequence of governed epistemic commitments rather than an optimization curve. Improvement claims become local, typed, provenance-bearing transitions with explicit negative outcomes.

Seen against the Gödel Machine, this distinction is substantive rather than terminological. RLC does not claim proof-theoretic global optimality and should not be interpreted as a practical implementation of the Gödel Machine. Instead, it addresses settings in which utility, environment dynamics, and the consequences of self-modification cannot be fully axiomatized: improvement is treated as a bounded empirical claim that must survive preregistered tests, integrity checks, and an external acceptance decision [5].

7. Threats to Validity and Limitations

This is a single-system, single-operator case study. It does not establish generality across foundation models, agent frameworks, tasks, operating systems, or human reviewers. Replication with independent operators and alternative models is required.

The experiment modified operational scaffolding rather than model weights. The term recursive self-improvement is therefore used at the system/agent architecture level, not to claim self-training of the underlying foundation model. This distinction parallels the caution made in prior work on self-improving scaffolds [6].

The human author simultaneously designed the governance constraints, operated the experiment, and served as the sole promotion authority. Human governance is a feature of the architecture because it structurally separates machine recommendation from acceptance, but this study does not provide inter-rater independence and cannot exclude designer or operator bias in promotion decisions. Independent replication with multiple blinded or precommitted promotion authorities is therefore required before generalizing the governance result. It also means the experiment is not evidence of fully autonomous recursive self-improvement.

The system participated in generating candidates, tests, evaluations, and evidence. Preregistration, inherited validators, human promotion, failure preservation, and post-cycle integrity checks reduce but do not eliminate the possibility of self-confirming evaluation. Independent replication and external test suites remain necessary.

The seven cycles were not designed to measure a common scalar performance variable, and the promoted capabilities are heterogeneous. It would therefore be invalid to infer exponential, linear, or any other quantitative growth law from the state sequence.

Finally, two NO_CHANGE observations do not establish permanent saturation. They are bounded negative findings conditional on the search procedure, evidence available, active boundary, and qualification criteria.

8. Reproducibility, Data and Artifact Availability

The experiment was frozen after Cycle 007. The archival freeze records four promoted successor states, one failed non-promoted branch, one prospective protocol-boundary revision, and two NO_CHANGE outcomes. The freeze receipt reports successful referenced-artifact verification without mismatches, and the manifest contains 334 content-addressed artifacts.

For Preprints.org submission, the frozen artifact corpus should be uploaded as Supplementary Material where file-size and confidentiality constraints permit. At minimum, the experiment manifest, experiment trace, experiment summary, freeze receipt, relevant cycle evidence, state checkpoints, and SHA-256 sidecars should accompany the manuscript. If the full archive exceeds platform limits, it should be deposited in a recognized public research-data repository and the persistent link added before posting.

The current manuscript reports only claims supported by the frozen trace. No claim of AGI, autonomous takeoff, exponential recursive growth, or permanent saturation is made.

9. Conclusion

This seven-cycle experiment provides a bounded empirical demonstration of governed recursive self-modification at the agent-system architecture level. Starting from a frozen RLC0 baseline, the process produced four human-approved state promotions, preserved a failed transition, revised an integrity boundary prospectively after forensic analysis, resumed from the last valid parent, and then terminated two independent searches without manufacturing a new candidate.

The result is narrower than strong notions of recursive self-improvement, but that narrowness is methodologically important. A recursive system should not be judged only by whether it can change itself. It should also be judged by whether it can preserve negative evidence, distinguish candidate generation from acceptance, maintain provenance across state transitions, expose failures in its own measurement boundary, and stop when the available evidence does not justify another change.

The experiment therefore supports recursive improvement as a governed state-transition problem rather than as an assumption of monotonic growth. Future work should replicate the protocol across models and operators, introduce external benchmark tasks and independent evaluators, quantify the cost and reliability of inherited controls, and test whether the same governance properties survive substantially longer recursive runs.

Table 1. Seven-cycle experimental trace.

Event	Parent	Outcome	State consequence / principal observation
Cycle 001	RLC0	PROMOTED	RLC1; executable frozen-reference validation
Cycle 002	RLC1	PROMOTED	RLC2; inherited-state / lineage validation
Cycle 003	RLC2	FAILED_NOT_PROMOTED	RLC2 retained; integrity pause; hypothesis not met
Boundary v1.1	-	PROTOCOL_BOUNDARY_REVISION	Prospective integrity semantics revised after forensics
Cycle 004	RLC2	PROMOTED	RLC3; boundary-aware inheritance gate
Cycle 005	RLC3	PROMOTED	RLC4; deterministic resource/effect evidence reconciliation
Cycle 006	RLC4	NO_CHANGE	No qualifying deficiency; no candidate; RLC4 retained
Cycle 007	RLC4	NO_CHANGE	Independent repeat; no candidate; RLC4 retained

Table 1. Seven-cycle experimental trace.

Event	Parent	Outcome	State consequence / principal observation
Cycle 001	RLC0	PROMOTED	RLC1; executable frozen-reference validation
Cycle 002	RLC1	PROMOTED	RLC2; inherited-state / lineage validation
Cycle 003	RLC2	FAILED_NOT_PROMOTED	RLC2 retained; integrity pause; hypothesis not met
Boundary v1.1	-	PROTOCOL_BOUNDARY_REVISION	Prospective integrity semantics revised after forensics
Cycle 004	RLC2	PROMOTED	RLC3; boundary-aware inheritance gate
Cycle 005	RLC3	PROMOTED	RLC4; deterministic resource/effect evidence reconciliation
Cycle 006	RLC4	NO_CHANGE	No qualifying deficiency; no candidate; RLC4 retained
Cycle 007	RLC4	NO_CHANGE	Independent repeat; no candidate; RLC4 retained