Paper deep dive
Drafting Agents, Not Just Tokens: Speculative Recursive Self-Improvement for Agentic Systems
Xin Xu, Ke Cheng, Hao Wang, Yangru Huang, Yanghao Xiao, Zhichao Chen, Zhisheng Zhong, Xun Liu, Yi Li, Qian Li, Haibin Lv, Jun Zhang, Jie Jiang, Zhouchen Lin
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Improving an agent through successive revisions requires balancing exploration and evaluation under a limited budget. A narrow search can miss useful sequences of edits, while fully evaluating every intermediate version can exhaust the budget before those sequences yield a verified improvement. We introduce Speculative Recursive Self-Improvement (SpecRSI), which drafts executable successor agents before their predecessors are fully evaluated, while requiring complete verification before adoption. Verification-Aware Tree Search (VATS) allocates the budget between further edits and outstanding checks using the predicted verified return of a continuation. Group Verification Optimization (GVO) learns the improver from completed searches while keeping the real evaluator fixed. In the main scientific comparison, terminal gains exceed Janus by 33.3%--40.0%. Additional evaluations show that SpecRSI outperforms Janus in all 50 scientific backbone--task pairs and exceeds MetaRSI-v1 by 1.85%--2.38% in macro-average system score across twenty backbones. Coding-validation success reaches 69.4% versus HGM's 64.3% at a 20.8% lower target-cost index.
Tags
Links
- Source: https://arxiv.org/abs/2610.16491v1
- Canonical: https://arxiv.org/abs/2610.16491v1
Trouble viewing inline? Open PDF directly →
Full Text
154,059 characters extracted from source content.
Expand or collapse full text
Drafting Agents, Not Just Tokens: Speculative Recursive Self-Improvement for Agentic Systems Xin Xu Ke Cheng Hao Wang Yangru Huang Yanghao Xiao Zhichao Chen Zhisheng Zhong Xun Liu Yi Li Qian Li Haibin Lv Jun Zhang Jie Jiang Zhouchen Lin Abstract Improving an agent through successive revisions requires balancing exploration and evaluation under a limited budget. A narrow search can miss useful sequences of edits, while fully evaluating every intermediate version can exhaust the budget before those sequences yield a verified improvement. We introduce Speculative Recursive Self-Improvement (SpecRSI), which drafts executable successor agents before their predecessors are fully evaluated, while requiring complete verification before adoption. Verification-Aware Tree Search (VATS) allocates the budget between further edits and outstanding checks using the predicted verified return of a continuation. Group Verification Optimization (GVO) learns the improver from completed searches while keeping the real evaluator fixed. In the main scientific comparison, terminal gains exceed Janus by 33.3%–40.0%. Additional evaluations show that SpecRSI outperforms Janus in all 50 scientific backbone–task pairs and exceeds MetaRSI-v1 by 1.85%–2.38% in macro-average system score across twenty backbones. Coding-validation success reaches 69.4% versus HGM’s 64.3% at a 20.8% lower target-cost index. Drafting Agents, Not Just Tokens: Speculative Recursive Self-Improvement for Agentic Systems Xin Xu1,4,† , Ke Cheng1,6,† , Hao Wang2,† , Yangru Huang1,† , Yanghao Xiao3,† , Zhichao Chen4,† , Zhisheng Zhong5, Xun Liu1, Yi Li1, Qian Li1, Haibin Lv1, Jun Zhang1,*, Jie Jiang1, Zhouchen Lin4,* 1Tencent AMS, Beijing, China; 2Xiaohongshu; 3University of Chinese Academy of Sciences; 4State Key Laboratory of General Artificial Intelligence, School of Intelligence Science and Technology, Peking University, Beijing, China; 5Tencent Hunyuan; 6CCSE lab, Beihang University. † contribution. *Corresponding authors. Contact: pkushinnxu@tencent.com, neoxzhang@tencent.com, zlin@pku.edu.cn. Code: https://github.com/SpecRSI-GPR/SpecRSI. 1 Introduction Agent systems can be improved through successive revisions to their prompts, tools, and workflows. Each round proposes executable changes and then evaluates whether they improve task performance, and both consume time and computation. This raises a central question: how should an agent allocate its limited budget between exploring new revisions and verifying their benefits? Successful revisions can make later ones easier, but the evaluations that identify them are often far more expensive than proposing another edit (Zhang et al., 2026a; Wang et al., 2026b; Liu et al., 2026). The difficulty is not a shortage of candidates. It is turning exploration into verified progress before time or computation runs out. Two limiting strategies expose the tradeoff. Following one fully evaluated lineage gives every decision fresh feedback, but it narrows the alternatives and inserts an evaluation barrier between dependent edits. Maintaining many lineages explores more, but fully evaluating them all buys evidence for branches that may never be used. Extra workers cut elapsed time without making the work free, and under a fixed budget a wider search need not leave enough computation to finish the most useful branch. The barrier, not the shortage of ideas, is what stalls progress: can we draft successors ahead of their parents’ full evaluation, yet still spend verification only where it pays? For example, one coding-agent revision adds a file–test map; a successor uses it for focused intermediate retesting while retaining the final full suite. Prior systems relax part of this by separating expansion from evaluation or validating in parallel (Wang et al., 2026b; Liu et al., 2026; Hu et al., 2026b). Here we focus on jointly selecting further revisions and bundles of outstanding checks under the remaining budget. Once successors can be drafted ahead, where should we spend the budget next? A candidate that looks strong may still need several checks before it can be adopted, while a child that repairs an unhelpful parent may need only one remaining check. A scorer that only asks How good does this version look?” therefore misses the cost of making it usable. What governs the budget is not a candidate but a continuation, a sequence of further edits and checks from the current state, and the operative question becomes What verified improvement can this continuation still deliver with the remaining budget?” This quantity must be estimated before the checks that would reveal it are paid, and a wrong estimate wastes irreversible budget; this pre-verification estimate under a hard budget, not the drafting of successors, is what makes the problem hard. It shifts the scoring target from candidate quality to the marginal verified return of further editing and checking. (a) Single-path RSI (b) Parallel branches (c) Speculative RSI (ours) (d) Greedy decoding (e) Beam search (f) Speculative decoding Figure 1: Explore ahead, verify before adoption. Agent patterns (a–c) and their token-level counterparts (d–f). Agent checks are external and paid; only the adopted version needs complete, admissible evidence. However, the drafting–confirmation idea cannot be transferred unchanged from tokens to agent revisions. (1) Revisions are revisable programs, not accepted prefixes. A successor may repair or build on a parent that is not yet admissible. (2) Verification consists of paid, complementary checks. External evaluations are not supplied by one target-model pass: checks have heterogeneous costs and dependencies, and several may be jointly required for adoption. (3) Progress is verified improvement under a budget. Search outcomes depend on realized gains and all incurred costs, including failed and unfinished work, rather than proposal or acceptance counts. We propose SpecRSI with the following contributions: • A Two-Level Framework for Speculative Self-Improvement. To address (1), inner loop searches extend incompletely evaluated versions but adopt only fully evaluated, admissible ones. The improver remains frozen within each search and learns from complete-search feedback between rounds. • Verification-Aware Tree Search (VATS). To address (2), the Solver preserves affordable completion bundles, including individually low-value checks; the Scorer predicts verified gains from further edits and checks, net of subsequent costs; and the Policy selects the next draft or verification plan under the remaining budget. • Group Verification Optimization (GVO). To address (3), GVO uses independent complete searches from the same start as its unit of credit. Verified gains minus all search costs provide delayed credit to sampled edits and work choices, training the Drafter and Policy. Realized suffix returns and paid same-state comparisons train the Scorer. 2 Preliminaries and Related Work 2.1 Recursive Self-Improvement An agent version c comprises executable code and persistent prompts, tools, and workflows. Recursive self-improvement (RSI) revises these artifacts to support later improvement rounds. With retained versions tV_t and evaluation history HtH_t, an improver ProposeΘtPropose_ _t selects and revises a version: c~t∼ProposeΘt(⋅∣t,Ht),zt=freal(c~t),(t+1,Ht+1)=Update(t,Ht,c~t,zt), gathered c_t _ _t(· _t,H_t), z_t=f_ real( c_t),\\ (V_t+1,H_t+1)=Update(V_t,H_t, c_t,z_t), gathered (1) where update records observed feedback ztz_t; a useful stepping stone need not immediately outperform the incumbent. Existing methods search over agents, workflows, or prompts (Zhang et al., 2026a; Robeyns et al., 2025; Hu et al., 2025; Zhang et al., 2025b; Agrawal et al., 2026). HGM separates expansion from evaluation (Wang et al., 2026b), while Hyperagents and MetaRSI adapt improvement generation or scheduling (Zhang et al., 2026b; Tan et al., 2026). 2.2 Evaluators and Verified Improvement Following Janus (Liu et al., 2026), frealf_ real executes the task’s assessment, returning higher-is-better utility J(c)∈ℝJ(c) and validity flag v(c)∈0,1v(c)∈\0,1\ for constraint satisfaction. After n real-evaluation attempts, the best observed valid candidate satisfies freal(c)=(J(c),v(c)),cn⋆∈argmax(c,J,v)∈Hn:v=1J,f_ real(c)=(J(c),v(c)), c_n ∈ *arg\,max_(c,J,v)∈ H_n:\,v=1J, (2) where n counts attempts, not computation or monetary cost. A proxy evaluator cheaply prioritizes real evaluations; Janus admits only real-valid candidates to its population or incumbent. SpecRSI preserves this separation between prediction and validation, but allocates individual checks and scores further edits and checks by their eventual verified return. Section 3.2 defines its state and evidence; Appendix A provides extended comparisons. 3 Method 3.1 Motivation (a) Target-cost index (b) Macro-average score Figure 2: Performance across ten backbones. Target-cost indices and macro-average scores on Terminal-Bench 2.1 (TB2.1), SWE-Pro, GPQA-hard100, and AIME (mean ± 1.0 × sample SD across five training seeds). Panels follow Initial Agent means; lines connect model categories. On all ten backbones, SpecRSI scores higher than MetaRSI-v1 at lower target cost but 0.83–0.90% higher total-cost indices. Accurate benefit evaluation is central to guiding RSI toward better agents. It informs which revisions and checks deserve further work, guiding the direction of improvement. Inaccurate evaluation can overlook useful revisions or waste resources on candidates that cannot be adopted. Therefore, evaluation should reflect the verified improvement that further work can deliver. However, accurate benefit evaluation is non-trivial: a candidate’s current quality does not determine the value of continuing from it. This difficulty stems from two key challenges. 1 Benefit evaluation should reflect downstream verified improvement. Intermediate revisions may enable later gains, but establishing them requires subsequent edits and real checks. 2 Benefit evaluation should account for completion costs. Complementary checks, planning, and failed attempts consume the same limited budget; even promising gains may be unaffordable to verify. Together, these challenges create a performance–cost trade-off: a useful continuation must promise sufficient verified improvement while remaining affordable to complete. Figure 2 illustrates the resulting trade-off empirically. 3.2 Two-level Speculative RSI Loop (a) Two-level Speculative RSI Loop (b) Verification-Aware Tree Search (VATS) (c) Group Verification Optimization (GVO) Figure 3: Two-level Speculative RSI Loop. VATS allocates drafts and checks under a frozen improver; Accept returns the best complete admissible version. GVO updates the improver between searches; Γ stays fixed. SpecRSI tracks individual evaluation checks. A complete admissible root r anchors tree =(,)T=(C,A) of immutable agent versions and executed edit edges. Versions freeze prompts, tools, workflows, and permitted persistent state, including memory; only D/H/M permits model-parameter edits. The uneditable verification contract Γ specifies finite required-item set ℐI, execution/admission rules, constraints, and higher-is-better score JΓJ_ , instantiating task utility J. State S=(,ℰ,H,B,N,w)S=(T,E,H,B,N,w) records admitted evidence ℰE, history H, remaining expense B≥0B≥ 0, attempts N≥0N≥ 0, and workers w≥1w≥ 1. For version c and item i, mci∈0,1m_ci∈\0,1\ marks a valid outcome’s presence, not whether it passed. The complete admissible set and its best observed gain are full(S) _full(S) =c∈:mci=1∀i∈ℐ,c admissible under Γ, =\c :m_ci=1\ ∀ i ,\ c admissible under \, (3) F(S) F(S) =maxc∈full(S)[JΓ(c)−JΓ(r)], = _c _full(S)[J_ (c)-J_ (r)], where F is observed adoption-ready gain, not a learned value; the eligible root ensures F≥0F≥ 0. The fixed contract Γ and execution interface AcquireΓAcquire_ form the real evaluator: Γ specifies valid evidence; VERIFY invokes AcquireΓAcquire_ to run selected real checks. Complete admissible evidence determines JΓ(c)J_ (c) and ACCEPT eligibility. The learned Scorer Q^ϕ(S,ω) Q_φ(S,ω) is the score evaluator; it predicts expected verified gain net of subsequent expense and elapsed-time costs (Equation (6)), guiding expenditure without supplying evidence. DRAFT generates successor edits and assigns no evaluation score. At round k, ckc_k is the agent and Θk=(θk,ψk,ϕk,ν) _k=( _k, _k, _k,ν) the improver: drafter, work-selection policy, continuation-value scorer, and fixed menu settings. Collection freezes all four, with scorer snapshot ϕ¯k=ϕk φ_k= _k. Independent searches from the same root supply agents and logs for the outer update: (ck+1(g),k(g))=SearchΘk(ck),g=1,…,G (c_k+1^(g),D_k^(g))=Search_ _k(c_k), g=1,…,G (inner loop searches), (inner loop searches), (4) k=⋃g=1Gk(g),Θk+1=GVO(Θk,k) _k= _g=1^GD_k^(g), _k+1=GVO( _k,D_k) (outer loop update), (outer loop update), where G≥2G≥ 2 counts independent searches, not shared-tree leaves. Figure 3 connects VATS inner searches and GVO outer updates. Carry/reset selects the next root separately from within-search acceptance, isolating learning from artifact retention. Contract Γ and the outer update rule remain fixed (Appendix F.1). Table S1 in Appendix A compares roles with Janus (Liu et al., 2026): its proxies screen candidate programs; our Scorer values state–work pairs, including later edits and checks. 3.3 Inner-loop Search with VATS Verification-Aware Tree Search (VATS) selects bounded work ω: DRAFT(P,h) DRAFT(P,h) or VERIFY() VERIFY(J), where P=(Pa)a=1|P|P=(P_a)_a=1^|P| tags existing parents, h≥1h≥ 1 bounds edit depth, and J lists existing-version jobs. Expense and attempt caps are enforced. Either action may repeat; ACCEPT terminates search. Complementary checks require more than token-confidence ranking: Solver constructs completion options, Scorer refines scope, and Policy selects work (Algorithm 2). Execution updates state before replanning under the frozen improver (Algorithm 1, Appendix F). 3.3.1 Solver The Solver forms completion bundles that fit the remaining budget. Missing items are Uc(S)=i∈ℐ:mci=0U_c(S)=\i :m_ci=0\, and outstanding outcomes are Kc(S)=(c,i):i∈Uc(S)K_c(S)=\(c,i):i∈ U_c(S)\. The relation reader ℛ(S)=Remaining(S)R(S)=Remaining(S) reads masks, dependencies, shared setups, and source relations from existing records. It acquires no new outcomes; forecasts cannot fill missing evidence (Appendix F.2). Bundles cover selected missing-item sets even when individual checks have little value: Ωt=t∪VERIFY(A):A∈ℳt∪ACCEPT, _t=D_t∪\ VERIFY(A):A _t\∪\ ACCEPT\, (5) where draft plans tD_t use existing, possibly incomplete parents; ℳtM_t contains feasible verification bundles. A MILP covers selected KcK_c sets and cross-branch unions subject to prerequisites, shared setups, conflicts, and reserved budgets. Original completion seeds remain eligible during refinement. Feasibility guarantees neither successful outcomes nor exhaustive coverage. 3.3.2 Scorer The Scorer Q^ϕ(S,ω) Q_φ(S,ω) values state–work pairs under the frozen procedure π, including later edits, checks, and branch switches: Qπ(St,ω)=π[F(Send)−F(St)−λCt:end−μLt:end∣St,ω],Q^π(S_t,ω)=E_π\! [F(S_ end)-F(S_t)-λ C_t: end-μ L_t: end S_t,ω ], (6) where St−S_t^- precedes preparation; StS_t follows its payment; SendS_ end is terminal. Subsequent expense Ct:endC_t: end and elapsed time Lt:endL_t: end include later preparation and failures, excluding current sunk preparation. Fixed λ,μ≥0λ,μ≥ 0 convert costs to score units (μ=0μ=0 for cost-only evaluation). π includes edit generation and work selection with fixed menu rules. Predictions never replace observed F or evidence; Qπ(S,ACCEPT)=0Q^π(S, ACCEPT)=0. For feasible bundle A, let DjD_j contain job j and its prerequisites. The frozen snapshot Q^ϕ¯ Q_ φ refines bundles by Δϕ¯(j∣A,S~)=Q^ϕ¯(S~,VERIFY(A∪Dj))−Q^ϕ¯(S~,VERIFY(A)), _ φ(j A, S)= Q_ φ( S, VERIFY(A∪ D_j))- Q_ φ( S, VERIFY(A)), (7) where both terms use the same conservative state S~ S reserving the preparation cap. Whole-bundle comparisons preserve interactions without summing isolated check scores. Shared jobs/setups count once. Query and extension caps bound overhead, while original feasible seeds remain eligible (Appendix F.3). 3.3.3 Policy After paying preparation, the Policy samples from nonempty Ωt _t using observed relations ℛt=Remaining(St)R_t=Remaining(S_t): πψ(ω∣St,ℛt,Ωt)=(1−ϵ)exp(zψ(St,ℛt,ω)/Tpol)∑v∈Ωtexp(zψ(St,ℛt,v)/Tpol)+ϵ|Ωt|, _ψ(ω S_t,R_t, _t)=(1-ε) (z_ψ(S_t,R_t,ω)/T_ pol) _v∈ _t (z_ψ(S_t,R_t,v)/T_ pol)+ ε| _t|, (8) where preference logits zψz_ψ differ from value estimates: selection need not maximize Q Q, Tpol>0T_ pol>0, ϵ∈[0,1)ε∈[0,1), and the ACCEPT logit is zero. Collection samples; deployment maximizes logits (training supports: Appendix F.5). 3.3.4 Execution and Acceptance DRAFT. For draft plan (P,h)(P,h), the drafter starts at ca,0=Pac_a,0=P_a and samples using only context Ha,dH_a,d observed before editing: ea,d∼πθ(⋅∣ca,d−1,Ha,d),ca,d=Freeze(Apply(ca,d−1,ea,d)),d=1,…,h,e_a,d _θ(· c_a,d-1,H_a,d), c_a,d=Freeze(Apply(c_a,d-1,e_a,d)), d=1,…,h, (9) where ApplyApply executes the edit; FreezeFreeze saves its immutable result. Generateθ(P,h,S)Generate_θ(P,h,S) runs the bounded plan on actual artifacts: incomplete parents may expand, but each edit waits for its parent. Invalid edits are charged and end that path, preserving its valid prefix. VERIFY. For requested jobs Jobs(ω)Jobs(ω), AcquireΓAcquire_ reads valid identical records or executes real checks. The core is direct-only; checked reuse imports results after scoped equality checks through the backend shared with compatible controls. Forecasts never create evidence. VATS selects branches; the executor obtains records and updates state before replanning (Appendix F.4). Acquired records alone authorize adoption. ACCEPT. Records must satisfy identity, scope, fields, and provenance requirements, including when reporting failure. At termination, ACCEPT(S)=TieArgMaxc∈full(S)JΓ(c),ACCEPT(S)=TieArgMax_c _full(S)J_ (c), (10) where ties prefer the root only if tied for best, then use a fixed version order. Only the selected version needs complete admissible evidence. The reference rule adds no hidden completion/adoption margin. 3.4 Outer-loop Learning with GVO Group Verification Optimization (GVO) updates the learned components between search rounds while the verification contract stays fixed. Supervised warm-up initializes Drafter θ from executed legal edits, Policy ψ from legal plan choices, and Scorer ϕφ from observed returns, producing Θ0 _0. Unexecuted alternatives have no labels. Solver feasibility rules and menu settings ν are not learned. Solver outputs and environment results have no policy likelihood. The Scorer fits realized, undiscounted suffix returns from executed plan starts: Gt G_t =F(Send)−F(St)−λCt:end−μLt:end, =F(S_ end)-F(S_t)-λ C_t: end-μ L_t: end, (11) ℒQ(ϕ) _Q(φ) =(St,ωt,Gt)∼Q[(Q^ϕ(St,ωt)−Gt)2], =E_(S_t, _t,G_t) _Q [( Q_φ(S_t, _t)-G_t)^2 ], where QπQ^π is the conditional expectation of GtG_t. QD_Q records plan starts under the frozen procedure, including paid alternatives; current preparation is sunk, later preparation charged. For legal plans a,ba,b from the same saved paid state S, let G¯a,G¯b G_a, G_b be mean returns of paid repetitions under the same continuation policy: δ^ab=G¯a−G¯b,ℒpair(ϕ)=pair[(Q^ϕ(S,a)−Q^ϕ(S,b)−δ^ab)2]. δ_ab= G_a- G_b, _ pair(φ)=E_D_ pair [( Q_φ(S,a)- Q_φ(S,b)- δ_ab)^2 ]. (12) Regression anchors the mean (Gneiting, 2011). Difference-based training targets relative values (Bertsekas, 1997); here, pair differences alone leave the common offset undetermined. Both train one Scorer through ℒQ+βpairℒpairL_Q+ _ pairL_ pair, βpair≥0 _ pair≥ 0. Forced continuations train only the Scorer, never actor likelihood; copies and rollout costs remain charged. Collect G≥2G≥ 2 independent searches from S0−S_0^- under frozen Θk _k, matching root, contract, budgets, and workers. “Complete” means terminated with output and costs recorded, not every visited version fully evaluated. Expense CgC_g and elapsed time LgL_g charge initial preparation and failed or unfinished work: Rg=F(Sendg)−F(S0−)−λCg−μLg,Ag=Rg−1G−1∑u=1u≠gGRu.R_g=F(S_ end^g)-F(S_0^-)-λ C_g-μ L_g, A_g=R_g- 1G-1 _ subarraycu=1\\ u≠ g subarray^GR_u. (13) No new complete improvement earns no gain, but costs remain charged. Intermediate edits receive delayed credit through verified descendants without themselves qualifying for adoption. AgA_g compares whole searches, without a learned baseline. Only sampled edit tokens and plan choices update θ,ψθ,ψ through the clipped objective (Equation (20); Schulman et al., 2017; Ahmadian et al., 2024). After collection, GVO updates Θk+1 _k+1 and freezes it for the next round. Actor updates change the continuation law, requiring fresh searches to recalibrate the Scorer (Algorithm 3). These updates guarantee neither per-edit causal attribution nor monotonic improvement; Γ remains unchanged. 4 Experimental Results 4.1 Evaluation setup. Tasks, models, and baselines. We evaluate five scientific domains (PyBaMM, AQM, FDTD, Reactor, and IRP), four system tasks (Terminal-Bench 2.1 (TB2.1), SWE-Pro, GPQA-hard100, and AIME), and separate coding, prompt, and workflow profiles. Qwen3.5-35B-A3B serves as the reference backbone for mechanism studies and the primary matched system comparison. For cross-backbone evaluation on the scientific domains, we additionally test GPT-6-Astra, Claude-Opus-5, Gemini-3.5-Flash, DeepSeek-V4-Pro, GLM-5.3, Kimi-K3, MiniMax-M3, GPT-5.6-Sol, Claude-Sonnet-5-1M, and GPT-5.5, covering 50 backbone–task pairs in total. We further evaluate the four system tasks across twenty model backbones to test whether the observed gains persist across different starting models. Baselines include Janus, HGM, MetaRSI, FlashEvolve, and task-specific optimizers (Liu et al., 2026; Wang et al., 2026b; Tan et al., 2026; Hu et al., 2026b). D/H/M permits data, harness, and model edits, whereas D+H excludes model edits. Comparisons remain within matched permission bands; SpecRSI uses direct checks. Measurements. Scientific gain and call-axis AUBC retain native units; task scores use percentages, absolute gains percentage points (p). Target-cost, training-cost, and lifecycle indices are not pooled. Validation normally uses five training seeds with three nested searches each. Reproducibility. The reference reproduction configuration uses official BF16 Qwen3.5-35B-A3B with a frozen text backbone and rank-16 Drafter LoRA. SFT uses AdamW (2×10−52× 10^-5; component minibatch 1; one epoch); GVO uses two frozen collection/update rounds (group 3; actor/Scorer SGD rates 10−3/5×10−410^-3/5× 10^-4; at most one joint update per complete collection). Training uses 2,048-token sequences and one H20 per scientific domain; a separate H20 serves 32,768-token inference. Other evaluated backbones use provider APIs. The repository specifies 14 versioned data pools and 42 exact member lists, model/checkpoint identities, simulator parameters, seeds, and separate training/serving software versions. 4.2 Overall Performance RQ1: Does SpecRSI produce better successors within comparable evaluation settings? Scientific progress. SpecRSI leads terminal gain and call-axis AUBC in all five domains (Table 1A), exceeding Janus by 33.3%–40.0% and 30.4%–33.7%, respectively. Scientific cost indices are 158.7 versus 148.1; call-budget efficiency and lifecycle expense are distinct quantities. System performance. Under matched D/H/M access, gains over MetaRSI-v1 are 1.6–2.9 p (Table 1B). Matching D+H access retains a 2.20 p average advantage, versus 2.25 p with D/H/M, showing that the gains persist without model-weight updates. Table 1: Performance across scientific discovery and agent improvement. A: terminal gain (upper entry) and call-axis AUBC (lower entry), in native units. B: task scores (%) within matched edit permissions. Entries show mean ±1.0×± 1.0× SD; B uses SD. Bold denotes the highest mean within each comparable group. A Scientific gain / AUBC Method PyBaMM AQM FDTD Reactor IRP Alg.-Only 0.12±0.01 [2pt]7.3±0.4 0.09±0.01 [2pt]5.1±0.3 0.14±0.01 [2pt]8.5±0.5 0.11±0.01 [2pt]6.7±0.3 0.10±0.01 [2pt]5.8±0.2 Direct-LLM 0.21±0.01 [2pt]19.2±0.6 0.17±0.01 [2pt]14.3±0.5 0.24±0.02 [2pt]22.6±0.7 0.19±0.01 [2pt]16.2±0.4 0.18±0.01 [2pt]13.7±0.4 Embed-GP 0.30±0.02 [2pt]30.5±0.8 0.25±0.01 [2pt]24.8±0.7 0.33±0.02 [2pt]36.2±0.9 0.27±0.01 [2pt]27.4±0.6 0.25±0.01 [2pt]23.1±0.5 Janus 0.36±0.02 [2pt]42.8±1.0 0.30±0.02 [2pt]34.7±0.8 0.39±0.02 [2pt]51.3±1.1 0.32±0.02 [2pt]36.9±0.8 0.30±0.01 [2pt]31.5±0.7 SpecRSI (ours) 0.48±0.02 [2pt]56.7±1.2 0.41±0.02 [2pt]45.8±1.0 0.52±0.02 [2pt]66.9±1.3 0.44±0.02 [2pt]49.3±1.0 0.42±0.02 [2pt]42.1±0.9 B System scores (%, ↑ ) Method TB2.1 SWE-Pro GPQA AIME D/H/M: data, harness, model Initial 23.6±0.7 10.3±0.5 71.2±0.8 55.0±0.6 Data-RSI 27.4±0.8 12.4±0.6 73.8±0.9 57.7±0.7 Harness-RSI 29.4±0.9 14.9±0.7 78.8±1.0 63.3±0.8 Model-RSI 27.0±0.8 14.0±0.6 75.4±0.9 59.3±0.7 Fixed D→ → 30.3±0.9 15.3±0.7 79.4±1.0 64.3±0.8 Static router 30.8±1.0 14.9±0.7 79.6±1.1 64.0±0.9 MetaRSI-v1 31.9±1.0 19.5±0.8 83.8±1.1 68.3±0.9 SpecRSI (ours) 33.5±1.1 21.7±0.9 86.1±1.2 71.2±1.0 D+H: no model update MetaRSI-H 28.7±0.8 14.2±0.6 77.5±0.9 61.8±0.7 SpecRSI-H (ours) 30.1±0.9 16.3±0.7 79.9±1.0 64.7±0.8 Backbone consistency. Figure 2 and Figure S2(a) use the same ten backbones for system and scientific evaluation, respectively; Figure S2(b) covers twenty system backbones, including the reference model. Across all 50 scientific backbone–task pairs, terminal-gain and AUBC uplifts over Janus are 17.8%–27.6% and 15.7%–19.8%. SpecRSI exceeds MetaRSI-v1 on every system backbone by 1.85–2.38 p in four-task macro-average score. Five-seed summaries cover weaker and stronger starting agents in the tested set. Code, prompt, and workflow. SWE-Pro coding validation gives direct-check SpecRSI 69.4±1.2%69.4± 1.2\% versus HGM’s 64.3±1.1%64.3± 1.1\%, with target-cost indices 60.8 versus 76.8 (20.8% lower; Figure S3 in Appendix B.4). Separate profiles give GPQA-hard100 scores of 82.4% versus GEPA+Merge’s 78.5%, and PlanBench success of 67.8% versus EMAS’s 62.7%, with 9,290 versus 10,210 task-inference tokens. Starting agents and costs remain profile-specific; full comparisons and the separate frozen audit are in Appendix B. 4.3 Verification-Aware Search RQ2: Does verification allocation help beyond more information or exploration? Work scope. At fixed full-state information, bundles raise gain from 4.8 to 6.3 p, lower cost from 63.1 to 59.2, and reduce completion failure from 9.8% to 6.5% (Figure 4a; Table S9 in Appendix C.1). Planning ablations. Across eight budget caps from 10% to 150%, full SpecRSI has the highest reported mean gain and lowest total-cost index of seven conditions (Figure 4b,c). At 70%, full versus additive planning raises gain from 4.73±0.294.73± 0.29 to 5.99±0.405.99± 0.40 p: planning takes 201 versus 141 ms, but total cost falls from 65.1 to 58.9. Removing completion seeds reduces gain by 0.77–1.79 p across the reported paired-difference sweep (Figure S4). Appendix C further separates the effects of evidence quality and work scope, showing that the gain is not explained by simply executing more or deeper work. Appendix G.5 provides an exact matched-scope analysis showing how bundled verification can reduce dispatch cost under fixed information. (a) Verification scope (b) Verified gain (c) Total cost Figure 4: Verification scope and planning ablations. (a) Gain versus total-cost index for one check or bundles at fixed Summary or Full-state information; bars show reported SD. (b) Verified gain and (c) total-cost index across eight budget caps. In (b), means average five reported seed means; SD averages within-seed SDs. Lines join means; bands/bars show ±1± 1 SD. 4.4 Improver Learning RQ3: Is improvement learned by the improver, or merely retained in a stronger task agent? Artifact controls. Improver updates raise reset/carry gains from 4.1±0.184.1± 0.18 to 5.2±0.215.2± 0.21 p and from 4.8 to 6.2 p, respectively. Original/updated improvers yield 5.7/6.9 p from the same released artifact (Table 2(a)), , showing gains beyond simply retaining a stronger task agent. Roles and supervision. Scorer-only updates yield science/code/agent gains of 5.2/5.4/5.3 p, versus 4.7/4.9/4.8 for the drafter and 5.0/5.2/5.1 for the policy. Joint updates are stronger with unequal training costs (Table 2(b)). Adding pair loss to the reported same acquired arms raises gain from 5.4±0.235.4± 0.23 to 6.3±0.256.3± 0.25 p and lowers RMSE from 1.05 to 0.85, while training cost rises from 23.7 to 28.4. Repeated rounds. Updated SpecRSI reaches 21.7 p by round 5, exceeding updated Meta by 3.9 p (17.8 p) and original-improver SpecRSI by 7.9 p (13.8 p; Table 2(c)). All reported rounds continue to yield positive incremental gains, from 8.5 p in round 2 to 2.1 p in round 5. Table 2: Learning the improver. Gains (p). (a) Reported uncertainty; compare within each starting condition. (b) Updated roles: D, drafter; Sc, scorer; P, policy; Sh, shared backbone. Sci.: Science. Last two rows have unmatched training costs. (c) Incremental (Inc.)/cumulative (Cum.) gains for original (Orig.)/updated (Upd.) improvers. All carry the agent; round 1 initializes. Full controls: Appendix D. Start Update Gain (p) Reset Frozen 4.1±0.184.1± 0.18 SFT only 4.6±0.194.6± 0.19 GVO only 5.0±0.205.0± 0.20 All roles 5.2±0.215.2± 0.21 Carry Frozen 4.8±0.204.8± 0.20 SFT only 5.3±0.215.3± 0.21 GVO only 5.8±0.225.8± 0.22 All roles 6.2±0.246.2± 0.24 Same artifact Original 5.7±0.225.7± 0.22 Updated 6.9±0.256.9± 0.25 (a) Artifact controls Updated roles Gain (p) Sci. Code Agent None 4.0 4.2 4.1 D 4.7 4.9 4.8 Sc 5.2 5.4 5.3 P 5.0 5.2 5.1 D+Sc 5.4 5.6 5.5 D+P 5.3 5.5 5.4 Sc+P 5.6 5.8 5.7 D+Sc+P 6.1 6.3 6.2 Sh 4.5 4.7 4.6 D+Sc+P+Sh 6.4 6.6 6.5 (b) Updated roles MetaRSI SpecRSI (ours) Rd. Orig. Upd. Orig. Upd. Inc. 2 4.9 7.2 5.8 8.5 3 3.6 5.4 4.2 6.4 4 2.1 3.8 2.7 4.7 5 0.7 1.4 1.1 2.1 Cum. 2 4.9 7.2 5.8 8.5 3 8.5 12.6 10.0 14.9 4 10.6 16.4 12.7 19.6 5 11.3 17.8 13.8 21.7 (c) Repeated rounds (p) 4.5 Resource Trade-offs and Limits RQ4: When are more planning and parallel work worth their cost? Planning and parallelism. Doubling plans from 32 to 64 raises gain from 6.3 to 6.5 p but lowers net return from 4.7 to 4.5 (Table 3(a)). Increasing workers from one to eight reduces elapsed time from 1,287 to 192 s, raising worker time from 1,287 to 1,403 s and gain from 6.3 to 6.5 p (Table S17). Thus, planning and parallelism expose different resource trade-offs: the former has a finite useful range, while the latter primarily exchanges additional total work for substantially lower latency. Verification cost. Batching lowers verification cost in three regimes and raises it in three (Table S16). The separate lifecycle ledger gives SpecRSI (ours) a 5.7% lower total-cost index: 106.3 versus MetaRSI-v1’s 112.7 (Table 3(b)). This lifecycle result complements Figure 2’s ten-backbone target-cost analysis, which measures a different cost endpoint. Appendix E further separates planning, batching, parallelism, and objective sensitivity, clarifying when additional computation reduces cost or latency. Table 3: Planning capacity and lifecycle cost. (a) MENU varies the offered-plan cap; gain is in p with reported SD, and Missing is the percentage of omitted good options. Overhead and Net retain their reported definitions; Net is not recomputed as Gain minus Overhead. (b) Reported lifecycle indices; overlapping components are not independently additive. Plans Gain (p) Overhead Missing (%) Net 8 5.2±0.195.2± 0.19 1.81.8 8.6 3.9 16 5.8±0.215.8± 0.21 2.7 5.2 4.4 32 6.3±0.256.3± 0.25 3.9 3.1 4.74.7 64 6.5±0.246.5± 0.24 5.6 2.02.0 4.5 (a) Offered-plan cap Category MetaRSI-v1 SpecRSI (ours) Acquisition 14.5 14.214.2 Training 38.6 34.834.8 Search 37.2 36.236.2 Reuse checks 5.1 4.84.8 Copies 6.3 6.16.1 Failed work 6.8 6.36.3 Planning 4.2 3.93.9 Total 112.7 106.3106.3 (b) Lifecycle ledger 5 Conclusion SpecRSI’s two-level loop extends incompletely evaluated parents but adopts only complete, admissible versions. VATS allocates edits and complementary checks by predicted net verified return; GVO updates the improver from completed searches under a fixed verification contract. SpecRSI outperforms Janus in all 50 scientific backbone–task pairs and MetaRSI-v1 by 1.85–2.38 p in four-task macro-average score across twenty backbones. Full planning achieves the highest mean verified gain and lowest total-cost index among tested planning conditions at all eight budget caps. Starting-artifact controls support gains from improver updates beyond retaining stronger task agents. Learned allocation thus turns speculation into verified agent improvement under limited budgets. References Agrawal et al. (2026) Lakshya A. Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Arnav Singhvi, Herumb Shandilya, Michael J. Ryan, Meng Jiang, Christopher Potts, Koushik Sen, Alexandros G. Dimakis, Ion Stoica, Dan Klein, Matei Zaharia, and Omar Khattab. GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning. In International Conference on Learning Representations, p. 8479–8565, 2026. URL https://proceedings.iclr.c/paper_files/paper/2026/hash/0e9e708b6f48e14fd0ac29e167413f76-Abstract-Conference.html. Ahmadian et al. (2024) Arash Ahmadian, Chris Cremer, Matthias Gallé, Marzieh Fadaee, Julia Kreutzer, Olivier Pietquin, Ahmet Üstün, and Sara Hooker. Back to basics: Revisiting REINFORCE-style optimization for learning from human feedback in LLMs. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 12248–12267, 2024. doi: 10.18653/v1/2024.acl-long.662. URL https://aclanthology.org/2024.acl-long.662/. Bertsekas (1997) Dimitri P. Bertsekas. Differential training of rollout policies. In Proceedings of the 35th Allerton Conference on Communication, Control, and Computing, 1997. URL https://faculty.engineering.asu.edu/bertsekas/papers-reports. Bhansali & Heck (2025) Shrenik Bhansali and Larry Heck. Draft, verify, and improve: Toward training-aware speculative decoding. arXiv preprint arXiv:2510.05421, 2025. URL https://arxiv.org/abs/2510.05421. Chen et al. (2024) Zhuoming Chen, Avner May, Ruslan Svirschevski, Yuhsun Huang, Max Ryabinin, Zhihao Jia, and Beidi Chen. Sequoia: Scalable and Robust Speculative Decoding. In Advances in Neural Information Processing Systems, volume 37, p. 129531–129563, 2024. doi: 10.52202/079017-4116. URL https://proceedings.neurips.c/paper_files/paper/2024/hash/ea1f5f0878d43f4fb8bf64ef4a2326c-Abstract-Conference.html. Deshpande et al. (2014) Amol Deshpande, Lisa Hellerstein, and Devorah Kletenik. Approximation algorithms for stochastic boolean function evaluation and stochastic submodular set cover. In Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, p. 1453–1466. Society for Industrial and Applied Mathematics, 2014. doi: 10.1137/1.9781611973402.107. URL https://epubs.siam.org/doi/10.1137/1.9781611973402.107. Ghuge et al. (2026) Rohan Ghuge, Jai Moondra, and Mohit Singh. Stochastic function certification with correlations. arXiv preprint arXiv:2604.02611, 2026. URL https://arxiv.org/abs/2604.02611v1. Gloeckle et al. (2024) Fabian Gloeckle, Badr Youbi Idrissi, Baptiste Roziere, David Lopez-Paz, and Gabriel Synnaeve. Better & Faster Large Language Models via Multi-token Prediction. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, p. 15706–15734. PMLR, 2024. URL https://proceedings.mlr.press/v235/gloeckle24a.html. Gneiting (2011) Tilmann Gneiting. Making and evaluating point forecasts. Journal of the American Statistical Association, 106(494):746–762, 2011. doi: 10.1198/jasa.2011.r10138. URL https://doi.org/10.1198/jasa.2011.r10138. Guan et al. (2026) Yilin Guan, Qingfeng Lan, Fei Sun, Dujian Ding, Devang Acharya, Chi Wang, William Yang Wang, and Wenyue Hua. Dynamic speculative agent planning. In International Conference on Learning Representations, p. 7695–7717, 2026. URL https://openreview.net/forum?id=YZ5k2dVj6O. Hellerstein et al. (2022) Lisa Hellerstein, Devorah Kletenik, Naifeng Liu, and R. Teal Witter. Adaptivity gaps for the stochastic boolean function evaluation problem. In Approximation and Online Algorithms, volume 13538 of Lecture Notes in Computer Science, p. 190–210. Springer, 2022. doi: 10.1007/978-3-031-18367-6_10. URL https://link.springer.com/chapter/10.1007/978-3-031-18367-6_10. Hu et al. (2022) Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-Rank Adaptation of Large Language Models. In International Conference on Learning Representations, 2022. URL https://openreview.net/forum?id=nZeVKeeFYf9. Hu et al. (2025) Shengran Hu, Cong Lu, and Jeff Clune. Automated Design of Agentic Systems. In International Conference on Learning Representations, p. 21344–21377, 2025. URL https://proceedings.iclr.c/paper_files/paper/2025/hash/36b7acf6f6010652b3f2a433774a66fe-Abstract-Conference.html. Hu et al. (2026a) Shijing Hu, Jingyang Li, Zhihui Lu, and Pan Zhou. Bridging draft policy misalignment: Group tree optimization for speculative decoding. In The Fourteenth International Conference on Learning Representations, 2026a. URL https://openreview.net/forum?id=dwPdYFqVWO. Hu et al. (2026b) Zhengding Hu, Mingge Lu, Zhen Wang, Jixuan Ruan, Chang Chen, Zaifeng Pan, Yue Guan, Ruiyi Wang, Zhongkai Yu, Chao Zhang, and Yufei Ding. FlashEvolve: Accelerating agent self-evolution with asynchronous stage orchestration. arXiv preprint arXiv:2605.08520, 2026b. URL https://arxiv.org/abs/2605.08520. Kim et al. (2026) Sungkyun Kim, Jaemin Kim, Dogyeong Yun, Jiho Shin, Junyeol Lee, and Jiwon Seo. Speculative Verification: Exploiting Information Gain for Speculative Decoding. In Findings of the Association for Computational Linguistics: ACL 2026, p. 36290–36307. Association for Computational Linguistics, 2026. doi: 10.18653/v1/2026.findings-acl.1809. URL https://aclanthology.org/2026.findings-acl.1809/. Lee et al. (2019) Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, p. 3744–3753, 2019. URL https://proceedings.mlr.press/v97/lee19d.html. Leviathan et al. (2023) Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast Inference from Transformers via Speculative Decoding. In International Conference on Machine Learning, p. 19274–19286, 2023. URL https://proceedings.mlr.press/v202/leviathan23a.html. Li et al. (2024) Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. EAGLE-2: Faster Inference of Language Models with Dynamic Draft Trees. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, p. 7421–7432. Association for Computational Linguistics, 2024. doi: 10.18653/v1/2024.emnlp-main.422. URL https://aclanthology.org/2024.emnlp-main.422/. Lightman et al. (2024) Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let’s Verify Step by Step. In International Conference on Learning Representations, p. 39578–39601, 2024. URL https://proceedings.iclr.c/paper_files/paper/2024/hash/aca97732e30bcf1303bc22ac3924fd16-Abstract-Conference.html. Liu et al. (2026) Ximeng Liu, Qianlong Wang, Yingming Mao, Annan Li, Yatao Li, Shizhen Zhao, Jianmin Wu, Dawei Yin, and Dou Shen. Janus: An Algorithm-Evaluator Co-Evolution Framework for LLM-Driven Discovery under Expensive Evaluation Budgets. arXiv preprint arXiv:2608.08189, 2026. URL https://arxiv.org/abs/2608.08189. Miao et al. (2024) Xupeng Miao, Gabriele Oliaro, Zhihao Zhang, Xinhao Cheng, Zeyu Wang, Zhengxin Zhang, Rae Ying Yee Wong, Alan Zhu, Lijie Yang, Xiaoxiang Shi, Chunan Shi, Zhuoming Chen, Daiyaan Arfeen, Reyna Abhyankar, and Zhihao Jia. SpecInfer: Accelerating Large Language Model Serving with Tree-based Speculative Inference and Verification. In Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3, p. 932–949. Association for Computing Machinery, 2024. doi: 10.1145/3620666.3651335. URL https://doi.org/10.1145/3620666.3651335. Robeyns et al. (2025) Maxime Robeyns, Martin Szummer, and Laurence Aitchison. A Self-Improving Coding Agent. arXiv preprint arXiv:2504.15228, 2025. URL https://arxiv.org/abs/2504.15228. Presented at the ICLR 2025 Workshop on Scaling Self-Improving Foundation Models (Oral). Schulman et al. (2017) John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347, 2017. URL https://arxiv.org/abs/1707.06347. Shao et al. (2024) Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv preprint arXiv:2402.03300, 2024. URL https://arxiv.org/abs/2402.03300. Snell et al. (2025) Charlie Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. Scaling LLM Test-Time Compute Optimally Can be More Effective than Scaling Parameters for Reasoning. In International Conference on Learning Representations, p. 10131–10165, 2025. URL https://proceedings.iclr.c/paper_files/paper/2025/hash/1b623663fd9b874366f3ce019fdfdd44-Abstract-Conference.html. Tan et al. (2026) Zihan Tan, Leixin Sun, Zitong Shi, Yitao Liu, Jiajun Wu, Nathaniel Brooks, Jiaru Qian, Xiaoran Shang, Suyuan Huang, Yi Ding, Yangxu Liao, Mukai Li, Qiushi Sun, Shudong Liu, Xuankun Rong, Xiaohang Yu, Zhuo Chen, Hejia Geng, Chenxin Li, Aozhou Wang, Zengji Tu, Robert Tang, Yuxin Zhan, Eric Jiang, Yuxin Wu, Jianqing Zhang, Xiao Liang, Fang Wu, Haochi Zhang, Alexander Marlow, and Guancheng Wan. MetaRSI / RSI2: A meta-recursive self-improving system for recursive self-improving systems themselves. arXiv preprint arXiv:2609.06396, 2026. URL https://arxiv.org/abs/2609.06396v2. Version 2, 9 September 2026. Wang et al. (2026a) Kun Wang, Guibin Zhang, ManKit Ye, Xinyu Deng, Dongxia Wang, Xiaobin Hu, Jinyang Guo, Yang Liu, and Yufei Guo. MAS2: Self-generative, self-configuring, self-rectifying multi-agent systems. In International Conference on Learning Representations, 2026a. URL https://openreview.net/forum?id=qumy27hMDY. Wang et al. (2026b) Wenyi Wang, Piotr Piękos, Li Nanbo, Firas Laakom, Yimeng Chen, Mateusz Ostaszewski, Mingchen Zhuge, and Jürgen Schmidhuber. Huxley-Gödel Machine: Human-Level Coding Agent Development by an Approximation of the Optimal Self-Improving Machine. In International Conference on Learning Representations, p. 80356–80386, 2026b. URL https://proceedings.iclr.c/paper_files/paper/2026/hash/821d20219c2f14850af1b5220f0ed13f-Abstract-Conference.html. Yao et al. (2023) Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Thomas L. Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of Thoughts: Deliberate Problem Solving with Large Language Models. In Advances in Neural Information Processing Systems, volume 36, p. 11809–11822, 2023. doi: 10.52202/075280-0517. URL https://proceedings.neurips.c/paper_files/paper/2023/hash/271db9922b8d1f4d7aaef84ed5ac703-Abstract-Conference.html. Ye et al. (2026) Naimeng Ye, Arnav Ahuja, Georgios Liargkovas, Yunan Lu, Kostis Kaffes, and Tianyi Peng. Speculative Actions: A Lossless Framework for Faster AI Agents. In The Fourteenth International Conference on Learning Representations, 2026. URL https://openreview.net/forum?id=P0GOk5wslg. Zhang et al. (2025a) Guibin Zhang, Haotian Ren, Chong Zhan, Zhenhong Zhou, Junhao Wang, He Zhu, Wangchunshu Zhou, and Shuicheng Yan. MemEvolve: Meta-evolution of agent memory systems. arXiv preprint arXiv:2512.18746, 2025a. URL https://arxiv.org/abs/2512.18746. Preprint version; also presented at ICML 2026. Zhang et al. (2026a) Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents. In International Conference on Learning Representations, p. 104223–104294, 2026a. URL https://proceedings.iclr.c/paper_files/paper/2026/hash/a5f5e6eb6f613ec412f1d948dfa21a5-Abstract-Conference.html. Zhang et al. (2026b) Jenny Zhang, Bingchen Zhao, Wannan Yang, Jakob Foerster, Jeff Clune, Minqi Jiang, Sam Devlin, and Tatiana Shavrina. Hyperagents. arXiv preprint arXiv:2603.19461, 2026b. URL https://arxiv.org/abs/2603.19461. Zhang et al. (2025b) Jiayi Zhang, Jinyu Xiang, Zhaoyang Yu, Fengwei Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, Bingnan Zheng, Bang Liu, Yuyu Luo, and Chenglin Wu. AFlow: Automating Agentic Workflow Generation. In International Conference on Learning Representations, p. 34040–34077, 2025b. URL https://proceedings.iclr.c/paper_files/paper/2025/hash/5492ecbce4439401798dcd2c90be94cd-Abstract-Conference.html. Zhou et al. (2024) Yifei Zhou, Andrea Zanette, Jiayi Pan, Sergey Levine, and Aviral Kumar. ArCHer: Training language model agents via hierarchical multi-turn RL. In International Conference on Machine Learning, p. 62178–62209, 2024. URL https://proceedings.mlr.press/v235/zhou24t.html. Contents for Appendix Reading Guide. Figure S1 maps the main paper and Appendix. Main paper Foundations 2 Preliminaries and related work 3.1 Motivation Sections 2, 3.1 Method 3.2 Two-level speculative RSI loop 3.3 Inner-loop search with VATS 3.4 Outer-loop learning with GVO Sections 3.2–3.4 Experiments 4.1 Tasks, models, and baselines 4.2 Overall performance 4.3 Verification-aware search 4.4 Improver learning 4.5 Resource trade-offs and limits Sections 4.1–4.5 Conclusion 5 Verified improvement under limited budgets Section 5 Appendix Related work 1. Recursive self-improvement 2. Speculative decoding 3. Learning for agent improvement Appendix A Additional results B Overall Performance C Why Verification-Aware Search Helps D Learning the Improver Across Rounds E Resource Trade-offs and Limits Technical details F Algorithms and training G Theoretical analysis H Nomenclature Figure S1: Main paper and Appendix. Appendix A Extended Related Work Recursive Self-improvement. Unlike within-task reasoning search or adaptive inference compute (Yao et al., 2023; Snell et al., 2025), agent improvement persistently revises task solvers and their improvers. DGM, SICA, ADAS, AFlow and GEPA iteratively revise and evaluate code, workflows, or prompts (Zhang et al., 2026a; Robeyns et al., 2025; Hu et al., 2025; Zhang et al., 2025b; Agrawal et al., 2026); MemEvolve co-evolves experience and memory programs, while Hyperagents and MetaRSI adapt improvement generation or scheduling (Zhang et al., 2025a; Zhang et al., 2026b; Tan et al., 2026). HGM separates lineage-metaproductivity-guided expansion from agent–task evaluation (Wang et al., 2026b); Janus co-evolves programs and proxies but retains real promotion checks (Liu et al., 2026). SpecRSI uses VATS to connect exploration to evaluation completion, jointly selecting branches and outstanding-check bundles by attainable verified improvement under the remaining budget. Speculative Decoding. Speculative decoding decouples cheap drafting from target verification without changing the target distribution (Leviathan et al., 2023). SpecInfer and EAGLE-2 use token trees; Sequoia adapts their size and depth to hardware costs (Miao et al., 2024; Li et al., 2024; Chen et al., 2024). Multi-token prediction learns future-token heads for speculative inference (Gloeckle et al., 2024); Speculative Verification adapts verification length to predicted draft–target alignment (Kim et al., 2026). Dynamic Speculative Agent Planning and Speculative Actions speculate on planning or executing actions within a task (Guan et al., 2026; Ye et al., 2026); FlashEvolve asynchronously overlaps evolution stages, optionally starting downstream work from partially evaluated artifacts (Hu et al., 2026b). SpecRSI separates executable-successor proposals from residual-check confirmation: incomplete parents may expand, but adoption requires complete, admissible outcomes for the selected version, not every ancestor. The analogy concerns verification expenditure, not exact token sampling or one-forward-pass agent evaluation. Learning for Agent Improvement. Process supervision learns step evaluators; hierarchical agent RL learns long-horizon values and policies (Lightman et al., 2024; Zhou et al., 2024). GRPO estimates relative advantages for same-prompt responses (Shao et al., 2024); DVI trains token drafters from verifier feedback; GTO targets expected tree acceptance length (Bhansali & Heck, 2025; Hu et al., 2026a); MAS2 trains meta-agents with value-weighted preferences from cost-sensitive terminal outcomes (Wang et al., 2026a). GVO instead credits independent complete successor searches from identical starting conditions, not responses or shared-tree leaves. Only complete admissible versions earn improvement; computation, elapsed time, failed and unfinished work remain charged. Established leave-one-out baselines and clipped updates train the drafter and work-selection policy (Ahmadian et al., 2024; Schulman et al., 2017); observed-return regression trains the scorer, with paid alternative continuations supplying scorer-only labels. These updates improve later searches while the evaluator stays fixed. The contribution is this verification-grounded, cost-sensitive learning unit integrated with successor search, not a new policy-gradient estimator. Table S1 summarizes the functional correspondence between Janus (Liu et al., 2026) and SpecRSI. Table S1: Functional correspondence between Janus and SpecRSI. The Scorer predicts continuation value; the real evaluator supplies evidence for adoption. Janus SpecRSI (ours) LLM program generator Drafter / DRAFT: propose executable edits Target program / offspring Immutable successor agent c′c Proxy evaluator Scorer: learned score evaluator Q^ϕ(S,ω) Q_φ(S,ω) Promotion / acquisition rule VATS Solver + Policy: allocate draft and check work Real evaluator frealf_ real Γ + AcquireΓAcquire_ ; invoked by VERIFY Real-validated incumbent ACCEPT: best complete admissible version Proxy-evaluator adaptation GVO Scorer update from acquired outcomes Program / evaluator co-evolution Agent / improver two-level loop Appendix B Overall Performance This appendix expands Section 4.2. The question is whether the method returns better successors within each comparable profile. Table 1 and Figure S3 contain the scientific, system, and coding comparisons; the additional tables below supply their costs and the prompt/workflow profiles. B.1 Scientific Performance The five columns of Table 1A are five native objectives. SpecRSI has the largest reported terminal gain and AUBC in each. For example, PyBaMM terminal gain changes from 0.36 for Janus to 0.48, a 33.3% relative increase, not a 33.3 p task-score increase. Table S2 keeps evaluation, proposal, proxy-training, and planning costs visible. Its total is 158.7 for SpecRSI and 148.1 for Janus: a 7.2% premium. Table S2: Scientific cost breakdown. Normalized source indices, not monetary lifecycle totals. Category Alg.-Only Direct-LLM Embed-GP Janus SpecRSI (ours) Evaluation 100.0100.0 100.0100.0 100.0100.0 100.0100.0 100.0100.0 Proposals 0 12.412.4 18.7 22.3 29.5 Proxy training 0 0 15.215.2 18.6 20.7 Planning 0 0 0 7.27.2 8.5 Total 100.0100.0 112.4112.4 133.9 148.1 158.7 B.2 Matched-Permission Results The system comparison controls what each method is allowed to modify. D, H, and M denote data, harness, and model edits. D+H excludes model updates; it is not a harness-only setting. Within D/H/M, SpecRSI exceeds MetaRSI-v1 by 1.6, 2.2, 2.3, and 2.9 p on TB2.1, SWE-Pro, GPQA-hard100, and AIME. The corresponding D+H differences are 1.4, 2.1, 2.4, and 2.9 p. Both permission bands remain in Table 1B alongside the single-surface, fixed-schedule, and static-router controls. The separate operator-combination study in Table S3 asks a narrower question about allowed combinations and their costs. Its full SpecRSI row has a 7.2% cost premium over the full MetaRSI row. Table S3: Operator combinations. Prior deployment-profile study; absolute gains (↑ ) and cost ratios (↓ ). Operators Gain Relative gain Relative cost D only 2.8 21.4% 32.532.5% H only 6.6 50.4% 58.758.7% M only 3.9 29.8% 65.2% D+H 7.7 58.8% 67.3% D+M 5.2 39.7% 72.1% H+M 8.9 67.9% 84.6% D+H+M (MetaRSI-v1) 10.910.9 83.283.2% 100.0% D+H+M / SpecRSI (ours) 13.113.1 100.0100.0% 107.2% B.3 Backbone Comparisons Figure S2 provides the scientific and system backbone comparisons summarized in Section 4.2. (a) Scientific tasks (b) System tasks Figure S2: Performance across backbones. (a) Relative terminal-gain and AUBC uplift over Janus across ten backbones and five scientific tasks. (b) Macro-average scores over TB2.1, SWE-Pro, GPQA-hard100, and AIME across twenty backbones, ordered by Initial Agent mean. Within-backbone segments connect the three methods; markers and horizontal error bars show means and ±1± 1 sample SD over five training seeds. The right-hand difference panel shows seed-paired SpecRSI −- MetaRSI-v1 differences in percentage points with the same uncertainty convention. B.4 Coding and Audit Coding validation measures the resulting agent’s success, while the asynchronous completion profile measures whether the relevant execution completes. They are different endpoints, even when method names coincide. Figure S3 reports coding-validation means and target costs. The corresponding SDs are 1.0, 1.1, 1.1, 1.0, 1.1, 1.2, and 1.2 p for DGM, SICA, HGM, Beam-Spec, FlashEvolve async, FlashEvolve optional, and SpecRSI, respectively. (a) Code (b) Prompt (c) Workflow Figure S3: Performance across code, prompt, and workflow tasks. Reported means: Score, Succ., and Comp. in percent; Gain in p; Tok. in thousands. Darker cells indicate better within-metric performance; dashes mark unreported values. Code completion uses a separate profile, and costs retain task-specific definitions. Beam: Beam-Spec; FE-A/FE-O: FlashEvolve async/optional; M2/M2–D: MIPROv2 with/without demos; Tr.: Trace; TG: TextGrad; G+M: GEPA+Merge; Gen./G+S: Genesis/Genesis+SOP. Table S4: Asynchronous completion. Completion rate supplements the coding-validation scores; it is not another estimate of coding success. The two native FlashEvolve modes remain separate. Method Complete (%) native FlashEvolve async-stages 91.2 native FlashEvolve optional-spec 92.892.8 SpecRSI (ours) 94.794.7 The frozen-successor audit assesses a selected, frozen artifact on a separately declared untouched split. It reports a SpecRSI score of 69.4±1.3%69.4± 1.3\% and 23/25 target hits (Table S5). Table S5: Separately reported frozen-successor audit. Method Audit score (%) Target hits SpecRSI (ours) 69.4±1.369.4± 1.3 23/25 B.5 Prompts and Workflows These profiles test whether the result is restricted to agent-code editing. Each retains its own initial agent and benchmark. For GPQA-hard100 prompt optimization, SpecRSI reaches 82.4%, compared with 78.5% for GEPA+Merge (Table S6). Table S6: Prompt optimization. GPQA-hard100 means; no reported SD. Gain is an absolute change on the % score scale. Method Score (%) Gain (%, abs.) MIPROv2 74.8 +3.6 MIPROv2 (no demos) 73.5 +2.3 Trace 75.9 +4.7 TextGrad 76.5 +5.3 GEPA 77.6 +6.4 GEPA+Merge 78.578.5 +7.3+7.3 SpecRSI (ours) 82.482.4 11.211.2 On PlanBench, SpecRSI reaches 67.8% success while using 9,290 task-inference tokens, versus 62.7% and 10,210 for EMAS (Table S7). This is a serving-token comparison, not a total-search-cost comparison. Table S8 separately reports SpecRSI scores and token use on Math, MBPP, and Game24. Table S7: Workflow optimization on PlanBench. Success is a task score; tokens count task inference only, excluding search and training. Both columns retain the supplied means. Method Success (%) Task tokens Genesis 51.3 11260 Genesis+SOP 57.2 11080 AFlow 59.6 10720 ADAS 61.1 10490 EMAS 62.762.7 1021010210 SpecRSI (ours) 67.867.8 9290 Table S8: Additional workflow tasks. Success (%) / serving tokens; PlanBench is already in Table S7. Method Math MBPP Game24 SpecRSI (ours) 62.3 / 10390 59.4 / 11020 54.7 / 12080 Appendix C Why Verification-Aware Search Helps This appendix expands Section 4.3. It separates three explanations that would otherwise be conflated: seeing more information, offering completion-aware work, and choosing how much work to execute before observing feedback. The latter’s resource regimes are examined separately in Appendix E.2. C.1 Information and Work Scope The information–scope study crosses two information levels (summary or full state) with two work scopes (one check or a bundle). The relevant comparison is between rows that hold one factor fixed, not just the weakest and strongest rows. With full state, gain rises from 4.8 to 6.3 p and total cost falls from 63.1 to 59.2 when bundles are permitted (Table S9). Failure falls from 9.8% to 6.5%, while hit rate rises from 84.0% to 92.0%. With summaries only, permitting bundles raises mean verified gain by 0.9 p (3.2 to 4.1), compared with 1.5 p under full-state information. At both information levels, bundles yield higher mean gain and lower total cost than the corresponding one-check controller. These fixed-information comparisons support completion-aware work scope as a contributor to VATS’s performance beyond richer inputs alone. The larger gain contrast under full state is consistent with complementarity between information and work scope; the 0.6 p difference is descriptive rather than a significance-tested interaction. Appendix G.5 complements this empirical comparison with an exact, output-matched analysis of how permitting verification blocks can reduce dispatch cost under fixed information and explicit dispatch-cost assumptions. Table S9: Verification scope with information held fixed. Gain is in percentage points (p), with reported SD. Cost is the study’s total-cost index; failure and hit rates retain the study’s definitions. The two full-state rows isolate work scope at a fixed information level. Information Work scope Gain (p)↑ Cost↓ Fail (%)↓ Hit (%)↑ Summary One check 3.2±0.213.2± 0.21 67.4 15.2 72.0 Summary Bundle 4.1±0.244.1± 0.24 65.8 12.7 78.0 Full state One check 4.8±0.254.8± 0.25 63.1 9.8 84.0 Full state Bundle 6.3±0.266.3± 0.26 59.259.2 6.56.5 92.092.0 C.2 Planning Ablations The planning ablation changes how the menu is built and selected, rather than changing the success criterion. Additive MILP uses the additive planning control; completion seeds retain candidate-completing check packages; refinement uses whole-plan continuation predictions. Frozen-policy, coupled scorer/policy, and greedy-selection rows then separate refinement from the final selection rule. The figure’s “scorer” is the table’s “value” model. At the standard budget, removing seeds lowers gain from 6.3 to 4.5 p, and greedy value selection reaches 4.8 p. At the 70% cap, the corresponding values are 6.0, 4.2, and 4.9 p. These are independent budget cohorts with their own seed pools, not extra replicates of the same condition. Figure S5 makes the trade-off explicit: full planning spends more time preparing work yet has a lower total-cost index. Figure S4: Paired gain differences and planning time. (a) Method minus Full SpecRSI gain uses the separately reported paired-seed difference means and SDs, not differences recomputed from Figure 4b. Full relative to itself is zero. Lines join means; bars/bands show ±1± 1 SD. (b) Color encodes planning-time mean; cells report mean ± SD in milliseconds. Methods and eight budget caps match Figure 4; Full (ours) denotes Full SpecRSI (ours). Seeds only: completion seeds only; No seeds: no completion seeds; Frozen policy: refinement/frozen policy; Coupled: coupled scorer/policy; Greedy: greedy scorer selection. (a) Gain at 70% and 100% budgets (b) Difference from the same-cohort full method (c) Planning time and total cost (d) Completion and executed work Figure S5: What changes when planning components are removed? These are the original reduced- and standard-budget panels, not four experiments. A/B show raw gains and each cohort’s difference from its own full method; C shows planning milliseconds and total-cost indices. In D, fin. is finalist completion (%), chk. checks per block, dep. draft depth, and cand. candidates. A larger work count is not intrinsically better. Except for B, shading is within-column scaling; darker does not always mean better. The expanded eight-budget gain/cost curves and SDs are in Figure 4; paired differences and planning times are in Figure S4. C.3 Evidence and Relations The evidence-input study asks what the controller needs to know about work already done. “Allocator blind” withholds the evidence features; “Mask only” provides missingness; “No relations” removes relation information; “Restored valid fields” reinstates valid observed fields. Full evidence is the reference. These interventions affect the controller’s inputs, not which predictions are accepted as real outcomes. Table S10 reports gain and the observed draft depth/checks per block. Full evidence reaches 6.3 p, versus 3.2 for the blind controller and 5.8 after valid fields are restored. Figure S6 adds costs, hits, failures, and coverage. More checks per block and greater depth are descriptive consequences of the selected work; maximizing either would be a different objective. The normalized heatmap is only another view of the same summaries. Table S10: Evidence and selected work. Gain ± SD; depth and checks per block are observed means, not optimization targets. Condition Gain (%, abs.) Draft depth Checks/block Allocator blind 3.2±0.173.2± 0.17 1.1 1.1 Mask only 4.7±0.204.7± 0.20 1.6 1.6 No relations 3.8±0.183.8± 0.18 1.4 1.3 Restored valid fields 5.8±0.235.8± 0.23 2.3 2.5 Full evidence 6.3±0.256.3± 0.25 2.6 2.8 (a) Gain, cost, target hits, and failures (b) Depth, checks, blocks, and candidates (c) Available fields and relations (d) The same columns on normalized scales Figure S6: What information changes verification allocation? All panels describe the evidence-input study. C reports valid-field fraction, relation coverage, and observed blocks. D min–max rescales the same summaries to [0,1][0,1], reversing cost only; it is not another evaluation. Dep. means draft depth, chk. checks per block, and cand. candidates. Source gain SDs remain in Table S10. C.4 Prediction and Verification The predictor study asks whether the model ranks candidate outcomes accurately and at what fitting cost. It is not the fixed-information work-scope experiment above, and it does not certify a candidate. In Table S11, MAE is prediction error, NDCG@3 summarizes the top-three ranking, and Regret@3 is the supplied top-three regret metric. The source calls one predictive row “SpecRSI evolved evaluator.” This is a historical predictor label, not a claim that the Verification Contract Γ is learned or editable. That row has the lowest reported MAE and regret and the highest NDCG, but not the smallest fitting cost. Its quality diagnostics must not be conflated with the continuation scorer’s same-data-supervision RMSE or with acquired pass/fail records. Table S11: Predictive-model diagnostics. Lower MAE, regret and fitting cost are preferred; higher NDCG is preferred. The historical row name “evolved evaluator” denotes a candidate predictor, not the protected Verification Contract. Predictor MAE NDCG @3 Regret @3 Fit cost GP 0.0870.087 0.7820.782 0.1240.124 12.3 RF 0.102 0.735 0.156 8.7 MLP 0.095 0.758 0.141 10.5 Quadratic 0.114 0.703 0.172 7.2 RBF-SVR 0.091 0.771 0.133 13.8 Direct LLM 0.136 0.654 0.208 5.35.3 LLM arithmetic proxy 0.158 0.612 0.247 3.93.9 SpecRSI evolved evaluator (ours) 0.0760.076 0.8350.835 0.0980.098 11.7 Appendix D Learning the Improver Across Rounds This appendix expands Section 4.4. The experiments progress from controlling the starting artifact, to changing the learned roles and supervision, to running repeated improvement rounds. They test whether the search procedure improves, in addition to the task artifact. D.1 Starting-Artifact Controls Reset controls return the task agent to the registered starting version while changing the improver. Carry controls retain the stronger task agent. The released-artifact fork is a third comparison: both continuations start from the same already released version, but use original or updated improvers. Comparing across these three starting conditions without holding the starting artifact fixed would conflate learning with artifact retention. In the reset condition, frozen and all-role-updated improvers obtain 4.1±0.184.1± 0.18 and 5.2±0.215.2± 0.21 p; in the carry condition, they obtain 4.8±0.204.8± 0.20 and 6.2±0.246.2± 0.24 p (Figure S7a). The difference of update effects is 0.3 p, but paired runs would be needed for an interaction test. Starting from the same released artifact, updating the improver raises the mean gain from 5.7 to 6.9 p and lowers the reported cost index from 54.2 to 50.8 (Table S12). This is stronger evidence for improver transfer than merely carrying a higher-scoring task agent forward. Figure S7: Starting-artifact controls and updated roles. (a) Reset, carry, and same-artifact controls; gain is in p. Reported uncertainty, regression values, and cost/hit/failure shading are retained. Compare rows within each starting condition. (b) Filled switches mark updated roles: D, drafter; Sc, scorer; P, policy; Sh, shared backbone. Columns report Science (Sci.), Code, and Agent gains (p). The final two rows use a separate shared-backbone extension; training costs are unmatched. (a) Artifact controls (b) Updated roles Table S12: Continuation from the same released artifact. Released-fork means and costs. Improver New-task gain (p) Cost index Regressions Original 5.7 54.2 0.1 Updated 6.96.9 50.850.8 0.00.0 D.2 Role Updates Figure S7b shows the role study, which changes the updated parts of the improver: drafter (D), scorer (Sc), policy (P), and the separately permitted shared-backbone extension (Sh). In the supplied science/code/agent aggregates, scorer-only updating has the largest single-role means, 5.2/5.4/5.3 p; drafter-only gives 4.7/4.9/4.8 and policy-only gives 5.0/5.2/5.1. Updating all three gives 6.1/6.3/6.2. D.3 Supervision and Cost The supervision-and-acquisition study asks two different questions. First, holding the acquired arms fixed, does adding pairwise return supervision help the scorer? Second, at the same acquisition expense, is buying matched alternative continuations preferable to ordinary-search acquisition? Table S13 keeps these contrasts separate. Adding the pair term increases the reported Gain from 5.4±0.235.4± 0.23 to 6.3±0.256.3± 0.25 p and lowers RMSE from 1.05 to 0.85, while total training cost increases from 23.7 to 28.4 (19.8%). The equal-acquisition ordinary-search row has 5.1±0.225.1± 0.22 p gain. Table S13: Learning signal versus data acquisition. The first two rows use the reported same acquired arms and differ in loss. The third uses ordinary-search acquisition at the reported equal acquisition cost. Gain follows the source Gain field. Condition Gain (p)↑ RMSE↓ Training cost↓ Same arms / means 5.4±0.235.4± 0.23 1.05 23.7 Same arms / means + pair 6.3±0.256.3± 0.25 0.850.85 28.4 Equal-acquisition-cost search 5.1±0.225.1± 0.22 1.17 25.3 The earlier acquisition-control record reports reset gain, not the supervision study’s Gain endpoint (Table S14). The same-arm means and means-plus-pair rows give 4.8 and 5.3 p; the extra ordinary-search row gives 4.5 p. Table S14: Continuation acquisition. Paid runs are reported averages; equal-data and equal-cost controls answer different questions. Acquisition Paid runs Data cost Reset gain State relation Ordinary searches 24.6 1.0x 4.2 Independent Extra ordinary equal-cost 24.6 1.0x 4.5 Independent Same arms / means 24.6 1.0x 4.84.8 Paired Same arms / means + pair 24.6 1.0x 5.35.3 Paired Different policy snapshot 24.6 1.0x 4.0 Mismatched D.4 Repeated Rounds The multi-round study starts at round 1 and reports rounds 2–5. All four method/improver conditions carry the agent forward; “original” versus “updated” refers to the improver, not whether the task agent is reset. Table 2(c) gives the raw increments and cumulative gains. For updated SpecRSI, the increments 8.5, 6.4, 4.7, and 2.1 p accumulate to 21.7 p. Updated Meta accumulates 17.8 p, while original-improver SpecRSI accumulates 13.8 p. Figure S8 separates the gains from improver updates from the differences between methods. Updating the improver raises SpecRSI’s gain in every evaluated round, with cumulative advantages reaching 7.9 p over its original-improver control and 3.9 p over updated MetaRSI by round 5. Figure S9 reports seed-level mean increments with task agents carried forward and the real evaluator fixed. Updated SpecRSI leads the other three conditions in every evaluated round across all five training seeds, supporting the consistency of its multi-round advantage. (a) Updating the improver: per-round difference (b) Updating the improver: cumulative difference (c) Spec versus Meta: per-round difference (d) Spec versus Meta: cumulative difference Figure S8: Which contrast is being read in the recursive-round study? A/B subtract original from updated within a method; C/D subtract Meta from Spec (ours) at the same improver status. All values are differences of Table 2(c)’s means, not new runs. Units are percentage points (p). (a) Supplied per-seed mean increments (b) Declared repeated-round protocol Figure S9: Repetition and protocol for the recursive-round results. Each row in A is a supplied seed mean, not an individual search. B declares carried roots in all four conditions, initialization at round 1, evaluated rounds 2–5, five training seeds, and three searches per seed. Appendix E Resource Trade-offs and Limits This appendix expands Section 4.5. Each intervention changes a different resource: planning effort, committed verification work, or worker count. These are kept separate from repeated improver updates in Appendix D. E.1 Planning Capacity The menu-cap study supports the use of a bounded planning menu in VATS (Table 3(a); Figure S10(a)). Increasing the cap from 8 to 32 raises mean gain from 5.2 to 6.3 percentage points and net return from 3.9 to 4.7, while reducing the missing-option percentage from 8.6% to 3.1%. Among the tested caps, 32 plans achieve the highest net return: compared with 64 plans, they yield higher net return (4.7 versus 4.5) and lower overhead (3.9 versus 5.6), while mean gain is only 0.2 percentage points lower (6.3 versus 6.5). Table S15: Menu construction and planning cost. Comparison of singleton-only menus, completion seeds, seeded growth, larger menus, and exhaustive construction. This study varies the construction strategy separately from the menu-cap sweep in Table 3(a). Menu Forecast Plan Work Final Singleton only 3.8 1.21.2 54.754.7 3.7 Seeds 5.2 2.82.8 55.3 5.1 Seeds + growth 6.1 3.9 54.8 5.95.9 Larger menu 6.46.4 5.6 55.1 6.06.0 Exhaustive 6.76.7 8.9 54.654.6 5.8 The menu-construction study further shows the value of completion seeds and bounded growth (Table S15; Figure S10(b)). Adding completion seeds raises Final from 3.7 to 5.1, and seeded growth further raises it to 5.9. Compared with exhaustive construction, seeds plus growth achieve higher mean Final (5.9 versus 5.8) with 56.2% lower planning cost (3.9 versus 8.9), while approaching the highest Final of 6.0 obtained with the larger menu. Together, these results support VATS’s completion-seed and bounded-growth design: effective verification options can be constructed without exhaustively enumerating all combinations. Figure S10(c) shows that Final minus Forecast decreases from −0.1-0.1 for singleton and seed-only menus to −0.9-0.9 for exhaustive construction. (a) Offered-plan cap: quality, expense, and executed work (b) Construction strategy: forecast, execution, and final result (c) Final minus Forecast in the construction record Figure S10: More planning is useful only if its options repay its cost. Menu-cap and menu-construction results are separate studies. In (a), over is reported overhead, miss the missing-option percentage, and net the reported net return; the outline marks the largest tested net. In (b), fore and final denote Forecast and Final; (c) shows Final minus Forecast. Comp. denotes completion, cand. candidates, chk. checks, dep. depth, and n retained searches. Darker shading indicates a larger value within each column. E.2 Verification Blocks The batch–serial study highlights the importance of selecting verification scope according to execution conditions (Table S16; Figure S11). Batching reduces mean verification cost by 17.1%, 6.5%, and 12.2% in the Dependent fail, Independent fail, and Early cancellation configurations, respectively, while serial execution is cheaper in the other three. These results identify opportunities for batching to save cost and motivate making verification scope a decision variable rather than fixing the execution mode throughout search. Table S16: Batch versus serial verification. Δ=Cbatch−Cserial =C_batch-C_serial; negative values favor batching. Comparisons are within each row; the six configurations do not constitute a controlled single-factor sweep. Regime Batch Serial Δ Dependent fail 10.210.2 12.312.3 -2.1 Independent fail 11.511.5 12.312.3 -0.8 Cheap dispatch 13.213.2 12.012.0 +1.2 Costly dispatch 15.415.4 12.012.0 +3.4 Early cancellation 10.810.8 12.312.3 -1.5 Reinvestment 14.714.7 12.012.0 +2.7 Figure S11 reports the associated cost components and execution conditions. Separately, the output-matched two-check analysis in Appendix G.3.1 characterizes when dispatch savings outweigh batch-construction cost and checks made unnecessary by early failure. This trade-off motivates VATS’s state-dependent work selection: it retains feasible singleton checks and completion bundles, evaluates their downstream verified return net of cost, and replans after each executed block updates the search state. Complementary evidence in Appendix C.1 shows that, at fixed full-state information, permitting bundles raises verified gain from 4.8 to 6.3 p while reducing the total-cost index from 63.1 to 59.2. (a) Reported cost components and execution conditions (b) Batch minus serial cost Figure S11: Cost trade-offs support adaptive verification scope. (a) Batch and serial cost components and execution conditions. (b) Mean batch-minus-serial cost. Batching lowers mean verification cost by 6.5%–17.1% in three configurations, while serial execution is cheaper in the other three, supporting VATS’s state-dependent choice between singleton checks and completion bundles. SD.b/SD.s denote the batch/serial cost SDs; stems show mean differences. Dashes denote unreported values. E.3 Time and Total Work Increasing the worker count from one to eight reduces elapsed time from 1,287 to 192 seconds, a 6.7×6.7× speedup, while total worker time increases by 9.0%, from 1,287 to 1,403 worker-seconds (Table S17). Reported gain also rises from 6.3±0.256.3± 0.25 to 6.5±0.256.5± 0.25 p. Parallel execution thus substantially shortens latency with a modest increase in total work. Table S17: Worker configurations. Time is elapsed wall-clock time; Work is total worker time. Eight workers achieve a 6.7×6.7× speedup with 9.0% more total work. w Gain (%) Time (s) Work (s) 1 6.3±0.256.3± 0.25 1287 1287 2 6.4±0.246.4± 0.24 672 13121312 4 6.4±0.266.4± 0.26 354354 1348 8 6.5±0.256.5± 0.25 192 1403 E.4 Cost Sensitivity The lifecycle ledger reports a 5.7% lower total-cost index for SpecRSI than for MetaRSI-v1: 106.3 versus 112.7, with lower indices across all listed cost categories (Table 3(b)). Table S18 shows how the regression penalty balances objective return and cost. Moving from no penalty to the standard penalty reduces ΔJ J from +2.4+2.4 to +2.1+2.1 and cost from 1.03 to 1.00. A heavy penalty lowers cost to 0.98 while retaining a positive ΔJ J of +1.7+1.7. These settings provide a tunable trade-off between improvement and expense under the same verification contract. Table S18: Regression-penalty sensitivity. Lower and Upper retain the supplied interval endpoints. Stronger penalties reduce normalized cost while retaining positive objective improvement. Condition ΔJ J Lower Upper Cost Baseline 0.0 - - 1.001.00 No penalty +2.4+2.4 +1.8 +3.0 1.03 Standard +2.1+2.1 +1.6 +2.6 1.001.00 Heavy +1.7 +1.2 +2.2 0.980.98 Appendix F Algorithms and Training GVO calls the complete-search procedure, which invokes VATS whenever it needs a new work plan. Parameters change only after collection; versions, evidence and budgets change during search. Algorithm 1 SpecRSI: Speculative Recursive Self-Improvement 1: Complete admissible r, fixed Γ , budgets B0,N0B_0,N_0, workers w; frozen θ,ψ,ϕ¯,νθ,ψ, φ,ν; mode. 2: Best complete admissible version and execution log D; no within-search parameter updates. 3: 0←(r,∅)T_0←(\r\, ); S0−←(0,ℰr,∅,B0,N0,w)S_0^-←(T_0,E_r, ,B_0,N_0,w); Send←S0−S_ end← S_0^-; ←∅D← ; t←0t← 0. 4: while preparation cap fits Bt−B_t^- and Nt>0N_t>0 do 5: (St,Ωt,ωt,ot,ℓtm,t)←VATS(St−,ϕ¯,ψ,ν,mode)(S_t, _t, _t,o_t, _t^m,P_t) (S_t^-; φ,ψ,ν,mode). → Algorithm 2 6: Send←StS_ end← S_t; rtm←−λot−μℓtmr_t^m←-λ o_t-μ _t^m; append (St−,St,t,rtm)(S_t^-,S_t,P_t,r_t^m) to D. 7: if ωt=ACCEPT _t= ACCEPT then 8: St+1−←StS_t+1^-← S_t; record a zero-cost terminal transition with rtw=0r_t^w=0; t←t+1t← t+1. 9: break 10: end if 11: if ωt=DRAFT(P,h) _t= DRAFT(P,h) then 12: Zt←Generateθ(P,h,St)Z_t _θ(P,h,S_t) ⊳ grow actual parent–child paths 13: else if ωt=VERIFY() _t= VERIFY(J) then 14: Zt←AcquireΓ(Jobs(ωt),St)Z_t _ (Jobs( _t),S_t) ⊳ check existing nodes; no new edges 15: end if 16: (Δt,Δℰt,κt,ℓtw,nt,ℬt)←Zt( _t, _t, _t, _t^w,n_t,B_t)← Z_t ⊳ Δt=(Δt,Δt) _t=( _t, _t) 17: (t+1,t+1)←(t∪Δt,t∪Δt)(C_t+1,A_t+1)←(C_t∪ _t,A_t∪ _t); t+1←(t+1,t+1)T_t+1←(C_t+1,A_t+1). 18: ℰt+1←ℰt∪e∈Δℰt:ValidΓ(e)=1E_t+1 _t∪\e∈ _t:Valid_ (e)=1\ ⊳ admit observed outcomes 19: (Bt+1−,Nt+1,Ht+1)←(Bt−κt,Nt−nt,Ht∥(ωt,Zt))(B_t+1^-,N_t+1,H_t+1)←(B_t- _t,N_t-n_t,H_t\|( _t,Z_t)). 20: St+1−←Update(t+1,ℰt+1,Ht+1,Bt+1−,Nt+1,w)S_t+1^- (T_t+1,E_t+1,H_t+1,B_t+1^-,N_t+1,w). 21: rtw←F(St+1−)−F(St)−λκt−μℓtwr_t^w← F(S_t+1^-)-F(S_t)-λ _t-μ _t^w; append (St,ωt,St+1−,Zt,rtw)(S_t, _t,S_t+1^-,Z_t,r_t^w) to D. 22: Send←St+1−S_ end← S_t+1^-; t←t+1t← t+1. 23: end while 24: T←tT← t; store T,SendT,S_ end in D. 25: return ACCEPT(Send) ACCEPT(S_ end) and D to the caller. 26: If invoked for training: return records to the caller. → Algorithm 3 Table S19: Two timescales, three procedures. Only the outer training procedure updates the improver’s parameters. Procedure Returns Changes and calls Algorithm 1: search Complete agent and log Updates versions, evidence and budget; calls Algorithm 2 Algorithm 2: VATS Feasible selected plan Settles preparation; fixed feasibility rules and frozen scorer/policy Algorithm 3: GVO Updated improver Calls Algorithm 1; updates only after collection F.1 RSI State Equation (4) separates the per-search agent outputs from the group-level parameter update. Algorithm 3 collects independent complete searches before each improver update. Table S20 specifies the permitted writes; the verification contract Γ and outer update rule remain protected. Table S20: What changes, and when? A legal search need not edit every task surface in one round. Object Permitted change Update boundary Task agent ckc_k Prompts, tool code, workflow and scoped persistent memory Executed edit creates an immutable successor Task-model snapshot Weights only when M is allowed D/H/M profile; absent from direct fixed-weight core Improver Θk _k Drafter, continuation value, plan-selection parameters GVO after complete searches; frozen inside each search Verification contract Γ None Fixed tasks, admission and scoring rules Outer update rule None GVO algorithm fixed; learned parameters may change Reset controls fix the starting task agent while changing the improver checkpoint. They test transfer beyond artifact retention, not improvement of every individual surface or modification of the verification contract Γ . F.2 Notation and Evaluation Table S21: The state separates versions, observations, and predictions. These objects are shared by all three algorithms. Symbol Meaning Γ,ℐ,JΓ ,I,J_ Fixed verification contract, required items, and score aggregation =(,)T=(C,A) Actual immutable versions and executed parent–child edit edges ℰ,HE,H Admitted outcome records and observed execution history mci,Uc,Kcm_ci,U_c,K_c Outcome completeness bit, missing items, and candidate–item target keys full,FC_full,F Complete admissible versions and their best improvement over the initial root B,N,wB,N,w Remaining expense, primitive-attempt allowance, and worker count S−,S,S~S^-,S, S Pre-menu state, paid choice state, and conservative proposal state ω,Ωω, Executable work plan and bounded offered plan set ℛ(S)R(S) Known candidate–job, dependency, setup, and source relations Q^ϕ,zψ Q_φ,z_ψ Single predicted action value (scorer/critic) and a separate policy logit θ,ϕ,ψ,νθ,φ,ψ,ν Drafter, single value/scorer, preference parameters, and fixed menu-generator settings D Execution log; not the draft-plan catalog tD_t or draftD_ draft An agent action solves a task; an improvement action modifies the agent that will solve later tasks. A version-tree node is therefore not a step in one task rollout. Each node freezes prompts, tools, code, and runtime dependencies; a permitted task-weight update also creates a new immutable node. Old artifacts are not mutated when the improver’s parameters change. A record is keyed by candidate identity, task item, checker/executor version, relevant environment state, and required output fields. A successful-looking scalar without those fields is not a complete record. Conversely, a valid record may state that a hard constraint failed; it is admitted to the ledger but does not make the candidate admissible. Aggregation can be nonlinear and may require all outcomes. Incompleteness and failure therefore have different meanings. Figure S12: Observed results, planned work, and predictions have different roles. Planning may use missingness and source proposals; only contracted direct execution or sound scoped equality adds a valid result. Observed does not mean passed; a missing item blocks adoption but not further editing. Speculative correspondence. A token proposal becomes an executable edit; a draft continuation becomes a path of actual revisions; a verification batch becomes a set of required checks; acceptance becomes selection of a complete admissible agent. These are role correspondences, not a bijection of probability laws. An unlikely edit may be valuable, a failed parent may be repairable, and many external checks need many real executions. A target-model distribution guarantee does not follow from this mapping. What is retained is the separation between inexpensive exploration and authoritative validation. Revision example. This supplementary illustration instantiates the design principles in Section 3.1; it changes the coding agent’s test strategy, not the application it repairs. Version r runs the full test set after each edit. Version c1c_1 adds a file–test dependency map but keeps that behavior. Version c2c_2 uses the map for intermediate feedback and still runs the full suite before returning a repair. Thus c1c_1 can enable c2c_2 without itself showing a score increase. A separate cached-pass branch b1b_1 must invalidate entries after the corresponding code changes. A stale-pass counterexample is evidence against b1b_1, not evidence against every child it could later produce. The verification contract Γ remains unchanged and requires separate checks of cross-module behavior and fresh-checkout behavior. Both records are needed for adoption under the illustrative contract. Their outcomes are unknown until executed. This illustrative example shows how a preparatory agent revision can enable a useful successor while preserving the verification contract. The successor changes intermediate test selection but retains the full test suite before returning a repair. F.3 Tree Search and Solver Search progress. A draft descriptor names existing parents and a bounded path shape. Each dependent edit waits for its actual parent, while independent branches may run in isolation. Invalid edits are charged and end their path; valid prefixes remain searchable. Parents may be internal nodes, incomplete nodes, or previously failed but editable nodes. A verification descriptor names jobs on existing nodes. It adds no version edge. Formally, DRAFT:+=∪Δ,+=∪Δ,VERIFY:+=,ℰ+=ℰ∪e∈Δℰ:ValidΓ(e)=1. array[]l DRAFT:&C^+=C∪ , ^+=A∪ ,\\ VERIFY:&T^+=T, ^+=E∪\e∈ :Valid_ (e)=1\. array Here a superscript ++ denotes the post-execution object and Δ denotes newly produced versions, edges or records; ValidΓ(e)∈0,1Valid_ (e)∈\0,1\ checks a record’s identity, required fields and provenance, not whether the task passed. Both operations update history and budgets. The next decision can return to another branch; there is no requirement to expand the most recent leaf. Dependencies between checks belong to a typed job graph, not the parent–child version tree. No visit-count or UCT backup is assumed. Feasible work. Let avail(S~)J_ avail( S) be the finite available-job catalog and setupG_ setup its setup groups. In this subsection, sums over j and g range over those sets, not training searches. For job j, Kj⊆×ℐK_j ×I is its requested candidate–item key set, DjD_j includes itself and all prerequisites, c¯j≥0 c_j≥ 0 caps job expense excluding shared setup, n¯j≥0 n_j≥ 0 caps primitive attempts, and g(j)g(j) names its setup group. A setup group g costs sg≥0s_g≥ 0 once. A nonempty target K is one candidate’s missing keys KcK_c, or a selected union of such sets. Empty targets require no work and are excluded from seed construction. Binary variables xj,ygx_j,y_g select jobs and activated setups. The incompatible-job pairs form conflictX_ conflict. The solver minimizes the enforceable cost cap: minx,y _x,y ∑jc¯jxj+∑gsgyg _j c_jx_j+ _gs_gy_g (14) s.t. .t. ∑j:k∈Kjxj≥1 _j:k∈ K_jx_j≥ 1 (k∈K), (k∈ K), xj≤xi x_j≤ x_i (i∈Dj∖j), (i∈ D_j \j\), xj+xj′≤1 x_j+x_j ≤ 1 ((j,j′)∈conflict), ((j,j ) _ conflict), xj≤yg(j),yg≤∑j:g(j)=gxj, x_j≤ y_g(j), y_g≤ _j:g(j)=gx_j, ∑jc¯jxj+∑gsgyg≤Bplan,∑jn¯jxj≤N,xj,yg∈0,1. _j c_jx_j+ _gs_gy_g≤ B_ plan, _j n_jx_j≤ N, x_j,y_g∈\0,1\. The expense budget is Bplan=B−o¯B_ plan=B^-- o, where B−B^- is the pre-menu remainder and o¯ o is the enforceable preparation cap. Only nonnegative BplanB_ plan is considered; N is the current attempt allowance. Conflict and prerequisite sets are known implementation constraints, not guesses about future success. After solving, check integrality, closure, coverage, setup activation, and resource limits independently. A feasible timeout incumbent may be used but must not be called optimal. The Solver constructs feasible work bundles covering the requested candidate–item keys under the dependency, conflict, and resource constraints. A key is marked observed only after its required fields are supplied by a valid record under Γ . For a job set A, define K(A)=⋃j∈AKjK(A)= _j∈ AK_j, D(A)=⋃j∈ADjD(A)= _j∈ AD_j, n¯(A)=∑j∈An¯j n(A)= _j∈ A n_j, and C¯(A)=∑j∈Ac¯j+∑g∈g(j):j∈Asg. C(A)= _j∈ A c_j+ _g∈\g(j):j∈ A\s_g. The second sum counts each shared setup once. Let Γ(S~)X_ ( S) denote the nonempty job sets legal under the fixed dependency, conflict, and resource rules at S~ S. A returned completion seed must satisfy AK∈A∈Γ(S~):K⊆K(A),D(A)=A,C¯(A)≤Bplan,n¯(A)≤N.A_K∈ \A _ ( S):K K(A),\ D(A)=A,\ C(A)≤ B_ plan,\ n(A)≤ N \. (15) Equation (14) specifies the minimizing objective; Equation (15) specifies the required feasibility of every returned seed, including a timeout incumbent. An infeasible target returns no seed, not an unverified optimum. Seeds and refinement. The reference catalog retains up to four candidate targets, four pairwise target unions, and four singleton closures. Round-robin order and an independently seeded reservoir choose target candidates before new outcomes are acquired. All original feasible completion seeds remain eligible even when a single check has negative predicted marginal value. The frozen model then refines them with Equation (7). A positive extension is retained with the original seed; a nonpositive best increment ends that seed’s extension. By default, we cap refinement at four extensions per seed, 96 uncached whole-plan value queries per decision, and 32 retained plans, including DRAFT and ACCEPT alternatives. These limits bound planning overhead while keeping the original feasible completion seeds and singleton fallbacks available for selection. Table S22: What the solver must preserve at one decision. These are executable constraints, not learned predictions of correctness. Candidate work Required information Role One edit or check Existing parent or item; expense and attempt caps Feasible fallback Completion bundle All missing keys; dependency and setup closure Preserve joint options Refined bundle Same proposal state and frozen value model Compare continuations Selected plan Paid state, canonical menu, policy preference Execute; then replan Pseudocode conventions. Algorithm 2 uses K for the bounded family of selected target-key sets, ℳ0M_0 for feasible initial bundles, and ℳsingletonM_ singleton for feasible one-job closures. W(A)=Q^ϕ¯(S~,VERIFY(A))W(A)= Q_ φ( S, VERIFY(A)) is a cached prediction. q counts attempted uncached value queries, s counts extensions of the current seed, and qmax,smaxq_ ,s_ are their limits. KΩK_ caps the final menu. (A)U(A) is the feasible extension family, ^(A) U(A) its query-limited subset, and +(A)U^+(A) contains extensions with both values available and a positive difference. A missing query result is not zero. TargetsTargets selects target sets; DraftPlansDraftPlans constructs bounded parent/path descriptors under ν; RetainRetain keeps the registered action families within KΩK_ . Required seeds and fallback slots must fit the cap; an inconsistent cap configuration is rejected rather than silently discarding promised support. P records preparation events, snapshots, the menu, and the selected probability. Algorithm 2 Verification-Aware Tree Search (VATS) 1: Pre-planning state S−S^-; frozen ϕ¯,ψ,ν φ,ψ,ν; mode; overhead, query, extension, and menu caps. 2: Paid state S, menu Ω , chosen plan ω, and metered overhead/log (o,ℓm,)(o, ^m,P). 3: Solver: construct feasible completion seeds. 4: ℛ←Remaining(S−)R (S^-); S~←S−[B←B−o¯] S← S^-[B← B^-- o]; q←0q← 0; initialize cache. 5: ←Targets(Kc(S~):c∈,Kc(S~)≠∅,ℛ)K (\K_c( S):c ,\ K_c( S)≠ \,R). 6: ℳ0←AK:K∈,AK satisfies (15)∪ℳsingletonM_0←\A_K:K ,\ A_K satisfies eq:seed-cover\ _ singleton. 7: Scorer: estimate continuation values and refine bundles. 8: ℳ←ℳ0M _0; W(A)=Q^ϕ¯(S~,VERIFY(A))W(A)= Q_ φ( S, VERIFY(A)) when queried. 9: for A0∈ℳ0A_0 _0 in the registered order do 10: A←A0A← A_0; s←0s← 0; query/cache W(A)W(A) if caps permit; meter an attempted cache miss in q,oq,o. 11: while s<smaxs<s_ , q<qmaxq<q_ , and metered overhead permits do 12: (A)←A∪Dj:A∪Dj∈Γ(S~)U(A)←\A∪ D_j:A∪ D_j _ ( S)\ ⊳ solver feasibility filter 13: Query a capped ^(A)⊆(A) U(A) (A); meter every attempted cache miss in q,oq,o. 14: +(A)←U∈^(A):W(U),W(A) available,W(U)>W(A)U^+(A)←\U∈ U(A):W(U),W(A) available,\ W(U)>W(A)\. 15: if +(A)=∅U^+(A)= then 16: break 17: end if 18: A←argmaxU∈+(A)[W(U)−W(A)]A← *arg\,max_U ^+(A)[W(U)-W(A)]; ℳ←ℳ∪AM ∪\A\; s←s+1s← s+1. 19: end while 20: end for 21: Solver: assemble and validate the final work menu. 22: draft←DraftPlans(,ℛ,S~,ν)D_ draft (T,R, S,ν) ⊳ parent nodes and bounded path shapes 23: Ω←RetainKΩ(ACCEPT∪draft∪VERIFY(A):A∈ℳ) _K_ (\ ACCEPT\ _ draft∪\ VERIFY(A):A \). 24: Validate caps and canonicalize duplicates; retain feasible seeds and promised action families. 25: Policy: select the next action, branch, and work scope. 26: Settle preparation, including the reserved final policy call; S←Debit(S−,o)S (S^-,o); append preparation history.⊳ single debit 27: pψ(ω)←πψ(ω∣S,ℛ,Ω)p_ψ(ω)← _ψ(ω S,R, ) using (8). 28: ω∼pψω p_ψ in collection; ω←argmaxu∈Ωzψ(S,ℛ,u)ω← *arg\,max_u∈ z_ψ(S,R,u) in deployment. 29: Finalize metered time ℓm ^m; record S,Ω,ωS, ,ω, actual choice probability, mode, snapshots, and preparation events in P. 30: return (S,Ω,ω,o,ℓm,)(S, ,ω,o, ^m,P) → Algorithm 1 Policy support. Every attempted value query, MILP call, and final policy evaluation consumes metered overhead. The final policy call uses a contracted expense known before its logits are evaluated, included in the preparation debit; its measured elapsed time is finalized before return. This avoids evaluating at one budget and later relabeling the likelihood as conditioned on another. Cache reuse requires an identical state, model snapshot, and plan-semantics version. Failed queries leave a missing value feature, not an invented zero. ACCEPT, a feasible single edit, a feasible singleton check, and an affordable completion batch retain reserved menu slots when available. Higher-order plans can still be omitted; the policy cannot recover them later. Algorithm 2 settles preparation once and returns the paid state, canonical menu, selected plan, and its actual behavior probability. Algorithm 1 does not debit that preparation again. During training, recompute policy likelihoods on the same logged menu; changing the menu changes the support. Preparation records are appended to observed history without importing task outcomes. A deterministic MILP output is not a sampled policy action and has no policy-gradient likelihood. We implement the completion-seed MILP in Equation (14) using SciPy’s MILP interface with the HiGHS solver. F.4 Verification and Execution Direct execution. Requested checks run the frozen version under Γ or read an already admitted identical record. A valid record is keyed to its candidate, item, fields, executor/checker version, randomness semantics, and relevant environment state. A record with a different key does not satisfy the requested check; fresh evaluation is required. A timeout or partial result leaves missing fields missing. A hard failure is a valid observation; it can disqualify the current version while still informing a repairable descendant. Predictions choose which verification work to buy, not which results to admit. Execution safeguards. Draft and verification branches execute in isolated snapshots. Changes to shared files, irreversible messages, financial actions, or external services cannot be rolled back merely because a branch was speculative. Such effects require a separately enforced execution contract. A copied state must include the relevant tool and environment state, not only a prompt string. A work cap bounds attempts and expense, not success. Every failed edit, failed check, setup, cancellation, copy, and preparation call has an explicit account. Within a synchronous reference block, feedback changes the next decision only after the block ends. An asynchronous adapter must log launches, in-flight commitments, cancellation fees, stale results, and completion times. The fastest observed configuration cannot be declared the cheapest when it also increases total worker time. Matched asynchronous comparisons cross the allocation rule with the execution scheduler, instead of attributing all speedup to the policy. F.5 Two-Stage Training Learned roles. Our open-model implementation uses frozen text representations, a rank-16 Drafter adapter (Hu et al., 2022), and separate trainable Scorer and Policy branches. Each of the two branches processes parent–child context, typed candidate–job relations, and plan features through message passing and set attention (Lee et al., 2019), with width 256 and four attention heads. Inputs explicitly include the remaining budget, primitive-attempt allowance, current complete score, missing-item masks, observed outcomes, and proposed work. Draft features are computed from existing artifacts and observed history. The scorer, value model, and critic all denote the single action-value model Q^ϕ(S,ω) Q_φ(S,ω). Its input is a search state and proposed work plan; its scalar output predicts future verified improvement minus resource costs. It is not a model of an agent’s current task score. The policy’s scalar logit zψ(S,ℛ,ω)z_ψ(S,R,ω) instead defines a choice distribution. These are separate value and preference branches, not two value models. During collection, ϕ¯k=ϕk φ_k= _k is an immutable copy of the current scorer parameters. After collection, ϕφ is fitted to observed returns and becomes ϕk+1 _k+1; the next collection refreshes ϕ¯k+1=ϕk+1 φ_k+1= _k+1. The bar marks a collection snapshot, not an independently trained second critic or a bootstrapped target network. No separate learned state-value V(S)V(S), twin-Q minimum, temporal-difference target, or generalized advantage estimator is specified by this reference. The group advantage in Equation (13) uses other searches’ realized returns, not a learned value baseline. The score aggregation JΓJ_ prescribed by the verification contract Γ produces task scores and is neither the scorer nor the policy. Frozen shared text inputs do not imply shared trainable parameters; actor gradients do not train ϕφ. The draft-menu settings ν have no learning rule in the supplied formulation and remain fixed here. Updating θ,ψ,ϕθ,ψ,φ between epochs changes future decisions, not immutable artifacts or acquired evidence. The value/preference architecture therefore contains one return model and one choice model, not two critics. Figure S13: Two data paths train different quantities. Ordinary complete searches provide actor likelihoods and return labels. Paid forced continuations provide critic labels only. The next epoch freezes the updated improver; the verification contract Γ stays unchanged. Return accounting. Supervised examples initialize legal edit generation and plan selection. The exact supervised losses are stated below; they do not label unexecuted alternatives. For reinforcement learning, use two transitions per visited decision t: preparation changes St−S_t^- to StS_t, then the selected work changes StS_t to St+1−S_t+1^-. ℬtB_t contains sampled drafter-token records (context, support, token and actual probability); verification returns ℬt=∅B_t= . Together with the sampled plan record in tP_t, these logs supply actor likelihoods. Let ot,ℓtmo_t, _t^m be metered preparation expense and elapsed time; let κt,ℓtw _t, _t^w be work expense and elapsed time. The superscripts m,wm,w label menu preparation and work, not powers. ntn_t is the number of charged primitive attempts. Every actual charge belongs to exactly one transition: Bt B_t =Bt−ot, =B_t^--o_t, Bt+1− B_t+1^- =Bt−κt, =B_t- _t, Nt+1 N_t+1 =Nt−nt, =N_t-n_t, (16) rtm r_t^m =−λot−μℓtm, =-λ o_t-μ _t^m, rtw r_t^w =F(St+1−)−F(St)−λκt−μℓtw. =F(S_t+1^-)-F(S_t)-λ _t-μ _t^w. Preparation changes resources and bookkeeping but acquires no outcomes, so F(St)=F(St−)F(S_t)=F(S_t^-). Define T as the number of visited paid choices, including a sampled ACCEPT when present. For ACCEPT, set St+1−=StS_t+1^-=S_t and κt=ℓtw=nt=rtw=0 _t= _t^w=n_t=r_t^w=0; this is bookkeeping, not extra work. If no further preparation fits, the last pre-menu state is terminal. Thus Send=ST−S_ end=S_T^-, also for T=0T=0. At a saved post-menu choice, current preparation is sunk. Its observed return is Gt G_t =rtw+∑u=t+1T−1(rum+ruw), =r_t^w+ _u=t+1^T-1(r_u^m+r_u^w), (17) Ct:end C_t: end =κt+∑u=t+1T−1(ou+κu),Lt:end=ℓtw+∑u=t+1T−1(ℓum+ℓuw). = _t+ _u=t+1^T-1(o_u+ _u), L_t: end= _t^w+ _u=t+1^T-1( _u^m+ _u^w). This telescopes to Equation (11), including any later terminal preparation fee. In contrast, whole-search totals are Cg=∑t=0Tg−1(otg+κtg)C_g= _t=0^T_g-1(o_t^g+ _t^g) and Lg=∑t=0Tg−1(ℓtm,g+ℓtw,g)L_g= _t=0^T_g-1( _t^m,g+ _t^w,g). Hence Rg=∑t=0Tg−1(rtm,g+rtw,g)R_g= _t=0^T_g-1(r_t^m,g+r_t^w,g). Here TgT_g is the decision count of search g, G is the number of searches, and GtG_t is a return; they are different quantities. Elapsed-time intervals follow one search clock, not a sum of concurrent worker durations. All formulas in this reference use discount one. Supervised objectives. Let editsupD_ edit sup contain executed legal edits e and their generation contexts H (including the actual parent), and let plansupD_ plan sup contain demonstrated legal plan choices with their paid states and menus. Warm-up minimizes ℒSFT(θ,ψ)= _ SFT(θ,ψ)= −(H,e)∼editsuplogπθ(e∣H) -E_(H,e) _ edit sup _θ(e H) (18) −(S,ℛ,Ω,ω)∼plansuplogπψ(ω∣S,ℛ,Ω). -E_(S,R, ,ω) _ plan sup _ψ(ω S,R, ). The edit likelihood is the product of its autoregressive token probabilities, including a sampled end token. Its logarithm is their sum, not an additional second likelihood. Each expectation denotes an empirical mean over the specified dataset. Equation (11) separately initializes the scorer from executed returns. These losses formalize the stated warm-up roles; they do not create missing demonstration or rollout records. Actor update. GVO groups independent searches conditional on the same root, contract, budgets, workers, and collection snapshot. A leaf inside a shared tree is not a group member. Set ϑ=(θ,ψ) =(θ,ψ); this parameter vector excludes ϕφ and ν. Index genuinely sampled controlled choices in search g by j=1,…,Jgj=1,…,J_g, where JgJ_g is their count, yg,jy_g,j is the sampled token or plan, Hg,jH_g,j is its logged conditioning context, and g,jY_g,j is its sampling support. In this paragraph j indexes model choices, not verification jobs. Write their typed probabilities as pϑ(yg,j∣Hg,j,g,j)=πψ(ωt∣St,ℛt,Ωt),sampled plan,πθ(yg,j∣Hg,j,g,j),sampled edit token.p_ (y_g,j H_g,j,Y_g,j)= cases _ψ( _t S_t,R_t, _t),&sampled plan,\\ _θ(y_g,j H_g,j,Y_g,j),&sampled edit token. cases (19) For a plan, g,j=ΩtY_g,j= _t and yg,j=ωty_g,j= _t. For a token, the context includes the real parent, observed history, and generated prefix, and the support is the allowed token set. Use the actual post-temperature, post-mask probabilities and, for plans, the exploration mixture in Equation (8). Record invalid sampled edits as well as successful ones; neither failed work nor its likelihood disappears. A deterministic choice is not assigned a fictitious sampling probability. Keeping the collection probabilities and advantages fixed, define ρg,j(ϑ) _g,j( ) =pϑ(yg,j∣Hg,j,g,j)pϑk(yg,j∣Hg,j,g,j), = p_ (y_g,j H_g,j,Y_g,j)p_ _k(y_g,j H_g,j,Y_g,j), (20) ℒGVO(ϑ) _ GVO( ) =−1G∑g=1G∑j=1Jgminρg,j(ϑ)Ag,clip(ρg,j(ϑ),1−ϵc,1+ϵc)Ag. =- 1G _g=1^G _j=1^J_g \! \ _g,j( )A_g,clip( _g,j( ),1- _c,1+ _c)A_g \. Here ϵc∈(0,1) _c∈(0,1) is the clipping radius, distinct from the exploration probability ϵε, and clip(x,l,u)=min(max(x,l),u)clip(x,l,u)= ( (x,l),u). AgA_g in Equation (13) is a detached whole-search advantage, not a temporal-difference residual or a critic prediction. Each sampled choice uses it once. The denominator is the stored behavior probability, not a recomputed probability after changing the menu. Keep the recorded token support, plan menu, frozen scorer, and generator rules fixed during this update; changed supports require fresh collection. The context may change across decisions, but the same recorded context is used in each numerator–denominator pair. Only sampled plan choices and edit tokens enter the actor sum. Solver outputs, environment results, deterministic fallbacks, and entire forced continuations are excluded. Keeping the sum over each trajectory avoids reweighting searches by JgJ_g; a search with no sampled choices contributes zero. This is a PPO-style surrogate with a leave-one-out baseline, not a new gradient theorem or monotonic-improvement guarantee (Schulman et al., 2017; Ahmadian et al., 2024). KL regularization. To make the optional penalty explicit, let pg,jrefp ref_g,j be a registered frozen reference distribution on the same support g,jY_g,j. One current-to-reference convention is ℒKL(ϑ) _ KL( ) =1G∑g=1G∑j=1JgDKL(pϑ(⋅∣Hg,j,g,j)∥prefg,j), = 1G _g=1^G _j=1^J_gD_ KL\! (p_ (· H_g,j,Y_g,j)\,\|\,p ref_g,j ), (21) DKL(p∥q) D_ KL(p\|q) =∑y∈g,jp(y)logp(y)q(y). = _y _g,jp(y) p(y)q(y). The reference has positive probability wherever the current distribution is positive; 0log(0/q)0 (0/q) is zero. Its checkpoint, direction, coefficient βKL≥0 _ KL≥ 0, and any estimator used instead of the full sum must be registered. βKL=0 _ KL=0 disables this term. The input manuscript does not identify these settings for the reported deployment; Equation (21) defines the optional convention, not an inferred experimental configuration. A frozen reference policy is not a second value model. The environment return RgR_g excludes this optimization penalty, which is applied only once in the actor loss. Same-state continuations. On a prespecified development subset, restore identical paid states S. Let SW_S be the finite set of legal first plans to compare, drawn from that saved menu. Each arm a∈Sa _S uses a prospectively fixed number na≥1n_a≥ 1 of independently seeded suffix rollouts under the same frozen Θk _k. Define Ga,sG_a,s as the realized suffix return of repetition s=1,…,nas=1,…,n_a, from forced plan a to termination, excluding the already paid initial menu. Every later menu and failed action is charged. Unsuccessful but fully logged rollouts stay in the average; absent logs cannot be replaced by invented zeros. G¯a=1na∑s=1naGa,s,δ^ab=G¯a−G¯b,Var(δ^ab∣S)=σa2na+σb2nb. G_a= 1n_a _s=1^n_aG_a,s, δ_ab= G_a- G_b, ( δ_ab S)= _a^2n_a+ _b^2n_b. (22) Here σa2=Var(Ga,s∣S,a,Θk) _a^2=Var(G_a,s S,a, _k); the last equality assumes independent repetitions and independent arms conditional on the state and snapshot. For coupled arms, subtract 2Cov(G¯a,G¯b∣S)2Cov( G_a, G_b S) instead. Matching the initial state alone does not guarantee smaller variance. Copies and all branch rollouts are charged to acquisition, without subtracting clone acquisition a second time from the suffix’s counterfactual decision budget. The empirical dataset QD_Q contains fully logged tuples (S,a,G)(S,a,G) from ordinary plan starts and paid forced rollouts with a matched continuation snapshot. pairD_ pair contains (S,a,b,G¯a,G¯b)(S,a,b, G_a, G_b) from the same arm records. Labels collected under different continuation policies must not silently be treated as observations of one QπQ^π; policy IDs are retained. At a fixed state write ea=Q^ϕ(S,a)−G¯ae_a= Q_φ(S,a)- G_a. The pair penalty is (ea−eb)2(e_a-e_b)^2: it reweights differences but cannot identify a common offset. Thus the single scorer minimizes ℒvalue(ϕ)=ℒQ(ϕ)+βpairℒpair(ϕ),βpair≥0.L_ value(φ)=L_Q(φ)+ _ pairL_ pair(φ), _ pair≥ 0. Both targets are observed Monte Carlo returns, with no bootstrapped Q or learned V target. The loss comparison separates same-data loss weighting from equal-acquisition-cost sampling; neither comparison implies equal fitting cost. Algorithm 3 Group Verification Optimization (GVO) 1: Θk=(θk,ψk,ϕk,ν) _k=( _k, _k, _k,ν); complete root r, fixed Γ , budgets B0,N0B_0,N_0, workers w, group size G≥2G≥ 2; registered loss/update settings. 2: Full updated snapshot Θk+1 _k+1 and acquisition/training ledger; forced rollouts remain scorer-only. 3: Set ϕ¯←ϕk φ← _k; freeze θk,ψk,ϕ¯,ν _k, _k, φ,ν during all collection below. 4: for g=1,…,Gg=1,…,G independently do 5: (ck+1(g),g)←SearchΘk(r,collection)(c_k+1^(g),D_g) _ _k(r,collection). → Algorithm 1 6: end for 7: Compute Rg,AgR_g,A_g by Equation (13), using each search’s terminal state and full expense/time. 8: actor←⋃ggsampledD_ actor← _gD_g sampled; Q←⋃ggplanstartsD_Q← _gD_g plan\ starts with suffix labels from (11); pair←∅D_ pair← . 9: ←SelectStates(g)Z (\D_g\) using the prespecified development rule. 10: for saved paid state S∈S , legal arm a∈Sa _S, repetition s=1,…,nas=1,…,n_a do 11: Clone S, including its tree, records, budgets, root reference and environment state; log clone acquisition separately. 12: Set the suffix log empty and local clock zero; execute ω0=a _0=a at the restored post-menu entry, then continue under Θk _k. → Algorithm 1 13: Compute Ga,sG_a,s by Equation (11); add fully logged plan starts to QD_Q, never to actorD_ actor. 14: Log snapshot/state/arm IDs, repetitions, missing records, and all acquisition charges. 15: end for 16: Form arm means and matched tuples in pairD_ pair using Equation (22). 17: Initialize live ϕ←ϕkφ← _k, ϑ←(θk,ψk) ←( _k, _k); keep collection probabilities and AgA_g detached. 18: Update ϕφ on ℒvalueL_ value and ϑ on ℒGVO+βKLℒKLL_ GVO+ _ KLL_ KL as in Equation (23). 19: Refresh ϕ¯k+1←ϕk+1 φ_k+1← _k+1 for the next collection; keep Γ and ν unchanged. 20: return Θk+1=(θk+1,ψk+1,ϕk+1,ν) _k+1=( _k+1, _k+1, _k+1,ν) and the ledger; checkpoint choice uses development data only. 21: Next collection: run new searches with the refreshed snapshot. → Algorithm 1 Update schedule. An ordinary Algorithm 1 call initializes the root. A matched continuation instead restores the complete paid state, sets its suffix log empty and clock to zero, fixes ω0=a _0=a, and enters after the solver. It does not reset the tree, reacquire an already paid menu, or resample the forced first choice. Later decisions use normal paid preparation. Entire forced continuations are excluded from actor updates; they supply critic targets only. The return goes back to the external training caller. For one update step with learning rates ηϕ,ηπ>0 _φ, _π>0, the parameter assignments are ϕk+1 _k+1 =ϕk−ηϕ∇ϕℒvalue(ϕ)|ϕ=ϕk, = _k- _φ . _φL_ value(φ) |_φ= _k, (23) ϑk+1 _k+1 =ϑk−ηπ∇ϑ[ℒGVO(ϑ)+βKLℒKL(ϑ)]|ϑ=ϑk, = _k- _π . _ [L_ GVO( )+ _ KLL_ KL( )] |_ = _k, Θk+1 _k+1 =(θk+1,ψk+1,ϕk+1,ν),ϕ¯k+1=ϕk+1. =( _k+1, _k+1, _k+1,ν), φ_k+1= _k+1. ∇ denotes differentiation with respect to the subscripted parameters; all returns, advantages, logged contexts, old probabilities, and reference distributions are constants in these derivatives. Registered minibatches may repeat update steps over the frozen collection. The fitted ϕk+1 _k+1 uses returns under the collection procedure πk _k. Updating the actors changes the continuation law to πk+1 _k+1, so the refreshed scorer is an approximation there, not an exact new-policy value obtained merely by copying parameters. Fresh collection supplies calibration for the next round. Parameters refresh only for subsequent collection. Deployment chooses the largest preference rather than sampling, so its calibration and quality need direct evaluation. Resetting the task agent while holding allowed histories and budgets fixed tests whether the updated improver transfers. Task-family and model-backbone transfer are separate settings. No reporting audit is used to select a training epoch, and no indefinite recursive acceleration follows from a finite number of rounds. Appendix G Theoretical Analysis This appendix proves the conditional claims underlying Sections 3.2–3.3. Read Appendix G.4.2 for the central three-check result; the remaining sections establish accounting, planning, and learning properties. These are finite analytical statements, not new agent benchmarks. Each proposition states the assumptions needed for its conclusion. Table S23: What each formal result establishes. The assumptions belong to the reference model; these results are not neural benchmark measurements. Reader question Result to read Essential condition Can predictions corrupt a completed result? Outcome consistency (Proposition 1) Sound records; fixed contract Does grouping enlarge every policy class? Singleton simulation (Proposition 4) Free serial decision boundaries When does commitment save expense? Feedback threshold (Proposition 5) Identical output and charged blocks What do success summaries omit? Scope reversal and matched control (Propositions 7, 8) Equal marginals/all-pass rate; distinct joint laws How can an approximate menu lose value? Menu bound (Proposition 9) Fixed continuation; bounded value error G.1 Validity and Termination G.1.1 Outcome Consistency Proposition 1. Fix immutable candidates and a deterministic finite contract. Assume direct records equal contracted executions and inherited records have sound equalities to valid earlier sources. Then every completely covered candidate has the same aggregate and hard-constraint outcomes as full direct execution under that contract. Proof. Order records by their well-founded provenance relation. Direct records are correct by assumption. Each inherited record equals an earlier correct source under a checked equality, hence is correct by induction. The complete outcome vector and unchanged aggregation therefore match a full execution. No additive-score assumption is needed. ∎ The result guarantees consistency of completed finite outcomes under the stated execution assumptions. Stochastic services need justified replay semantics or fresh evaluation. Prediction errors can harm allocation even when admitted records remain correct; population generalization is a separate question. G.1.2 Reward Conservation Proposition 2. Use the preparation/work clock in Appendix F.5, with T visited choices and disjoint metered charges. Then ∑t=0T−1(rtm+rtw)=F(ST−)−F(S0−)−λ∑t=0T−1(ot+κt)−μ∑t=0T−1(ℓtm+ℓtw). _t=0^T-1(r_t^m+r_t^w)=F(S_T^-)-F(S_0^-)-λ _t=0^T-1(o_t+ _t)-μ _t=0^T-1( _t^m+ _t^w). Proof. Preparation leaves F unchanged: F(St)=F(St−)F(S_t)=F(S_t^-). Substituting Equation (16) telescopes the progress terms and sums disjoint resource charges. The zero-cost terminal transition preserves the identity; empty sums cover T=0T=0.∎ Regrouping the same realization into different work blocks preserves the undiscounted objective, not necessarily the realization produced by another policy. For μ=0μ=0, a serial and parallel schedule with identical results and billed work has identical reward. A block-count discount changes the objective and is not introduced implicitly. Already paid menu cost belongs to the episode but not a selected plan’s remaining return. G.1.3 Finite Termination Admit overhead and each plan only when their enforceable reservations fit the remaining cap. Settle actual cost no greater than the reservation before releasing unused resources. Induction prevents overspending; a predicted mean expense cannot replace the cap. Every legal nonempty plan consumes at least one registered primitive attempt, including invalid edits and failed checks. Empty verification plans are excluded; empty targets need no work. No-feasible-work terminates, so zero-cost diagnostics cannot loop indefinitely. These statements require the backend to enforce its caps; violations must be reported. G.2 Completion and Equivalence G.2.1 Completion Complementarity Proposition 3. Immediate selectable gain need not be additive or submodular in obtained checks. Proof. Let a positively improving candidate require two remaining records a,ba,b. For a subset A⊆a,bA \a,b\, let v(A)v(A) be the newly selectable verified gain after obtaining exactly A, with other evidence fixed. Then v(∅)=v(a)=v(b)=0v( )=v(\a\)=v(\b\)=0 while v(a,b)=g>0v(\a,b\)=g>0. Additivity would imply g=0g=0; submodularity would require the marginal of b at the empty set to be at least its positive marginal after a. ∎ This rules out identifying individual immediate gains with batch utility, not all singleton policies or additive proposal heuristics. A correct long-horizon policy can take a anticipating b. Shared setup creates another interaction; multiple complete candidates can substitute because only the best is deployed. All strong controls receive the best complete score to avoid a trivial information disadvantage. G.2.2 Full-State Simulation Proposition 4. Under serial execution, zero replanning/dispatch cost, no shared setup discounts, identical primitive edits/checks, and a finite primitive allowance, every history-dependent bounded-plan policy can be simulated by a history-dependent singleton policy with identical output and cost distribution. Proof. At each plan boundary, sample the same descriptor and store it. Execute its primitives one by one using the same random streams and actual-edit conditioning, deliberately ignoring intermediate feedback until the original block would return. Artifacts, observations and primitive costs match inductively. Boundary cost and discounts are absent, so final output and cost match. The singleton class can also react earlier, hence its optimal value is at least that of the bounded class under these assumptions. ∎ This is a policy-class comparison, not a claim that a trained singleton learner finds its optimum. It excludes real parallel latency, nonzero model calls, setup sharing and function-approximation difficulty. Grouping n≥1n≥ 1 identical serial jobs, with dispatch price d≥0d≥ 0 per launched block, can save (n−1)d(n-1)d of dispatch expense before batch-construction cost, but may buy unnecessary jobs after a revealing first failure. Regime experiments test both effects. G.2.3 Repairable Versions An executable two-stage adapter supplies a minimal example. An old tool emits an unstructured string consumed by an old parser. Edit e1e_1 changes the output to a structured record; the unchanged parser fails the contract. Edit e2e_2 updates the parser to consume that record. It can then satisfy the contract. Thus a version c∉full(S)c _full(S) or a failed hard requirement does not logically imply every editable child must fail. This example uses actual transformations and direct executions; it is not a simulated successful observation fed to the drafter. Nor does it show such two-step improvements are common. It explains the distinction between editing permission and adoption permission. G.3 Feedback Costs G.3.1 Delayed Feedback Proposition 5. Consider two prescribed serial checks with costs c1,c2≥0c_1,c_2≥ 0. The first reveals a hard failure with probability p∈[0,1]p∈[0,1]; after failure, the second cannot change the final eligible output. Otherwise both checks are required. Dispatch costs d≥0d≥ 0 per launched block. A blind two-check batch has extra construction cost a≥0a≥ 0. Assume both policies can afford their maximal path, have identical results and output, and end this comparison without reinvesting savings. A sequential policy stops checking after first-check failure. Then Cbatch=d+a+c1+c2,Csequential=d+c1+(1−p)(d+c2),C_ batch=d+a+c_1+c_2, _ sequential=d+c_1+(1-p)(d+c_2), Cbatch−Csequential=a+pc2−(1−p)d.C_ batch-EC_ sequential=a+pc_2-(1-p)d. (24) In the cost-only objective with λ>0λ>0, the batch has higher return exactly when (1−p)d>a+pc2(1-p)d>a+pc_2. Proof. Both policies pay for the first dispatch and check. The sequential policy pays the second dispatch and check exactly on the probability-1−p1-p branch. The batch always pays the second check and its extra construction cost. Subtracting gives the result; identical output makes terminal utility cancel. ∎ This crossover explains a limited mechanism, not a universal scheduler. With p=1/2p=1/2, c2=1c_2=1, and a=0a=0, batching is cheaper exactly when d>1d>1. These are analytical values. Allowing a batch to cancel work on early feedback, changing shared setup, parallelizing elapsed time, repairing a failed candidate, or reinvesting unused budget changes the model. Such settings require new accounting rather than reusing the threshold. First-check failure excludes only the tested version from this output comparison; it does not rule out useful descendants. Figure S14: Early feedback changes the cost of committing work. Exact sensitivity of Equation (24), with dispatch 1 and planning 0.2. These curves do not fit the batch-versus-serial study or assert that batching always wins. G.3.2 Menu Overhead Additional proposals can remove good execution options by consuming their budget. To isolate this effect, consider two menu builders on the same pre-overhead state with deterministic settled costs o1≥o0o_1≥ o_0. They reveal no additional task evidence and differ only in their current proposal computation and offered plans; future generator and execution rules are fixed. Write S0,S1S_0,S_1 for the corresponding post-overhead states. The cost-only objective uses μ=0μ=0. An ideal continuation policy can ignore extra budget, so its feasible policy classes are nested. This assumption is about an ideal class, not a learned network’s behavior. Let Ω0 _0 be the cheap menu, Ω0′ _0 its still-affordable subset at S1S_1, and Ω1⊇Ω0′ _1 _0 the richer menu. Each includes ACCEPT. For this comparison, Q∗(S,ω)Q^*(S,ω) is the supremum of expected net returns over the stipulated feasible continuation-policy class after first work ω. It is an analytical oracle quantity, not another trained network. Let ViV_i be the optimal value before paying builder i’s overhead, for i∈0,1i∈\0,1\. Define M00=maxΩ0Q∗(S0,⋅),M01=maxΩ0′Q∗(S1,⋅),M11=maxΩ1Q∗(S1,⋅).M_0^0= _ _0Q^*(S_0,·), M_0^1= _ _0Q^*(S_1,·), M_1^1= _ _1Q^*(S_1,·). The best pre-overhead values for the two builders satisfy the accounting identity V1−V0=M11−M01⏟new offered-work value−λ(o1−o0)−(M00−M01)⏟lost execution opportunity.V_1-V_0= M_1^1-M_0^1_new offered-work value-λ(o_1-o_0)- (M_0^0-M_0^1)_lost execution opportunity. (25) In MjiM_j^i, superscript i identifies the paid state and subscript j the menu family. The scalars V0,V1V_0,V_1 are used only in this comparison; they are not learned state-value models. Both bracketed differences are nonnegative under the stated inclusion and nested-policy assumptions. The first follows from menu inclusion at S1S_1; the last follows by simulating any lower-budget continuation at the higher budget. Substituting Vi=−λoi+MiiV_i=-λ o_i+M_i^i proves the identity. A richer menu is worthwhile only if its new options pay for both its direct cost and its lost execution opportunity. This is not an optimal menu-generation algorithm, nor a bound for approximate Q or an actor that changes with budget. The menu-size study in Table S15 reports pre-overhead and final gains, but does not identify them as matched-policy values in this proposition. The default controller still uses the bounded menu of Appendix F.3; no oracle is added. G.4 Evidence and Scope G.4.1 Incomplete Summaries The two-check model extends without assuming independent failures. Fix an ordered list of n≥1n≥ 1 serial checks, nonnegative costs cic_i, common dispatch cost d, and extra blind-batch construction cost a. A hard failure at any prefix makes later checks irrelevant to the final eligible output in this comparison. Let si−1s_i-1 be the probability that the first i−1i-1 checks contain no such failure, with s0=1s_0=1. Assume identical potential check outcomes, no early cancellation inside the blind batch, maximal-path affordability, and no repair or reinvestment after termination. Proposition 6. Under these conditions, for arbitrary dependence between check outcomes, Cbatch C_ batch =d+a+∑i=1nci, =d+a+ _i=1^nc_i, (26) Csequential _ sequential =∑i=1nsi−1(d+ci), = _i=1^ns_i-1(d+c_i), (27) Cbatch−Csequential C_ batch-EC_ sequential =a+∑i=2n[(1−si−1)ci−si−1d]. =a+ _i=2^n [(1-s_i-1)c_i-s_i-1d ]. (28) Proof. The sequential policy launches check i exactly when the preceding checks survive. Multiply its launch and check costs by this indicator and take expectations. The blind batch always executes the full list and pays one dispatch. Subtraction cancels d+c1d+c_1 because s0=1s_0=1. Dependence changes the survival probabilities, not the identity. ∎ For n=2n=2, s1=1−ps_1=1-p recovers Equation (24). Estimating survival by a product of marginal pass rates would add an independence assumption that the result does not require. These probabilities are diagnostic inputs, not secretly available to the deployed controller. The finite test enumerates joint outcomes; Table S16 reports costs but not the survival probabilities and coupled regime settings needed for a numerical test of this identity. This calculation predicts a cost crossover for a fixed output, not that longer speculative drafts always help. G.4.2 Ordering-Robust Reversal Finite setting. A candidate is adoptable exactly when three binary hard checks all pass; otherwise the incumbent is returned. Each check costs one and each dispatched nonempty block costs d=3/2d=3/2. A launched block completes all its checks before feedback can affect the next choice. Policies must stop at an observed failure and finish all checks on a surviving path. They may choose any unchecked subset at each boundary. Both contexts have a budget of at least 15/215/2 and at least three primitive attempts. There is no within-block cancellation, repair, or reinvestment after termination. These are output-equivalent verification policies, not unrestricted agent-search policies allowed to stop without completing a promising version. Prior legal evidence identifies the conditional law, not the realized future outcome. Let X∈0,13X∈\0,1\^3 be the potential outcome vector, with 1 denoting pass. In context A, the four atoms 111,100,010,001111,100,010,001 each have probability 1/41/4. In context B, atom 111111 has probability 1/41/4, each of 110,101,011110,101,011 has probability 1/81/8, and 000000 has probability 3/83/8. All other probabilities are zero. Both laws are exchangeable: every permutation of the checks leaves the law unchanged. Both have Pr(Xi=1)=1/2 (X_i=1)=1/2 and Pr(X=111)=1/4 (X=111)=1/4. The same candidate description, missing-item mask, resources, marginal predictions, and final-success prediction therefore do not identify the context. Observing its joint evidence does not reveal any future check result. Proposition 7 (Ordering-robust scope reversal). In this setting, the unique optimal first-block size is two in A and one in B, even when subsequent subset choices are adaptive and ordering is unrestricted. Optimal costs are 33/833/8 and 17/417/4, respectively. A selector whose first decision receives identical compressed input in the two contexts has worst-context expected excess cost at least 3/403/40, even if its subsequent decisions are optimal. This bound is tight. In the cost-only objective it gives net-return loss at least 3λ/403λ/40 for λ>0λ>0. Proof. Before a failure, every observed bit equals one. Exchangeability makes all remaining subsets of the same size equivalent. Thus every deterministic surviving-path policy is represented by one of the four ordered block-size compositions →11\!→\!1\!→\!1, →21\!→\!2, →12\!→\!1, or 33. Randomization is a mixture over such boundary choices and cannot improve a linear expected cost. Let q=Pr(Xi=Xj=1)q= (X_i=X_j=1) for distinct items. Its values are 1/41/4 in A and 3/83/8 in B. Costs for the four compositions are, respectively, 52(32+q),174,72+52q,92. 52 ( 32+q ), 174, 72+ 52q, 92. For example, the two-then-one plan always pays 2+3/22+3/2 for its first block, and pays 1+3/21+3/2 again only with probability q. Substitution gives the four costs in Table S24. Conditioning on a first block of size one, the optimal continuation batches the two remaining checks in both contexts. The best achievable regrets conditional on first-block sizes 1,2,31,2,3 are therefore :(1/8,0,3/8),:(0,3/16,1/4). A:\ (1/8,0,3/8), B:\ (0,3/16,1/4). These already grant optimal subsequent information use. For any first-block mixture, averaging its regret with context weights (3/5,2/5)(3/5,2/5) is at least 3/403/40: the three pure-size averages are 3/403/40, 3/403/40, and 13/4013/40. Its worst-context regret is no smaller. Choosing first size one with probability 3/53/5 and size two with probability 2/52/5 attains 3/403/40 in both contexts. Identical realized adoption outcomes make terminal utility cancel, yielding the stated return loss. ∎ Scope of the result. Reordering checks does not remove the reversal. The result isolates information missing from compressed summaries; it does not lower-bound a named baseline given full evidence. Learned joint features may distinguish the contexts, but incorrect features can still select poorly. Cost-sensitive information acquisition is studied in stochastic function evaluation (Deshpande et al., 2014; Hellerstein et al., 2022); correlated observations are studied in stochastic function certification (Ghuge et al., 2026). The example isolates the consequence of correlation for paid, feedback-delaying blocks with unchanged success summaries. Table S24: Exact laws and complete scheduling costs. Each bit is a required check outcome. The left panel lists all probability atoms; the right lists all surviving-path block compositions at c=1c=1, d=3/2d=3/2. Both contexts have marginal pass probability 1/21/2 and all-pass probability 1/41/4. This is one finite construction, not two experimental datasets. Outcome A B 000 0 3/8 001 1/4 0 010 1/4 0 011 0 1/8 100 1/4 0 101 0 1/8 110 0 1/8 111 1/4 1/4 Schedule Cost A Cost B 1→1→11→ 1→ 1 4.3750 4.6875 1→21→ 2 4.25004.2500 4.25004.2500 2→12→ 1 4.12504.1250 4.43754.4375 33 4.5000 4.5000 A compressed first-block choice has regret LA(p)=p/8L_A(p)=p/8, LB(p)=3(1−p)/16L_B(p)=3(1-p)/16. Here p is the probability of choosing first-block size one (otherwise two), not a check-failure probability. They meet at p=3/5p=3/5, with loss 3/403/40. Continuous family. For pair-survival probability q∈[1/4,3/8]q∈[1/4,3/8], let x∈0,13x∈\0,1\^3 denote an outcome atom and |x|=x1+x2+x3|x|=x_1+x_2+x_3 its number of passes. Assign the probability of each atom according to its Hamming weight: Prq(X=x)=3q−3/4,|x|=0,3/4−2q,|x|=1,q−1/4,|x|=2,1/4,|x|=3. _q(X=x)= cases3q-3/4,&|x|=0,\\ 3/4-2q,&|x|=1,\\ q-1/4,&|x|=2,\\ 1/4,&|x|=3. cases The singleton and doubleton lines apply to each of their three atoms. Probabilities are nonnegative and sum to one. Every marginal remains 1/21/2, all-pass remains 1/41/4, and every pair-survival probability is q. With unit per-check cost and arbitrary dispatch d≥0d≥ 0, the costs for schedules 1→1→11→ 1→ 1, 1→21→ 2, 2→12→ 1, and 33, in that order, are (1+d)(3/2+q),2+3d/2,2+d+q(1+d),3+d.(1+d)(3/2+q), 2+3d/2, 2+d+q(1+d), 3+d. (29) At d=3/2d=3/2, the optimum is min17/4,7/2+(5/2)q \17/4,7/2+(5/2)q\, with a tie at q=3/10q=3/10. This is an exact sensitivity analysis, not a fitted empirical law. (a) Expected cost at fixed dispatch cost (b) Optimal scope across commitment costs Figure S15: The optimal scope depends on commitment costs. Both plots evaluate the stated analytical costs, not fitted outcomes. The one-dimensional slice fixes dispatch at 3/23/2; the phase map varies dispatch and pair-survival probability. Boundaries and ties follow the declared formulas. Executable checks. The accompanying rational-arithmetic module enumerates every joint atom and solves the finite decision problem by dynamic programming over all nonempty unchecked subsets. Eleven tests check normalization, equal summaries, exchangeability, all six permutations, realized output equivalence, budget sufficiency, global optimality, the continuous switch, and the tight minimax certificate. Earlier fixed-order reference code is retained for provenance but is not used to establish this stronger proposition. These are finite mathematical tests, not neural or environment experiments. G.5 Matched Scope Control The preceding reversal can also be read as an exact two-factor comparison. This separates the benefit of a different permitted work scope from a weaker controller. Draw contexts A and B with probability 1/21/2 each. Both arms see the same candidate, initial missing mask, budget, and check outcomes as they are acquired. Only the full-context row observes which joint law applies before acting. Both work-scope columns pay the same 3/23/2 per dispatch and one per check, with the same final output for each realized vector. A singleton policy may remember all observed history and plan nonmyopically; it is not forced to optimize immediate reward. Proposition 8 (Exact information–scope comparison). Under the three-check setting in Appendix G.4.2, optimal expected costs, averaging the two contexts, are singleton onlyblocks permittedcompressed summaries145/3217/4full joint context145/3267/16. array[]c|c&singleton only&blocks permitted\\ summaries&145/32&17/4\\ full joint context&145/32&67/16 array. At full information, permitting blocks reduces expected cost by 11/3211/32. With blocks permitted, context information reduces expected cost by 1/161/16. These are dispatch-cost differences, not improved final output probabilities. Proof. For singleton execution, all check orders are equivalent by exchangeability, and every surviving path must finish. Its costs are 35/835/8 in A and 75/1675/16 in B, averaging 145/32145/32. Knowing the context cannot improve check order. Without the context, the four fixed surviving-path block compositions have average costs 145/32,17/4,137/32,9/2145/32,17/4,137/32,9/2; their minimum is 17/417/4. Adaptation does not add a fifth surviving-path composition because every observed bit before termination is one. With full context, choose 2→12→ 1 in A and 1→21→ 2 in B, averaging (33/8+17/4)/2=67/16(33/8+17/4)/2=67/16. Subtracting gives the two differences. ∎ The matrix above retains all four matched conditions; the zero-dispatch boundary separates the effect of information from the cost of committing a work block. The zero-dispatch boundary is essential: when dispatch is free, singleton costs are 7/47/4 and 15/815/8, and allowing blocks cannot improve them. This agrees with Proposition 4. Our reference calculation exhausts all orders and nonempty unchecked subsets and checks identical realized output. Thus the comparison establishes a real cost mechanism without giving the singleton arm less information or a shorter planning horizon. It does not show that a learned network attains these optimal policies on real agent tasks. A matched empirical factorial is still needed. G.6 Menu Approximation G.6.1 Approximation Error Proposition 9. At one paid state S and fixed continuation policy π, let finite nonempty catalogs satisfy Ω⊆Ω⋆ _ , where Ω⋆ _ is the comparison catalog. Suppress the common state argument in QπQ^π and Q^=Q^ϕ¯ Q= Q_ φ. Suppose |Q^(ω)−Qπ(ω)|≤ε| Q(ω)-Q^π(ω)|≤ for every ω∈Ωω∈ , where ε≥0 ≥ 0 is a uniform error bound, not the exploration rate. For selected ωa∈Ω _a∈ , write Δmenu=maxΩ⋆Qπ−maxΩQπ,δa=maxΩQ^−Q^(ωa). _ menu= _ _ Q^π- _ Q^π, _a= _ Q- Q( _a). Here Δmenu _ menu is omitted-menu loss and δa _a is the scorer gap of the chosen plan. Each maximum ranges over its displayed catalog. Then maxΩ⋆Qπ−Qπ(ωa)≤Δmenu+2ε+δa _ _ Q^π-Q^π( _a)≤ _ menu+2 + _a. Proof. Split at maxΩQπ _ Q^π, upper-bound this maximum by maxΩQ^+ε _ Q+ , and lower-bound the chosen value by Q^(ωa)−ε Q( _a)- .∎ Observed RMSE is not a uniform error guarantee. Full catalog values require paid continuation experiments on bounded cases; unrestricted alternatives are unknown. The inequality diagnoses one decision and does not establish global regret or policy improvement. Solver gap under its additive surrogate is a separate computational quantity. G.6.2 Seeded Refinement For m≥1m≥ 1 extensions forming feasible job sets A0⊂⋯⊂AmA_0⊂·s⊂ A_m, set W(A)=Q^ϕ¯(S~,VERIFY(A))W(A)= Q_ φ( S, VERIFY(A)) at one fixed proposal state. Then ∑t=1m[W(At)−W(At−1)]=W(Am)−W(A0). _t=1^m[W(A_t)-W(A_t-1)]=W(A_m)-W(A_0). The equality holds without additivity or submodularity. Unlike summing W(Dj)W(D_j), it does not repeatedly add the same base continuation. However, positive single-job increments can still miss bundles: with two jobs of unit cost, gain g>2λg>2λ, and a fixed continuation that stops immediately after the offered work, W(∅)=0W( )=0, W(a)=W(b)=−λW(\a\)=W(\b\)=-λ, and W(a,b)=g−2λ>0W(\a,b\)=g-2λ>0. Empty-seed positive-gain greedy stops; an affordable complete-candidate seed presents the pair to the actor. This verifies the purpose of the seed family, not a general approximation ratio. Higher-order cross-candidate interactions and inaccurate W remain limitations. G.7 Learning Identities G.7.1 Policy-Gradient Baseline Fix the initial state, verification contract Γ , menu settings ν, scorer snapshot ϕ¯k φ_k, and support rules. Let ϑ=(θ,ψ) =(θ,ψ) contain only the sampled edit/plan parameters, τ a full search trajectory, PϑP_ its induced law, and R(τ)R(τ) its realized return. With the typed probabilities of Equation (19) and the usual differentiability, integrability, and fixed-support conditions, ∇ϑτ∼PϑR(τ)=[Rg∑j=1Jg∇ϑlogpϑ(yg,j∣Hg,j,g,j)]. _ E_τ P_ R(τ)=E\! [R_g _j=1^J_g _ p_ (y_g,j H_g,j,Y_g,j) ]. A deterministic menu generator may depend on observed history; its parameters are held fixed here and it contributes no sampled likelihood. Random environment outcomes likewise have no actor likelihood. For G conditionally independent searches, the baseline bg=(G−1)−1∑u≠gRub_g=(G-1)^-1 _u≠ gR_u is independent of trajectory g conditional on the common start and snapshot. The expectation of bgb_g times that trajectory’s score function is zero. Consequently, at ϑk _k, the expected unclipped group estimator using Ag=Rg−bgA_g=R_g-b_g equals the displayed gradient, with bgb_g detached. It is not an identity for gradients through scorer fitting, generator changes, or KL regularization. Clipping remains a surrogate, not a monotonicity guarantee (Ahmadian et al., 2024; Schulman et al., 2017). Each sampled token and plan contributes once; a deterministic solver contributes none. Dividing each search by JgJ_g, reusing shared-tree leaves as independent group members, or differentiating through AgA_g changes this estimator. Frozen-menu optimization is the local update in Appendix F.5; refreshed menus require fresh collection. This does not establish global policy improvement or an unbiased off-policy gradient after arbitrary optimization steps. G.7.2 Contrast Identifiability At a fixed state and continuation policy, each prospectively forced arm has an ordinary expected return. Independence and fixed sample sizes make its sample mean unbiased. Their difference therefore identifies the conditional contrast in Equation (12). Minimizing population squared difference error identifies that contrast, but is invariant to a common offset added to both predictions. The ordinary return loss in Equation (11) is consequently required to anchor mean calibration. Neither identity establishes data efficiency, actor improvement, or causality of an individual edit. These are separately measured claims. Appendix H Nomenclature Full forms of abbreviations and method names in Section 2 and its cited work are collected below. Named systems without an initialism expansion are listed by their published title or a brief definition. Table S25: Abbreviations and terminology. Term Full form or published name Recursive Self-improvement RSI Recursive Self-Improvement. SpecRSI (ours) Speculative Recursive Self-Improvement (this work; Section 3). VATS Verification-Aware Tree Search (this work; Section 3.3). GVO Group Verification Optimization (this work; Section 3.4). DGM Darwin Gödel Machine (Zhang et al., 2026a). SICA Self-Improving Coding Agent (Robeyns et al., 2025). ADAS Automated Design of Agentic Systems (Hu et al., 2025). AFlow Automating Agentic Workflow Generation (Zhang et al., 2025b). GEPA Genetic-Pareto (Agrawal et al., 2026). MemEvolve Meta-Evolution of Agent Memory Systems (Zhang et al., 2025a). Hyperagents Self-referential agents combining a task agent and an editable meta agent in one program (Zhang et al., 2026b). MetaRSI / RSI2 A Meta-Recursive Self-Improving System for Recursive Self-Improving Systems Themselves (Tan et al., 2026). HGM Huxley-Gödel Machine (Wang et al., 2026b). Janus An Algorithm-Evaluator Co-Evolution Framework for LLM-Driven Discovery under Expensive Evaluation Budgets (Liu et al., 2026). Speculative Decoding SpecInfer Accelerating Large Language Model Serving with Tree-based Speculative Inference and Verification (Miao et al., 2024). EAGLE-2 Extrapolation Algorithm for Greater Language-model Efficiency; the suffix denotes the dynamic-draft-tree variant (Li et al., 2024). Sequoia Scalable and Robust Speculative Decoding (Chen et al., 2024). MTP Multi-token Prediction (Gloeckle et al., 2024). SV Speculative Verification (Kim et al., 2026). DSP Dynamic Speculative Planning, the method introduced in Dynamic Speculative Agent Planning (Guan et al., 2026). Speculative Actions A Lossless Framework for Faster AI Agents (Ye et al., 2026). FlashEvolve Accelerating Agent Self-Evolution with Asynchronous Stage Orchestration (Hu et al., 2026b). Learning for Agent Improvement RL Reinforcement Learning (Zhou et al., 2024). LLM Large Language Model (Leviathan et al., 2023). ArCHer Actor-Critic Framework with a Hierarchical Structure (Zhou et al., 2024). GRPO Group Relative Policy Optimization (Shao et al., 2024). DVI Draft, Verify, & Improve (Bhansali & Heck, 2025). GTO Group Tree Optimization (Hu et al., 2026a). MAS Multi-Agent System (Wang et al., 2026a). MAS2 Self-Generative, Self-Configuring, Self-Rectifying Multi-Agent Systems (Wang et al., 2026a). LOO Leave-One-Out (Ahmadian et al., 2024). PPO Proximal Policy Optimization (Schulman et al., 2017). ToT Tree of Thoughts (Yao et al., 2023).