acceptodds
Under review as a conference paper at ICLR 2027

Repair or Rebuild? What Validators Miss When Agents Revise Executable World Models

Abstract

When the rules of its world change, an agent can repair its executable world model or rebuild it, and a validator decides which revision its planner will trust. To test whether that trust is earned, we executed the confident plans of accepted programs in a pre-registered Crafter-OO audit. Acceptance did not protect them: they failed on new tasks about as often as rejected candidates' plans (19.0% against 23.3%, exploratory), and a pre-registered replication gives 17.3% (10.8–25.0%). Repair solved the most tasks, and collateral regressions, errors at rules the change left valid, came almost only from rebuilds; 136 of the 265 failing plans were shortcuts through a world that exists only in the model (post hoc). The pre-registered strictest gate, perfection on sealed held-out transitions, removed every failure and admitted 7 of the 30 accepted programs. We then turned to code, where no engine defines correct behavior. For 11 of 62 resolved SWE-bench Verified patches, the issue or the unpatched code certifies a counterexample, against 1 of 13 coder-cleared controls. On one selected issue, all 8 top systems ship the same crash that every released test misses, and we prove that agreement among revisions cannot flag a defect most revisions share. A detector anchored on the unpatched code raised fewer false flags than a matched auditor on every backbone (pre-registered). Gate revisions on a regression check and a sealed check, never on agreement alone.

Primary area:
reinforcement learning
Keywords:
world models, program synthesis, model-based planning, continual learning, adaptation, validation, coding agents, SWE-bench

Reviews

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

This paper presents an empirical audit of validator reliability when agents revise executable world models and patch code repositories. The authors compare repairing versus rebuilding programmatic world models in a controlled Crafter-OO slice and audit test-passing patches on SWE-bench Verified. Their findings indicate that validator-accepted revisions still suffer from high failure rates during execution (primarily due to collateral regressions) and that consensus-based checks fail to catch shared defects. Consequently, the authors advocate gating revisions on sealed held-out checks and regression checks anchored on the unpatched code.

Critical strengths
  1. Rigorous experimental protocol and reproducibility effort. The authors pre-registered their experimental designs, prompts, and statistical tests, and transparently reported negative or inconclusive results.

  2. Investigating validator blind spots by directly executing confident plans and counterexample tests is a practical perspective that exposes meaningful evaluation gaps in current agent benchmarks.

  3. Clear categorization and empirical breakdown of failure modes (missing requirements vs. collateral regressions) across both testbeds.

Critical weaknesses
  1. Despite the thorough empirical audit, the methodological novelty is somewhat limited. The core contributions are primarily empirical observations, while the theoretical claims (e.g., Observation 1 on consensus limitations) are relatively elementary. Moreover, the proposed remedies—using sealed held-out sets and regression checks against unpatched code—closely mirror standard software testing and ML evaluation practices rather than introducing novel learning mechanisms.

  2. The experimental setup for the world model testbed is quite constrained (evaluating only one learner and two hand-picked rule changes on a simplified 16×1616\times16 Crafter-OO slice). It is unclear whether the findings on repair versus rebuild can generalize to more complex or stochastic RL environments.

  3. While the proposed regression detector in Section 6 reduces false flags, it incurs a noticeable drop in recall across backbones alongside higher API costs.

