acceptodds
Under review as a conference paper at ICLR 2027

Self-Regression-Test:Continuous Integration for Self-Evolving Agents That Rewrite Their Own Skills

Abstract

**ABSTRACT** Self-evolving agents adapt to new tasks by rewriting reusable skills, and every such rewrite is a potential regression: a change that improves one use can silently break behaviors that other tasks still depend on. Aggregate safeguards—parameter regularization, replay, or diff-magnitude penalties—leave the specific behaviors each candidate edit puts at risk unspecified. We study capability preservation at the level of the skill artifact. Each skill carries a versioned regression suite whose predicates are deterministically executable on cached inputs and act as a test-backed, coverage-conditioned partial contract for future edits. Self-Regression-Test (SRT) realizes this contract in three steps. First, a synthesizer converts a skill's past successful and failed trajectories into a fixed suite of typed predicates: outcome, trace, and negative, each carrying a severity label. Semantic outcome checks use a five-vote LLM-judge ensemble whose fallibility is measured on an independent audit rather than assumed away. Second, an executor evaluates every candidate update against the current suite and returns predicate-level verdicts. Third, a controller turns those verdicts into one of three inspectable actions—commit, bounded repair, or rollback. SRT never touches the policy weights or the upstream evolution operator, and refreshes the suite periodically as usage drifts. Across four evolution operators and three lifelong benchmarks, SRT raises retained accuracy by \(8.3\)–\(11.4\) points at a \(0.8\)–\(1.5\)-point cost in adaptation accuracy, at approximately verifier overhead. A six-cell cross-matrix attribution against replay, one-shot Self-Verify, and historical failure-set rerun shows the gain is not explained by rejection alone or extra computation, and an independent -update mutation audit reaches F1 \(0.90\) with hidden-paraphrase pass ( for snapshot exact-match). The guarantee is scoped: it certifies preserved behavior only on inputs whose predicates deterministically cover, LLM-judge errors are audited empirically, and per-skill contracts do not compose across simultaneous multi-skill refactorings.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
self-evolving agents, large language models, lifelong learning, capability erosion, regression testing, skill evolution

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_KSrPOpenReview ↗
Rating
3(+1)
Confidence
2(−1)
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes SRT, which generates and maintains skill-level regression tests from historical trajectories and uses them to accept, repair, or reject updates. Experiments across three benchmarks and four evolution operators show improved retention with a small loss in adaptation performance.

Critical strengths
  1. The paper addresses how agents can retain existing capabilities as their skills evolve. This is a central problem in continual agent learning that arises repeatedly in practice.
  2. The framework is simple and easy to follow. Using regression tests, repair, and rollback provides a straightforward and effective way to manage skill updates.
  3. The experiments are fairly extensive, covering multiple benchmarks, evolution operators, and ablations. Overall, the results provide good support for the authors’ main claims.
Critical weaknesses
  1. Test generation, regression checking, and repair are well-established ideas. SRT mainly brings them together for skill evolution, so I find the methodological novelty somewhat limited. What it adds beyond existing testing and repair mechanisms could be clearer.
  2. I would expect the framework to depend heavily on how diverse and representative its history is. The paper uses a buffer of 64 trajectories, but does not sufficiently explain how they are selected, what information is retained, or how performance changes with the amount and coverage of the history.
  3. The framework trades off retention, adaptation, and computational cost. The ablations provide some support for the defaults, but the selection procedure for the rejection threshold, repair budget, and other parameters remains unclear. Were these values tuned on a separate validation set, why were they chosen, and would different tasks require different settings?
Questions for authors

Please see the questions raised in the weaknesses. I would consider raising my score if the authors can satisfactorily address these concerns.

4 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer KSrP (1/2)

W1. Test generation, regression checking, and repair are well-established ideas. [...] What it adds beyond existing testing and repair mechanisms could be clearer.

AW1. We have added an evaluation of off-the-shelf transplants in Table 15 (Lines 965–970) ↗ and rewritten the end of Section 2 (Lines 152–160) ↗.

