acceptodds
Under review as a conference paper at ICLR 2027

Safety Must Survive Self-Improvement: Why Failures Persist and How Agents Recover

Abstract

Recursive self-improvement (RSI) allows agents to carry useful changes across generations. Maintaining safety across these generations involves both preventing unsafe behavior from persisting and enabling recovery when failures occur. We study these challenges through a controlled testbed of stateful authorization tasks, where fixed LLM editors optimize executable agent components and independent traces record their effects. Paired interventions separate which revisions pass validation, which program continues running, and which program the editor revises next. After a new authorization dependency invalidates previously tested optimizations, historical scores preserve the same unsafe programs in 22 of 48 framework histories despite a correct alternative in every affected archive. Refreshing scores restores correctness on the original suite, with residual failures on independently composed tests. Failures also persist under an unchanged contract when all proposals are rejected and the failed incumbent remains active. Starting from shared failures, editing the initial implementation instead of the failed one improves recovery, although the advantage varies across editors. Full validation and validated rollback end with fully correct programs in the core trajectory study while retaining over 43% deployment savings. Preserving agent safety requires checking what will run under current conditions and choosing which implementation to edit next.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
self-improving agents, AI safety, safe fallback, evolutionary code search

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_mHVFOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies safety failures during repeated LLM based revision of executable agent components. It separates three controller decisions: whether a program passes current validation, which program is executed, and which program is supplied to the next editor. In constructed authorization tasks, stale archive scores can retain programs that become invalid after a contract change, a keep rule can continue running a failed incumbent when every candidate is rejected, and editing the correct founder can improve recovery. The paper evaluates these effects across several editors, four task families, selected components from OpenEvolve and DGM, and a Casbin task. It concludes that current deployment validation and validated rollback can preserve correctness while retaining some service cost savings.

Critical strengths
  1. The distinction among failure detection, deployment, and repair is clear and useful. The paper correctly emphasizes that finding a defect does not determine what executes next.

  2. The experimental bookkeeping is careful. Paired branches share programs, proposals, or candidate pools where appropriate. Protected effects are recorded independently of program outputs, and the paper distinguishes safety, full correctness, final correctness, and safety throughout a trajectory.

  3. The authors report intermediate states rather than only favorable endpoints. The examples of stale permission caches make the observed mechanisms concrete. The discussion of unknown outcomes, repeated states, validation cost, and test coverage is also unusually transparent.

Critical weaknesses
  1. The main findings have limited conceptual novelty because they largely follow from the controller definitions. Scores measured under an obsolete contract can rank an obsolete program highly. Equation 1 explicitly returns the failed incumbent when the eligible set is empty, so continued execution after rejection is a direct consequence of the rule. Founder fallback selects an implementation assumed correct by construction. The experiments quantify how often these cases occur, but the proposed remedies are standard revalidation, rollback, and pausing rather than a new learning method, safety mechanism, or theoretical result.

  2. The recursive self improvement framing is broader than the evidence. The editors and improvement procedures are fixed, while the evolving objects are small Python authorization components with externally supplied contracts and oracles. The framework experiments still use custom authorization evaluators, the DGM study transfers only selected functions, and some related systems are inspected rather than executed. Most importantly, the native dialogue transfer executes no proposed writes and finds no established increase in authorization failures over evolution. The evidence therefore supports a claim about regression control and cache invalidation in iterative program optimization, but not a general claim about safety in self improving agents.

  3. The safety conclusions remain strongly conditional on test coverage. Public, audit, and hidden splits are seeded instances of the same designed categories. Independently composed streams still expose unsafe endpoints after current validation and score refresh. Thus statements that full validation or rollback ends with fully correct programs apply to this benchmark and oracle, not to safety under an incomplete contract or distribution shift. A stronger paper would compare against runtime enforcement, versioned certificates, adversarial test generation, or formal authorization invariants on genuinely unseen mechanisms.

  4. The utility evidence is difficult to interpret outside the simulator. Service costs are manually assigned logical weights. The headline deployment savings exclude model generation and usually exclude validation. Figure 11 shows that validation outweighs savings at low deployment volume. End to end latency, compute, monetary cost, and realistic deployment frequency are needed before concluding that the controls preserve useful efficiency.

  5. The confirmatory interpretation and reproducibility need improvement. The seed count was expanded after the pilot was inspected, yet the pilot and expansion are pooled for inference. The shared failure study conditions on a selected set of failures and its largest effect is dominated by Qwen, which limits generalization. No code, data, prompts, traces, or executable artifact is available with the reviewed submission, despite the complexity of the custom simulators and analysis.

Questions for authors
  1. What nontrivial guarantee remains when the validator is incomplete or when no known correct founder exists?

  2. How much of the founder editing advantage remains after controlling for code size, distance to a correct solution, and editor specific failure incidence?

  3. Can the central interventions be evaluated in a complete agent improvement system with real protected actions, unseen tasks, and measured end to end cost?

6 comments
AuthorsOpenReview ↗

Response to Reviewer mHVF [1/5]

Thank you for the thorough assessment. We appreciate your recognition that the distinction among failure detection, deployment, and repair is "clear and useful", and of the experimental bookkeeping and the reporting of intermediate states. Several of your points lead to changes in the paper. For the others, we add experiments or clarify what the evidence supports. We will upload the revised PDF shortly, with all changes marked in blue. Material shared by several reviews, including the new experiments E1, E2, E3, E7, and E8, is in our Response to Common Questions, posted as a separate comment on this page, and we refer to its sections as C1 to C6.

W1. Novelty relative to the controller definitions

The remedies are standard, and the revised paper will present them as such. The contribution is empirical: the paper measures a gap that the controller definitions permit but do not quantify, and the revised discussion will be organized around it.

A deployed program can be unsafe for two different reasons. In a coverage gap, the current validator cannot detect the failure. In a selection gap, the current validator would reject the program, and the controller runs it anyway. The definitions say that a selection gap can exist. They do not say how large it is, whether continued search closes it, or which standard remedy closes it. These are what the paper measures.

  • Size after a contract change. Stored scores leave 22 of 48 framework histories unsafe, and in every one the archive already holds a passing program. On independent compositions, 25 histories are unsafe under stored scores and 3 after refresh at the matched endpoint, and stress tests remove those 3 (new experiment E5, under W3).
  • Size under an unchanged contract. Under efficiency editing with inheritance, 48 of 72 consent lineages end unsafe (Table 12), although the editor is told to preserve the contract. In a separate audit of 198 branches, all 346 unsafe states under full validation are incumbents kept after every candidate was rejected.
  • The gap does not close with more search. At iteration 100, every affected archive holds 72 to 91 programs that pass the current tests, yet in all 22 histories stored scores still select the same unsafe program as at iteration 20. The best passing program costs a median of 24.5% more per request, because the stale program's savings come from skipping the check that the new dependency requires. No valid program can outscore the stale record, so only re-evaluation removes it.
  • Two natural remedies do not close it. In the 72-history study, rolling back to the last program that passed the full suite before the change leaves 20 histories unsafe, because that program can share the broken assumption. Re-evaluating only the program the editor starts from leaves all 22 unsafe endpoints. Only re-evaluating what is deployed removes them.
  • A repair is usually already present. When stored scores keep an unsafe program, a passing program is already available in 123 of 132 cases.
  • Current frameworks leave the gap open. In the default loop of 15 open-source LLM-driven improvement systems (E7, C5), all 14 that have a selection step select on scores recorded at evaluation time, none re-evaluates stored candidates in its standard loop, and every population-based system keeps its elites when no new candidate is better.

