SBCO: Self-Supervised, Verifier-Grounded Harness Optimization For Planning Agents

# Self-Supervised, Verifier-Grounded Harness Optimization For Planning Agents
Source: [https://arxiv.org/html/2608.10157](https://arxiv.org/html/2608.10157)
###### Abstract

Self\-improving agents seek to reduce the human engineering effort behind AI systems by enabling them to evolve and self\-improve their performance over time\. Recently, methods like the Darwin Gödel Machine and the Huxley Gödel Machine have been proposed which enable open\-ended,*recursive*self\-improvement through*self\-reference*where a coding agent edits its own code\. Such self\-referential self\-improvement methods require that the competence required to perform the task coincides or aligns well with the competence required for self\-modification which is the case for coding tasks\. For domains or tasks, which do not satisfy the alignment needed, self\-referential self\-improvement is not available\. In such cases, it is possible to adapt the above algorithms to other tasks by removing the self\-referential aspect or introducing explicit self\-modification of a meta\-agent – both computationally expensive, relying on population or self\-modification search over many candidate agents\. For planning tasks with explicit constraints, we propose a far cheaper alternative\. We introduceSBCO\(*Self\-supervised Block Coordinate Optimizer*\), a verifier\-grounded harness optimizer in the same closed\-loop, improve\-from\-experience family as the Gödel\-machine methods, but self\-supervised rather than self\-referential\. Given an agentic harness, SBCO learns a decomposed bank of verifiers and a harness policy via approximate block coordinate ascent, improving the agent’s outputs from its own graded feedback—with a fixed meta\-agent and no human labels\. Across two domains SBCOmatches or exceedsa customized self\-modifying baseline while using4–5\.5times less compute budget\.

## 1Introduction

Building capable AI agents still demands substantial human engineering–hand\-crafted prompts, tools, control flow, and checks\.*Self\-improving*agents aim to reduce that effort by letting a system improve its own problem\-solving over time\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)\. Recently, methods like the Darwin Gödel Machine\(Zhanget al\.[2025a](https://arxiv.org/html/2608.10157#bib.bib15)\)and the Huxley Gödel Machine\(Wanget al\.[2025](https://arxiv.org/html/2608.10157#bib.bib14)\)have been proposed in this realm\. These methods enable open\-ended,*recursive*self\-improvement of coding agents through*self\-reference*where the coding agent edits its own code to self\-improve in a recursive manner\. As noted by\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\), the ability to self\-improve the improvement mechanism relies on*self\-reference*where the competence the agent is scored on coincides with the competence it needs to improve itself, and gains at the task translate into gains at self\-improving which holds for coding tasks\. Beyond coding this alignment generally breaks: improving a planning agent is a coding or specification problem, and a better planner is not thereby a better agent\-editor\. It is possible to adapt these algorithms to non\-coding tasks, by either \(a\) removing the self\-referential nature and introducing a hand\-crafted fixed meta\-agent \(per domain\) or \(b\) introduce self\-modification in the meta\-agent itself enabling meta\-cognition which Hyperagents accomplished\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)\. However they also note that introducing meta\-cognition \(Option b\) mainly benefits transfer of the meta\-cognitive strategy to other domains with no significant gain in task performance beyond customized fixed meta\-agents \(Option a\)\. Nevertheless, both options are*computationally expensive*, relying on population self\-modification search that generates and evaluates many candidate agents\.

We ask whether for planning tasks with explicit constraints, a far cheaper mechanism suffices\. We introduceSBCO\(*Self\-supervised Block Coordinate Optimizer*\), a self\-improving verifier\-grounded harness optimizer in the same closed\-loop, improve\-from\-experience family as the Gödel\-machine methods, but*self\-supervised rather than self\-referential*\. Given an agentic harness–SBCO learns a*decomposed bank of per\-constraint verifiers*and a*policy*that checks the agent’s output and repairs it when a reliable verifier fires\. The optimizer is a*fixed*meta agent: it improves the harness by approximate block coordinate ascent with textual gradients, from its own graded feedback and with no human labels\. In summary, our main contributions are:

- •SBCO, a fixed, verifier\-grounded harness optimizer that improves a long horizon planning agent via approximate block coordinate ascent with textual gradients over a learned, decomposed verifier bank and a repair policy\.
- •SBCO reaches the frontier of a customized self\-modifier at44–5\.5×5\.5\\timesless compute \(on par on travel, exceeding on shopping\)\.
- •Our analysis shows that improvement tracks verifier reliability \(86%86\\%of gains come from verifiers with F1≥0\.80\\geq 0\.80\), and the policy transfers across base LLMs\.

## 2Related Work

Related work can be categorized into four main areas:

#### Recursive or Self\-referential Self\-improvement\.

These works propose methods which improve an agent where the agent rewrites its own code\(Zhanget al\.[2025a](https://arxiv.org/html/2608.10157#bib.bib15); Wanget al\.[2025](https://arxiv.org/html/2608.10157#bib.bib14); Zelikmanet al\.[2023](https://arxiv.org/html/2608.10157#bib.bib16); Zhanget al\.[2026a](https://arxiv.org/html/2608.10157#bib.bib18)\)\. Because these methods are both self\-referential and self\-improving, they require that the competence for self\-improvement aligns well in the task and this typically is the case for coding\. The variants of the Gödel machine namely the Darwin Gödel Machine\(Zhanget al\.[2025a](https://arxiv.org/html/2608.10157#bib.bib15)\)and Huxley Gödel Machine\(Wanget al\.[2025](https://arxiv.org/html/2608.10157#bib.bib14)\)belong to this class and propose evolutionary search algorithms which evolves an archive of self\-modified agents via mutations and select a final agent from the archive\. As mentioned, these methods focus on coding tasks\. The works of\(Fernandoet al\.[2023](https://arxiv.org/html/2608.10157#bib.bib17); Zhanget al\.[2026a](https://arxiv.org/html/2608.10157#bib.bib18)\)are close to that of the Darwin Gödel Machine but instead only restrict themselves to improving prompts\(Fernandoet al\.[2023](https://arxiv.org/html/2608.10157#bib.bib17)\)or adopt a a more bounded search procedure\(Zhanget al\.[2026a](https://arxiv.org/html/2608.10157#bib.bib18)\)\.

In contrast to the above which are self\-referential and hence by design are limited to primarily modifying only prompts or only coding tasks, SBCO instead shows how one can improve long\-horizon planning tasks \(breaking away from coding\) using an iterative self\-improvement procedure using a*fixed meta\-agent*\. We further distinguish ourselves from\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)in that they introduce meta\-cognitive ability to Darwin Gödel Machine variants and mainly note that this meta\-cognitive ability enables transfer of learned cognitive strategy across tasks but does not yield statistically significant improvements over customized Darwin Gödel Machines\. Moreover, because the fundamental nature of open\-ended and evolutionary search persists, it can still be computationally expensive to run\. Different from them, our focus is not meta\-cognition or transfer of any meta\-cognitive strategy but primarily task performance on planning tasks with constraints where we show how to obtain frontier performance with significant compute budget efficiency\.

#### Automated Design of Agents and Workflows\.

A parallel line of work uses a fixed meta agent to search over agent*designs*—inventing or composing agentic building blocks \(chain\-of\-thought, debate, tool use, ensembling\) into agents or workflows under aggregate benchmark reward: ADAS\(Huet al\.[2025](https://arxiv.org/html/2608.10157#bib.bib19)\)invents new agent programs, AFlow\(Zhanget al\.[2025b](https://arxiv.org/html/2608.10157#bib.bib20)\)searches code\-represented workflows, andZhouet al\.\([2026](https://arxiv.org/html/2608.10157#bib.bib21)\)optimize multi\-agent prompts and topologies\. The product is a new, often multi\-agent, system\. SBCO does not yield focus on multi\-agent system design and instead grounds optimization in a*learned, decomposed bank of per\-constraint verifiers*plus a repair policy that internally utilizes a correctness signal per constraint as well as an overall reward score\.

#### Harness Optimization\.

A broad line of work improves a base model by optimizing the*harness*wrapped around it rather than redesigning the agent\. Some approaches update model parameters while most are training\-free\. STaR\(Zelikmanet al\.[2022](https://arxiv.org/html/2608.10157#bib.bib22)\)fine\-tunes on self\-generated rationales filtered by correctness\. Self\-Refine\(Madaanet al\.[2023](https://arxiv.org/html/2608.10157#bib.bib26)\)refines the output of a LLM by just asking a critique model to provide feedback on that output which it would add to the LLM and iteratively refine the output \(essentially focusing on on only prompt refinement\)\. AlphaEvolve\(Novikovet al\.[2025](https://arxiv.org/html/2608.10157#bib.bib25)\)focuses on evolving entire algorithms and programs with the aim of enabling scientific discovery using evolutionary approaches\. More recent harness tuning approaches like Trace2Skill learn a skill\-bank over time\(Niet al\.[2026](https://arxiv.org/html/2608.10157#bib.bib27)\), Meta\-Harness\(Leeet al\.[2026](https://arxiv.org/html/2608.10157#bib.bib23)\)tune a harness*monolithic*object against a scalar reward, AutoHarness\(Louet al\.[2026](https://arxiv.org/html/2608.10157#bib.bib24)\)*tree\-searches*an LLM\-coded harness\. While SBCO shares the “training\-free” aspect with these approaches, it differs from these approaches in several ways: \(a\) it optimizes the entire harness and not just prompts or skills \(b\) it does not model the harness as a mono\-lith but adopts a structured optimization approach \(c\) adopts an iterative approach instead of a tree\-search and \(d\) focuses on long horizon planning tasks with constraints\.

#### Using Verifiers to Improve Task Performance

There has been some prior work in using verifiers \(either using an LLM as judge or deterministic functions\) to improve task performance of LLMs\. The first line of work uses them to provide a training signal, especially in reinforcement learning based training by introducing process reward models that score intermediate reasoning steps\(Setluret al\.[2025](https://arxiv.org/html/2608.10157#bib.bib29); Khalifaet al\.[2025](https://arxiv.org/html/2608.10157#bib.bib30); Pronestiet al\.[2026](https://arxiv.org/html/2608.10157#bib.bib31); Zhanget al\.[2026c](https://arxiv.org/html/2608.10157#bib.bib32)\)\. The second line, closest to ours, applies verifiers over a fixed generator\(Arora and Kambhampati[2023](https://arxiv.org/html/2608.10157#bib.bib34); Zhanget al\.[2026d](https://arxiv.org/html/2608.10157#bib.bib33); Pezeshkpour and Hruschka[2026](https://arxiv.org/html/2608.10157#bib.bib35)\)\.Arora and Kambhampati \([2023](https://arxiv.org/html/2608.10157#bib.bib34)\)train a verifier to detect constraint violations in a blocks\-world action space and re\-plan when a violating action is found; they do not optimize the harness, only proposing a replan\-if\-failed loop\.Zhanget al\.\([2026d](https://arxiv.org/html/2608.10157#bib.bib33)\)address complex question answering with a plan–execute–verify–replan framework that decomposes a question into sub\-questions, solves each with a sub\-agent, and verifies sub\-answers before composing a final answer but the verifier is a fixed, hand\-designed LLM\-as\-judge prompt\. Finally,Pezeshkpour and Hruschka \([2026](https://arxiv.org/html/2608.10157#bib.bib35)\)propose a search\-based method that infers both a set of criteria and corresponding verifiers for judging LLM outputs, but do not learn a repair workflow\. In contrast, SBCO jointly learns to optimize both the verifier set and the underlying harness \(replan strategy\) in a self\-supervised manner targeting long\-horizon planning tasks\.

## 3SBCO

### 3\.1Overview

We are given a*base agent*𝒜\\mathcal\{A\}that performs a task𝒳\\mathcal\{X\}and produces a plan𝒪\\mathcal\{O\}\. We assume we can evaluate any generated plan assuming a black\-box evaluation suite that outputs a concrete reward \(score\) and reasonable descriptions of errors \(eg\. plan exceeded budget\)\. We also assume some reasonable knowledge or description of the semantics of constraints \(eg\. budget exceeded means the total cost of the itinerary travel, accommodation exceeds the user specified budget\)\.

Because SBCO optimizes in structured manner, let us formalize the components of the agentic harness\. Let us define the agentic harness to be a tuple of the form\(𝒫,𝒯,𝒲\)\(\\mathcal\{P,T,W\}\), a prompt𝒫\\mathcal\{P\}, a set of frozen tools𝒯\\mathcal\{T\}that the LLM can use to perform the planning task, and𝒲\\mathcal\{W\}the agentic work\-flow\. We further partition𝒲\\mathcal\{W\}into two parts: \(a\)𝒱\\mathcal\{V\}: a set of verifiers we will learn/introduce and \(b\)Π\\Pi\- the actual code or policy that will be executed to perform the task\. SBCO seeks to maximize the expected reward𝔼x​\[R​\(x,o\);𝒫,𝒯,𝒲\]\\mathbb\{E\}\_\{x\}\[R\(x,o\);\\mathcal\{P,T,W\}\]over the task distribution by optimizing the following components of the harness:𝒫\\mathcal\{P\},𝒱\\mathcal\{V\}, the set of verifiers andΠ\\Pi\. During optimizations SBCO iteratively alternates between two main phases: \(a\) Optimizing the verifier set𝒱\\mathcal\{V\}fixing𝒫\\mathcal\{P\},Π\\Piand \(b\) Optimizing the prompt𝒫\\mathcal\{P\}and the policyΠ\\Pifixing𝒱\\mathcal\{V\}– both optimizations done in textual space using textual gradients obtained through a critic/strategist \(see Figure[1](https://arxiv.org/html/2608.10157#S3.F1)\)\. In following sections, we will describe each phase in detail\.

![Refer to caption](https://arxiv.org/html/2608.10157v1/sbco_overview.png)Figure 1:SBCO iteratively alternates between two main phases: \(a\) Optimizing the verifier set𝒱\\mathcal\{V\}fixing𝒫\\mathcal\{P\},Π\\Piand \(b\) Optimizing the prompt𝒫\\mathcal\{P\}and the policyΠ\\Pifixing𝒱\\mathcal\{V\}\.
### 3\.2Optimizing the Verifier Set𝒱\\mathcal\{V\}

For each constraintccwe seek to learn a verifier that can check whetherccis satisfied or not\. Learning such a verifier involves two coupled blocks \(a\)Signature Block: A function signature that describes the input and output signatures, and the semantics of the verifier\. \(b\)Implementation Block: this is the actual implementation or the body of the function/verifier\. To judge the quality of a learned verifier, we use a small set of evaluations from a baseline run which allows us to construct a ground\-truth set \(positive examples and negative examples corresponding to the specific constraint passing or failing\) and use a precision/recall \(F1\) score to ascertain how good the verifier is for that specific constraint\. This provides a very cheap and computationally inexpensive way to judge verifier quality\. We optimize both blocks using textual gradients by keeping one block fixed while optimizing the other\.

#### Quality Checks and Acceptance Gating the Verifier Set

Because learning verifiers for some constraints may be hard, to ensure a very poor verifier does not enter the final bank, we introduce quality checks and acceptance gating\. A verifier is*accepted*and entered into the bank iff it clears a reliability floor \(a precision floorτP=0\.80\\tau\_\{P\}=0\.80and recall floorτR=0\.55\\tau\_\{R\}=0\.55\), Verifiers that cannot clear the reliability floor because the needed signal is not extractable from the available fields, or precision/recall stays below threshold are*left out*of the bank\. This ensures the bank meets at\-least a certain level of base quality\.

### 3\.3Optimizing the Prompt𝒫\\mathcal\{P\}and the policyΠ\\Pi

In this phase, we keep the learned verifier set𝒱\\mathcal\{V\}fixed, and only optimize the prompt𝒫\\mathcal\{P\}, and the code \(policy\)Π\\Pi\. Importantly, policyΠ\\Pican decide how to use the set of verifiers to improve task performance \(eg\. check plans and repair them as needed\)\. It is worth noting that in practiceΠ\\Pican be completely free\-form code or may be constrained to follow some enforced structure – an implementation choice\. Once again, as in prior stage, we optimize these using textual gradients\(Yuksekgonulet al\.[2024](https://arxiv.org/html/2608.10157#bib.bib37)\)using the reward returned by the evaluation benchmark\. Finally in both phases, we introduce a keep\-best ratchet to ensure we do not regress to a worse setting when optimizing each block\.

### 3\.4SBCO – Outer Loop

The outer loop of SBCO mainly iterates through every block in sequenced\-order \(encoding dependencies\) and optimizes each block keeping the rest of the blocks fixed \(Alg\.[1](https://arxiv.org/html/2608.10157#alg1)\)\. The inner optimization routine \(Alg\.[2](https://arxiv.org/html/2608.10157#alg2)\) which optimizes each block performs tactical refinement interleaved with occasional strategic pivots \(to break out of poor regimes\)\.

Specifically, the tactical refinement phase uses textual gradients to optimize the block\. To break out of local optima, we introduce the ability to strategically pivot if the improvement over several iterations does not meet the acceptance gate\. During such a strategical pivot the critic sees all prior strategies tried, their failures and proposes a completely new strategy \(try a different tool, a different algorithm etc\) or declares a potential information ceiling\.

Furthermore, because the verifier set optimization uses a surrogate reward metric for optimization that is not exactly the same as the final task reward objective, it is possible that the policy block optimizer would like to flag potential mismatches back to the verifier optimization phase to re\-visit/re\-open an already accepted constraint verifier\. Therefore, we enable down\-stream phases to potentially escalate to upstream phases to re\-open upstream artifacts\.

Finally, given access to the task agent, the evaluation benchmark and its output, the loop is a closed loop – a loop consisting of propose→\\tograde→\\tocritique→\\torevise, steps closed over the model’s own outputs\. This is the sense in which SBCO is*self\-improving*—the loop improves its artifacts from its own experience—while remaining*self\-supervised*but not recursive/self\-referential\.

Algorithm 1SBCO \(outer loop\)0:agent

𝒜\\mathcal\{A\}; constraints

𝒞\\mathcal\{C\}; gate

\(τP,τR\)\(\\tau\_\{P\},\\tau\_\{R\}\); epochs

EE
0:verifier bank

𝒱\\mathcal\{V\}, policy

π\\pi
1:

𝒱←∅\\mathcal\{V\}\\leftarrow\\emptyset; initialise per\-constraint state;

π←πseed\\pi\\leftarrow\\pi\_\{\\text\{seed\}\}\{no\-op seed\}

2:for

e=1e=1to

EEdo

3:for allactive

c∈𝒞c\\in\\mathcal\{C\}do

4:

σc←BlockOptimize​\(signature,c\)\\sigma\_\{c\}\\leftarrow\\textsc\{BlockOptimize\}\(\\textsf\{signature\},c\)
5:

φc←BlockOptimize​\(implementation,c∣σc\)\\varphi\_\{c\}\\leftarrow\\textsc\{BlockOptimize\}\(\\textsf\{implementation\},c\\mid\\sigma\_\{c\}\)
6:if

accept​\(φc\)\\text\{accept\}\(\\varphi\_\{c\}\)then

7:

𝒱←𝒱∪\{compile​\(φc\)\}\\mathcal\{V\}\\leftarrow\\mathcal\{V\}\\cup\\\{\\textsc\{compile\}\(\\varphi\_\{c\}\)\\\}\{reliability gate\}

8:endif

9:endfor

10:

π←BlockOptimize​\(policy\)\\pi\\leftarrow\\textsc\{BlockOptimize\}\(\\textsf\{policy\}\)\{policy block\}

11:Escalate\(π,𝒱\)\(\\pi,\\mathcal\{V\}\)if needed;

12:endfor

13:returnkeep\-best

𝒱,π\\mathcal\{V\},\\pi

Algorithm 2BlockOptimize: tactical refinement \+ strategic pivot \(fixedℳ\\mathcal\{M\}\)0:block type; unit \(constraint or bank\); tactical budget

TT; max pivots

ρ\\rho
1:

b⋆←seedb^\{\\star\}\\leftarrow\\text\{seed\};

s←seeds\\leftarrow\\text\{seed\}
2:for

p=0p=0to

ρ\\rho\(outer: strategic pivots\)do

3:if

p\>0p\>0then

4:

s←Strategist​\(brief\)s\\leftarrow\\textsc\{Strategist\}\(\\text\{brief\}\)\{pivot: structurally new, or InfoCeiling\}

5:endif

6:for

t=1t=1to

TT\(inner: tactical refinement\)do

7:

b←Generate​\(s\)b\\leftarrow\\textsc\{Generate\}\(s\);

g←Grade​\(b\)g\\leftarrow\\textsc\{Grade\}\(b\)
8:if

Better​\(g,g​\(b⋆\)\)\\textsc\{Better\}\(g,g\(b^\{\\star\}\)\)then

9:

b⋆←bb^\{\\star\}\\leftarrow b\{keep\-best\}

10:endif

11:if

MeetsGate​\(g\)\\textsc\{MeetsGate\}\(g\)then

12:return

b⋆b^\{\\star\}
13:endif

14:

s←TextGradStep​\(critic,b,GradeReport​\(g\)\)s\\leftarrow\\textsc\{TextGradStep\}\(\\text\{critic\},b,\\textsc\{GradeReport\}\(g\)\)
15:endfor

16:if

accept​\(b⋆\)\\text\{accept\}\(b^\{\\star\}\)or

¬ShouldPivot​\(\)\\lnot\\,\\textsc\{ShouldPivot\}\(\)then

17:break\{converged, or strategist declines to pivot\}

18:endif

19:endfor

20:return

b⋆b^\{\\star\}

## 4Experiments

#### Benchmarks and Evaluation Metrics

To evaluate our method, we consider the popular*DeepPlanning*benchmark\(Zhanget al\.[2026e](https://arxiv.org/html/2608.10157#bib.bib36)\)which consists of two long\-horizon planning tasks with constraints: \(a\)Travel Planning– where the task agent is provided access to task\-specific tools \(that query a local database\) and is tasked to generate a multi\-day itinerary based on the specification of the user\. The user specifies their travel requirements and outlines constraints \(eg\. budget should be within10001000dollars, need to stay in a 3\.5 star hotel, a plan for 4 days and 3 nights\.\)\. \(b\)Shopping– where the task agent is provided access to a set of tools \(that query a product catalog\) and is asked to create a cart consisting of items from a product catalog that meet the user’s request\. The user’s request specifies what kind of items they want and potential constraints \(eg\. need a 4\.5 star rated Ralph Lauren sweater\)\. Both tasks can be challenging because the agent needs to reason about implicit constraints \(like size based on user profile\) and many explicit constraints\. We evaluate our method on multiple dimensions:

- •Task Performance: We report standard task performance metrics as specified by the benchmark – namely Composite score and Case Accuracy for Travel Planning, and Match Score and Case Accuracy for Shopping\.
- •Compute Budget: To evaluate the compute efficiency of our algorithm against baselines like HGM, we use the same protocol they used to quantify the compute budget – namely the number of plans generated during the optimization process \(which they term as evaluation budget\)\.
- •Latency: We also report the average latency of methods to generate a plan\.

#### Baseline Methods

We compare against state\-of\-the\-art*self\-improving*methods that, like SBCO, drive improvement with a*fixed*meta agent–a handcrafted,*non\-metacognitive*improvement procedure, following the terminology ofZhanget al\.\([2026b](https://arxiv.org/html/2608.10157#bib.bib13)\): \(a\) the Huxley\-Gödel Machine self\-improving algorithm HGM\(Wanget al\.[2025](https://arxiv.org/html/2608.10157#bib.bib14)\)and a domain\-customized variant, HGM\-C\. Note we consider HGM \(and its customization\) over DGM\(Zhanget al\.[2025a](https://arxiv.org/html/2608.10157#bib.bib15)\)because HGM is known to already outperform DGM on task performance and budget\. We also report a no\-op*Baseline*\(the base agent with no improvement loop\)\. We deliberately omit the recent*metacognitive*self\-modifier DGM\-H\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)for two reasons grounded in that work itself\. First,Zhanget al\.\([2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)note that their proposed meta\-cognitive self\-modification \(DGM\-H\) yields*no statistically significant gain*in*task performance*over the fixed\-meta customized baseline DGM\-C \(a higher median butp\>0\.05p\>0\.05\); its measured benefit is actually cross\-domain*transfer*and accumulation, which we do not claim\. Because we make only a task\-performance claim and make no claims about*meta\-cognitive*ability or cross\-domain transfer ability, the appropriate state\-of\-the\-art comparison for task\-performance is therefore the strongest fixed\-meta self\-improving baselines, HGM and HGM\-C\.

#### Evaluation Protocol\.

The task\-agent use GPT\-5\.4\-mini as the backbone LLM while the critic/strategist are GPT\-5\.4\-medium unless specified\. For HGM baseline, we set the evalauation budget to80008000with all other parameters set to their default\. For SBCO, we set the total number of epochsE=3E=3for the outer\-loop, and for the block\-optimizer, the maximum number of iterations for tactical refinement is set to55with at\-most22strategic pivots\. SBCO uses a subset of the benchmark data for training \(and validation\)\. However,*final performance*is reported on the full task set \(training\+\+validation\)\. This matches the reporting protocol of the Gödel\-machine baselines \(DGM and HGM\) which select and report on the same benchmark rather than a held\-out test split, so all methods in Table[1](https://arxiv.org/html/2608.10157#S5.T1)are evaluated identically and the comparison is apples\-to\-apples\. All numbers are the mean of two runs of the policy to account for variance in planning111The number of independent runs of the policy was the best choice under the budget compute we had available\.\.

We argue that this setting does not confer an unfair advantage here, for the same reason it does not for DGM or HGM: improvement is mediated by*general artifacts*, not by memorizing per\-task answers\. SBCO’s verifiers are constraint\-checking*programs*\(e\.g\. “is the chosen hotel the cheapest of the required brand?”\) and its policy is general repair logic; neither of which encodes a instance specific answers\. This is similar to DGM/HGM where the improvement comes from general code and not per\-instance solution look\-up\. To alleviate concerns of SBCO overfitting, we explicitly also report separately train and validation set performance of the best policies and show the train\-validation gap is small\. Further\-more we also show that the learned artifacts generalize directly to different LLM backbones of the task agent further underscoring the generalizability of SBCO\.

## 5Results

### 5\.1Quantitative Results

Table[1](https://arxiv.org/html/2608.10157#S5.T1)reports the main comparison on both domains\. Note that budget is the number of plans generated \(tasks evaluated\) during the optimization phase of each algorithm\. First, observe that the naive Huxley Gödel\-machine method fails to improve meaningfully despite8×8\\timesthe budget \(on Shopping it does not move from the baseline at80008000plans\)\. Second the customized HGM \(HGM\-C\) \(which includes a hand\-crafted meta\-agent prompt and guidelines\) yields significant improvement over the baseline \(8383vs7676on Travel, and9191vs8383on Shopping\)\. This performance however used a budget of40004000plan generations\. On the other hand, SBCO reaches the quality frontier of HGM\-C at44–5\.5×5\.5\\timeslower budget\. On Travel it matches HGM\-C \(8484vs\.8383composite, matching case accuracy\) and on Shopping it exceeds it \(\+3\+3match,\+9\+9case accuracy\)\. Finally, to assess any potential over\-fitting of SBCO to training samples, we compare SBCO’s performance of the final harness on on the training and validation splits and compute the train\-validation gap\. Across both domains the train–validation gap is negligible or favors validation — Travel 84\.3 \(training\) vs\. 83\.9 \(validation\) and Shopping 93\.7 \(training\) vs\. 94\.8 \(validation\) — indicating SBCO does not over\-fit to the data it selects on\. Finally, because self\-improving methods learn an improved policy, we incur a cost of increased average latency for plan generation as is expected compared to the baseline\.

Table 1:SBCO matches or exceeds HGM\-C at44–5\.5×5\.5\\timeslower budget; the naive self\-modifier barely improves at8×8\\timesthe budget\. Budget==number of plans generated in optimization phase\. Quality is composite score \(Travel\) / match score \(Shopping\) on a0–100100scale \(scores rounded to22significant digits\); higher is better for all columns except Latency and Budget, where lower is better\.Bold==best among methods\.#### Generalization to weaker models

Having empirically demonstrated that SBCO matches the quality frontier of strong baselines \(and even outperforms in some cases\) at a fraction of the compute budget, we now shift gears to assess the generalization of SBCO to a weaker model in two settings: \(a\) Policy Transfer – Do the verifiers and learned policy learned on a model transfer to a different model \(potentially weaker\)? \(b\) Does SBCO also help with a different weaker LLM used as the backbone when it is optimized from scratch?\.

To assess policy transfer, we consider the Travel task and use the best policy and verifiers obtained with GPT\-5\.4\-mini as the backbone task\-agent LLM and use them*as is*on a task\-agent powered by Mistral model, the results of which we show in Table[2](https://arxiv.org/html/2608.10157#S5.T2)\. Note that indeed we are able to still lift the performance of the weaker agent suggesting that our learned verifiers and policy do not overfit to the underlying back\-bone LLM\.

To assess whether SBCO itself generalizes to task\-agents with different back\-bone LLMs, we instantiate a travel agent with Mistral as the backbone LLM and optimize the harness from scratch, the results of which are presented in Table[3](https://arxiv.org/html/2608.10157#S5.T3)\. We note that Mistral is a substantially weaker planner \(baseline composite32\.232\.2vs\. GPT’s76\.576\.5\)\. SBCO nonetheless lifts it by\+9\.6\+9\.6composite \(Table[3](https://arxiv.org/html/2608.10157#S5.T3)\), comparable to the\+9\.9\+9\.9obtained by transferring the GPT\-learned policy\. The absolute ceiling, however, remains bounded by the base agent: SBCO raises Mistral to41\.841\.8but cannot approach GPT’s84\.384\.3\. Verify\-and\-repair recovers violations the agent*can*fix once flagged; it does not elevate the base planning capability of the agent which is considerably weaker than GPT\-5\.4\-mini\. This experiment thus demonstrates the robustness of our learned verifiers, policy to different backbone LLMs of the task agent\.

Table 2:Cross\-model transfer: a learned policy \(where task agent was GPT\-5\.4\-mini\) applied as\-is to a Mistral task agent, showing policy and verifiers transfer to other backbone LLMs for the task agent\.Table 3:SBCO on a weaker task agent \(Travel\)\. SBCO run end\-to\-end against a weaker agent \(Mistral\) matches the lift of transferring a strong agent’s policy; the optimizer is identical in all rows, only the base agent differs\.

### 5\.2Qualitative Results and Analysis

We now turn to qualitatively analyzing the learned verifiers, policies to gain insights into functionality learned by the improved agents\.

#### Reliability of the learned verifiers

For both tasks, we observe that the learned verifiers are generally highly reliable with many verifiers having near\-perfect precision \(mean precision\>0\.97\>0\.97for both tasks\)\. Ranking verifiers by F1 within each domain reveals insights into which constraints are easy for SBCO to learn to verify and which constraints it still finds challenging\.

*Travel\.*From Table[4](https://arxiv.org/html/2608.10157#S5.T4)we observe that SBCO is very good at learning verifiers for constraints that involve matching on a specific attribute \(hotel rating\), a clear top ranking \(cheapest direct\) or a very clear mathematical constraint \(plan within budget\) However we note that it is still challenging to learn verifiers for constraints that involve geo\-proximity look\-up and slightly implicit constraints \(where there may be grader\-specific tolerances eg\.*closest*or*cheapest*restaurant near an attraction, reasonable transfer time\)\. We hypothesize that this is because the feedback signal in the evaluation log for these constraints is not rich enough – for eg\. what time buffer is deemed to be “reasonable in transfer time” or its challenging for the model to know how exactly to compute geo\-proximity for restaurants and near\-by attractions since this likely requires complex queries and ranking\. We also note that by class, personalized \(hard\) constraints fare slightly better than commonsense ones because most hard constraints typically involve clean lookups and rankings though we note the hard class appears to be bimodal, with the best*and*worst travel verifiers both belong to the hard class \(perfect lookups vs\. completely failed geo\-spatial checks\)\.

*Shopping\.*Similar conclusions hold for Shopping where SBCO is able to learn reliable verifiers for checking whether a attribute matches, or perform well\-defined combinatorial combination checks \(eg\. whether a required product filter \(color, brand, size, delivery time, rating, review count or threshold, sales volume\) is satisfied, all at precision1\.001\.00\(F1 up to1\.001\.00\)\. It also learns the combinatorial cheapest\-combination check \(F10\.830\.83\)\. It generally struggles on constraints that involve over\-inclusion where we note that the verifier over\-flags and does not meet the acceptance gates\.

Table 4:Travel: Top55best and worst learned verifiers by F1\.*Top*: 5 constraints F1==1\.00 \(local, decidable predicates\), spanning check types\.*Bottom*: the 5 lowest, clustering in geo\-spatial proximity \(F1≈\\approx0; no field encodes inter\-entity distance\) and derived\-quantity reasoning \(temporal windows\), and exhibiting all three error modes—no signal \(P==R==0\), low recall \(P==1\.00\), and over\-flagging \(low P\)\. Class: H==personalized hard, CS==commonsense\.Table 5:Shopping: best and worst verifiers by F1\.*Top*: missing\-required\-attribute checks \(*miss*\) and coupon presence, all at precision1\.001\.00\.*Bottom*: over\-inclusion \(*extra*\) checks, which fail on*precision*\(0\.140\.14–0\.530\.53\), plus two missing\-attribute checks that have low*recall*\. Kind: miss==missing required attribute, extra==over\-inclusion\.
#### Policy analysis of the improved agents\.

We analyze the improved policies of the task agent\. Broadly, we observed that the learned policies are not generic “re\-plan on failure” heuristics but repair strategies thar are adapted to the specific task and agent capability\.

*Travel*learns a gated, LLM\-replan\-centric pipeline with the following main components:

- •Tiered reliability gating\.It acts on hard verifiers only at precision≥0\.98\\geq 0\.98and on commonsense verifiers only at≥0\.999\\geq 0\.999, and only for four common sense constraints below: \(traceable\_accommodation,diverse\_attraction\_options,seamless\_intercity\_transfers,validated\_meals\); everything else is ignored\.
- •Three\-stage repair\.A deterministic code patch for one structural check \(blank the final\-day accommodation fortraceable\_accommodation\) which can be done very reliably in code; then a*single batched*LLM replan that lists all trusted\-hard failures*and*the passing checks to preserve, instructing the agent to copy exact literals verbatim \(names, flight/train numbers, dates\); then a narrow commonsense re\-plan only if no hard failures remain\.
- •Conservative verify\-and\-accept\.Every repair re\-runs the verifiers and is kept only if it*strictly*reduces the trusted\-fail set with no regression, otherwise it reverts to the pre\-repair plan \(with at most two replans\)\.

*Shopping*– In contrast with Travel where the replan strategy was mainly accomplished by calling an LLM, for Shopping the repair\-policy is code\-application\-dominant and has the following main components:

- •Near Deterministic Plan Repair via CodeBecause many of the verifiers in order to verify the constraint end also end up knowing what the correct products are \(as a side\-effect\), the policy prefers to use that information, but crucially realizes that it is possible to make changes to the cart reliably using code avoiding LLM calls for the most part\. So the policy is near\-deterministic and uses code to modify the LLM generated cart\.
- •Append to cart, do not remove existing products in cart\.The policy only adds missing products/coupons and chooses to not delete existing ones\. This highlights a potential issue with the standard reward function for Shopping\. Based on definition of the match score and observing that extra items do not affect the match score, the optimizer realized that the reward essentially is a recall\-only metric where the final reward does not penalize extra items\. It uncovers this potential “hole” and and uses this to maximize the reward\. That said, note that this “gap” was uncovered by the optimization agent itself and reveals the need for better reward metrics for that benchmark\.
- •Try an LLM replan after code\-check repair if neededFor failures remaining after the code append, it issues at most two grouped replans \(failures grouped by sub\-query, exact ids named, “preserve all existing, add cheapest valid missing”\), then re\-merges the returned cart in code and runs a deterministic append pass\.

#### Error Analysis

Finally, we conduct a error analysis of our deployed policy to identify what are the top drivers of the improvement in task performance and identify what error classes are still challenging\. Comparing the deployed policy to the baseline agent on the gold grader shows that the errors SBCO fixes are precisely those it can verify reliably\.

For Travel, the largest per\-constraint gains over baseline come from a handful of banked, high\-precision verifiers \(we compute fix and false\-repair counts averaged across two evaluation runs and rounded; a “fix” is a single constraint flipping fail→\\topass within a task, not a fully solved instance\)\. The policy yielded the greatest improvement forseamless intercity transfers\(6 fixes, 1 false repair, net gain\+5\+5\),hotel star service requiredandtrain departure time range\(4 fixes, net gain\+4\+4each\), anddiverse attraction options\(3 fixes, net gain≈\+2\{\\approx\}\{\+\}2\)\. Whilereasonable transfer time, cost calculation correctnessremain among the top dominant errors still persisting, we saw marginal gains on these as a side effect where fixing a different constraint incidentally corrects these \(net gain≈\+2\{\\approx\}\{\+\}2and\+1\+1respectively\)\.

On Shopping, SBCO lifts the score from0\.8280\.828to0\.9400\.940\(\+0\.112\+0\.112\), but the gain is uneven across difficulty levels\. Most of it comes from L1 and L2: adding missing single\-attribute products \(L1,\+0\.096\+0\.096\) and repairing cheapest\-within\-budget combinations \(L2,\+0\.154\+0\.154—the largest per\-level gain\), both of which SBCO verifies and repairs reliably\. L3 improves least \(\+0\.045\+0\.045\) because it requires coupon\-stacking optimization, for which SBCO does not learn a reliable verifier; its gains are therefore limited here on this level\.

## 6Limitations

Although we have demonstrated the effectiveness of SBCO empirically both quantitatively and qualitatively, our work is not without limitations\. First, we focus and evaluate on two constraint\-based planning domains\. Whether SBCO’s advantages extend to domains without explicit, checkable constraints—or to tasks where verification is as hard as solving—remains open\. Second, like all training free methods, the gains offered by our method will be limited by the power of the base LLM\. Finally, SBCO improves a harness with a*fixed*meta agent; it does not have meta\-cognitive abilitiies like that of\(Zhanget al\.[2026b](https://arxiv.org/html/2608.10157#bib.bib13)\)\. Extending the loop to enable meta\-cognitive abilities is left to future work\.

## 7Conclusion

We introducedSBCO, a self\-improving, verifier\-grounded harness optimizer for planning agents\. Where the Gödel\-machine lineage achieves self\-improvement through evolutionary search which is computationally expensive, SBCO offers a cheaper alternative for long horizon planning tasks with constraints\. SBCO learns a bank of decomposed verifiers and a repair policy, optimized by a*fixed*meta agent via approximate block coordinate ascent with textual gradients\. It thus belongs to the same closed\-loop, improve\-from\-experience family as those methods, but is self\-supervised rather than self\-referential\. On two constraint\-based planning domains, SBCO matches or exceeds a customized Gödel Machine baseline while using44–5\.5×5\.5\\timesless compute\.

Our analysis shows that SBCO improves precisely the constraints it can verify reliably\. It learns near\-perfect, precision\-heavy verifiers for constraints that reduce to*local, decidable predicates*\(attribute lookups, thresholds, presence checks, single\-objective rankings\) and abstains rather than mislead on constraints that require a*derived*signal \(eg\. geo\-distance\)\. These observations suggest that for constraint\-based planning, the bottleneck is the*structure of the improvement signal*: decomposed, correctness\-grounded verification is a far cheaper route to comparable or better quality than expensive self\-modification or metacognitive search222GenAI was used for editing and polishing the paper\.\.

## References

- D\. Arora and S\. Kambhampati \(2023\)Learning and leveraging verifiers to improve planning capabilities of pre\-trained language models\.arXiv preprint arXiv:2305\.17077\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- C\. Fernando, D\. Banarse, H\. Michalewski, S\. Osindero, and T\. Rocktäschel \(2023\)Promptbreeder: self\-referential self\-improvement via prompt evolution\.arXiv preprint arXiv:2309\.16797\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p1.1)\.
- S\. Hu, C\. Lu, and J\. Clune \(2025\)Automated design of agentic systems\.InInternational Conference on Learning Representations,Vol\.2025,pp\. 21344–21377\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px2.p1.1)\.
- M\. Khalifa, R\. Agarwal, L\. Logeswaran, J\. Kim, H\. Peng, M\. Lee, H\. Lee, and L\. Wang \(2025\)Process reward models that think\.arXiv preprint arXiv:2504\.16828\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- Y\. Lee, R\. Nair, Q\. Zhang, K\. Lee, O\. Khattab, and C\. Finn \(2026\)Meta\-harness: end\-to\-end optimization of model harnesses\.arXiv preprint arXiv:2603\.28052\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- X\. Lou, M\. Lázaro\-Gredilla, A\. Dedieu, C\. Wendelken, W\. Lehrach, and K\. P\. Murphy \(2026\)Autoharness: improving llm agents by automatically synthesizing a code harness\.arXiv preprint arXiv:2603\.03329\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- A\. Madaan, N\. Tandon, P\. Gupta, S\. Hallinan, L\. Gao, S\. Wiegreffe, U\. Alon, N\. Dziri, S\. Prabhumoye, Y\. Yang,et al\.\(2023\)Self\-refine: iterative refinement with self\-feedback\.Advances in neural information processing systems36,pp\. 46534–46594\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- J\. Ni, Y\. Liu, X\. Liu, Y\. Sun, M\. Zhou, P\. Cheng, D\. Wang, E\. Zhao, X\. Jiang, and G\. Jiang \(2026\)Trace2skill: distill trajectory\-local lessons into transferable agent skills\.arXiv preprint arXiv:2603\.25158\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- A\. Novikov, N\. Vũ, M\. Eisenberger, E\. Dupont, P\. Huang, A\. Z\. Wagner, S\. Shirobokov, B\. Kozlovskii, F\. J\. Ruiz, A\. Mehrabian,et al\.\(2025\)Alphaevolve: a coding agent for scientific and algorithmic discovery\.arXiv preprint arXiv:2506\.13131\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- P\. Pezeshkpour and E\. Hruschka \(2026\)AutoPyVerifier: learning compact executable verifiers for large language model outputs\.arXiv preprint arXiv:2604\.22937\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- M\. Pronesti, A\. Belz, and Y\. Hou \(2026\)Beyond outcome verification: verifiable process reward models for structured reasoning\.InFindings of the Association for Computational Linguistics: ACL 2026,pp\. 32187–32202\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- A\. Setlur, C\. Nagpal, A\. Fisch, X\. Geng, J\. Eisenstein, R\. Agarwal, A\. Agarwal, J\. Berant, and A\. Kumar \(2025\)Rewarding progress: scaling automated process verifiers for llm reasoning\.InInternational Conference on Learning Representations,Vol\.2025,pp\. 60808–60838\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- W\. Wang, P\. Piękos, L\. Nanbo, F\. Laakom, Y\. Chen, M\. Ostaszewski, M\. Zhuge, and J\. Schmidhuber \(2025\)Huxley\-g\\\\backslash" odel machine: human\-level coding agent development by an approximation of the optimal self\-improving machine\.arXiv preprint arXiv:2510\.21614\.Cited by:[§1](https://arxiv.org/html/2608.10157#S1.p1.1),[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p1.1),[§4](https://arxiv.org/html/2608.10157#S4.SS0.SSS0.Px2.p1.1)\.
- M\. Yuksekgonul, F\. Bianchi, J\. Boen, S\. Liu, Z\. Huang, C\. Guestrin, and J\. Zou \(2024\)Textgrad: automatic" differentiation" via text\.arXiv preprint arXiv:2406\.07496\.Cited by:[§3\.3](https://arxiv.org/html/2608.10157#S3.SS3.p1.5)\.
- E\. Zelikman, E\. Lorch, L\. Mackey, and A\. T\. Kalai \(2023\)Self\-taught optimizer \(stop\): recursively self\-improving code generation\.arXiv preprint arXiv:2310\.02304\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p1.1)\.
- E\. Zelikman, Y\. Wu, J\. Mu, and N\. Goodman \(2022\)Star: bootstrapping reasoning with reasoning\.Advances in Neural Information Processing Systems35,pp\. 15476–15488\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px3.p1.1)\.
- H\. Zhang, S\. Zhang, K\. Li, C\. Zhang, Y\. Chen, Y\. Zhang, L\. Bai, and S\. Hu \(2026a\)Self\-harness: harnesses that improve themselves\.arXiv preprint arXiv:2606\.09498\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p1.1)\.
- J\. Zhang, S\. Hu, C\. Lu, R\. Lange, and J\. Clune \(2025a\)Darwin godel machine: open\-ended evolution of self\-improving agents\.arXiv preprint arXiv:2505\.22954\.Cited by:[§1](https://arxiv.org/html/2608.10157#S1.p1.1),[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p1.1),[§4](https://arxiv.org/html/2608.10157#S4.SS0.SSS0.Px2.p1.1)\.
- J\. Zhang, B\. Zhao, W\. Yang, J\. Foerster, J\. Clune, M\. Jiang, S\. Devlin, and T\. Shavrina \(2026b\)Hyperagents\.arXiv preprint arXiv:2603\.19461\.Cited by:[§1](https://arxiv.org/html/2608.10157#S1.p1.1),[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px1.p2.1),[§4](https://arxiv.org/html/2608.10157#S4.SS0.SSS0.Px2.p1.1),[§6](https://arxiv.org/html/2608.10157#S6.p1.1)\.
- J\. Zhang, J\. Xiang, Z\. Yu, F\. Teng, X\. Chen, J\. Chen, M\. Zhuge, X\. Cheng, S\. Hong, J\. Wang,et al\.\(2025b\)Aflow: automating agentic workflow generation\.InInternational Conference on Learning Representations,Vol\.2025,pp\. 34040–34077\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px2.p1.1)\.
- J\. Zhang, Z\. Fu, Z\. Xi, W\. Jing, M\. Chai, W\. He, G\. Zhang, C\. Fan, C\. An, W\. Chen,et al\.\(2026c\)AgentV\-rl: scaling reward modeling with agentic verifier\.InFindings of the Association for Computational Linguistics: ACL 2026,pp\. 23078–23100\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- X\. Zhang, Y\. Cui, G\. Wang, W\. Qiu, Z\. Li, F\. Han, Y\. Huang, H\. Qiu, B\. Zhu, and P\. He \(2026d\)Verified multi\-agent orchestration: a plan\-execute\-verify\-replan framework for complex query resolution\.arXiv preprint arXiv:2603\.11445\.Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px4.p1.1)\.
- Y\. Zhang, S\. Jiang, R\. Li, J\. Tu, Y\. Su, L\. Deng, X\. Guo, C\. Lv, and J\. Lin \(2026e\)DeepPlanning: benchmarking long\-horizon agentic planning with verifiable constraints\.arXiv preprint arXiv:2601\.18137\.Cited by:[§4](https://arxiv.org/html/2608.10157#S4.SS0.SSS0.Px1.p1.1)\.
- H\. Zhou, X\. Wan, R\. Sun, H\. Palangi, S\. Iqbal, I\. Vulić, A\. Korhonen, and S\. Arik \(2026\)Multi\-agent design: optimizing agents with better prompts and topologies\.External Links:[Link](https://arxiv.org/pdf/2502.02533)Cited by:[§2](https://arxiv.org/html/2608.10157#S2.SS0.SSS0.Px2.p1.1)\.