Off-the-shelf designOriginWhat failsResultSRT
Snapshot regression (exact match)classical regression suitesmemorizes surface formshidden pass 71.0%90.3%
Historical failure-set rerunregression test selectionno typed oracle, no repairF1 0.78; CPI 102.10.90; 106.3
Change-time verification (SelfVerify-Once)commit-conditioned test generation, e.g., CLEVERESTtests derived from the edit under reviewF1 0.81; CPI 103.30.90; 106.3
Outcome-only assertionsLLM unit-test generationmisses dropped dependenciesF1 0.830.90
Regenerated tests + same repairtest generation + repairmatches SRT only at 23.1% vs. 14.0% overheaderosion 8.9 (matched)7.3
Rate-of-change regularization (CPE)skill-level continual learninglimits how much a skill changes, not which behavior breaksCPI 113.2 / 108.7119.9

Each established technique, transplanted directly, fails on evolving skills in a measurable way. Because a skill is a natural-language and code artifact executed by a stochastic policy without a fixed code oracle, preservation needs paraphrastic inputs with typed equivalence, trace and negative predicates mined from failed trajectories, and a suite frozen across versions and during repair so that the edit under review cannot shape its own tests.

Hidden pass is from Table 23 (Lines 1147–1155) ↗, F1 from the 600-update audit in Table 25 (Lines 1188–1195) ↗, CPI is the micro-average over the six settings of Table 3 (Lines 432–443) ↗, and the CPE row is Lifelong×SkillRL at λ=0.3 / 0.7 (Table 2). Table 14 (Lines 949–959) ↗ compares the closest work along seven axes.

W2. I would expect the framework to depend heavily on how diverse and representative its history is. [...] does not sufficiently explain how they are selected, what information is retained, or how performance changes with the amount and coverage of the history.

AW2(1/2). We have specified the buffer in Section 4 (Lines 201–205) ↗ and Appendix B.1 (Lines 785–788) ↗. Each skill keeps up to 64 trajectories in which it was retrieved, selected by reservoir sampling over its retrieval history. Each entry stores the task input, full tool-call trace, final answer, verifier outcome, and skill version used. Skills with fewer than 64 trajectories use all available ones; at the start of the stream this applies to 41% of skills.

(AW2(2/2) and W3 continue in Part 2/2.)

AuthorsOpenReview ↗

Rebuttal to Reviewer KSrP (2/2)

AW2(2/2). We have added buffer-size and selection-policy sweeps in Table 8 (Lines 790–800) ↗.

Buffer size8163264 (default)128
Coverage ↑0.660.750.830.860.87
Erosion ↓10.48.97.77.37.2
CPI ↑116.1117.9119.4119.9119.8
Hidden pass ↑82.586.489.490.390.6
Overhead ↓13.1%13.3%13.6%14.0%15.2%
Selection (size 64)FIFOReservoir (default)Success/failure-stratifiedDiversity (k-center)
Erosion ↓7.97.37.07.1
CPI ↑119.2119.9120.1120.1

Performance saturates at 32–64 trajectories; doubling to 128 adds 1.2 points of overhead without gain, and even 8 trajectories cut erosion from 18.7 (vanilla) to 10.4. Selection matters less than size: stratified and diversity selection are 0.2 CPI above the default, within noise, while FIFO is worst because it discards early failed trajectories, the source of negative predicates (consistent with the 4.1-point erosion increase without negatives, Table 22).

Values are Lifelong×SkillRL means over three seeds. In the main runs, skills that start with short histories show 9.8 erosion vs. 6.9 for full buffers; this comparison is descriptive, since rarely used skills also differ in how often they are edited (Lines 805–806 ↗).

W3. The framework trades off retention, adaptation, and computational cost. [...] Were these values tuned on a separate validation set, why were they chosen, and would different tasks require different settings?

AW3(1/2). We have stated the selection protocol in Section 5 (Lines 349–352) ↗ and Appendix B (Lines 753–755) ↗. All defaults (β=0.5, K=3, L=8, T=50, buffer 64) were selected once on a validation split of 400 Lifelong AgentBench old tasks with SkillRL, disjoint from the held-out retention set. They were then fixed for all twelve benchmark–operator cells without per-setting tuning.

AW3(2/2). We have added hyperparameter sweeps and a cross-benchmark check in Table 30 (Lines 1350–1365) ↗.