The guarantee, stated as a proposition. With deployment revalidation and validated fallback or pause, no program that fails the current validator executes, so unsafe execution is confined to the validator's false passes. Stored-score selection and the keep rule do not have this property. The statement is simple, and the revision will include it because it makes precise what the selection controls provide and what they leave to testing and enforcement.

On Equation 1. The definition does not say how often every proposal fails. With identical incumbents, proposals, and tests, every proposal was rejected in 6 of 42 GPT cases and 8 of 42 Sonnet cases. The keep rule restored safety in none of them, and founder fallback in all of them.

AuthorsOpenReview ↗

Response to Reviewer mHVF [2/5]

W2. Scope of the self-improvement framing

We agree, and the revised paper will narrow the framing (C1). It will describe the main experiments as regression control and cache invalidation in iterative, LLM-driven program optimization, for the case in which the optimized component keeps executing protected actions. It will call this setting self-evolution of agent components, following the self-evolving-agent literature [1, 2, 3], and it will not claim a general account of safety in self-improving agents. The specific gaps listed under this weakness are addressed as follows.

  • Fixed editors. In a new experiment the improver rewrites its own strategy. Unsafe programs become rarer, 7 of 24 histories against 22 of 24, and stored scores keep the unsafe program deployed in all 29 affected histories (E1, C2).
  • Small components, external contracts, and custom evaluators. The handlers are small so that every protected effect can be audited, and the contract is supplied externally because the deployer, not the agent, defines who may do what. To replace the custom evaluators, we replayed the evolved programs on Casbin and OpenFGA. Programs selected by stored scores commit unauthorized writes in 35 of 72 histories on the original request streams, and none of the 120 programs selected after refresh does (E2, C3).
  • Selected DGM functions and inspected systems. We execute DGM's parent-sampling, archive-update, and score functions unchanged because they implement the selection decision. This is not a full DGM run, and the main text will say so. Behavioral claims rest only on executed code. Source inspection supports one claim, that selecting on recorded scores without re-evaluation is the default (E7, C5).
  • Native dialogue. Appendix G will still be reported as mixed. It did not show that evolution makes unauthorized proposals more frequent. It did show that the underlying failure occurs in released environments before any evolution: after a consent withdrawal followed by 4 or 12 neutral dialogue pairs, 42 and 21 of 224 next-action queries propose an unauthorized write. The paper's central claim is a different one: once the evaluator changes, the selection rule decides whether an invalidated version keeps running. We tested this claim in the same environments with executed writes. Stored scores select a policy-violating configuration in 24 of 64 lineages, and current scores in 3 (E8, C4).

W3. Test coverage and unseen mechanisms

Validation protects only what the tests cover, and every correctness claim in the revision will be stated relative to the evaluated suites and oracle. In the suggested comparison (new experiment E5), stress tests remove the failures that current validation leaves on new compositions and on an unseen mechanism that is consistent with the declared contract. For an undeclared change that contradicts the contract, only declaring and testing the change or runtime enforcement removes the failures.

We added two authorization mechanisms that appear in no suite, prompt, or document.

  • U1, principal suspension. Suspending the hidden owner of a token disables the token.
  • U2, shared account quota. Executing one token can exhaust a budget that it shares with sibling tokens.

Both respect the documented API, so the founder stays correct. We generated 64 held-out streams per mechanism and family, and recorded hashes of the generators and streams before evaluating any evolved program. We then compared the controls on the 48 framework histories at two endpoints.

Iteration 100, no refreshIndependentU1U2Savings (%)
Stored scores24242949.4
Current validation663145.2
With random stress tests112745.0
With LLM-generated stress tests002744.8
Monitor with a formal model of the declared contract063145.2
Certificates, change declared and tested00036.6
Runtime monitor on the live authorization state0007.7
Iteration 60IndependentU1U2Savings (%)
Stored scores (no refresh)25252849.1
Refresh at iteration 20, then continue332944.4
With random or LLM-generated stress tests002744.4
Monitor with a formal model of the declared contract032944.4
Certificates, change declared and tested00036.5
Runtime monitor on the live authorization state0006.9
AuthorsOpenReview ↗

Response to Reviewer mHVF [3/5]

Counts are histories out of 48. The table separates three kinds of unseen behavior.

  1. New compositions of known mechanisms. Current validation leaves 6 unsafe histories at iteration 100 and 3 at the refresh endpoint. LLM-generated stress tests remove them at both endpoints, and random stress tests leave one at iteration 100.
  2. An unseen mechanism that is consistent with the declared contract (U1). The pattern is the same. The stress tests do not exercise U1. They reject the same fragile programs for composition failures, and those are the programs that fail under U1.
  3. An undeclared change that contradicts the declared contract (U2). U2 lets one token's execution affect a sibling, which the declared contract implies cannot happen. Here current validation gives no benefit over stored scores (31 against 29 at iteration 100, and 29 against 28 at iteration 60), and neither does any other control derived from the declared contract. Among the 4,737 distinct programs that pass the current suite, out of the 6,326 distinct programs proposed in the 48 histories and their two continuations, U2 reveals unauthorized effects in 57.7%, while random and LLM-generated stress tests reveal them in 2.3% and 3.2%.

Only two controls handle U2: declaring and testing the change, after which versioned certificates work, and enforcement against the live authorization state. Enforcement has a price. The savings come from avoiding authoritative checks, so a monitor that pays for an authoritative check on every action reduces savings from 44.4% to 6.9%. A colocated monitor priced at one to three units would keep 35% to 41%. The monitor also does not repair programs or restore missing permitted work.

The conclusion is therefore stated for this benchmark and oracle: full validation and rollback end with fully correct programs. They close the selection gap and leave the coverage gap, so selection controls and runtime enforcement are complementary. The revised discussion will state what each control guarantees.

W4. Utility outside the simulator

