acceptodds
Under review as a conference paper at ICLR 2027

VERSE: Verified Self-Evolving Optimizer for Agent Harnesses

Abstract

Harness evolution improves an LLM agent's prompts, tools, and workflow, while the optimizer's own tools and procedures often remain fixed. We study whether an optimizer can improve another agent more effectively by also improving how it diagnoses failures, develops edits, and tests their effects. Two observations guide our design. In a controlled study, optimizer self-evolution fails to improve performance without execution-based verification, but achieves the best result of that study when verification is available. Across five executors, self-evolving optimizers build their own tools for failure analysis, verification, training audits, and workflow control. Motivated by these findings, we introduce VERSE, a Verified Self-Evolving optimizer for agent harnesses. VERSE lets the optimizer test draft edits, replay failures, and perturb suspected steps before submission, while tracking fixes and regressions across rounds. Using this feedback, the optimizer revises both the executor harness and its own prompts, skills, tools, hooks, and notes, while the weights of the optimizer and executor models stay fixed. Under a shared protocol with disjoint training, validation, and test tasks, VERSE improves all four evaluated harness optimizers on held-out SWE-rebench tasks and newer out-of-distribution tasks in five languages. Its best harness reaches 42.3% and 37.7% accuracy, respectively, against 39.2% and 29.3% for the strongest baselines.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM agents, harness evolution, self-evolving systems, execution-based verification

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_DXmNOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes VERSE, a framework that jointly evolves an LLM agent’s harness and its optimizer while keeping model weights fixed. It uses execution-based verification, failure analysis, and regression tracking to guide improvements to both components. Experiments show that VERSE improves four harness optimizers on held-out SWE-rebench and out-of-distribution tasks.

Critical strengths

The paper addresses an important limitation of existing harness evolution methods, where the optimizer itself remains fixed. The motivation for combining optimizer self-evolution with execution-based verification is clear and practically relevant. The paper is well organized and easy to follow.

Critical weaknesses
  1. The main components, including execution-based verification, failure attribution, regression tracking, and optimizer self-improvement, have been explored in prior work. The contribution appears to lie primarily in combining these mechanisms into a unified framework. Although the paper discusses related approaches, more direct comparisons or stronger evidence of the unique benefits of their integration would help establish its novelty.

  2. The independent contribution of optimizer self-evolution is not consistently demonstrated. In Table 2, adding self-evolution to VERSE improves validation-selected test accuracy in only three of eight comparisons relative to VERSE without self-evolution.

Questions for authors

In Table 2, adding self-evolution lowers validation-selected test accuracy relative to VERSE without self-evolution in five of the eight comparisons. Under what conditions is optimizer self-evolution actually beneficial (e.g., which hosts, executors or failure types)? Is there statistically reliable evidence for this, such as results over multiple independent evolution runs per configuration?

3 comments
AuthorsOpenReview ↗

Response to Reviewer DXmN (1/2)

Dear Reviewer DXmN,

Thank you for the careful reading and constructive feedback. We answer each point below. Weakness 2 and your question ask the same thing, so we answer them together. The General Response lists the changes in the revised PDF.

Weakness 1: The components have been explored in prior work; the contribution is their combination.

VERSE focuses on a problem that deserves more attention in harness evolution: how to evolve a harness that generalizes to unseen tasks (General Response, Parts 2 and 3). Its design follows from this goal: an optimizer that tests its edits while it writes them, and that revises its own harness between rounds.

(1) The goal: a harness that generalizes to unseen tasks. Most harness evolution work optimizes a harness for a given benchmark: the harness is evolved on the tasks of the benchmark and evaluated on the same tasks, sometimes with an additional check on other tasks after the search. Higher accuracy on the search tasks does not show that the harness has learned lessons that carry over to other tasks (General Response, Parts 2 and 3). In our setting, generalization is the goal of the optimization: the optimizer learns on training tasks, and the harness is selected and tested on tasks it has never seen (Section 2.2). There, out of distribution, the four baselines stay within two points of the initial harness, while VERSE gains 2.8 to 10.3 points (Table R1).

Table R1: Each baseline alone and with VERSE (with self-evolution), on the two test sets (Table 2). Avg@3 test accuracy (%) of the harness selected on validation. Bold: higher than the baseline alone.

MethodIn distributionOut of distribution
Initial harness33.9527.41
Meta-Harness39.2028.66
Meta-Harness + VERSE42.2837.69
AHE33.9526.17
AHE + VERSE35.1930.22
Self-Harness29.6329.28
Self-Harness + VERSE34.8830.22
HarnessX32.7227.41
HarnessX + VERSE35.8037.69

(2) The design follows from this goal. For the harness to generalize, the optimizer has to learn lessons that are not tied to particular tasks. Self-evolution leads the optimizer to such lessons. Its own harness does not change how the executor solves a task, only how the optimizer finds the cause of a failure and tests an edit. So what the optimizer writes there is about how to improve a harness, not about particular tasks. For example, after an edit fixed three tasks but broke two, an optimizer wrote these two lessons for itself (Appendix L.3):

  • Before submitting, test each edit on two tasks it should fix and on one task the current harness already passes.
  • Prefer changes that remove a whole class of failures over changes aimed at one task.

We also found that self-evolution needs verification (Observation 1). In Table 1, the self-evolving optimizer without verification never produced a harness that beat the initial one on validation, and with verification it gives the best harness of the table; the same comparison on Terminal-Bench shows the same pattern (Table 18). This is why VERSE gives the self-evolving optimizer verification tools.

(3) "The main components have been explored in prior work." The closest methods do not do them as VERSE does.

Verification. In earlier harness optimizers, an edit is executed only after it is written, on tasks fixed by the method: after the round has been evaluated (Meta-Harness, AHE), or to decide whether a finished edit is kept (AutoSaddler, HarnessEvolve). In VERSE, the optimizer runs tests itself while it is still writing the edit, and it decides what to test (Section 3.1).

Self-improvement. Recursive self-improvement methods such as STOP, Gödel Agent, and DGM have a single agent that rewrites itself; none of them improves the harness of another agent. The four baselines we compare against improve the harness of an executor with an optimizer that stays fixed. VERSE does both: its optimizer improves the executor's harness and also its own harness.

(4) "More direct comparisons or stronger evidence of the unique benefits of their integration." The paper has both.

