- Rating
- 3
- Confidence
- 3
- Informativeness
- 3
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper studies how language-model agents infer changes in a system from evidence and act on those judgments. Experiments on discrete controllers, CartPole, and Python programs show that knowing the correct cause does not always lead to an appropriate repair. The paper also examines how fabricated reports and optional verification affect model behavior.
Critical strengths
- The experimental design is easy to follow. Replacing an incorrect hypothesis and observing the resulting program tests whether the diagnosis influences action. Repairs are evaluated through execution.
- Selective repair considers preservation of existing behavior, which provides a fuller assessment than passing the current tests alone.
Critical weaknesses
- The main experiments ask models to report a leading hypothesis and repair the system based on their diagnosis. When several environments fit the evidence, could this encourage premature commitment to one cause? Comparing repairs based on the leading hypothesis with repairs that consider the full plausible set would help determine how much this setup contributes to failure.
- In the disclosed-change CartPole experiment, only 21 of 60 responses produce runnable programs. The low repair rate therefore includes both code-generation failures and problems with the repair strategy. Please retain the overall results but also report repair performance among runnable programs, separating execution failures from preservation failures. This would help explain why correct diagnoses still lead to failed actions.
- Section 3.3 should provide the actual prompts for the initial report and the fresh test result. If models are told that the fresh result is reliable and the initial report may be wrong, trusting the fresh result is reasonable. Verification costs and the information available beforehand also matter when interpreting the low rate of voluntary checking.
Questions for authors
Please check the weaknesses.
Besides, two minor points:
- please check why the introduction reports an upper bound of 36.1% while later results are higher
- please update the template
4 comments
Part 2 of Response to Reviewer jJoy
If models are told that the fresh result is reliable and the initial report may be wrong, trusting the fresh result is reasonable. Verification costs and the information available beforehand also matter when interpreting the low rate of voluntary checking.
We have added the exact verbatim prompts for the initial report and the fresh verification result to §3.4 and Appendix A.4, along with a new experiment testing how prior reliability information and verification cost affect voluntary checking.
- Interpreting verification behavior.
The initial test report is presented as authenticated evidence. If the model requests a fresh test, the returned result explicitly supersedes the earlier report. As you note, trusting the fresh result once obtained is therefore reasonable. We now clarify in Appendix A.4 that choosing NO_CHANGE after verifying a correct program (96.5–100% across the six models that ever verify, versus 0.0–10.8% when acting without verifying) shows that models follow whichever report is presented as authoritative, not that they independently resolve conflicting evidence. What this setting measures is whether models request verification before acting. The exact instructions are provided in Appendix A.4.
- Prior reliability information and verification cost.
We ran two additional conditions on the same 40 programs and eight models, varying only the information available before the verification decision (§3.4; Appendix A.4, Tables 8 and 9, and Figure 7):
- Version A (baseline): The initial report is presented as authenticated, with no stated verification cost.
- Version B (reliability cue): Models are told that the test suite produced different results on 9 of its last 30 runs.
- Version C (reliability + cost cue): Models receive the same warning and are told that the last test run took 18 minutes.
Table R2. Effect of reliability (Version B) and duration (Version C) cues on verification requests and final actions (eight-model averages, %):
| Outcome | A: baseline | B: + run history | B − A (pp) [95% CI] | C: + history & 18 min | C − A (pp) [95% CI] |
|---|---|---|---|---|---|
| Correct program, fabricated failure report | |||||
↳ Requests verification (VERIFY) ↑ | 20.6 | 16.6 | −4.1 [−9.1, +0.6] | 12.8 | −7.8 [−12.5, −3.8] |
↳ Appropriate final action (NO_CHANGE) ↑ | 22.5 | 19.4 | −3.1 [−7.5, +0.9] | 15.3 | −7.2 [−10.9, −3.8] |
| Faulty program, fabricated passing report | |||||
↳ Requests verification (VERIFY) ↑ | 0.6 | 4.7 | +4.1 [+1.6, +7.2] | 0.9 | +0.3 [−0.6, +1.6] |
↳ Appropriate final action (passing EDIT) ↑ | 70.9 | 77.2 | +6.2 [+1.9, +10.9] | 75.0 | +4.1 [+0.0, +8.8] |
Warning that the test suite changed on re-run in 9 of its last 30 runs does not increase verification of correct programs (requests edge down from 20.6% under A to 16.6% under B), and adding the 18-minute duration reduces verification further to 12.8%, pulling appropriate NO_CHANGE decisions down from 22.5% to 15.3%. On faulty programs, the run-history warning raises verification slightly from 0.6% to 4.7% (driven by GPT 6 Astra and Grok 4.6), but adding the 18-minute duration brings it back to 0.9%. Rather than prompting models to verify, the added cues make them edit more often on both correct programs (59.7% → 65.6% → 68.1%) and faulty programs (82.8% → 89.7% → 86.6%), with reasoning traces showing that several models blame the reported flakiness on the program itself (Appendix A.4, Figure 7).
Changes to the paper. We have added the exact verification prompts and clarified the interpretation of fresh test results in Appendix A.4, and incorporated the Version A/B/C experiments into §3.4 and Appendix A.4 (Tables 8 and 9), with reasoning-trace examples in Appendix Figure 7.
Part 3 of Response to Reviewer jJoy
In the disclosed-change CartPole experiment, only 21 of 60 responses produce runnable programs. The low repair rate therefore includes both code-generation failures and problems with the repair strategy. Please retain the overall results but also report repair performance among runnable programs, separating execution failures from preservation failures. This would help explain why correct diagnoses still lead to failed actions.
To distinguish code-generation failures from unsuccessful repair strategies, we re-scored the 60 disclosed-change CartPole responses (§3.3; Appendix A.5, Table 14 [Appendix Table 11 in the original submission]): 21 revisions run, 12 meet both control goals in the true environment, and 5 are selective repairs.
Execution failures (39 of 60). Of the 39 non-runnable revisions, 26 reach the 16,384-token output limit, 11 violate a code rule stated in the prompt (calling a disallowed function or accessing forbidden private attributes), and 2 return no controller class.
Among the 21 runnable revisions, 5 (23.8%) are selective repairs, 9 (42.9%) fail the control goals in the true environment, and 7 (33.3%) meet both goals in the true environment but fail in the original environment. In these 7 cases, the pole remains upright, but the cart settles 0.5-1.1 m from the center (allowed: ) because the controller applies a constant force or angle offset regardless of whether the disturbance is present, rather than estimating it online (§3.3, Figure 4).
To distinguish output truncation from unsuccessful repair strategies, we re-ran the four models whose output limits could be enforced at 16,384, 32,768, and 65,536 tokens (48 responses per budget):
| Four models, change disclosed | 16,384 tokens (paper) | 16,384 (rerun) | 32,768 tokens | 65,536 tokens |
|---|---|---|---|---|
| Revisions that run (of 48 responses) | 21 | 22 | 27 | 32 |
| ↳ Selective repair among revisions that run (%) ↑ | 23.8 | 36.4 | 29.6 | 43.8 |
| ↳ Miss the goals in the true environment (%) ↓ | 42.9 | 45.5 | 48.1 | 46.9 |
| ↳ Meet goals in true environment, fail in original environment (%) ↓ | 33.3 | 18.2 | 22.2 | 9.4 |
Increasing the output budget raises runnable revisions from 21 to 32 of 48, but at every budget more than half of the runnable revisions fail selective repair, and nearly half fail in the true environment despite the disclosed change. Thus, code-generation failures explain part of the low overall success rate, but unsuccessful repair strategies persist among the executable controllers models write.
Changes to the paper. We have added a side-by-side comparison of a runnable preservation failure and a selective repair in the main paper (§3.3, Figure 4), and added the full breakdown across output budgets as Appendix Table 15 (next to Appendix Table 14 [Table 11 in the original submission]).
Minor points: 1. "please check why the introduction reports an upper bound of 36.1% while later results are higher" 2. "please update the template"
- Thank you for flagging this. The 36.1% figure is the ten-model average selective-repair rate on disclosed one-change tasks (and 33.8% on two-change tasks; Appendix A.5, Table 11 [Table 4 in the original submission]), whereas individual models range from 1.1% to 77.8% with one change and from 5.6% to 78.9% with two. In the revised paper, we have distilled the introduction's contributions list to high-level findings without numbers, and we state explicitly in §3.3 that 36.1% and 33.8% are the ten-model averages and that 8/10 models with one change, and 7/10 with two, produce selective repairs on fewer than half of their tasks.
- Thank you. We have updated the paper to use the official ICLR 2027 style files.
Appreciate your responses. I think they address my concerns and I would like to keep my original positive score. The updated version looks good to me.
Part 1 of Response to Reviewer jJoy
We thank the reviewer for the constructive review. We have run the requested experiments and added them to the revised paper.
Yes, committing to a single explanation contributes to failure, although the results reveal an important trade-off. We re-ran all 180 hidden-change controller tasks (90 with one changed assumption and 90 with two) with the same ten models and settings, changing only the change-control instruction:
"CHANGE-CONTROL REQUIREMENT: handle every factor you diagnose as changed, preserve the certified source behavior for factors you diagnose as unchanged, and retain source-regime compatibility. Blanket all-regime rewrites fail the authorization review even if they happen to complete this target.""CHANGE-CONTROL REQUIREMENT: the revised controller must complete the goal in every environment you list in possible_environments, not only in top_environment, and retain source-regime compatibility."For the original condition, we re-scored the main experiment's first-attempt revisions on the same tasks and models with the same code, reproducing the reported scores exactly. We ran each revision in the true environment θ⋆ and original environment θ(0). Success in both is weaker than selective repair, which additionally requires removing behavior reliant on changed assumptions and preserving behavior tied to unchanged assumptions.
Table R1. Revisions under instructions to follow their leading hypothesis (original instruction) vs. cover every plausible hypothesis (new instruction), averaged over ten models on 180 hidden-change tasks:
Takeaways:
Which criterion is appropriate depends on the deployment setting: an unfixed failure leaves the system broken, an unnecessary behavioral change requires extra review and re-certification, and breaking compatibility with the original environment causes a regression when normal conditions resume.
Changes to the paper. We have added this experiment, both instructions, the aggregate and per-model tables, and two concrete rollout examples to §3.3 and Appendix A.3 (Tables 6 and 7, and Figures 5 and 6).