Assigned weights alone do not establish utility, so we measured what the headline excluded (new experiment E6). On two real authorization stacks, savings remain positive against a single-check baseline and are much smaller than against the founder, and the loop repays its cost only at sufficient request volume.

Model and validation cost. One edit takes 11.3 s and 0.018 USD with Sonnet, and 59.0 s and about 0.1 USD with GPT. Validating one program takes 0.087 s of CPU time. A full archive refresh takes 1.7 s and a lazy refresh 0.35 s.

Deployment latency. The embedded stack runs Casbin with SQLite in the client process. The remote stack runs OpenFGA on one server and the replay client on a second server in the same data center, with protected actions committed to PostgreSQL on the service host. Authoritative checks cross the network, and version reads are served from a local cache that follows the service's change stream. The replay is sequential and applies every change-stream event before each request, so a version read never lags the service state. Every operation was timed over five passes. These measurements are conditional on this synchronized, sequential, single-client workload: cache maintenance is not reported as a separate operation, and concurrent load was not measured.

Median latencyAuthoritative checkVersion readCommitted write
Embedded (Casbin, SQLite)115 µs6 µs56 µs
Remote (OpenFGA, PostgreSQL)2.9 ms4 µs1.1 ms

On the remote stack the 95th percentiles are 6.4 ms, 9 µs, and 2.3 ms.

Savings against two baselines. The headline compares each endpoint with the founder of the same seed, and some founders check permission more than once per request. We therefore also compare against a handler that makes exactly one authoritative check per request.

Endpoints, 48 histories eachBaselineWeighted savings (%)Embedded: authorization latency saved (%)Embedded: total latency saved (%)Remote: authorization latency saved (%)
Full refreshFounder of the same seed43.947.740.353.9
Lazy refreshFounder of the same seed44.548.441.254.6
Full refreshSingle check per request16.613.710.423.2
Lazy refreshSingle check per request16.914.711.324.3

Savings remain positive against the single-check baseline on every stack, and they are much smaller than against the founder. The revised paper will report both baselines wherever it reports savings. On the remote stack an authoritative check costs about 700 version reads, far above our assigned ratio of 12, which is why measured savings there exceed the weighted ones.

Reviewer_qj1vOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies how authorization failures arise, persist, and recover during repeated LLM-driven modification of executable agent components. The editor remains fixed while programs and their histories evolve. Four stateful task families distinguish unauthorized effects from successful completion of permitted work. The paper separates three decisions: which programs pass validation, which program executes, and which implementation supplies the next edit. Matched experiments show that historical scores can retain unsafe programs despite correct alternatives in the same archive, and that keeping the incumbent after all candidates fail can prolong a detected failure. Editing the founder rather than the failed incumbent improves recovery for the original-editor cohort, although the advantage is strongly editor-dependent. Current deployment validation, score refresh, and validated fallback improve outcomes in these tasks. The core study reports fully correct endpoints with approximately 43% deployment service-cost savings for full validation and validated rollback. Independent event compositions reveal remaining coverage failures, while native dialogue transfer provides mixed results.

Critical strengths
  1. Strong experimental separation of mechanisms. The same-archive readout comparison, identical-candidate retention comparison, and shared-failure editing-source comparison isolate decisions that would otherwise be conflated. In particular, historical readout retains the same 22 unsafe programs across 48 framework histories despite correct alternatives being available. This supports a concrete conclusion about selection, rather than merely showing that generated code can fail. The distinction between readout and score refresh also separates immediate selection effects from subsequent changes in search.
  2. Evaluation distinguishes authorization, functionality, and temporal exposure. Independently recorded effects prevent output manipulation from hiding unauthorized actions, while full correctness prevents blanket refusal from counting as repair. Tracking intermediate selections exposes failures concealed by correct endpoints. Independent event compositions, block-level statistical inference, and transparent reporting of mixed native-transfer results make the empirical conclusions more credible.
Critical weaknesses
  1. The broader significance is constrained by the evaluation setting. The strongest evidence comes from constructed authorization tasks with externally specified contracts, fixed editors, and controlled validators. The framework experiments strengthen the evidence, but they evolve authorization components through upstream search components rather than demonstrating the same effects in complete, jointly evolving agent systems. Native dialogue transfer in Appendix G does not establish increased authorization failures over evolution. This does not invalidate the controlled mechanisms, but it limits claims about their prevalence and impact in general recursive self-improvement.
  2. Founder editing has limited evidence as a general recovery strategy. The aggregate improvement from 14 to one unsafe endpoint is substantial, but most of the difference comes from Qwen. GPT reaches zero unsafe endpoints under both editing sources, and Sonnet differs by only one endpoint (Table 10). Moreover, the founder comparison does not determine whether the benefit specifically requires the initial implementation, or whether another currently validated historical version would provide a better repair starting point while preserving accumulated improvements. This limits the practical recommendation that can be drawn from the editing-source result.
Questions for authors
  1. Scope and transfer. Given the mixed native dialogue results, which conclusions do you consider established beyond the constructed authorization tasks? Please distinguish evidence that a mechanism can occur from evidence about its frequency in deployed self-improving agents. This distinction would materially affect my assessment of significance.
  2. Choice of repair source. Do you have results comparing founder editing with editing the most recent currently validated historical program? Such a comparison would help determine whether the observed benefit requires returning to the founder or can be obtained while retaining useful accumulated changes.
  3. Total evaluation budget. The matched framework continuation fixes the editing budget, whereas score refresh additionally reevaluates archived programs. What is the additional validation cost, and how does refresh compare with a baseline given the same total evaluation budget? The existing same-archive comparison establishes a selection effect, but practical efficiency requires this additional accounting.
  4. Reproducibility materials. Are the task generators, independent-composition oracle, adapters, prompts, exact model identifiers, and recorded program histories available to reviewers through an anonymous artifact? These would be particularly useful for checking the separation between selection tests and independent outcome measurement.
5 comments
AuthorsOpenReview ↗

Response to Reviewer qj1v [1/3]

Thank you for the careful assessment. We appreciate your recognition that the matched comparisons "isolate decisions that would otherwise be conflated" and that the evaluation separates authorization, functionality, and temporal exposure. We will upload the revised PDF shortly, with all changes marked in blue. Material shared by several reviews, including the new experiments E1, E2, E3, E7, and E8, is in our Response to Common Questions, posted as a separate comment on this page, and we refer to its sections as C1 to C6.

W1 and Q1. What is established beyond the constructed tasks: mechanism versus frequency

The mechanisms are established beyond the constructed tasks, and their frequency in deployed agents is not. The revised abstract and limitations will state this distinction.