Direct comparisons. We compare with four published harness optimizers under one protocol, in distribution and out of distribution. VERSE improves each of them on both test sets (Table R1).

Benefit of the integration. Table 1 tests the two parts separately and together on the same baseline. With self-evolution alone, the optimizer never produced a harness that beat the initial one on validation. With simple verification alone, it reaches 39.81%, close to Meta-Harness (39.20%). With both, it reaches 41.05%, the best of the table. Neither part gives this gain alone.

AuthorsOpenReview ↗

Response to Reviewer DXmN (2/2)

Weakness 2 and Question: The independent contribution of self-evolution is not consistently shown.

Self-evolution makes the improvement hold on every baseline: with it, VERSE is above its baseline in all 16 comparisons of Table 2 (General Response, Part 1, point 2).

The full VERSE method is the harness optimizer with self-evolution; VERSE without it is an ablation that tests whether the verification tools alone are enough. In Table 2, the tools alone improve on the baseline in some comparisons but not in all. With self-evolution, the optimizer learns how to use the tools: it also tests an edit on tasks that the current harness already solves, and it revises a draft more often when a test fails (Section 4.4).

With the closed-weight models of Appendix F, VERSE with self-evolution also matches or exceeds its baseline in all 8 comparisons (Table G2). There, the tools alone already do so, and adding self-evolution scores higher in 6 of the 8, by 0.4 to 2.6 points.

"Under what conditions is self-evolution beneficial?" When the optimizer can verify its edits by execution. We compare self-evolution with and without verification on two benchmarks: SWE-rebench (Table 1) and Terminal-Bench (Appendix J.1, Table 18). On both, self-evolution alone does not improve on Meta-Harness at the selected round, and self-evolution with verification is the best of the four configurations. With the verification tools, it then keeps VERSE above the baseline on all four baselines and on both test sets (Table 2).

"Is there evidence over multiple independent evolution runs?" Yes: in Appendix F, we ran the whole evolution three times (General Response, Part 1, Table G1). VERSE has the highest mean on both benchmarks. On HarnessX, VERSE with self-evolution has three runs and VERSE without it has two (General Response, Part 1, Table G3). VERSE with self-evolution has the higher mean on both benchmarks (32.82% against 32.10% on SWE-rebench, and 40.57% against 36.89% on Terminal-Bench), and each of the three runs with self-evolution scores at least as high as both runs without it. On τ³-bench and AppWorld, with three runs per configuration, VERSE with self-evolution is also higher than without it on both test sets: by 1.4 and 1.1 points on τ³-bench (in distribution and OOD), and by 1.6 and 0.6 on AppWorld (Section "Additional Experiments").


We appreciate your valuable feedback and hope that our answers address your concerns! Please let us know if you have any further questions or suggestions.

AuthorsOpenReview ↗

Follow-up on Our Response

Dear Reviewer DXmN,

Thank you again for your time and feedback! In addition to our response, we have added Section "Additional Experiments" to the General Response: results on two more benchmarks, τ³-bench and AppWorld, and an ablation study of self-evolution.

As the author discussion closes on Nov 18, we would be grateful for any feedback, and we would be happy to answer further questions.

Sincerely, The Authors

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

The paper proposes VERSE, a framework for improving LLM agent harnesses by allowing the harness optimizer to evolve its own optimization procedures. Unlike conventional harness optimization, where the optimizer remains fixed, VERSE introduces an outer self-evolution loop that updates the optimizer's prompts, skills, tools, hooks, and memory while keeping model weights fixed.

The approach combines execution-based failure attribution, trajectory replay and perturbation, verification of proposed harness modifications, and tracking of fixes and regressions across optimization rounds. The authors also provide a theoretical analysis motivating the role of verification in reducing incorrect repairs.

Experiments primarily use SWE-rebench, with additional out-of-distribution tasks and Terminal-Bench evaluations. The best configuration achieves 42.3% in-distribution and 37.7% out-of-distribution accuracy, compared with 39.2% and 29.3% for the strongest original baselines in the main comparison. The authors conclude that execution-based verification enables more reliable self-evolution of harness optimizers.

Critical strengths
  1. Practical and relevant problem. The paper addresses the reliability of agent harness optimization, particularly the difficulty of diagnosing failures and verifying proposed improvements. Execution-based verification and regression tracking are important for improving agent systems without modifying model weights.

  2. Useful empirical analysis of verification. The paper provides detailed experiments on failure attribution, trajectory replay, verification, and regression behavior. The finding that many proposed edits fail to produce the expected improvements, and that nearly half of validation outcome changes do not reproduce, offers useful insights into the limitations of trajectory-based harness optimization. The use of disjoint training, validation, and test sets, including newer out-of-distribution tasks, is also a positive aspect of the evaluation.

Critical weaknesses
  1. Limited methodological novelty. The proposed framework combines failure attribution, execution-based verification, regression tracking, and recursive optimizer improvement. These ideas have already been explored in a growing body of closely related work, including Meta-Harness, AHE, HarnessEvolve, AutoSaddler, and recursive self-improvement approaches. The paper does not clearly establish a sufficiently distinct methodological contribution beyond integrating existing mechanisms.

More importantly, the experiments do not consistently demonstrate the benefit of the proposed optimizer self-evolution. In Table 2, the self-evolving variant performs worse than the fixed-optimizer VERSE variant on three of four hosts in the in-distribution setting. This raises questions about whether self-evolution, rather than improved verification, is responsible for the reported gains.

  1. Limited experimental breadth and generalization evidence. The main evaluation relies primarily on SWE-rebench, with 108 in-distribution and 107 out-of-distribution test tasks. Although SWE-rebench is a published benchmark, it is less established for evaluating agent harness optimization than SWE-bench Verified. The OOD evaluation uses newer tasks and additional programming languages but remains within the same benchmark family.

The additional Terminal-Bench and cross-model transfer results are mixed, and the main comparisons rely on only one independent evolution run per configuration. Given the crowded field and limited methodological novelty, more comprehensive evaluation on established and diverse agent benchmarks is needed to demonstrate the significance and generality of the approach.

  1. Insufficient isolation of improvements and optimization cost. VERSE introduces additional execution probes, replay, failure attribution, and optimizer self-updates. The reported wall-clock cost is 1.3–2.5 times that of the corresponding baselines, but the methods are not compared under matched total optimization budgets. It remains unclear whether the observed improvements are attributable to the proposed self-evolution mechanism, better verification, or additional optimization resources.