Repair budget K0123 (default)5
Repair success ↑—36%58%73.2%79%
A_adapt ↑57.759.360.360.961.0
CPI ↑116.4118.2119.3119.9119.9
Overhead ↓12.3%13.2%13.7%14.0%14.9%
Threshold β0.30.5 (default)0.7
Erosion ↓5.87.39.1
A_adapt ↑59.360.961.4
CPI ↑119.8119.9118.6
Test CPILifelongSealQAOfficeQA Pro
Configuration selected per benchmarkdefaultβ=0.3, K=3default
Default119.972.9130.4
Per-benchmark selection119.973.3130.4

The defaults sit on plateaus: K=5 adds no CPI at 0.9 points more overhead, K=2 is a reasonable cheaper choice, and β in [0.3, 0.5] gives nearly equal CPI while 0.5 keeps more adaptation. Per-benchmark selection changes test CPI by at most 0.4, within one seed standard deviation, so a single default suffices in our benchmarks.

Sweeps use Lifelong×SkillRL with three seeds; in the cross-benchmark check each benchmark selects on its own validation split. Appendix M.1 (Lines 1341–1349) ↗ gives the details, and Table 33 (Lines 1442–1452) ↗ adds the joint β–K surface with audit error rates.

Thank you for your rebuttal, which has addressed most of my concerns. I will raise my score to 3.

We thank the reviewer for the follow-up and for raising the score. We are glad the buffer, hyperparameter, and novelty analyses addressed the concerns, and we will keep them in the final version.

Reviewer_vYCHOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SRT generates persistent behavioral tests for evolving agent skills and uses failures to trigger repair or rollback. Across three benchmarks and four operators, it reports improved retention with a small adaptation cost.

Critical strengths

SRT provides a method to preserve agent skills through behavioral tests and targeted repair. The hidden-paraphrase evaluation and independent mutation audit strengthen the evidence that its benefits extend beyond passing exposed tests.

Critical weaknesses
  • I could not reconcile the rejection rates. For Lifelong×SkillRL, Table 8 implies about 14.3% of updates are eventually rejected, including failed repairs, but Table 12 reports 22% rollback. The experiments use different protocols, so these numbers may be compatible, but the paper needs to explain the difference.

  • It is unclear how the reported coverage is measured. The theorem requires that passing the tests guarantees preserved performance on covered tasks, while Table 4 reports coverage of 0.71–0.89 without explaining how that requirement is checked. This makes it difficult to connect the theorem to the experimental results.

Questions for authors

See Weakness.

6 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer vYCH (1/2)

W1. I could not reconcile the rejection rates. For Lifelong×SkillRL, Table 8 implies about 14.3% of updates are eventually rejected, including failed repairs, but Table 12 reports 22% rollback. [...] the paper needs to explain the difference.

AW1(1/2). We have added the eventual-rejection rate to the decision decomposition in Table 16 (Lines 972–988) ↗ (Table 8 in the submission).

SettingImmediate rejectEntered repairRepair successEventual reject ↓
Lifelong×SkillRL9.1%19.5%73.2%14.3%
Lifelong×EvoSkill8.8%17.2%71.5%13.7%
SealQA×SkillRL7.5%16.4%77.4%11.2%
SealQA×EvoSkill8.1%17.1%75.3%12.3%
OfficeQA×SkillRL6.5%15.3%78.1%9.9%
OfficeQA×ALITA-G6.6%15.9%76.9%10.3%
Micro-average7.8%16.9%75.4%12.0%

The reviewer's computation is correct: 9.1% + 19.5% × (1 − 0.732) = 14.3%. The 7.8% "reject rate" in the submission counted immediate rejections only, and the eventual micro-average is 12.0%.

Section 5.3 (Lines 424–427) ↗ now reports both rates. Eventual reject = immediate reject + entered repair × (1 − repair success), per proposal. Values are means over five seeds and 300 proposals per cell on Lifelong AgentBench , SealQA, and OfficeQA Pro.


AW1(2/2). We have re-run the component ablation with the final configuration in Table 22 (Lines 1134–1146) ↗ (Table 12 in the submission).