ConclusionEvidence beyond the constructed tasksStatus
Stored scores keep an invalidated program deployed although the archive holds a valid oneUnmodified OpenEvolve controller and DGM selection functions; a self-modifying improver (E1); two real authorization services (E2); released τ environments after a policy change (E8)Established as a mechanism in real selection code and in native agent environments, conditional on an evaluator change
Keeping the incumbent after rejection leaves a detected failure runningMatched pools with GPT and Sonnet; source audit of open-source systems (E7)Established as a mechanism on constructed tasks, and as the default rule in current frameworks
Editing a validated program repairs more often than editing the failed oneNew experiment E3 (W2 and Q2)Editor-dependent, on constructed tasks only
How often these failures occur in deployed agentsIndirect evidence only (frequency section below)Not established
Evolution increases authorization failures in native dialogueAppendix G finds no increaseNot established
The same effects in a complete agent whose components all evolve jointlyNoneNot established

First row. With the unmodified OpenEvolve controller and DGM selection functions, stored scores keep the unsafe program deployed in 22 of 48 histories, and in 12 of 24 on the Casbin task. The same holds with an improver that rewrites its own strategy (E1, C2: all 29 affected histories), on two real authorization services (E2, C3: unauthorized writes in 35 of 72 histories on the original request streams, and in none of the 120 programs selected after refresh), and in the released τ environments after a policy change (E8, C4: a policy-violating configuration in 24 of 64 lineages, against 3 with current scores).

Second row. With identical incumbents, proposals, and tests, every proposal was rejected in 14 pools. The keep rule restored safety in none of them, and fallback in all 14.

The revised limitations will state the last three rows in these words.

AuthorsOpenReview ↗

Response to Reviewer qj1v [2/3]

What the evidence says about frequency

We do not estimate a deployment failure rate. A failure of the first kind needs three conditions, and the evidence differs for each.

1. A validated version becomes unsafe. This was common under efficiency pressure and was not confined to weak editors: 22 of 24 GPT checkpoints after the dependency change, 22 of 24 GPT histories in the framework study, and 12 of the 24 histories on the Casbin task, which are all 12 Sonnet histories. Evidence outside our tasks points the same way. In a recent benchmark, SWE-Agent with Claude 4 Sonnet produced functionally correct solutions for 57% of the tasks, and solutions that were also secure for only 11.8% [1]. Broken access control ranks first among web application security risks [2]. In our native dialogue study, after a consent withdrawal followed by 4 or 12 neutral dialogue pairs, 42 and 21 of 224 next-action queries propose an unauthorized write before any evolution.

2. The evaluator changes. This happens whenever a discovered failure leads to added tests, which is the form our change takes: the new contract and the expanded tests arrive together. As a proxy for how often it happens, we counted releases and commits that changed evaluator or test files in the evaluators that the inspected systems rely on.

Evaluator sourcePeriodReleases or commits that changed evaluator or test files
SWE-bench harness and test specificationsNov 2025 to Oct 202611
OpenEvolve example evaluatorsNov 2025 to Oct 202624
τ-bench and τ²-bench domain policies and tasksNov 2025 to Oct 20266
DGM benchmark subsets for SWE-bench and PolyglotMay 2025 to Oct 20260

Three of the four sources changed during the period, and the DGM benchmark subsets have not changed since their release, so an evaluator change is common in maintained benchmarks and not universal. This is a proxy for maintained benchmarks, and it is not a measurement of deployed agents.

3. The selection code keeps the stale version. Given 1 and 2, this was not a matter of chance. Stored scores kept the unsafe program in 22 of 22 affected framework histories and in 29 of 29 in the matched comparison of E1. In the default loop of 15 open-source LLM-driven improvement systems, all 14 that have a selection step select on scores recorded at evaluation time, and none re-evaluates stored candidates in its standard loop (E7, C5). One framework has already encountered the problem: OpenEvolve refreshes fitness before each phase of its newer coevolution mode, where the evaluator changes by design, and not in its standard loop.

The established claim is therefore conditional. When a deployment changes its contract or its tests, score-based selection as implemented in current frameworks keeps running invalidated versions unless it re-evaluates them. Conditions 1 and 3 are measured. Condition 2 is supported only by the proxy above, so the unconditional rate in deployed systems is not established, and the revised abstract will end with this statement.

W2 and Q2. Founder editing versus editing the latest validated program

The benefit comes from leaving the failed program and does not require returning to the founder. We ran the requested comparison as new experiment E3, with the design and the table in C6.

In E3, editing the latest validated program leaves none of the 36 roots unsafe, as does editing the founder, while editing the failed program leaves 15. The latest validated program also keeps the accumulated savings: on the 21 roots that end fully correct under all three sources, its first fully correct selection saves 28.4%, against 10.2% for founder editing, which recovers most of that gap by generation 6. In a second cohort, the changed-authorization study, editing the incumbent, the founder, or a validated archive program ends fully correct in all 72 histories, with mean savings of 35.6%, 37.6%, and 35.9%.

Editor dependence. The effect does depend on the editor, and the revised abstract will say so. In E3, editing the failed program leaves 9 of 12 Qwen roots and 6 of 12 GLM roots unsafe, and no Devstral root. Within each of these two editors, larger and more distant failed programs are harder to repair directly: for Qwen, 6 of 6 large against 3 of 6 small failed programs stay unsafe, and for GLM, 4 of 6 against 2 of 6. Both validated sources leave no unsafe root for any editor or stratum. GPT and Sonnet repair from either source (Table 10). The result is a statement about editors that cannot repair their own failed code, and a deployer does not know in advance whether its editor is one of them.

AuthorsOpenReview ↗

Response to Reviewer qj1v [3/3]

Revised recommendation. Protection during repair does not rest on the editing source. Validated fallback deploys a currently passing program while the editor works. In Table 10 it gives zero unsafe endpoints and 252 of 252 correct selected generations for the original editors, GPT, and Sonnet, whereas even GPT and Sonnet pass through unsafe selected generations without it. For the repair itself, the revised paper will recommend editing the latest validated program: it never did worse than the failed program, it keeps accumulated improvements, and it does not require a correct founder. The abstract and the third contribution will read "editing a currently validated program", with founder editing as one instance.

Q3. Validation cost of refresh and an equal-budget baseline

Refresh is cheap relative to editing, and under an equal total evaluation budget it still ends fully correct in every history, while the same budget without refresh leaves 22 of 48 histories unsafe (new experiment E4).

Cost. A full refresh of an archive at iteration 20 takes 19.5 public-suite evaluations and 1.7 s of CPU time. A lazy refresh, which re-evaluates programs in stored-score order until the first one passes, takes 3.7 evaluations and 0.35 s. For comparison, one model edit takes 11.3 s with Sonnet and 59.0 s with GPT.

New experiment E4: equal total evaluation budget