The theoretical analysis also relies on simplified assumptions and does not establish the stability or convergence of optimizer self-evolution. Its connection to the main empirical claims is limited.

Questions for authors
  1. Novelty: What is the essential methodological contribution of VERSE beyond existing verified harness optimization and recursive self-improvement methods? Which component enables a capability not already supported by related approaches?

  2. Contribution of self-evolution: Why does optimizer self-evolution underperform the fixed-optimizer VERSE variant on three of four hosts in the in-distribution experiments? What evidence demonstrates that the outer self-evolution loop provides a consistent benefit?

  3. Evaluation coverage: Can the authors extend the evaluation to more established and diverse benchmarks, particularly SWE-bench Verified, and evaluate generalization beyond the SWE-rebench task family?

  4. Robustness: How consistent are the reported improvements across independent evolution runs? Can the authors provide more comprehensive statistical analysis, particularly given the stochasticity and frequent regressions observed during harness evolution?

  5. Compute efficiency: Are the improvements maintained when comparing methods under matched total execution, token, or wall-clock budgets? How much of the gain comes from additional verification versus self-evolution?

5 comments
AuthorsOpenReview ↗

Response to Reviewer iRtb (1/4)

Dear Reviewer iRtb,

Thank you for the careful reading and constructive feedback. We answer each point below. Where a weakness and a question ask the same thing, we answer them together. The General Response lists the changes in the revised PDF.

Weakness 1 (part 1) and Question 1: Limited novelty: the framework integrates existing mechanisms.

VERSE focuses on a problem that deserves more attention in harness evolution: how to evolve a harness that generalizes to unseen tasks (General Response, Parts 2 and 3). Its design follows from this goal: an optimizer that tests its edits while it writes them, and that revises its own harness between rounds.

(1) The goal: a harness that generalizes to unseen tasks. Most harness evolution work optimizes a harness for a given benchmark: the harness is evolved on the tasks of the benchmark and evaluated on the same tasks, sometimes with an additional check on other tasks after the search. Higher accuracy on the search tasks does not show that the harness has learned lessons that carry over to other tasks (General Response, Parts 2 and 3). In our setting, generalization is the goal of the optimization: the optimizer learns on training tasks, and the harness is selected and tested on tasks it has never seen (Section 2.2). There, out of distribution, the four baselines stay within two points of the initial harness, while VERSE gains 2.8 to 10.3 points (Table R1).

Table R1: Each baseline alone and with VERSE (with self-evolution), on the two test sets (Table 2). Avg@3 test accuracy (%) of the harness selected on validation. Bold: higher than the baseline alone.

MethodIn distributionOut of distribution
Initial harness33.9527.41
Meta-Harness39.2028.66
Meta-Harness + VERSE42.2837.69
AHE33.9526.17
AHE + VERSE35.1930.22
Self-Harness29.6329.28
Self-Harness + VERSE34.8830.22
HarnessX32.7227.41
HarnessX + VERSE35.8037.69

(2) The design follows from this goal. For the harness to generalize, the optimizer has to learn lessons that are not tied to particular tasks. Self-evolution leads the optimizer to such lessons. Its own harness does not change how the executor solves a task, only how the optimizer finds the cause of a failure and tests an edit. So what the optimizer writes there is about how to improve a harness, not about particular tasks. For example, after an edit fixed three tasks but broke two, an optimizer wrote these two lessons for itself (Appendix L.3):

  • Before submitting, test each edit on two tasks it should fix and on one task the current harness already passes.
  • Prefer changes that remove a whole class of failures over changes aimed at one task.

We also found that self-evolution needs verification (Observation 1). In Table 1, the self-evolving optimizer without verification never produced a harness that beat the initial one on validation, and with verification it gives the best harness of the table; the same comparison on Terminal-Bench shows the same pattern (Table 18). This is why VERSE gives the self-evolving optimizer verification tools.

(3) "These ideas have already been explored in closely related work." The closest methods do not do them as VERSE does.

Verification. In earlier harness optimizers, an edit is executed only after it is written, on tasks fixed by the method: after the round has been evaluated (Meta-Harness, AHE), or to decide whether a finished edit is kept (AutoSaddler, HarnessEvolve). In VERSE, the optimizer runs tests itself while it is still writing the edit, and it decides what to test (Section 3.1).

Self-improvement. Recursive self-improvement methods such as STOP, Gödel Agent, and DGM have a single agent that rewrites itself; none of them improves the harness of another agent. The four baselines we compare against improve the harness of an executor with an optimizer that stays fixed. VERSE does both: its optimizer improves the executor's harness and also its own harness.

Weakness 1 (part 2) and Question 2: Self-evolution is lower than VERSE without it on three baselines.

Self-evolution makes the improvement hold on every baseline: with it, VERSE is above its baseline in all 16 comparisons of Table 2 (General Response, Part 1, point 2).

The full VERSE method is the harness optimizer with self-evolution; VERSE without it is an ablation that tests whether the verification tools alone are enough. In Table 2, the tools alone improve on the baseline in some comparisons but not in all.

With the closed-weight models of Appendix F, VERSE with self-evolution also matches or exceeds its baseline in all 8 comparisons (Table G2). There, the tools alone already do so, and adding self-evolution scores higher in 6 of the 8, by 0.4 to 2.6 points.

AuthorsOpenReview ↗

Response to Reviewer iRtb (2/4)

Weakness 1 (part 2) and Question 2 (continued)

"Does the gain come from self-evolution or from verification?" Both variants have the three verification tools and the same verification budget. What self-evolution changes is how the optimizer uses the tools (Section 4.4).

Without self-evolution, the optimizer tested its edits only on tasks that the current harness fails, so it could not notice when an edit broke a task that already passed. With self-evolution, the optimizer learns to also test edits on tasks that the harness already solves. It did so on each of the four baselines of Table 2 (in 34 of 81 tests), while the fixed optimizers ran 45 tests, none on such a task (Table R2). It also revises an edit more often after a failed test (79% against 61%).

Across the repeated runs, VERSE with self-evolution is higher than without it in all six comparisons: by 0.7 and 3.7 points on SWE-rebench and Terminal-Bench (General Response, Part 1, Table G3), by 1.4 and 1.1 on τ³-bench (in distribution and OOD), and by 1.6 and 0.6 on AppWorld (Section "Additional Experiments").