VariantSubmission (rollback)Revised (eventual reject)
Full SRT22%14.1%
Without negative assertions17%11.6%
Without repair31%28.8%
Exact-match outcomes41%33.0%
Without paraphrases19%13.2%
Without severity labels26%17.5%

The 22% came from an earlier configuration of the ablation run, before the severity threshold was fixed at β=0.5. With the final configuration, Full SRT matches Table 16 (14.1% vs. 14.3%), and the ordering of variants is unchanged.

Appendix E (Lines 1000–1006) ↗ states which runs the main and attribution studies share, and every rate in the paper is now re-derived from the run logs with the per-proposal definition. Values are Lifelong×SkillRL means over three seeds.

AuthorsOpenReview ↗

Rebuttal to Reviewer vYCH (2/2)

W2. It is unclear how the reported coverage is measured. The theorem requires that passing the tests guarantees preserved performance on covered tasks, while Table 4 reports coverage of 0.71–0.89 without explaining how that requirement is checked. [...]

AW2(1/2). We have added an operational definition of coverage in Section 4 (Lines 290–294) ↗ and clarified the scope of Proposition 1 in Section 4 (Lines 302–312) ↗. A held-out old task t is covered for skill s_k if t belongs to the behavior cluster of at least one predicate input in R_k and that predicate is checked deterministically or by the five-vote judge. Cov is the fraction of held-out old tasks meeting this rule. The rule uses no post-update reward, so it does not presuppose preservation.

Proposition 1 is an accounting statement: certified tasks lose no reward, so erosion can come only from uncovered tasks or from certification errors. Its testable content is a prediction about where erosion occurs, which AW2(2/2) checks directly.


AW2(2/2). We have added an erosion decomposition by coverage in Table 6 (Lines 738–745) ↗ and Section 5.5 (Lines 465–473) ↗.

Covered tasksUncovered tasks
Share of old tasks86%14%
Tasks losing reward per accepted update ↓4.0%18%
Share of total erosion58%42%
Certification error ε̂ (deterministic / LLM-judged)2.5% / 7%—

A covered task is 4.5× less likely to lose reward than an uncovered one, as Proposition 1 predicts. Covered tasks still carry 58% of erosion because they form 86% of old tasks; this residual is the certification error ε̂ of Appendix A (Lines 732–737) ↗, which we now measure instead of assuming away. Across the maintenance strategies of Table 4 (Lines 486–493) ↗, erosion falls monotonically as coverage rises (0.71 → 0.89, 10.6 → 6.9).

The decomposition covers every accepted single-skill update on Lifelong×SkillRL at the default refresh. The coverage reference in Section 4 now points to Table 4 instead of Table 13.

Presentation. We have simplified Figure 1 (Lines 054–079) ↗ and added a notation table in Table 5 (Lines 710–721) ↗.

AuthorsOpenReview ↗

Thank you for your feedback

Thank you for your time and thoughtful feedback.

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

SRT uses history-derived tests to gate skill edits while keeping policy weights fixed. Failed edits receive repair feedback, and the tests stay unchanged during repair. Across four operators and three benchmarks, retained accuracy improves by 8.3–11.4 points at a 0.8–1.5-point adaptation cost.

Critical strengths
  • The controller makes individual skill updates easy to inspect and repair. Linking each admission decision to a behavioral predicate gives the method practical value for maintaining an evolving skill library.
  • The retention–adaptation trade-off is practically attractive. The repair and hidden-input results give credible support for preserving useful skills while continuing to learn.
Critical weaknesses
  • SelfVerify-Once removes repair together with persistence in Appendix C, leaving the value of keeping tests across versions unclear. A budget-matched baseline that regenerates tests and uses the same repair procedure would resolve this.
  • The 600-update audit covers curated mutations on Lifelong AgentBench with SkillRL. Reliability on natural edits remains unclear, particularly when a valid fix conflicts with an incorrect historical answer.
Questions for authors
  • During suite refresh, are earlier predicates retained or replaced? What prevents previously protected behaviors from losing coverage as the trajectory buffer changes?
  • How are skill merges and deletions handled in the main experiments? Which pre-existing contracts must such updates satisfy?
6 comments
AuthorsOpenReview ↗

Rebuttal to Reviewer NW6v (1/2)