We ran new continuations in both frameworks from all 48 checkpoints at iteration 20 with the original editors. Each history has a hard cap of 40 controller evaluations. The cap charges each distinct program once, whether it is evaluated for refresh, for parent feedback, or as a new candidate.

ArmUnsafe endpointsFully correct endpointsNew candidates chargedRefresh evaluationsParent-feedback evaluationsTotal chargedModel cost per history (USD)
Stored scores22834.405.539.92.25
Full refresh04820.519.5040.01.40
Lazy refresh04831.73.74.640.02.04

Endpoint counts are histories out of 48. Evaluation counts are means per history.

The baseline with the same total budget and no refresh spends its budget on new candidates and ends with 22 unsafe histories. Full refresh spends about half of its budget on re-evaluation and still ends fully correct in every history, and because it makes fewer edits it also spends less on the model. Lazy refresh keeps most of the edits and gives the same safety. The result holds in each framework: stored scores leave 10 of 24 OpenEvolve histories and 12 of 24 DGM histories unsafe, and both refresh arms leave none. On independent compositions in these new runs, 24 histories remain unsafe under stored scores, 1 under full refresh, and 2 under lazy refresh.

Why more search does not substitute for refresh. In the affected archives, the best program that passes the current tests costs a median of 24.5% more per request than the stale program, because the stale program's savings come from skipping the check that the new dependency requires. No valid candidate can outscore the stored record. At iteration 100, each affected archive holds 72 to 91 passing programs, and stored scores still select the same unsafe one.

Q4. Reproducibility materials

We will upload an anonymous code archive in the supplementary material together with the revised PDF. It contains the task generators, the independent-composition oracle, the framework adapters, the prompts, and the exact model identifiers.

On the separation between selection tests and outcome measurement: selection and editor feedback use only the public suite. Hidden and independent outcomes are computed by a read-only observer and a separate declarative oracle, and they never enter prompts, selection, or feedback. The evaluation protocol of E8 is described in C4.

We hope the answer to Q1 makes clear which conclusions are established and which are not, and that E3 and E4 answer Q2 and Q3. We would be glad to discuss any point further.

References

[1] Zhao et al. Is Vibe Coding Safe? Benchmarking Vulnerability of Agent-Generated Code in Real-World Tasks. ICML, 2026.

[2] OWASP Top 10:2025. OWASP Foundation, 2025.

Reviewer_94uBOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper runs iterative program optimization on a small number of deterministic Python programs in a synthetic setting, and frames it as recursive self-improvement (RSI). A fixed LLM editor repeatedly rewrites small authorization handlers to lower a synthetic service cost, across four simulated task families: session authorization, filesystem containment, tool approval and user consent. A controller then decides which version runs next. The authors identify two ways an unsafe program keeps running:

  • archive scores that go stale after the authorization contract changes (“historical eligibility”);
  • keeping the incumbent when every candidate fails validation (“keep-after-rejection”).

They evaluate four solutions: re-validate deployed program, refresh archive scores, roll back to a validated version, and edit from the original program instead of the current one. Some experiments run inside OpenEvolve and DGM’s selection functions.

Critical strengths

None -- it was difficult to follow the paper well enough to identify clear strengths

Critical weaknesses

The RSI framing is misleading and overclaims. This is iterative program evolution, not recursive self-improvement: the program editor is not optimized. The paper states “the LLM editor fixed while the selected program and its history evolve”

The setting and scope are never clearly stated. I couldn’t follow the introduction. After two paragraphs on RSI and safety benchmarks, it jumps to low-level details about an agent that checks permissions, caching, delegation and so on.

It is not clear what the setting is. If it is general agent and program optimization, why are we talking about permissions? If the scope is narrower, it should be stated and justified.

The body mentions four task families but never explains what a task or a program actually is. Only the appendix shows that they are small authorization handlers run against simulated requests and services. But why are these a good target for evaluation?

The prose is hard to follow, and the terminology obscures what is new. The text is full of abstract statements that are hard to understand, for instance “parent eligibility governs editing sources and deployment eligibility governs execution”.

Rather than use established terminology from the iterative program optimization literature, Section 2 introduces 20–30 new terms for a standard problem. This makes it difficult to tease out what is really new, and the paper does not engage with that literature. Many of the key phenomena are standard there:

  • historical eligibility is stale fitness after the objective changes;
  • keep-after-rejection is elitism in evolutionary optimization: the incumbent survives when no candidate passes. The loop as a whole is greedy hill climbing with a verification filter
  • founder editing means generating every candidate from the seed rather than from the incumbent, essentially restarting from the seed.

The results cannot be adequately judged. The appendix describes the task contracts and prices, but the simulator, test generators and programs are not available. The paper links no code or data, although the reproducibility statement says the records exist.

Questions for authors

n/a

5 comments
AuthorsOpenReview ↗

Response to Reviewer 94uB [1/2]

Thank you for the review. We agree with the points on framing, presentation, terminology, and code, and we will revise the paper as requested. The first section below lists the changes. The other two sections clarify two points of substance: why authorization handlers are a suitable evaluation target, and what the paper contributes beyond the standard selection rules. Material shared by several reviews is in our Response to Common Questions, posted as a separate comment on this page, and we refer to its sections as C1 to C6.

W1, W2, W5, W7, and the presentation parts of W4 and W6: framing, writing, terminology, and code

The revised paper will make the following changes.

  • Framing (W1). Every experiment in the submission holds the LLM editor fixed, and the paper will no longer present these experiments as recursive self-improvement. It will describe them as self-evolution of agent components, following the self-evolving-agent literature [1, 2, 3], and reserve "self-improving" for systems whose evolving code also performs the next edit [4, 5, 6]. We propose the title Safety Must Survive Self-Evolution: Why Authorization Failures Persist and How to Recover. A new experiment in which the improver rewrites its own strategy gives the same result (E1, C2).
  • Introduction (W2). The introduction will state the setting in its first three sentences and give one running example before any terminology.
  • Tasks and programs (W4). Sec.3.1 will define both and list the initial handler. A task is a stream of requests for protected actions, interleaved with changes to the authorization state. A program is the Python handler that decides, for each request, whether to perform the protected action.
  • Prose (W5). Abstract statements such as the sentence quoted in the review will be replaced by descriptions of what the controller does, in the abstract and in Sec. 1, 2, and 3.1.
  • Terminology (W6). Sec. 2 will use the standard terms given in the review: stale fitness, elitist survivor selection, offspring generated from the seed, and greedy hill climbing with a validation filter. It will cite the literature on dynamic and evolutionary optimization [9, 10, 11, 12] and present revalidation, rollback, and pausing as standard remedies.
  • Code and Data (W7). We will upload an anonymous code archive in the supplementary material together with the revised PDF. It contains the simulator and task contracts, the test generators and oracles, all prompts and model identifiers, the framework adapters, and the scripts that run the main studies.