Table R2: Tests that the optimizer ran with the verification tool on each baseline of Table 2, and how many of these tests also included a task that the current harness already solves. Section 4.4 reports 2 of 89 and 57% for fixed optimizers because it also counts two ablation runs of Table 3.

BaselineFixed optimizer: testsFixed optimizer: also on an already-solved taskSelf-evolving optimizer: testsSelf-evolving optimizer: also on an already-solved task
Meta-Harness1202316
AHE9091
Self-Harness1102912
HarnessX130205
All four4508134

Weakness 2 (part 1) and Question 3: More established and diverse benchmarks, such as SWE-bench Verified.

(1) "The OOD evaluation remains within the same benchmark family." We evaluate on two benchmarks, SWE-rebench and Terminal-Bench, and also test new languages and transfer between the two.

Terminal-Bench (Appendix F). SWE-rebench follows the SWE-bench format, with GitHub issue tasks. Terminal-Bench has terminal tasks, and it is the benchmark that most harness optimizers report on (General Response, Part 3). We repeat the whole experiment there, with the closed-weight models of General Response, Part 1. VERSE improves all four baselines (Table R3), and it has the highest mean over three evolution runs (General Response, Part 1, Table G1).

Table R3: Terminal-Bench, each baseline alone and with VERSE (with self-evolution) (Appendix F, Table 9). Avg@3 test accuracy (%) of the harness selected on validation.

BaselineAloneWith VERSE
Meta-Harness37.0837.83
AHE38.5739.33
Self-Harness38.2040.45
HarnessX37.0841.20

New languages (Table 2; new Appendix G.1). The out-of-distribution test set of the main table is a newer release in five languages, four of which never appear in training. VERSE improves all four baselines there, by 6.1 points on average.

Transfer between the two benchmarks, in both directions (Appendix G.2). With the same models, Table R4 tests each harness evolved on SWE-rebench directly on Terminal-Bench, a benchmark it has never seen, with no further evolution, and then evolves it there for two more rounds. VERSE scores higher than all four baselines at every step. In the other direction, the VERSE harness evolved on Terminal-Bench scores 31.48% on SWE-rebench with no further evolution, above all four baselines (28.40% to 29.94%).

Table R4: Harnesses evolved on SWE-rebench and moved to Terminal-Bench (Table 13). Avg@3 test accuracy (%) on Terminal-Bench. Bold: highest.

MethodTested directly, no further evolutionAfter 1 roundAfter 2 rounds
Meta-Harness32.2136.7135.20
AHE36.3338.5837.08
Self-Harness30.7138.5835.58
HarnessX28.4635.5834.46
VERSE36.7040.0739.33

(2) "SWE-rebench is less established than SWE-bench Verified." We use SWE-rebench because our question is whether an evolved harness generalizes to newer tasks that the optimizer has never seen. SWE-rebench is released every month, so we can evolve on earlier releases and test on later ones (Section 2.2). SWE-bench Verified is a fixed set of 500 Python tasks, and recent work finds signs that models have memorized part of it: given only the issue text, Claude 3.5 Sonnet names all the files to edit for 65% of the issues of SWE-bench Verified, against 12% to 17% of the issues of SWE-rebench [1]. We report additional results on SWE-bench Verified in our follow-up response below.

AuthorsOpenReview ↗

Response to Reviewer iRtb (3/4)

Weakness 2 (part 2) and Question 4: Only one evolution run per configuration.

We ran the whole evolution three times in Appendix F, and the improvement of VERSE holds in all three runs (General Response, Part 1, Table G1). At the selected round, VERSE is +2.3 points over the strongest baseline on SWE-rebench and +2.7 points on Terminal-Bench. Each of its three runs scores above the three-run mean of every baseline, and on Terminal-Bench its lowest run scores above every baseline run.

Weakness 3 (part 1) and Question 5: Compute is not matched: do the gains come from extra resources?

(1) "The methods are not compared under matched total optimization budgets." Under the same compute budget, VERSE is above its baseline on all four baselines out of distribution and on three in distribution.

The budget is the cost of the baseline's whole run, with its six rounds and final selection (Table 5). We count executor tokens, agent runs (including the verification tools), and optimizer calls (including self-evolution) separately. We cut the VERSE run of Table 2 as soon as any of them reaches the budget, and VERSE selects among its finished rounds with the rule of Table 2; its final confirmation on validation is also within the budget. The round it selects was already finished after 37% to 81% of the budget in executor tokens (Table R5). Averaged over the four baselines, VERSE is 3.7 points above the baseline in distribution and 6.5 points out of distribution.

Table R5: VERSE (with self-evolution) cut at the budget of its baseline (runs of Table 2). Budget spent: share of the budget spent when the selected round is finished. Round 0 is the initial harness. Avg@3 test accuracy (%); bold: above the baseline.

Meta-HarnessAHESelf-HarnessHarnessX
Rounds finished within the budget0–50–30–50–3
Selected round (baseline / VERSE)4 / 26 / 36 / 50 / 2
Budget spent: executor tokens37%69%81%50%
Budget spent: agent runs37%59%88%47%
Budget spent: optimizer calls36%37%75%32%
In-distribution (baseline / VERSE)39.20 / 42.2833.95 / 33.3329.63 / 37.0432.72 / 37.65
OOD (baseline / VERSE)28.66 / 37.6926.17 / 30.5329.28 / 33.3327.41 / 35.83

(2) "It remains unclear whether the improvements are attributable to additional optimization resources." With the same verification budget, accuracy depends on who chooses the verification runs. The verification tools account for only 2 to 7% of all executor runs during evolution (Appendix D.3). Table R6 gives the same verification budget to a random schedule, to a fixed hand-written schedule, and to the optimizer itself (Appendix H). Accuracy is highest when the optimizer chooses its own verification runs; the fixed schedule falls below the baseline at the selected round. For self-evolution versus verification, see Weakness 1 (part 2) above.

Table R6: Same verification budget, with the verification runs chosen in three ways (Appendix H, Table 16; same setting as General Response, Part 1). Avg@3 test accuracy (%) on SWE-rebench. Bold: highest.