Questions for authors
  1. Given that the Crafter-OO evaluation is limited to two simple deterministic rule changes and the per-arm failure rates are confounded with acceptance leniency (Section 4.2), it is unclear how well the "repair over rebuild" finding extrapolates to general world-modeling tasks. Would these conclusions still hold if all arms were gated at a matched development accuracy threshold or tested in more complex, stochastic environments?

  2. In the code testbed, the pre-registered comparison of certified rates in Section 5.1 fails to separate resolved patches from coder-cleared controls (and is noted as compatible with zero true defects at the controls' specificity bound). Meanwhile, the frozen detector in Section 6 cuts false flags only by sacrificing more than half of the recall on witness-confirmed positives (e.g., finding only 6/17 on DeepSeek and Qwen) at a much higher cost per detection. To solidify the practical utility of this auditing pipeline, how can the authors improve the discriminative power over controls without losing the majority of true positives?

4 comments
AuthorsOpenReview ↗

Reply to Reviewer 8D98

Thank you for a careful review. We ran the matched-threshold test you proposed (Q1) and tested the findings on rule changes we did not choose (W2).

Q1, matched thresholds. Held to 24 of 26 on development, with the best admissible program re-selected per cell over nine runs, accepted programs still fail 4.2% of confident plans (59 of 1,409; frozen before computing), so a matched threshold does not remove the failure. By arm, repair's admitted programs fail least at every matched threshold from 19 of 26 up, and none of repair's 200 confident plans fails at 25-26 of 26; at 24 of 26, repair keeps a program in 38.9% of the changed cells (7 of 18; exploratory; table in the details below).

W1: novelty; remedies mirror standard practice. A sealed held-out set fails on new changes, so we now build that check from the change. We measured those practices against checks built from the change on 24 runs of two rule changes picked by a fixed rule and never run before (pre-registered; the boundary-value and mutation readings frozen before computing). Failing plans at the changed rule, of plans admitted: the gate as used, 11.4% (505 of 4,413); a sealed held-out panel, the standard ML practice, 10.6% (104 of 984); boundary-value tests built from the same change, then the comparison, 3.7% (197 of 5,329); mutation tests given the true edit keep no program; tests built from the change, none of 10,434. A check can reject a wrong revision only on a transition that separates it from the right one, the condition oracle-guided synthesis uses to choose among programs (Jha et al., 2010); on new changes the sealed panel separates none of the wrong rules that fit the reviser's evidence, while the change-built tests sit at the new threshold, where the revisers' wrong rules sit. Given to the reviser as training evidence, the same tests leave failure where it was (10.4% against 10.8%; pre-registered), so they work as an acceptance check, with no change to how the reviser learns. Observation 1 needs no independence assumption, and its condition occurs where agents are ranked (all 8 top systems ship one crash; a majority vote fixed in advance flags none of 16 surviving defects). On 24 fresh runs of the same changes, the change-built tests with the comparison and a rule that distrusts mispredicted actions leave a changed-rule failure in 1.4% of covered task cells, against 4.9% for the best of 88 standard test-adequacy gates covering as many (pre-registered; App. L.12; the pre-set comparison is inconclusive).

W2 and Q1: one learner, two hand-picked changes, a deterministic world. On the paper's two changes the reviser's evidence already ruled out every wrong rule within two grammar edits (of 2,339, only the true rule fits; frozen before computing), which is why the sealed panel reached zero there; on changes we did not pick it does not (10.6%, above). The failure itself persists: on the paper's changes a second reviser family fails on 51.0%; four changes drawn from a grammar give 34.0%; under sticky actions with replanning at every surprise, failures persist in 36.9% of covered task cells. On the same 1,391 task cells of fresh runs, rebuilds break a rule the change left valid in 38.4% of cells against 0.3% for repairs, and repairs' failures sit at the changed rule (15.6% of cells; all pre-registered). The revised paper's claim is this split; which strategy solves more tasks is a measured side result (Sec. 4.1).

Q2 and W3: discrimination, recall and cost. Running the detector alongside a filter that keeps an auditor counterexample only when the unpatched code passes it keeps 58.8%, 64.7% and 52.9% of the 17 positives per backbone (10, 11 and 9; detector alone: 6, 7 and 6), and removes 52.9% of the auditor's 34 false flags on reference patches, adding none (exact McNemar p = 0.000008; rule fixed before computing). The filter alone adds no model call to the auditor's, so no added API spend (its cost per detection rises from USD 1.14 to USD 1.51, as it keeps fewer positives), and removes 55.9% of those false flags (19 of 34) while keeping 54.9% of positives (28 of 51; exploratory). Against "zero true defects", five patches carry an executed regression and none of the 13 controls does; the maintainers' later releases keep the behaviour each of the 11 certified patches breaks.

What changed since your review. (1) Matched development thresholds by arm, and the same-cell split (Q1; Sec. 4.2, 4.3). (2) Rule changes drawn or picked by a fixed rule, a second reviser family, and stochastic execution with replanning (W2, Q1; App. L). (3) The held-out check is now built from the change and kept out of the reviser's evidence; the regression check against the replaced version stands (W1; Sec. 4.4, 8). (4) An operating point that keeps 58.8% of positives and removes 52.9% of reference false flags (Q2, W3; Sec. 6).

If these answers resolve your concerns, we would be grateful if you would reconsider your rating.

AuthorsOpenReview ↗

Details for 8D98: each check at the changed rule; matched thresholds by arm; operating points

Terms as in the general response; probes are test transitions built from a change by a fixed rule; the comparison flags plans where a revision departs from the program it replaces, outside actions the post-change evidence shows that program mispredicting; the per-action rule distrusts any action a program mispredicted on its development transitions.

W1, check by check, on one pool (two rule changes picked by a fixed rule, never run before; 24 runs, two reviser families, 970 programs; pre-registered; rows marked * frozen before computing; App. L.2):

CheckFailing / admitted plans, any ruleAt the changed ruleTask cells covered
Best development score (as used)32.3% (1,426 / 4,413)50591.5%
Perfect on the 27-transition held-out panel10.6% (104 / 984)10438.7%
The per-action rule on the gate's choices*8.6% (180 / 2,093)17964.8%
Boundary-value tests from the same change, then the comparison*9.2% (488 / 5,329)19757.6%
Mutation-adequate tests given the true edit, then the comparison*no program passesnone0%
Probes with the changed rule's held-out transitions46.8% (4,887 / 10,434)071.0%
Probes with the changed rule's held-out transitions, then the comparison7.0% (273 / 3,897)037.9%

The probes remove the changed-rule failures, which the per-action rule alone leaves (179 against 0); the comparison removes most of the rest, all at untouched rules (46.8% to 7.0%). At the first change, where the compared program is the correct source, probes then the comparison admit no failing plan (0 of 2,361, against 8.5% for the panel). All 273 that remain sit at the second change, where the compared program is the gate's own first-change pick; 84.2% (230) repeat its errors, and anchoring the comparison on the source program cuts the rate from 7.0% to 4.9% (177 plans; frozen before computing). Against the panel's 10.6%, the end-to-end rate missed our pre-set bar of half.

Why the panel protected before, and where it stops. On the paper's two changes, of 2,339 rules within two grammar edits of the replaced one, only the true rule fits the reviser's evidence (frozen before computing; App. L.3), so the panel had nothing left to separate: programs perfect on it fail none of 1,008 confident plans sealed and none of 902 visible. On new changes its 27 transitions separate none of the 114 plausible wrong rules we enumerated (frozen before computing; App. L, separation of plausible wrong rules). Probes add transitions at the new threshold, where the wrong rules revisers learned sit. Kept out of the reviser's evidence, the probe check admits 0 of 992 plans failing at the changed rule; 21.1% of programs perfect on probes the reviser had seen (12 of 57) still failed there (post hoc; App. L.8). On 12 more runs (pre-registered), 0.4% of plans kept by the probes fail (16 of 3,722), from one run whose programs dropped a condition no edit or probe touches; the full panel rejects all four programs (App. L.7).

Against existing gates, on 24 fresh runs (pre-registered). Probes, the comparison and the per-action rule together leave 2.4% of covered task cells failing at any rule (12 of 509), against 5.8% (52 of 904) for the best of 180 frozen gates built from development scores, held-out panels and plan filters; the check deploys in fewer cells and declines the plans it cannot trust (App. L.10). At the changed rule they leave a failure in 1.4% of covered cells (7 of 509), against 4.9% (27 of 550) for the best of 88 standard test-adequacy gates covering as many; on the 388 cells both admit, each has 3 failures, so the gap reflects which cells each admits (App. L.12; the pre-set comparison is inconclusive).

Q1, by arm at matched thresholds (exploratory; nine runs on the paper's two changes; the best admissible program re-selected per cell). From 19 of 26 up, repair's admitted programs fail least, and at 25-26 of 26 none of repair's 200 confident plans fails. At 24 of 26:

Arm, development ≥ 24/26Changed cells admitted (of 18)Failing / confident plans (each distinct program once)
Repair71.7% (4/240)
Rebuild, post-change evidence135.5% (33/600)
Rebuild, same archive215.0% (12/80)

With 5 admitted repair programs at this threshold, repair against the post-change rebuild is not separable (permutation p = 0.54).

Q2 and W3, operating points (three backbones pooled):

Operating pointPositives (of 51)Reference false flags (of 51)Control false flags (of 60)Cost per detection
Auditor373427USD 1.14
Anchored filter (exploratory)281518USD 1.51
Detector or anchored filter (rule fixed before computing)301621USD 3.88

Thank you for the detailed response. My concerns about the paper’s methodological novelty and the clarity of its core contribution have been only partially addressed, so I will maintain my original score.

Thank you for clarifying the remaining concerns.

The core contribution. The contribution is empirical: in our experiments, where an accepted revision fails depends on how it was made. On the same 1,391 task cells, rebuilds break rules the change left valid in 38.4% of cells, against 0.3% for repairs, whose failures concentrate at the changed rule.

What follows for checking. The tested checks have complementary blind spots, motivating separate checks of the requested change and preserved behaviour. On new changes, a sealed held-out panel admits plans of which 10.6% fail at the changed rule. Probes built from the change, combined with held-out transitions at that rule, admit no failures there (0 of 10,434). Failures at unchanged rules remain; comparison with the replaced program filters many of them, but can retain errors inherited from that program.

Does this clarify the contribution? If it changes your overall assessment, we would be grateful if you could update your review to reflect it.

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

The paper studies how AI agents react when underlying rules and requirements change. In Crafter-OO, the authors compare the success of rebuilding and repairing world models and find that repair generally performs better than rebuild. The authors also report that SWE-bench patches can pass existing tests but still contain bugs. The authors argue for more rigorous testing and caution against relying on agreement between AI systems.

Critical strengths
  • The authors raise some interesting and timely concerns, as AI-generated programs are becoming increasingly common.

  • Although the experiment with 62 samples is narrow, the authors have tried to validate their claims using counterexamples. I find this interesting.

Critical weaknesses
  • The paper is difficult to follow. It took me several readings to understand what the authors were trying to convey. In particular, the abstract and introduction are very dense, and the main research question and contributions are not clearly presented. I believe the paper would benefit from a clearer explanation of its central message and findings.

  • First, I do not find any clear takeaway from this paper. Most of the findings are well known in the software engineering and program analysis communities. For example, one of the core messages of this paper is that repair performs better than rebuild. I do not find this surprising. Even in software repositories, repairing something often requires much less effort than rebuilding it. I think most experts would agree that it is well known that (i) passing tests does not guarantee correctness, (ii) code changes can cause regressions, and (iii) AI systems can make the same mistakes. None of these messages seems particularly novel. The paper also argues that agreement cannot detect defects shared by multiple programs. This also seems trivial to me.

  • The authors also propose a detector based on the original code and report fewer false flags than an AI auditor. However, it is unclear how this approach differs from established regression-testing methods or what new methodological contribution it provides.

  • The authors cite the SWE-Proof paper, which became available on the day of the ICLR abstract submission deadline. I read SWE-Proof before reviewing this paper, and I think the reported results are not directly comparable. SWE-Proof found that some AI patches passed SWE-bench tests but still contained bugs. After additional testing, the measured success rate dropped from 85% to 58.2%. However, when the AI was given a correct formal specification, its performance improved to about 95%. SWE-Proof uses a different approach to identify incorrect patches, including formal specifications and reference-based evidence. This paper uses AI-generated tests and checks them against the original code or issue requirements. I do not think similar percentages are enough to show that the two studies confirm each other. The authors should explain how the methods and results are comparable and what their work adds beyond SWE-Proof.

  • I find it difficult to see the connection between Crafter-OO and SWE-bench. I believe that observations from one benchmark are not necessarily transferable to another benchmark, especially when the two are very different in nature. I do not find the connection convincing.

  • Finally, the experiments with SWE-bench are very narrow and unclear. From my reading, it seems that the authors use AI-generated tests or AI auditors to find counterexamples. How do the authors ensure that these tests are valid? Also, I do not find the results based on 62 examples sufficiently convincing. The authors show that their tests produce real, repeatable failures, but they do not conclusively establish that every failure represents a genuine software bug.

Overall, I did not find any clear takeaway from the paper. Therefore, I am not positive about this paper.

Questions for authors
  1. Could you please clarify how Crafter-OO and SWE-bench are connected? Also, could you comment on how SWE-Proof and this work are related?

  2. What are the actionable recommendations from this work?

  3. Could you please elaborate on how you ensure that your AI-generated tests are valid for SWE-bench? Specifically, could the authors explain why their certification procedure is sufficient to establish that AI-generated counterexamples represent genuine software bugs?

4 comments
AuthorsOpenReview ↗

Reply to Reviewer jEJi

Thank you for the review. We start with the question that decides whether the code results hold (Q3), then the takeaway (W2); the abstract and introduction are rewritten around one question (W1).

Are the generated tests valid, and are the failures genuine bugs? (W6, Q3) The LLM proposes an input; execution decides. Five accepted patches each fail a test that passes on the unpatched code and on the maintainers' merged fix, with the same outcome over five re-runs, and none of the 13 coder-cleared controls certifies this way; we claim these five as defects and report the other flags as flags. The maintainers' later releases keep the behaviour each of the 11 certified patches breaks. A worked example, django-11138 (Django ticket 28373): the accepted patch passes the benchmark's 74 tests, all in one module, yet our certificate test, a date extraction on a DateField, passes on the unpatched code and the merged fix and errors on the patch. Django's own full suite flags the same patch: 34 maintainer-written tests in nine other modules pass on the unpatched code and the merged fix and fail on the patch, in all 3 runs. Run in full, the maintainers' suites confirm this one of our 9 runnable certified patches and flag none of the 13 controls; they also miss 84.6% of the patches our earlier execution audit had already proven defective (11 of 13), so their silence is not evidence of correctness (App. I).

The takeaway (W2). Each revision strategy fails in its own place, so the check a revision needs depends on how it was made. Which strategy solves more tasks is a measured side result (Sec. 4.1), not the claim. On the same 1,391 task cells of fresh runs (two reviser families), rebuilt programs break a rule the change left valid in 38.4% of cells, against 0.3% for repaired programs, and repairs' failures sit at the changed rule (15.6% of cells; pre-registered). We start from (i)-(iii) (Gu et al., 2010; Yu et al., 2019; Knight and Leveson, 1986) and measure what they leave open: which revision strategy produces which failure, and which acceptance check removes it. On 24 runs of two rule changes picked by a fixed rule, programs perfect on a held-out panel still fail 10.6% of confident plans (104 of 984), all at the changed rule; adding tests built from the change to its transitions at the changed rule leaves none failing there (0 of 10,434; pre-registered), where boundary-value tests built from the same change alone leave 1.8% (225 of 12,225) and mutation tests given the true edit keep no program (both frozen before computing). On 24 fresh runs, the same tests with a comparison against the replaced program and a rule that distrusts mispredicted actions leave a changed-rule failure in 1.4% of covered task cells, against 4.9% for the best of 88 standard test-adequacy gates (App. L.12; the pre-set comparison is inconclusive). The details below take (i)-(iii) one by one, with the detector (W3), the two testbeds (W5, Q1) and SWE-Proof (W4, Q1).

Recommendations (Q2). Build the acceptance check from the change. Compare each revision with the version it replaces. Do not accept on agreement alone. Beside a pass rate, report how often what the gate accepts fails when executed (Sec. 8).

If the rewritten paper and these answers change your reading, we would be grateful if you would reconsider your rating. We will answer any remaining concern in this thread.

AuthorsOpenReview ↗

Details for jEJi: the certificate, the two testbeds, SWE-Proof, and regression testing

Q3, W6: the certificate. Each of the five executed regressions rests on a test that:

  1. passes on the unpatched code;
  2. passes on the maintainers' reference fix;
  3. fails on the agent's patch;
  4. gives the same outcome over five re-runs;
  5. checks behaviour that neither of two raters, from different model families and never shown the reference fix, judges the issue to ask for (a rater can only veto).

The maintainers' later release keeps the behaviour each of the 11 certified patches breaks (all 11; none contradicted), and all 26 certificate tests re-run as published. The defect claim rests on the five executed regressions (8.1% of 62; Wilson 95% 3.5-17.5%); the other six certified patches rest on the issue. The five tests are in the supplementary material (certificate_tests/); each reproduces with one command on a checkout of the instance's base commit.

The two testbeds and SWE-Proof (W4, W5, Q1). One failure definition and one split (a missed requirement or a collateral regression) apply to both, anchored on the version the revision replaces. The simulator settles whether a plan worked; in code, the unpatched code, the maintainers' fix and their later releases settle which behaviour should survive. The code testbed holds strategy fixed (every patch edits existing code); the world-model testbed varies it. SWE-Proof counts the same event, but its auditor works from a specification built from the reference patch, and its 95% comes from generation with a correct specification; ours sees neither the reference nor the hidden tests, and no number of ours rests on it. We add certificates resting on the issue or the unpatched code (17.7%, 11 of 62; 5 of them on an executed test), a specificity arm on coder-cleared controls, flagged patches that the hidden tests and three released augmenters all miss (8.1%), one crash shared by all 8 top systems, and a second testbed where execution is ground truth. All 62 of our instances are among SWE-Proof's 500.

W2, the three points, measured. The gates of the agent pipeline we study make no paired comparison of old and new behaviour beyond the development transitions. Regression-testing work proposes exactly that comparison (Taneja and Xie, 2008; Jin, Orso and Xie, 2010; Pradel, 2026). On your three points:

  1. Passing tests is not correctness. Measured here: what acceptance buys. Accepted programs solve more tasks (68.2% against 52.9%), yet about one confident plan in five fails when executed.
  2. Changes cause regressions. Program repair already separates the two ways a fix goes wrong (Gu et al., 2010; Yu et al., 2019). Measured here: which revision strategy produces which kind. On four rule changes drawn from a grammar, all 96 collateral regressions come from rebuilds and all 124 repair failures sit at the changed rule (pre-registered). On the paper's changes and four new ladders, rebuild regressions are regressions in the testing sense: at the first failing step the source program was right in 99.6% (1,679 of 1,686), and the program the revision replaced in 76.7% (1,293; fixed before computing). A check that looks only for disagreement with the previous version cannot catch a missed change, since tests with the old program as oracle encode the old behaviour exactly where the fix must change it (Yu et al., 2019); transitions built from the change close that side.
  3. AI systems make the same mistakes. Measured here: what agreement can see where agents are ranked. Independently written programs fail together (Knight and Leveson, 1986), and LLM-written program variants "may inherit the same bugs" as the program they imitate (Liu et al., 2025). On the leaderboard, 31.3% of the 739 patches are byte-identical to another system's, all 8 top systems ship one crash, and a majority vote fixed in advance flags none of 16 surviving defects; Observation 1 states this boundary with no independence assumption.

W3: the detector and regression testing. Behavioural regression testing runs inputs aimed at the changed code on the old and new version and reports where they differ. Like Testora (Pradel, 2026), our detector keeps only the differences it judges unintended; we take the intent from the issue and apply the design to agent patches that already pass the hidden tests. PatchDiff and UTBoost take the reference patch as their oracle; ours, like behavioural regression testing of human changes, uses the unpatched code as the baseline for preserved behaviour, which every revision has by definition. Its measured error: false flags on 23.5%, 11.8% and 5.9% of 17 reference patches per backbone (4, 2 and 1), against 58.8%, 88.2% and 52.9% for a matched agentic auditor (Holm-adjusted exact McNemar p = 0.031, 0.0007, 0.016).

Thank you for your response. After reading the rebuttal, I have decided to keep my original score.

Thank you for reading the response. One narrow question: for django-11138, 34 tests written by Django's maintainers pass on the unpatched code and on the merged fix, and fail on the accepted patch. Does that address your validity concern for that case? We understand it would not by itself resolve your concerns about novelty or breadth, but we would appreciate knowing whether the validity objection remains.

Reviewer_txRcOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

In this paper, the authors investigate how AI agents update their internal world models when the rules of their environment change. The study compares two strategies for the agents: repairing versus rebuilding. A major contribution is showing that the current checking systems, known as validators, are not reliable. Programs that pass these checks often generate confident plans that completely fail in reality. Moreover, the authors extend their testing to a software engineering dataset. They find that many accepted code patches actually break existing functions, which they call collateral regression. Finally, they propose the concept of a consensus blind spot. They prove that just because multiple top models agree on a solution, it does not mean it is correct, because they often generate the exact same faulty code.

Critical strengths
  • Rigorous cross domain evaluation: Testing the hypothesis on both an interactive simulation and a static software benchmark makes the empirical results very solid. This significantly broadens the impact of the paper.

  • Finding the consensus blind spot: Proving that different state of the art models make identical errors is a highly valuable insight. It effectively challenges the common practice of using majority voting to verify if an agent's output is correct.

Critical weaknesses
  • Dependence on perfect reference data: The authors' suggested solution requires perfectly sealed testing data and pristine original code. In real world open environments where agents explore autonomously, it might be practically impossible to acquire such perfect data.

  • Limited simulation environment: The interactive experiments are only tested on one specific simulation framework with specifically chosen rule changes. Therefore, it remains slightly uncertain if these exact failure patterns will generalize to much more complex environment structures.

Questions for authors
  1. How can an agent autonomously check for regression errors if a pristine original reference code is completely unavailable?

  2. Is there any observable relationship between how complex the environment rule changes and how often the agent makes collateral regressions when it chooses to rebuild the model?

4 comments
AuthorsOpenReview ↗

Reply to Reviewer txRc

Thank you for the review, and for singling out the consensus finding. Your two weaknesses changed the paper, so we answer them first.

W1 and Q1: what can an agent check without perfect reference data? One tested check needs no sealed panel, no reference program and no description of the change, and a pristine original is not needed.

  • No sealed panel, no reference, no description (W1). An agent holding only its revision, its own records and a simulator it can reset to chosen states tries each revision at its own cheapest working states, then distrusts any action its program mispredicts. The share of covered task cells (one task at one rule-change stage of one run) whose deployed plan fails drops from 11.45% under the distrust rule alone to 1.27%, while keeping 89.6% of that rule's covered cells (pre-registered, 24 fresh runs; App. L.11), and from 17.16% to 0.00% on a second pool of 12 runs (frozen before computing).
  • No pristine original (Q1). Every revision replaces a program the agent already holds: the pre-change program for a world model, the pre-patch commit for code. Comparing the revision with it, outside the actions the post-change evidence shows that program mispredicting, catches 95.8% of regressions (92 of 96), 88.6% (31 of 35) where that program is itself an earlier revision, and holds back 10.5% of good plans.
  • When the change is specified (an issue, a patch note, a designer's edit). Tests are generated from the specification when the revision is checked and are not shown to the reviser. Added to the held-out transitions at the changed rule, they admit no failing plan there on 24 runs of two new changes (0 of 10,434) or on two new ladders (0 of 1,183; both pre-registered), where 10.6% of the plans a held-out panel alone admits fail (104 of 984). On 24 further runs of the same changes, counted per task cell rather than per plan, with the comparison and the distrust rule, 1.4% of covered task cells fail at the changed rule, against 4.9% for the best of 88 standard test-adequacy gates covering as many (App. L.12; the pre-set comparison is inconclusive); on 12 more runs, one run leaves 0.4% of kept plans failing (16 of 3,722), from a requirement neither the change nor its tests touch (App. L.7).
  • Agents acting in open environments (W1). The check has to come before deployment, because acting repairs only some failures: on fresh runs (36 runs, five reviser families), replanning at every surprise repairs all 148 changed-rule failures in which the engine refuses no action, and none of the 221 in which it refuses one (pre-registered).

W2: one framework and chosen rule changes. On four rule changes drawn by a fixed rule from a grammar, not chosen by us, 34.0% of accepted programs' confident plans fail (241 of 708), and the split by strategy holds: all 96 collateral regressions come from rebuilds, and all 124 repair failures are at the changed rule. On the paper's two changes, a second reviser family (gpt-oss-120b) fails on 51.0%; on 24 fresh runs, under the field's standard sticky actions, with replanning at every surprise, failures persist in 36.9% of covered task cells (all pre-registered). The pinned engine is what lets every confident plan execute and every failure be located to a rule.

Q2: does a more complex change cause more collateral regressions when rebuilding? No. Rebuilds regress even when nothing changes (35.3% of confident plans for the same-archive rebuild). As the change grows, regressions per plan stay flat or fall (35.3%, 34.5%, 14.8%) while missing requirements rise (0%, 9.0%, 31.3%), and revision size shows no detectable association with failure (rank correlation 0.04). The table is in the details below.

What changed since your review. (1) The checks we now recommend need no pristine original, and one needs no sealed panel and no description of the change (W1, Q1; Sec. 4.4, 8; App. L.11). (2) The failure and its split by strategy were re-tested on rule changes drawn by a fixed rule, with a second reviser family and under stochastic execution (W2; App. L). (3) Change complexity against collateral regressions, by arm (Q2; details below).

Both weaknesses you raised are now tested in the paper. If these answers resolve them, we would be grateful if you would reconsider your rating. We will answer any remaining concern in this thread.

AuthorsOpenReview ↗

Details for txRc: what an agent needs, by what it holds; change complexity

Terms as in the general response. Probes are test transitions built from a change by a fixed rule.

The agent holdsCheckResultNeeds the change's description?
The program it replacesflag plans where the revision departs from it, outside the actions the post-change evidence shows that program mispredicting95.8% of regressions caught (92 of 96); 10.5% of good plans held backno
Its 26 development transitions (post hoc; App. A.1)distrust any action the program mispredicted there0.9% of plans fail (6 of 668), against 19.0% as used; all 168 tasks keep a trusted planno
Its own records and a simulator it can reset to chosen states (App. L.11)try each revision at its own cheapest working states, then the rule of the row abovethe share of covered task cells whose deployed plan fails falls from 11.45% under the row-above rule alone to 1.27% (pre-registered), keeping 89.6% of that rule's covered cells; from 17.16% to 0.00% on a second poolno
The held-out transitions at the changed rule, plus the change's description (pre-registered; Sec. 4.4, App. L.2, L.7, L.12)perfection on those transitions and on probeskept programs fail 0 of 10,434 confident plans at the changed rule on 24 runs and 0 of 1,183 on two new ladders; on 12 more runs, 0.4% (16 of 3,722; one run; a requirement no edit or probe touches); on 24 fresh runs, with rows 1 and 2 added, 1.4% of covered task cellsyes

Rows 1 and 2 come from the paper's two rule changes; rows 3 and 4 from new ones.

What covers missing requirements. A missed requirement is the job of the change-built tests (row 4). On the paper's two changes, a development-score floor at 24 of 26 added to the comparison leaves 0.99% of admitted plans failing (4 of 404). At a second change the replaced program is itself a revision: end to end, 84.2% of the 273 failures that remain (230) repeat its errors (App. L.2).

What a check needs. On the paper's two changes a panel the reviser could see protected as the sealed one did (0 of 902 against 0 of 1,008), because the reviser's evidence already left only the true rule there (App. L.3). A panel cannot reject a wrong rule that fits the evidence unless one of its transitions has a different outcome under that rule and under the true one. After four drawn changes, the four programs perfect on the 27 sealed transitions still fail 29.4% of their plans (40 of 136), all from two repairs that learned that mining stone needs a stone pickaxe, where the change required two wooden pickaxes. Probes add transitions at the new threshold, where the wrong rules revisers learned sit (App. L). Kept out of the reviser's evidence, the probe check admits 0 of 992 plans failing at the changed rule; shown to the reviser, the same probes were fitted with a wrong rule by 21.1% of programs (12 of 57; post hoc; App. L.8).

Q2. Rebuilding regresses even when nothing changes; a larger change adds missing requirements, and pooled regressions do not grow. With no change, the same-archive rebuild fails on 35.3% of its confident plans (73 of 207), all of them regressions (Table 8; Section 4.3). Failure rate; regressions / missing requirements (state rule: a failure is a missing requirement only if the old and new rules differ at the failing state):

ArmNo changeOne rule changedOne rule + a new precondition
Rebuild, same archive35.3%; 73 / 043.5%; 61 / 1646.1%; 17 / 36
Rebuild, post-change evidence only15.0%; 32 / 00.0%; 0 / 09.0%; 14 / 0
Repair (contrast)0.0%; 0 / 06.7%; 0 / 86.7%; 4 / 4

In the same-archive rebuild, regressions per confident plan stay flat or fall (35.3%, 34.5%, 14.8%) while missing requirements rise (0%, 9.0%, 31.3%). Pooled over nine runs (action rule: a failure is a missing requirement if the rule of the action where the plan first diverges changed), rebuilt programs' regressions per confident plan go 19.5%, 15.1% and 8.1% as the change grows, and missing requirements 0, 6.4% and 8.5%. Revision size shows no detectable association with failure (lines changed, rank correlation 0.04, -0.30 to 0.38; 30 programs); development accuracy does (rank correlation -0.58; App. A).

A second setting. In code, 72.2% of the flagged leaderboard patches (13 of 18) fail a test that the unpatched code and the maintainers' fix both pass: there too, most failures break behaviour the change left valid. Rates are reported per setting.

Thank you for the detailed response and additional experiments. I think the authors have reasonably addressed my previous concerns, and I have no further questions at this stage.

Thank you for reassessing the paper and considering the additional experiments. We are glad the response has reasonably addressed your concerns. If the revised evidence changes your overall assessment, we would be grateful if you could update the rating on your review to reflect it.

Comments on the paper

2 comments
AuthorsOpenReview ↗

Response to all reviewers: where accepted revisions fail, and the check each failure needs

We thank the three reviewers for questions that each led to a new test.

Validators in use accept revised world models whose confident plans fail when executed: about one in five under the pipeline's gate (19.0%; 17.3% in a replication). The submitted finding that rebuilds carry collateral regressions holds on fresh runs: on the same 1,391 task cells, rebuilds break a rule the change left valid in 38.4% of cells, against 0.3% for repairs, and repairs' failures sit at the changed rule (15.6% of cells). So each failure type needs its own check. On 24 runs of two rule changes picked by a fixed rule, 10.6% of the 984 plans a held-out panel admits fail, all at the changed rule; its transitions separate none of the wrong rules that fit the reviser's evidence. Tests built from the change, plus a comparison with the replaced program, admit none there (0 of 3,897). Every new failure rate here is pre-registered.

1. Does the failure persist beyond one learner and two chosen changes? (8D98 W2, Q1; txRc W2) Yes. On the paper's two changes, a second reviser family, gpt-oss-120b, fails on 51.0% of confident plans. On four rule changes drawn by a fixed rule from a grammar, 34.0% fail (241 of 708). Under standard sticky-action noise, with replanning at every surprise, failures persist in 36.9% of covered task cells (all three pre-registered). The pinned engine is what lets every confident plan execute and every failure be located to a rule.

2. What does a working check need? (txRc W1, Q1; 8D98 W1) No pristine original: comparing a revision with the program it replaces catches 95.8% of regressions, 88.6% (31 of 35) where that program is itself an earlier revision. No sealed panel or change description: an agent that tries each revision at its own cheapest working states, in a simulator reset to chosen states, then distrusts any action its program mispredicts (the per-action rule), cuts the share of covered task cells whose deployed plan fails from 11.45% under that rule alone to 1.27%, keeping 89.6% of that rule's covered cells (pre-registered). When the change is specified, tests built from it, added to the held-out transitions at the changed rule and kept from the reviser, admit no failing plan there on the 24 runs above (0 of 10,434) or on two new ladders of changes (0 of 1,183; both pre-registered), so the held-out half of the submitted recommendation is now built from the change; its regression half stands (Sec. 4.4, 8). On 24 fresh runs, these tests with the comparison and the per-action rule leave a changed-rule failure in 1.4% of covered task cells, against 4.9% for the best of 88 standard test-adequacy gates covering as many (App. L.12; the pre-set comparison is inconclusive); on 12 more runs, one run leaves 0.4% of the 3,722 kept plans failing, from a requirement neither the change nor its tests touch (App. L.7). End to end, the two checks cut failure at any rule from 32.3% under the gate as used to 7.0%, none at the first change (0 of 2,361); at the second change, 84.2% of the 273 failures repeat the compared earlier revision's errors, so the 7.0% missed our pre-set bar of half the held-out panel's 10.6% (App. L.2).

3. What is the takeaway, and what should practitioners do? (jEJi W2, Q2; 8D98 Q1) The revised paper's claim is where each strategy fails; which one solves more tasks is a measured side result (Sec. 4.1). Each failure type gets its own check: tests built from the change for a missed requirement, and a comparison with the replaced program for a broken old rule. Beside a pass rate, report how often what a gate accepts fails when executed, split into changed and unchanged behaviour, with its coverage. This replaces acceptance on a development score, a generic held-out panel or agreement alone.

4. Are the code-side counterexamples genuine defects? (jEJi W6, Q3; 8D98 Q2) Execution establishes five: each of five accepted patches fails a test that passes on the unpatched code and on the maintainers' fix, stable over five re-runs; none of the 13 coder-cleared controls certifies this way. The maintainers' later releases keep the behaviour each of the 11 certified patches breaks, which corroborates the certificates. The five tests are in the revised supplementary material.

App. I lists every test frozen during the discussion with its hash and the verdict its pre-set rule gives, those against our prediction included. No number of the submitted version changed value. Confident plans are those a program predicts will succeed; we execute each. A task cell is one task at one rule-change stage of one run. Pre-registered means the analysis and its pass bar were hashed before the runs existed; frozen before computing, that they were hashed before a reading was computed on runs that already existed.

AuthorsOpenReview ↗

Summary of changes in the revised PDF

Section numbers and appendix letters A to K are unchanged, so the references in the reviews still find their passages; App. L is new. Inserted passages in Sections 2 to 8 are in colour; the rewritten abstract and introduction and the redrawn figures are listed here. The main text is within 10 pages. Every addition answers a reviewer point named below, and no number of the submitted version changed value.

  • Abstract and introduction (jEJi W1): rewritten around one question and its answer.
  • Recommendation (8D98 W1, W2; txRc W1): the held-out check is now built from the change and kept out of the reviser's evidence; the regression check stands (Sec. 4.4, 8).
  • Sec. 4.2 (8D98 Q1, W2): matched development thresholds; a second reviser family; accepted against rejected programs on six new pools.
  • Sec. 4.3 (jEJi W2; txRc Q2): repair and rebuild scored on the same task cells.
  • Sec. 5.1 (8D98 Q2; jEJi W6, Q3): the executed certificates first; the maintainers' later releases; 14 more controls.
  • Sec. 6 and 7 (8D98 Q2, W3; jEJi W3, W4): operating points; the detector placed in regression testing; SWE-Proof.
  • Sec. 8 (jEJi Q2; 8D98 W2; txRc W1): what to check before trusting a revision, and its scope.
  • Figures 1 to 4 (jEJi W1): redrawn. Figures 2 to 4 use the same data; Figure 1 now shows the same-cell comparison of Sec. 4.3 beside the shared crash.
  • App. L (L.a to L.l, then L.1 to L.23): every analysis added in the discussion; Table 20 lists all 35 with their pre-set verdicts. App. I: every test frozen during the discussion, with its hash and the verdict its pre-set rule gives, those against our prediction included.
  • Extended appendix (in the supplementary material): detail moved out of Appendices A to E, J and L so that the paper reads in fewer pages, under the same letters and item numbers. No result is new there.
  • Supplement: the submitted supplement unchanged, plus the extended appendix, the new tests' specifications and code (discussion_phase/) and the five executable certificate tests (certificate_tests/).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.