W3 and W4: scope, and why authorization handlers are a suitable evaluation target

The paper's scope is authorization, not general program optimization, and the proposed title, the abstract, and the introduction will state this. All measured claims concern components and agent configurations that decide whether a protected action may run. The two selection rules are not specific to authorization, but we make no claim outside it. We chose authorization for three reasons.

  1. Harm can be measured separately from usefulness. The environment records each protected effect independently of the program's output, so an unauthorized action cannot be confused with a task failure, and a program that refuses everything is not counted as correct.
  2. Interventions can be compared on identical inputs. The same event stream can be replayed under different selection rules, which makes the paired comparisons possible.
  3. Efficiency edits lead to a known class of security failures. The four task families are the gates that deployed agents place in front of protected actions: session permission, workspace path containment, tool-call approval, and user consent. An agent that learns to skip a repeated approval is caching an authorization decision, and stale authorization decisions are a documented source of security failures, from time-of-check-to-time-of-use races [7] to the "new enemy" problem addressed in Zanzibar [8].

The handlers are small so that every effect can be audited and every stream replayed. The study itself is neither small nor confined to a simulator. It covers four task families and five LLM editors, with 288 matched blocks and 2,304 lineages in the core study alone, and the framework experiments search with the unmodified selection code of OpenEvolve and DGM. Two new experiments go beyond the simulator.

  • Real authorization services (E2, C3). On Casbin and OpenFGA, programs selected by stored scores commit unauthorized writes in 35 of 72 histories on the original request streams, and none of the 120 programs selected after refresh does.
  • Released agent environments (E8, C4). After a policy change in the τ airline and retail environments, the configuration selected by stored scores commits a policy-violating write in 24 of 64 lineages, and the configuration selected by current scores in 3.
AuthorsOpenReview ↗

Response to Reviewer 94uB [2/2]

W6: what the paper adds to the optimization literature

The selection rules are standard, and the revised paper will say so. Its contribution is a set of measurements that the definitions of these rules do not provide, for LLM-driven improvement of a component that keeps executing protected actions.

  1. Continued search does not remove a stale elite. In all 22 affected framework histories, the program selected at iteration 100 is the one selected at iteration 20, although each archive then holds 72 to 91 programs that pass the current tests. The best of them costs a median of 24.5% more per request, because the stale program's savings come from skipping the very check that the new dependency requires. No valid program can match its stored score, so more search never removes it.
  2. It matters which program is re-evaluated. In the 72-history study, re-evaluating only the parent leaves all 22 unsafe endpoints, and rolling back to the last program certified before the change leaves 20. Re-evaluating what is deployed leaves none, and doing so lazily takes 3.7 evaluations per archive.
  3. The starting point of repair matters for weaker editors. From 36 shared failures, editing the failed program leaves 15 unsafe endpoints, while editing the seed or the latest validated program leaves none (E3, C6).
  4. LLM-driven optimizers select on stale scores by default. In the default loop of 15 open-source LLM-driven improvement systems, all 14 that have a selection step select on scores recorded at evaluation time, and none re-evaluates stored candidates when the evaluator changes (E7, C5).

In optimization, a stale elite costs search efficiency. In an agent that keeps serving requests, it is the program that executes protected actions.

We hope this clarifies what the paper measures and why the measurements matter for systems that keep acting while they are being optimized. We would be glad to discuss any point further.

References

[1] Gao et al. A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve on the Path to Artificial Super Intelligence. Transactions on Machine Learning Research, 2026 (arXiv:2507.21046).

[2] Fang et al. A Comprehensive Survey of Self-Evolving AI Agents: A New Paradigm Bridging Foundation Models and Lifelong Agentic Systems. arXiv:2508.07407, 2025.

[3] Shao et al. Your Agent May Misevolve: Emergent Risks in Self-evolving LLM Agents. ICLR, 2026.

[4] Zelikman et al. Self-Taught Optimizer (STOP): Recursively Self-Improving Code Generation. COLM, 2024.

[5] Zhang et al. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents. ICLR, 2026.

[6] Robeyns et al. A Self-Improving Coding Agent. arXiv:2504.15228, 2025.

[7] Bishop and Dilger. Checking for Race Conditions in File Accesses. Computing Systems 9(2), 1996.

[8] Pang et al. Zanzibar: Google's Consistent, Global Authorization System. USENIX ATC, 2019.

[9] Branke. Memory Enhanced Evolutionary Algorithms for Changing Optimization Problems. CEC, 1999.

[10] Nguyen, Yang, and Branke. Evolutionary Dynamic Optimization: A Survey of the State of the Art. Swarm and Evolutionary Computation 6, 2012.

[11] De Jong. An Analysis of the Behavior of a Class of Genetic Adaptive Systems. PhD thesis, University of Michigan, 1975.

[12] Auger and Hansen. A Restart CMA Evolution Strategy with Increasing Population Size. CEC, 2005.

AuthorsOpenReview ↗

Revised PDF and code are uploaded

Dear Reviewer 94uB,

We have uploaded the revised PDF and an anonymous code archive (supplementary material). All changes are in blue. The section, table, and figure numbers of the submitted version are unchanged, and the new material is in Appendices J and K (Tables 19 to 35).

Where your points are addressed:

  • W1 (framing). New title, Abstract, Section 1 (third paragraph), Section 2, Section 4, and Section 6. The self-modifying improver experiment (E1) is in Appendix J.1 (Table 20).
  • W2 (introduction). Section 1, first two paragraphs: the setting first, then one running example.
  • W3 (scope). Title, Abstract, Section 1 (fourth paragraph), and Appendix K.3.
  • W4 (tasks and programs). Section 3.1 defines both and lists the initial handler. The experiments on real authorization services (E2) and on the released τ environments (E8) are in Appendix J.2 (Table 21) and J.8 (Table 30).
  • W5 (abstract sentences). Rewritten in the Abstract and in Sections 1, 2, and 3.1, including the sentence you quoted.
  • W6 (standard terms and literature). Section 2, the new paragraph "Dynamic and evolutionary optimization" in Section 4, Appendix H.6, and Table 33 in Appendix K.3. The audit of 15 open-source systems is in Appendix J.7 (Table 29).
  • W7 (code). The archive contains the simulator and task contracts, the test generators and oracles, the prompts and model identifiers, the framework adapters, and the scripts that run the studies. Its README has a quick start that needs no API key.

Thank you again for the detailed review.

Comments on the paper

4 comments
AuthorsOpenReview ↗

Response to Common Questions [1/3]

We thank all three reviewers for their detailed reviews. This comment collects the points raised by more than one reviewer and the new experiments that several reviews asked for, so that each is stated once. We will upload the revised PDF shortly, with all changes marked in blue, together with an anonymous code archive. The individual responses refer to the sections below as C1 to C6.