Who chooses the verification runsSelected roundLast round
No verification (AHE)29.3228.70
Random schedule30.8629.01
Fixed hand-written schedule26.8530.86
The optimizer itself32.7132.41
Reviewer_8PHxOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper introduces VERSE, a self-evolving optimizer for agent harnesses. Under a fixed evaluation protocol, VERSE improves four harness optimizers on held-out SWE-rebench tasks, as well as a set of OOD tasks that are not directly optimized for. The paper motivates components of VERSE (verification and self-evolution) via an initial study on Meta-Harness.

Critical strengths

Interesting topic. The question of what state should be maintained for an optimizer doing harness optimization is interesting and understudied; self-evolution can be seen as a way of maintaining some preferable optimizer state.

Experiments are generally sound. The general structure of experiments in the paper is sound. Test evaluations are repeated 3 times. Training, validation, and test splits are kept mutually exclusive. Ablations are conducted for the different components of VERSE.

Critical weaknesses
  • Setup and framing are unclear. In the Setup section, the paper states that the optimizer can modify 5 types of entities within its harness, however, the evaluation and selection steps in the optimization process remain the same. It further states that it (a) starts from Meta-Harness, and (b) adds simple verification and/or self-evolution. It is unclear where in the Meta-Harness algorithm the proposed changes are made. The authors could make this clearer by bringing their revised algorithm (currently Algorithm 1 in Appendix B) into the main text and stating where it departs from Meta-Harness. Taking notation from the Meta-Harness paper, my understanding is that the paper modifies the proposer PP with a state P(St)P(S_t) where tt indexes the outer loop over proposal steps. The state StS_t is fixed within a round and modified by the proposer itself in a separate self-update session between rounds. Coding agent conversation state, however, is reset at each tt.

    • Is this picture accurate? How does it extend to the other optimizers investigated in the paper?
    • In the current framing, "self-evolution" reads more like structured memory that is preserved between optimizer agent rollouts: the optimizer decides what to preserve between rounds, however, there is no notion of improvement over time, i.e. is the optimizer after rr rounds "better" than the initial optimizer? The self-evolution story would better be supported if the authors could show this improvement over time.
  • No comparison against self-improving optimizers. All four baselines keep the optimizer fixed (Appendix E), so the only evidence for self-evolution is the paper's own with/without ablation. The related work (Appendix A) discusses several methods in which the optimizer revises its own procedure, e.g. the Darwin Gödel Machine, Gödel Agent, STOP, Promptbreeder, and Meta Context Engineering, but none is evaluated. Additionally, Self-Harness is described as having one model play both roles, but in the re-implementation it uses a separate, fixed optimizer model like every other method. Could the authors compare against at least one existing self-improving optimizer under the same protocol, or explain why these methods are not comparable?

  • Insufficient control over stochasticity. Table 1 presents a ranking between methods and is used to support the claim that self-evolution with verification is the most performant method. There are two issues. The first is that each evolution method is run only once. Since evolutions are themselves stochastic, these results ignore the variance in the evolution process itself. Second, the val-selected results seem to be within error of each other. The main results in Tables 2 and 3 also share these issues; could the authors confirm that the rankings are statistically significant and not within noise?

  • Theoretical framework does not add much value. On page 6, the authors present a theoretical analysis of the optimization setup. However, no concrete connection is made to the experiments, either via constraints or insights; a loose connection is made with the observations from the setup, but the theory currently seems orthogonal, rather than central to setup or analysis.

  • Limited control over additional compute. Table 4 shows that VERSE runs use more compute than the baselines: 1.3–2.5× the wall-clock time and up to 58% more executor tokens, while optimizer tokens were not logged. It is unclear whether the results would hold if total compute was bounded and controlled.

Questions for authors
  1. I am interested in the benefit of self-evolution in Table 1's motivating experiment: I don't understand why adding a state to the proposal generator has any benefit over retaining the full archive of edits made by the optimizer, which Meta-Harness already does. The delta between self-evolution + verification and verification alone is quite small and within error. Could the authors clarify intuitively what additional benefit self-evolution provides over (a) reflecting on the archive of edits, and (b) verification alone?

  2. Observation 1 on page 4 reads "self-evolution helped with verification"; this sounds like verification benefits from self-evolution, when in fact the relationship is meant to be the other way around.

8 comments
AuthorsOpenReview ↗

Response to Reviewer 8PHx (1/4)

Dear Reviewer 8PHx,

Thank you for the careful reading and constructive feedback. The General Response explains our setting and why evaluation and selection are the same for every method, and lists the changes in the revised PDF. We answer each point below.

Weakness 1: Setup and framing are unclear.

(1) "The optimizer can modify five types of entities, but evaluation and selection remain the same." Yes, by design. Prior harness optimizers edit only the executor harness hh: the prompts, skills, hooks, and tools around the frozen model (Figure 1, left). VERSE with self-evolution also edits the optimizer's own harness gg, and the five types of entities are the parts of gg: prompts, skills, tools, hooks, and notes (Figure 1, right; Section 2.1). Neither harness can change the evaluation protocol: the training, validation, and test tasks are fixed, the best round is chosen on the validation set, and the test set is used only for evaluation (Section 2.1). The protocol is the same for every method, so that the comparison is fair (General Response, Part 2).

(2) "Where do the changes enter Meta-Harness?" At two points, marked in orange in the new Algorithm 1 (Section 3.1, lines 5 and 10).

While the optimizer writes an edit (Figure 2, bottom row). It can choose training tasks itself, run the edited executor harness on them, and read the results to check whether the edit works, revising it if not. In Meta-Harness, the optimizer learns how an edit performs only after the round ends and the edit has been evaluated. Observation 1 uses simple verification for this, and VERSE provides three verification tools.

Between rounds (Figure 1, right). The optimizer revises its own harness gg. Meta-Harness has no such step. We found that this step is what makes the lessons general (point (5)).

(3) "Is this picture accurate?" Yes. Your P(St)P(S_t) is our optimizer harness gtg_t, and StS_t is the part of it that evolves (prompts, skills, tools, hooks, notes). In Meta-Harness, PP is fixed: an off-the-shelf coding agent (Claude Code) with a fixed skill file (Table 8). In VERSE, StS_t is fixed within a round and updated at the end of the round from how the executor harness hth_t performed (Section 3.1; Figure 4).