W1. SelfVerify-Once removes repair together with persistence in Appendix C, leaving the value of keeping tests across versions unclear. A budget-matched baseline that regenerates tests and uses the same repair procedure would resolve this.

AW1(1/2). We have added the requested baseline as a clean persistence × repair study in Table 11 (Lines 901–911) ↗.

TestsRepairErosion ↓A_adapt ↑CPI ↑Overhead ↓
Regenerated, budget-matchedno9.257.4114.512.3%
Regenerated, budget-matchedyes8.960.4117.814.0%
Regenerated, uncappedno7.457.6116.521.0%
Regenerated, uncappedyes7.160.8120.023.1%
Persistent (SRT)no7.657.7116.412.3%
Persistent (SRT)yes7.360.9119.914.0%
SelfVerify-Once + same repairyes9.660.6117.314.0%

With the same repair and verifier budget, persistent tests lower erosion by 1.6 points and raise CPI by 2.1 relative to regenerated tests. Regeneration matches SRT only without a budget cap, at 23.1% vs. 14.0% overhead, while repair adds about 3 adaptation points in either arm.

Table 12 (Lines 918–926) ↗ repeats the budget-matched comparison on all six settings of Table 3. The persistence gain ranges from +1.5 to +2.8 CPI, and all paired-bootstrap 95% CIs exclude zero.

All cells share the synthesizer, typed predicates, and repair loop (typed feedback, K=3, tests fixed during repair). Only persistence and repair are switched. The budget-matched arm synthesizes 4 tests per update so that its verifier cost equals SRT's. Values are Lifelong AgentBench [1] × SkillRL [2] means over five seeds with identical proposals. Section 5.2 (Lines 411–420) ↗ summarizes the study.

AW1(2/2). We have added a repair-loop analysis in Table 13 (Lines 927–932) ↗.

Tests during repairRegressing, repair-admitted ↓Regressing, all admitted ↓
Frozen suite (SRT)9%6.0%
Regenerated from history at each attempt13%6.8%
Regenerated conditioned on the candidate24%8.9%

Persistence also matters inside the repair loop. Re-drawing tests gives a failing candidate repeated chances to meet an easier suite, and conditioning on the candidate lets the edit shape its own tests. Persistence therefore provides the same protection at about 40% lower verifier cost, and every admission traces to fixed, versioned predicates.

A version counts as regressing if it loses reward on held-out old tasks (Lifelong AgentBench × SkillRL).

AuthorsOpenReview ↗

Rebuttal to Reviewer NW6v (2/2)

W2. The 600-update audit covers curated mutations on Lifelong AgentBench with SkillRL. Reliability on natural edits remains unclear, particularly when a valid fix conflicts with an incorrect historical answer.

AW2(1/2). We have added an audit on naturally proposed edits in Table 27 (Lines 1242–1249) ↗.

MethodF1 ↑ [95% CI]False rollback ↓Missed regression ↓
Historical failure-set reject0.72 [0.64, 0.79]0.210.30
SelfVerify-Once0.76 [0.69, 0.83]0.180.26
Full SRT0.85 [0.79, 0.90]0.100.15
Full SRT, curated audit (Table 25)0.900.080.11

Natural edits are harder than curated mutations (F1 0.85 vs. 0.90), but the ordering of methods is unchanged. Per benchmark, Full SRT reaches 0.87 on Lifelong AgentBench, 0.84 on SealQA , and 0.83 on OfficeQA Pro , whose LLM-judged verifier makes labels noisier.

We sampled 150 updates proposed during the main runs (50 per benchmark), stratified by decision (60 commit / 45 repair / 45 reject), and labeled them with the independent execution audit; 38% are harmful. Reweighting to the natural decision distribution gives F1 0.86 (Appendix K.2, Lines 1238–1241 ↗).

AW2(2/2). We have added a seeded-bug study in Table 28 (Lines 1252–1258) ↗.

Without retirementWith retirement
Correct fixes blocked ↓31%8%
Repair reverted the fix ↓9%2%
Missed regression, ordinary harmful edits ↓0.110.12

Predicate retirement unblocks most valid fixes at almost no cost in missed regressions. In the main runs, 7 of 200 inspected rollbacks were valid fixes blocked by an incorrect predicate.