C1. What the revision changes and what it leaves unchanged

Unchanged. The two failure mechanisms, the remedies, and every result reported in the submission. No claim is broadened.

Changed.

  • Framing. The experiments with a fixed editor will be described as self-evolution of agent components and no longer as recursive self-improvement, and the scope will be stated as authorization. We propose the title Safety Must Survive Self-Evolution: Why Authorization Failures Persist and How to Recover.
  • Presentation. The introduction will state the setting first, Section 3.1 will define tasks and programs, and Section 2 will use the standard terms of evolutionary optimization.
  • Two statements will be narrowed. The expansion batch will be the confirmatory sample, and the repair result will be stated as editing a currently validated program, of which founder editing is one instance.
  • New experiments E1 to E8. They test the submitted claims under the conditions that the reviews asked about, and none reverses a conclusion. Two of them qualify one: savings are smaller against a single-check baseline (E6), and validation gives no protection against an undeclared change that contradicts the contract (E5).

New experiments at a glance.

  • E1, self-modifying improver (C2). Unsafe programs become rarer, and stored scores keep every one of them deployed.
  • E2, real authorization services (C3). The failure and the remedy reproduce on Casbin and OpenFGA.
  • E3, source of repair (C6). Editing the latest validated program is as safe as editing the founder and keeps the accumulated savings.
  • E4, equal evaluation budget (response to Reviewer qj1v, Q3). Under the same total budget, refresh ends fully correct in every history.
  • E5, unseen mechanisms and alternative controls (response to Reviewer mHVF, W3). Validation with stress tests handles new compositions. An undeclared contract change requires declaring it or runtime enforcement.
  • E6, measured latency and cost (response to Reviewer mHVF, W4). Savings remain positive against a single-check baseline and are much smaller than against the founder.
  • E7, audit of 15 open-source systems (C5). Every system with a selection step selects on stored scores without re-evaluation.
  • E8, released τ environments (C4). After a policy change, stored scores keep a policy-violating configuration selected in many lineages, and current scores remove most of them.

C2. Does a self-modifying improver change the result? (E1)

Result. No. A self-modifying improver makes unsafe programs rarer, but stored scores keep every one of them deployed, and refresh removes them.

Design. Each archive entry is an agent consisting of a handler and the natural-language strategy that drives its own improvement step. Each step rewrites both, and the child inherits the rewritten strategy. A matched control keeps the initial strategy. Each history runs 40 steps with the unchanged DGM selection functions, and the contract changes after step 8. We ran the matched comparison with two editors on different tasks.

Editor and taskStrategyUnsafe after the changeUnsafe with stored scores at step 40Unsafe with refresh at step 40
GPT-5.6 Sol, delegation and resource policyFixed11110
GPT-5.6 Sol, delegation and resource policySelf-modifying220
Sonnet 4.5, Casbin policy engineFixed11110
Sonnet 4.5, Casbin policy engineSelf-modifying550

Counts are histories out of 12 per row. With a self-modifying improver, 7 of 24 histories become unsafe after the change, against 22 of 24 with a fixed strategy. In all 29 affected histories, stored scores keep the unsafe program deployed through step 40. With refresh, every history ends fully correct. In the first GPT run, 96% of the strategies written after the change mention the new dependency, so the improver identifies the problem while the selection step keeps the unsafe program deployed.

After the first run we added 12 further seeds of the GPT self-modifying condition, without a fixed-strategy control. They show the same pattern: 2 histories become unsafe, stored scores keep both, and refresh leaves none. We report them separately and do not pool them with the matched comparison.

AuthorsOpenReview ↗

Response to Common Questions [2/3]

C3. Do the failures occur on real authorization services? (E2)

Result. Yes. On two real authorization stacks, programs selected by stored scores commit unauthorized writes in 35 of 72 histories, and none of the 120 programs selected after refresh does.

Design. We replayed 216 endpoint programs from the new framework runs: 72 selected by stored scores, 120 selected after refresh, and 24 intermediate checkpoints. One stack is the Casbin policy engine with SQLite, embedded in the client. The other is OpenFGA, an open-source Zanzibar-style authorization service, with PostgreSQL on a second server. Every protected action is committed as a database row. Both stacks agree with our simulator on all 3.57 million authorization decisions. Unauthorized writes are counted on the original request streams.

C4. Do the failures occur in released agent environments? (E8)

Result. Yes. After a policy change in the released τ airline and retail environments, the configuration selected by stored scores commits a policy-violating write in 24 of 64 lineages, and the configuration selected by current scores in 3.

Question. Appendix G asked whether evolution increases unauthorized proposals and found no increase. E8 asks the paper's main question in the same environments: once the evaluator changes, does the selection rule keep an invalidated version selected?

Design. We reused the archives of the 64 native dialogue lineages, 32 per domain from 2 models, 4 seeds, and 4 methods. The evolved objects are the history-selection rules and workflow notes of a complete tool-using agent. In each domain we changed one policy rule that determines which writes are permitted: free cancellation within 24 hours of booking became 6 hours (airline, 9 affected tasks), and refunds to an existing gift card were no longer allowed (retail, 14 affected tasks). We recorded the rule, the affected tasks, and a hash of the evaluation scripts before running.

Protocol. Every archived configuration was then evaluated under the new policy, with its writes executed in the environment database and each affected task run 8 times. All rows of the table are evaluated under this same policy. They differ only in which configuration of a lineage is read out: the one selected by the scores stored before the change, the one selected by the scores under the new policy, or the founder.

DomainConfiguration selected byLineages with a policy-violating writeReward on affected tasksReward on unaffected tasks
AirlineScores stored before the change110.410.58
AirlineCurrent scores10.470.58
AirlineFounder20.440.55
RetailScores stored before the change130.380.61
RetailCurrent scores20.490.61
RetailFounder20.460.57

Lineage counts are out of 32 per domain. In 19 of the 24 lineages where stored scores select a violating configuration, the archive already holds a configuration that commits no violating write and earns at least the founder's reward. Selecting on current scores raises reward on the affected tasks and does not lower it on the unaffected ones.

Scope of this result. E8 is a retrospective comparison of readouts over the re-evaluated archive. The current scores that select a configuration and the outcomes reported for it come from the same evaluation, so the current-score row is not a held-out estimate of deployment performance. The database is the environment's own, the agent's model is fixed, and selecting on current scores leaves 3 lineages with a violation.

AuthorsOpenReview ↗

Response to Common Questions [3/3]

C5. Is selection on stored scores the default in current systems? (E7)

Result. Yes. In the default loop of 15 open-source LLM-driven improvement systems, all 14 that have a selection step select on scores recorded at evaluation time, and none re-evaluates stored candidates in its standard loop when the evaluator changes.