(4) "How does it extend to the other optimizers?" The four baselines to which VERSE is added differ only in how the optimizer reads failed trajectories (Figure 2, top row): raw traces (Meta-Harness), debugger reports (AHE), failure clusters (Self-Harness), or trace summaries (HarnessX). Everything else is the same (Appendix E), and VERSE adds the same steps to each of them.

(5) "Is self-evolution only structured memory?" Partly. Broadly, gtg_t can be seen as memory, and the fixed optimizers also keep notes between rounds. But gtg_t is the optimizer's whole harness: of the 51 additions the optimizers made to their own harnesses in the five runs of Observation 2, 23 are code (7 tools and 16 hooks) and only 5 are notes (Figure 3).

Most of it encodes general lessons on how to improve a harness in this domain: how to diagnose a failure, how to check an edit, and which fixes held. For example, in our best run the optimizer wrote itself a tool that classifies all failed training runs in one call and lists the tasks that the current harness already solves (Appendix L.1). On each of the four baselines of Table 2, self-evolving optimizers tested their edits on such tasks (in 34 of 81 tests), while the fixed optimizers ran 45 tests, none on such a task (Question 1, Table R3).

(6) "Does the optimizer improve over time?" Yes, but not in every round. Appendix G.2 moves the optimizer harness accumulated during a run on SWE-rebench to Terminal-Bench, while the executor harness restarts from the initial harness h0h_0, so only the optimizer harness is carried over. Within two rounds, Terminal-Bench accuracy rises from 37.1% to 41.2% for the self-evolving optimizer, and from 36.3% to 39.3% for VERSE (Table 13). 41.2% matches the best of the twelve Terminal-Bench runs in Table 9, which start from a new optimizer harness and evolve for three rounds.

Within a run, Table R1 gives the validation tasks solved by the five self-evolving runs of Observation 2 (plotted in Figure 13). The best round beats round 0 on every executor, but some rounds drop, such as GLM-5 in rounds 1 and 2. A revised optimizer harness does not always write a better executor harness, which is why we select the final harness by its accuracy on the validation set, rather than taking the last round.

Table R1: Validation tasks solved (out of 50) per round. Round 0 is the initial harness.

Executorr0r1r2r3r4r5r6
Qwen3.8-27B17171820191920
DeepSeek V3.214171920212119
GLM-521181822232121
Qwen3-Coder-480B671214121413
Mistral Large 35799101012
AuthorsOpenReview ↗

Response to Reviewer 8PHx (2/4)

Weakness 2: No comparison against self-improving optimizers.

(1) "Why no comparison with existing self-improving optimizers?" They address a different problem. We cite these works to show the forms that self-improvement took in other settings: prompts (Promptbreeder), a short program (STOP), a function that answers single-turn questions (Gödel Agent), context for single-turn tasks (MCE), and one coding agent that edits its own code (DGM). None of these methods edits the harness of a separate executor, so they do not fit our comparison, in which every method edits hh under one protocol.

The four baselines in our comparison edit hh and keep gg fixed. We therefore test self-evolution by ablation: each baseline optimizer with and without self-evolution, under one protocol (Tables 1 and 2).

(2) "How does your Self-Harness differ from the original?" The original has one harness: the same model solves tasks under it and proposes edits to it. It keeps an edit only if the score rises on at least one of its two task sets and falls on neither. VERSE separates the executor harness hh from the optimizer harness gg, and revises gg to improve how the optimizer diagnoses and tests. Our version keeps how Self-Harness reads failures, by clustering failed traces, and shares the rest with the other baselines: a separate optimizer, the edit space, and selection on the validation set (Appendix E). All four baselines are such controlled adaptations, which keeps the comparison fair. The revised abstract states this, and the introduction is revised accordingly.

Weakness 3: Insufficient control over stochasticity.

(1) "Each evolution method is run only once." In Appendix F, the four baselines and VERSE (added to HarnessX) are each evolved three times from scratch, on SWE-rebench and Terminal-Bench (General Response, Part 1; Tables 10 and 12; Figure 6).

(2) "The val-selected results seem to be within error of each other." Across three evolution runs, the gap is larger than the run-to-run error. VERSE has the highest mean on both benchmarks, at both the selected and the final round (Table G1). At the selected round, it is +2.3 points over the strongest baseline on SWE-rebench and +2.7 points on Terminal-Bench. Each of its three runs scores above the three-run mean of every baseline, and on Terminal-Bench its lowest run scores above every baseline run (Table 12).

Weakness 4: The theoretical framework does not add much value.

The theory is connected to the experiments through both constraints and insights, and it is central to the setup and the analysis.

(1) "No concrete connection to the experiments, either via constraints or insights." Both are there. Constraints. The experimental protocol is the model of Section 3.2: the inner loop edits the executor harness, the outer loop edits the optimizer harness, the validation set selects the final harness, and the test set only evaluates it. Two rules of the protocol correspond to results of the analysis. The optimizer gets only a short validation summary, never task content: Appendix C.3.2 bounds how much this feedback can make validation accuracy overstate accuracy on new tasks. The verification tool counts a task as fixed only after two passes: a confirmation rerun lowers the overlap of a check (Appendix C.1).

Insights. Theorem 1 says that re-reading the same evidence leaves a floor on the chance of a wrong repair, while informative checks lower its upper bound. This is why VERSE gives the optimizer execution checks before submission. Theorem 2 says that a proposal succeeds only if the optimizer both targets the right failure and repairs it correctly. The two probabilities multiply, so better targeting helps little while repairs often fail. This is why VERSE combines self-evolution with verification.

(2) "A loose connection with the observations." Each theorem matches a measured result. Theorem 2 matches Observation 1, where self-evolution without verification did not improve validation accuracy (Table 1). Theorem 1 matches the ablation on the number of checks, where the gain appears with enough checks and then levels off (Figure 8), and the replay study, where reading traces often misses the faulty step (Appendix I).

(3) "Orthogonal, rather than central to setup or analysis." It is central to both. The setup is the model, and our analysis of the results uses the two theorems. For a system made of language models, tools, and many rounds of interaction, this is the level at which a theory can be stated: it describes each step by a few quantities, such as the number of checks, the number of proposals, and the size of the validation set, which we control or measure in the experiments.

AuthorsOpenReview ↗

Response to Reviewer 8PHx (3/4)

Weakness 5: Limited control over additional compute.

"Unclear whether the results would hold if total compute was bounded." Under the same compute budget, VERSE is above its baseline on all four baselines out of distribution and on three in distribution.