We injected a known bug into 60 skills, recorded the buggy outputs as verified history, and then proposed the correct fix. Section 4 (Lines 247–250) ↗ defines the rule: an outcome predicate is retired when the candidate's answer matches the gold label but contradicts the predicate. Limitations (Lines 544–546) ↗ states the remaining risk.

Q1. During suite refresh, are earlier predicates retained or replaced? What prevents previously protected behaviors from losing coverage as the trajectory buffer changes?

AQ1. We have clarified the refresh rule in Section 4 (Lines 268–287) ↗ and Appendix Q (Lines 1592–1599) ↗. Predicates are replaced at refresh and frozen between refreshes. At each refresh, the suite is re-synthesized from the current buffer and must pass on the currently accepted version. Between refreshes, a predicate is retired only by an intended behavior change or the gold-label rule. Replaced predicates stay in the versioned lineage, so every past admission remains replayable.

Refresh strategy (Appendix M.2, Lines 1390–1395 ↗)Round-0 clusters still covered ↑Erosion ↓Overhead ↓
Re-synthesize (default)78%7.314.0%
Re-synthesize + carry CRITICAL predicates91%7.114.6%

Re-synthesis covers more held-out old tasks than append-only retention (Cov 0.86 vs. 0.81, Table 4, Lines 486–493 ↗). Carrying CRITICAL predicates keeps 91% of round-0 behaviors covered at +0.6 points of overhead. Coverage loss would show up as erosion on a held-out old-task set fixed from the start of the stream.

Q2. How are skill merges and deletions handled in the main experiments? Which pre-existing contracts must such updates satisfy?

AQ2. We have stated the operation-specific contracts in Section 4 (Lines 252–256) ↗ and added decision rates in Table 31 (Lines 1382–1388) ↗.

OperationShareContractCommitRepairReject
Edit71%own R_k69%21%10%
Addition18%none (no history); suite starts at next refresh100%0%0%
Merge7%R_a ∪ R_b under normal retrieval61%24%15%
Deletion4%R_k still passes with the remaining library66%14%20%

Merges and deletions are rejected more often, as expected for operations that remove behavior. Algorithm 1 (Lines 270–279) ↗ applies to all four operations with the corresponding suite. We also corrected the Addition row of our earlier reply to match the stated contract.

AuthorsOpenReview ↗

Thank you for your feedback

Thank you for your time and thoughtful feedback.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Author Rebuttal by Authors

We sincerely thank all the reviewers for their time and their thoughtful comments and questions.

  • Our research addresses a central problem in continual agent learning, and the framework is simple and easy to follow (KSrP). Our experiments cover multiple benchmarks, evolution operators, and ablations, providing good support for the main claims (KSrP).
  • We have made the following contributions.
    • We have added a clean persistence × repair study and a repair-loop analysis in Tables 11–13 (NW6v, KSrP).
    • We have added an audit on naturally proposed edits and a seeded-bug study with predicate retirement in Tables 27 and 28 (NW6v).
    • We have clarified the refresh rule and the operation-specific contracts in Section 4, Appendix Q, and Table 31 (NW6v).
    • We have reconciled the rejection rates and re-run the component ablation in Tables 16 and 22 (vYCH).
    • We have added an operational definition of coverage and an erosion decomposition by coverage in Section 4 and Table 6 (vYCH).
    • We have added an evaluation of off-the-shelf testing and repair transplants in Table 15 and Section 2 (KSrP).
    • We have specified the history buffer and added buffer-size and selection-policy sweeps in Table 8 (KSrP).
    • We have stated the hyperparameter selection protocol and added sweeps and a cross-benchmark check in Table 30 (KSrP).
    • We have simplified Figure 1 and added a notation table in Table 5 (vYCH).
  • Linking each admission decision to a behavioral predicate makes skill updates easy to inspect and repair, and the retention–adaptation trade-off is practically attractive (NW6v). The hidden-paraphrase evaluation and independent mutation audit strengthen the evidence that the benefits extend beyond passing exposed tests (vYCH, NW6v).

We have done our best to address the reviewers' questions, and all revisions are marked in blue in the revised PDF. We believe their comments and the resulting revisions have made the paper stronger, and we thank all the reviewers for their help.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.