SystemWhat selection readsWhat runs when every new candidate fails
OpenEvolveStored metrics in the program databaseElites and the tracked best are kept
DGMStored score and offspring countsWhole archive kept
STOPUtility of the current targetTarget kept, prior improver restored on exception
SICARecorded benchmark statisticsBase agent chosen from recorded scores
FunSearchScores stored at registrationBest program per island kept
ADASFitness stored per archive entryWhole archive kept
AIDEBest node by stored metricAll nodes kept
ShinkaEvolveStored metrics and elite archiveElite archive kept
Gödel AgentNo selection stepRunning agent replaced by its own edit
EvoPromptPopulation sorted by stored scoresTop k kept
LLaMEAStored fitnessElitist plus selection
EoHStored objectiveBest by stored objective kept
ReEvoStored fitnessElitist kept and reselected
GEPAPareto front over stored validation scoresPareto front kept
OpenELMMAP-Elites cell fitnessCell replaced only by higher fitness

Every population-based system keeps its elites when no new candidate is better. OpenEvolve refreshes fitness only in its newer coevolution mode, where the evaluator changes by design. The inspected commit of each system will be listed in the revised appendix. This audit is source inspection. Behavioral claims in the paper rest only on the two systems that we executed, OpenEvolve and DGM.

C6. Where should repair start: the failed program, the founder, or the latest validated program? (E3)

Result. What matters is starting from a validated program. Editing the latest validated program leaves no unsafe endpoint, as does editing the founder, and it keeps the accumulated savings. Editing the failed program leaves 15 of 36 endpoints unsafe.

Design. The latest validated program is the most recent previously deployed program that passes the current public tests. Hidden outcomes are never used to choose it, and choosing it as the editing source does not deploy it. In the 42 roots of the submission it coincides with the founder in 37, because most failures entered with the first accepted edit, so those roots cannot separate the two sources. We therefore selected failed roots preceded by at least two accepted and fully validated optimizations, fixing the selection rule and recording a hash of the root list before running any condition. This gives 36 roots, 12 each from Qwen, GLM, and Devstral. Each root runs six generations with two proposals under the same feedback, validation gate, keep rule, and budget. Only the editing source differs.

Editing sourceUnsafe endpointsFully correct endpointsUnsafe selected generationsFirst fully correct generationSavings of that selection (%)Savings at generation 6 (%)
Failed program15211091.929.631.0
Founder036131.310.227.9
Latest validated program036121.228.433.1

Endpoints are out of 36 roots and selected generations out of 216. The last three columns use the 21 roots that end fully correct under all three sources. Savings are relative to the founder. The latest validated program differs from the founder in all 36 roots. The effect depends on the editor: editing the failed program leaves 9 of 12 Qwen roots and 6 of 12 GLM roots unsafe, and no Devstral root, and GPT and Sonnet repair from either source (Table 10).

AuthorsOpenReview ↗

Summary of the discussion period

Dear Area Chair and Reviewers,

We thank the Area Chair and the reviewers for their time and detailed feedback. This comment summarizes what the reviews asked for and what we provided during the discussion period: a revised PDF with all changes in blue, eight additional experiments (E1 to E8, Appendix J), an anonymous code archive, and point-by-point responses. The numbering of the submitted version is unchanged, and so are its results.

Framing and presentation. The reviews found the recursive self-improvement framing broader than the evidence, the setting and scope unclear, and the terminology non-standard (94uB W1 to W6, mHVF W2). The revised paper frames the work as self-evolution of agent components with authorization as its stated scope (new title), states the setting first in the introduction, defines tasks and programs in Section 3.1, and uses the standard terms of evolutionary optimization in Sections 2 and 4.

Experiments requested in the reviews.

  • E3, source of repair (qj1v Q2, mHVF Q2; Appendix J.3). It compares editing the failed program, the founder, and the latest validated program. Editing the failed program leaves 15 of 36 endpoints unsafe, and editing either validated program leaves none.
  • E4, equal evaluation budget (qj1v Q3; J.4). Under the same total budget, refresh ends fully correct in all 48 histories, whereas stored scores leave 22 unsafe. A lazy refresh takes 3.7 evaluations per archive.
  • E5, unseen mechanisms and alternative controls (mHVF W3; J.5). It compares random and LLM-generated stress tests, a monitor with a formal model, versioned certificates, and a runtime monitor on two mechanisms absent from the tests. Stress tests handle new compositions, and an undeclared change that contradicts the contract requires declaring and testing it or runtime enforcement.
  • E6, measured latency and cost (mHVF W4; J.6). It reports measured latency, a single-check baseline, and the break-even volume. The abstract now reports savings separately for redundant and minimal initial programs (57% and 30%).

Experiments we added to address scope and significance.

  • E1, self-modifying improver (J.1), for the concern that the editor is fixed (94uB W1, mHVF W2). Unsafe programs become rarer, stored scores keep every one of them deployed, and refresh removes them.
  • E2, real authorization services (J.2), for the concern that the evidence is confined to a simulator (qj1v W1, mHVF Q3). The failure and the remedy reproduce on Casbin and OpenFGA.
  • E7, audit of 15 open-source systems (J.7), for the question of whether this behavior is the default (qj1v Q1, 94uB W6, mHVF W1). All 14 systems with a selection step select on stored scores, and none re-evaluates stored candidates in its standard loop.
  • E8, released τ environments (J.8), for the concern about native transfer (qj1v W1, mHVF W2). After a policy change, stored scores keep a policy-violating configuration selected. As the paper states, this is a retrospective comparison.

Other material provided. A statement of what is and is not established, with the evidence on frequency (qj1v W1 and Q1; Section 5, Appendices K.1 and K.2). The relation to standard selection rules and what the measurements add (94uB W6, mHVF W1; Appendix K.3). Separate reporting of the pilot and expansion batches (mHVF W5; Appendix K.4). The code archive requested in all three reviews, with the simulator, task contracts, test generators and oracles, prompts, model identifiers, framework adapters, and run scripts.

Where the discussion stands. No error has been identified in the results of the original submission, and the remaining question is one of significance. The selection rules and the remedies are standard, as the paper states. The contribution is the measurement: the failure is not guarded against in any of the 14 audited systems with a selection step, continued search does not remove it, and two natural remedies do not suffice (re-evaluating only the editing parent leaves all 22 unsafe endpoints and rolling back to the last certified program leaves 20, whereas revalidating the deployed program leaves none on the original suite). The question is also timely, since LLM-driven program evolution is now used in production with user-supplied evaluators (references in our response to Reviewer 94uB).

We thank the Area Chair and the reviewers again for their consideration.

Best regards,

The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.