The budget is the cost of the baseline's whole run, with its six rounds and final selection (Table 5). We count executor tokens, agent runs (including the verification tools), and optimizer calls (including self-evolution) separately. We cut the VERSE run of Table 2 as soon as any of them reaches the budget, and VERSE selects among its finished rounds with the rule of Table 2; its final confirmation on validation is also within the budget. The round it selects was already finished after 37% to 81% of the budget in executor tokens (Table R2). Averaged over the four baselines, VERSE is 3.7 points above the baseline in distribution and 6.5 points out of distribution.

Table R2: VERSE (with self-evolution) cut at the budget of its baseline (runs of Table 2). Budget spent: share of the budget spent when the selected round is finished. Round 0 is the initial harness. Avg@3 test accuracy (%); bold: above the baseline.

Meta-HarnessAHESelf-HarnessHarnessX
Rounds finished within the budget0–50–30–50–3
Selected round (baseline / VERSE)4 / 26 / 36 / 50 / 2
Budget spent: executor tokens37%69%81%50%
Budget spent: agent runs37%59%88%47%
Budget spent: optimizer calls36%37%75%32%
In-distribution (baseline / VERSE)39.20 / 42.2833.95 / 33.3329.63 / 37.0432.72 / 37.65
OOD (baseline / VERSE)28.66 / 37.6926.17 / 30.5329.28 / 33.3327.41 / 35.83

Question 1: What does self-evolution add beyond the archive of edits and verification alone?

"What is the added state?" The optimizer's own harness: its prompt, notes, skills, tools, and hooks. With self-evolution, the optimizer edits these files after each round, and the next round starts from the edited files. Nothing in them changes how the executor solves a task. They only change how the optimizer does its own job: how it finds the cause of a failure, how it tests an edit, and when it submits. So what the optimizer writes there are lessons on how to improve a harness, rather than fixes for particular tasks.

Comments on the paper

7 comments
AuthorsOpenReview ↗

General Response (1/4): two questions from all four reviewers

We thank the reviewers for their comments. We first answer two questions that all four reviewers raised. Part 2 explains our setting, Part 3 compares it with recent work, and Part 4 lists the changes in the revised PDF.

1. "Each row of the main tables is a single evolution run."

We ran the whole evolution three times in Appendix F, and the improvement of VERSE holds in all three runs. Each of the four baselines and VERSE (added to HarnessX) is evolved three times from scratch on SWE-rebench and Terminal-Bench (Tables 10 and 12; Figure 6). This study uses closed-weight models: the small tier of a model family as the executor and its mid-size tier as the optimizer (the model names will be disclosed once approved). VERSE has the highest mean on both benchmarks (Table G1), for both the validation-selected and the final-round harness. At the selected round, VERSE is +2.3 points over the strongest baseline on SWE-rebench and +2.7 points on Terminal-Bench. Each of the three VERSE runs scores above the three-run mean of every baseline on both benchmarks, and on Terminal-Bench its lowest run scores above every baseline run (Table 12).

Table G1: Three evolution runs per method (Appendix F, Table 10). Avg@3 test accuracy (%), mean ± SEM across the three evolution runs; for h0h_0, ± is over three test evaluations.

MethodSWE-rebench, selected roundSWE-rebench, last roundTerminal-Bench, selected roundTerminal-Bench, last round
Initial harness h0h_028.70 ± 0.5428.70 ± 0.5437.08 ± 1.1237.08 ± 1.12
Meta-Harness30.56 ± 0.9928.71 ± 2.7036.95 ± 0.3338.33 ± 1.07
AHE29.94 ± 0.9429.32 ± 0.9437.45 ± 0.5737.45 ± 0.57
Self-Harness29.32 ± 0.9927.78 ± 0.4737.83 ± 0.3739.33 ± 0.65
HarnessX28.39 ± 1.2830.15 ± 0.9136.96 ± 0.5437.21 ± 0.33
VERSE32.82 ± 0.2031.79 ± 0.6240.57 ± 0.4540.20 ± 0.82

2. "VERSE with self-evolution is sometimes lower than VERSE without it."

Self-evolution makes the improvement hold on every baseline: with it, VERSE is above its baseline in all 16 comparisons of Table 2. The full VERSE method is the harness optimizer with self-evolution. VERSE without self-evolution is an ablation: it tests whether the verification tools alone are enough. In Table 2, the tools alone improve on the baseline in some comparisons but not in all. With self-evolution, the optimizer learns how to use the tools: it also tests an edit on tasks that the current harness already solves, and it revises a draft more often when a test fails (Section 4.4). VERSE then improves on every baseline.

Appendix F repeats Table 2 with the small-tier and mid-size-tier closed-weight models above, on SWE-rebench and Terminal-Bench. There, the tools alone are above the baseline in 7 of the 8 comparisons and equal to it in the other. With self-evolution, VERSE scores higher than without it in 6 of the 8, by 0.4 to 2.6 points, and it matches or exceeds its baseline in all 8 (Table G2).

Table G2: Each baseline alone, with VERSE without self-evolution, and with VERSE with self-evolution (Appendix F, Table 9). Avg@3 test accuracy (%) of the harness selected on validation. Bold: above the baseline. Underline: with self-evolution higher than without.

BenchmarkBaseline methodBaseline alone+ VERSE without self-evolution+ VERSE with self-evolution
SWE-rebenchMeta-Harness30.2530.2531.18\bf 31.1832.10‾\underline{\bf 32.10}
SWE-rebenchAHE29.3229.3232.71\bf 32.7134.88‾\underline{\bf 34.88}
SWE-rebenchSelf-Harness31.1831.1832.71\bf 32.7131.1831.18
SWE-rebenchHarnessX30.8630.8632.41\bf 32.4133.02‾\underline{\bf 33.02}
Terminal-BenchMeta-Harness37.0837.0839.33\bf 39.3337.83\bf 37.83
Terminal-BenchAHE38.5738.5738.5738.5739.33‾\underline{\bf 39.33}
Terminal-BenchSelf-Harness38.2038.2040.08\bf 40.0840.45‾\underline{\bf 40.45}
Terminal-BenchHarnessX37.0837.0838.57\bf 38.5741.20‾\underline{\bf 41.20}

Repeated runs on HarnessX. To the three runs of the HarnessX baseline and of VERSE (Table G1), we add a second evolution run of VERSE without self-evolution, which was not in the submission (Table G3; Table 11 in the revised PDF). The tools alone gain 3.7 points on SWE-rebench but are comparable to the baseline on Terminal-Bench. With self-evolution, VERSE improves consistently on both. Each of the three runs with self-evolution scores at least as high as both runs without it.

Table G3: HarnessX alone and with VERSE, without and with self-evolution. Accuracy (%) at the selected round, mean ± SEM across runs.

BenchmarkHarnessX alone (3 runs)+ VERSE without self-evolution (2 runs)+ VERSE with self-evolution (3 runs)
SWE-rebench28.39 ± 1.2832.10 ± 0.3132.82 ± 0.20
Terminal-Bench36.96 ± 0.5436.89 ± 1.6940.57 ± 0.45
AuthorsOpenReview ↗

General Response (2/4): our training and evaluation setting

Several questions concern our setting: how the baselines are run, and how the final harness is selected and evaluated for every method. We explain it here, and compare it with recent work in Part 3.

Goal. Most harness evolution work optimizes a harness for a given benchmark: the harness is evolved and evaluated on the same tasks. Some methods also report results on held-out or out-of-distribution tasks (Part 3), but as a post-hoc evaluation: generalization is not the objective of the search. Wang et al. [1] point out that searching on the evaluation tasks resembles test-time scaling: it allocates additional compute to these tasks themselves, and under matched budgets it does not consistently outperform sampling more attempts. Gains on the search tasks therefore do not establish that the harness has learned lessons that transfer to unseen tasks.

Our goal is a harness that generalizes. As stated in Section 2.2: "We study how to evolve harnesses that generalize to unseen tasks." Generalization is thus the objective of the optimization, not a post-hoc evaluation: the optimizer learns on training tasks, the harness is selected on a validation set, and it is evaluated on held-out test tasks. Held-out evaluation is what separates lessons that generalize from additional test-time compute.

Setup. We therefore split the tasks as in standard machine learning (Section 2.2):

  • Training: 110 SWE-rebench tasks from the January 2025 to February 2026 releases. The optimizer reads trajectories and runs its checks only on these tasks.
  • Validation: 50 tasks from the same releases, used to select the final harness.
  • Test: never used during evolution. In distribution, the 108 tasks of the March 2026 release. Out of distribution, the 107 tasks of the July 2026 release, in Go, Java, Python, Rust, and TypeScript, with only 20 in Python.

The validation set does three things in this setting:

  1. It shows whether an edit generalizes. The optimizer has read every training trajectory, so training accuracy cannot tell this; validation accuracy can.
  2. It selects the harness. We keep the harness with the best validation accuracy across rounds, not the last one, as in model selection.
  3. It guides the optimizer without exposing the tasks. After each round, the optimizer gets a short summary: validation accuracy, and which tasks its latest edit fixed or broke. It never sees task statements, tests, or trajectories.

Same setting for every method. All methods share the executor, optimizer model, edit space, number of candidates and turn limit per round, data splits, selection rule, and validation summary. Each method keeps its own evidence interface, that is, how its optimizer reads failed trajectories (Appendix E). The four baselines are thus controlled adaptations of the published methods. So only the method changes, and evaluation and selection stay fixed because they belong to the setting (Section 2.1).

References

  • [1] Wang et al. Rethinking the Evaluation of Harness Evolution for Agents. COLM 2026 Workshop.
AuthorsOpenReview ↗

General Response (3/4): settings of recent work

The table shows how the four methods we compare against [2–5] and concurrent work [6–9] set up their harness experiments.

MethodEvolved and selected onAlso tested on unseen tasksSeparate validation set
Meta-Harness [2]Terminal-Bench 2Yes for text classification and math; no for Terminal-BenchNo
AHE [3]Terminal-Bench 2SWE-bench VerifiedNo
Self-Harness [4]Held-in split of each benchmarkHeld-out split of the same benchmarkNo; its held-out split is used both to accept edits and to report results
HarnessX [5]Full task sets of five benchmarksNoNo
RRSI [6]Terminal-Bench 2.1SWE-bench Verified and other benchmarksNo
Dream-RSI [7]Terminal-Bench 2.1Yes for Lasso; no for Terminal-BenchNo
Harness² [8]Each test task, at test timeOne transfer testNo
ModularRSI [9]External tasks, disjoint from the benchmarksTerminal-Bench 2.0, SWE-bench VerifiedNo
VERSE (ours)110 training tasks108 held-out tasks; 107 newer tasks in five languagesYes

In their own reports, gains on a new benchmark are much smaller than on the search benchmark. AHE gains 7.3 points on Terminal-Bench 2 and 0.4 on SWE-bench Verified (OOD) [3]. RRSI gains 6.0 to 14.1 points on Terminal-Bench 2.1 and 1.8 to 2.2 on SWE-bench Verified (OOD) [6]. When AHE is evolved and tested on disjoint tasks, Wang et al. [1] find a gain of 0.6 points. These papers use different benchmarks, models, and splits, so we compare methods in one setting rather than by reported numbers. There, out of distribution, the four baselines stay within two points of the initial harness, while VERSE with self-evolution gains 2.8 to 10.3 points (Table 2).

References

  • [1] Wang et al. Rethinking the Evaluation of Harness Evolution for Agents. COLM 2026 Workshop.
  • [2] Lee et al. Meta-Harness: End-to-End Optimization of Model Harnesses. COLM 2026.
  • [3] Lin et al. Agentic Harness Engineering: Observability-Driven Automatic Evolution of Coding-Agent Harnesses. arXiv 2026.
  • [4] Zhang et al. Self-Harness: Harnesses That Improve Themselves. arXiv 2026.
  • [5] Chen et al. HarnessX: A Composable, Adaptive, and Evolvable Agent Harness Foundry. arXiv 2026.
  • [6] Xia et al. RRSI: Regularized Recursive Self-Improvement of Agent Harnesses. arXiv 2026.
  • [7] Zheng et al. Dream-RSI: Recursive Self-Improvement through Evolving Worlds. arXiv 2026.
  • [8] Xu et al. Harness²: Recursive Agent Harnessing for an Open World. arXiv 2026.
  • [9] Wu et al. ModularRSI: Modular and Generalizable Recursive Harness Self-Improvement. arXiv 2026.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.