acceptodds
Under review as a conference paper at ICLR 2027

ForkPilot: Self-Evolving Policy for Retrospective Search in Long-Horizon Agents

Abstract

Interactive language-model agents increasingly solve complex tasks through long-horizon, multi-call reasoning, where errors in beliefs or actions can compound across tool interactions. Retrospective search can recover from such failures but is prone to misallocation. Delayed outcomes obscure the contribution of intermediate search decisions, leading to Attribution Complexity, while evolving execution evidence leads to Adaptation Complexity, where previously learned estimates become stale. To address these challenges, we first introduce Search Value Dynamics (\method), which characterizes the evolving trade-off between the gain and cost of retrospective search. Building on \method, we propose , a self-evolving two-stage policy-learning framework. In the first stage, learns a search-value policy offline from completed trajectories through automatically constructed outcome comparisons. In the second stage, it makes search decisions on the current observations and then self-evolves, incorporating newly completed trajectories into subsequent policy updates. We evaluate across 6 diverse benchmarks and 7 widely used LLM backbone families, including four open-source families, GPT-5.6 Sol and Opus 4.8, against 9 competitive baselines, including real-world harness deployment used by hundreds of thousands of paid users. achieves comparable state-of-the-art performance while reducing token usage by up to 59.2%, demonstrating its efficacy.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Retrospective Search, Long-horizon Reasoning

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_3GTDOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes ForkPilot, a self-evolving search controller for long-horizon LLM agents. It learns to dynamically allocate retrospective search based on predicted benefits, computational costs, and uncertainty. Experiments across six benchmarks and multiple LLM backbones demonstrate substantial token savings while maintaining comparable task performance.

Critical strengths

The paper addresses an important practical problem of reducing inference costs in long-horizon agents. It provides extensive evaluations across diverse benchmarks and model scales, including frontier proprietary models. The ablation studies also provide evidence supporting the effectiveness of its adaptive search allocation and uncertainty-aware decisions.

Critical weaknesses
  1. Uncertain baseline reliability. Several baselines lack official implementations or validated results on the evaluated benchmarks, requiring adaptations by the authors. It remains unclear whether these adaptations faithfully reproduce the original methods or adequately optimize them for the new environments, potentially weakening the comparisons.

  2. Insufficient justification of necessity. While the paper demonstrates the effectiveness of a separately trained search controller, it does not establish whether such a mechanism is necessary. Stronger backbone models or direct LLM-based search decisions might achieve similar efficiency without expensive paired-replay training, whose costs are not adequately accounted for in the main comparisons.

Questions for authors
  1. How did the authors validate the correctness and competitiveness of baseline implementations on benchmarks not originally evaluated by those methods?

  2. Can the authors compare ForkPilot against direct LLM-based search allocation and evaluate whether its efficiency gains justify the additional training and data collection costs?

2 comments
AuthorsOpenReview ↗

Rebuttal Part I

Thank you for the review and the focused questions. We ran a new experiment with GPT-5.6 Sol controlling its own search on Automation: ForkPilot scores 69.00 versus 69.33, with 16% fewer raw and 28% fewer uncached tokens (W2 below).

W1 / Q1. Validity of the baseline implementations.

Following the reviewer's suggestion, we reproduced each memory and context baseline on a benchmark from its original paper and re-tuned all five with the same source-validation budget as ForkPilot. The implementations run from the authors' official repositories and prompts, with only the environment interface adapted; draft Table 16 (App. C.7) lists the commits; we restate the implementation setup here as well. Koh et al.'s official tree search has also been added. The reproductions (new, draft App. C.7):

Table 1. Reproduction of the five memory and context baselines on a benchmark from each original paper.

MethodOriginal benchmarkReportedOur reproduction
ReasoningBankWebArena (success rate)48.848.1
ACEAppWorld (task goal completion)59.458.7
ReflexionHumanEval (pass@1)91.090.2
GEPAHotpotQA (exact match)62.361.5
Trace2SkillSpreadsheetBench-Verified (pass rate)69.869.2

To check sensitivity to tuning in the new environments, we re-tuned each of these five baselines on Qwen3.5-27B / Automation with the same number of source-validation configurations as ForkPilot (5). No baseline moved by more than 0.3 points, and none improved on ForkPilot's score–cost operating point: the strongest, Trace2Skill, went from 29.2 to 29.3, which reaches ForkPilot's score of 29.2 but at 0.66 / 0.74 raw / uncached tokens against ForkPilot's 0.61 / 0.66. All methods share the same host infrastructure, tools, scorer, cache policy, source split and token accounting, and nothing is tuned on test tasks. These memory and context methods also complement ForkPilot: combining ReasoningBank with ForkPilot improves on both (draft Table 8).

AuthorsOpenReview ↗

Rebuttal Part II

W2 / Q2. Is a trained controller necessary, and does it justify its cost?

In the new experiment in which GPT-5.6 Sol controls its own search on Automation (part (b) below), ForkPilot reaches nearly the same score (69.00 vs. 69.33) with 16% fewer raw and 28% fewer uncached tokens, and its controller needs no additional LLM call per decision. With Sol deciding for the Qwen actor, price-weighted cost is 22% higher than ForkPilot's on Automation (17% on τ³; draft Table 25). The advantage over the adaptive allocators holds on both Qwen3.5-27B and Qwen3.5-122B-A10B.

Table 2. Task performance and token usage of ForkPilot, RTS baselines, and LLM-as-controller variants. (a) Qwen3.5-27B on AutomationBench and τ³. (b) GPT-5.6 Sol on AutomationBench with 600 tasks; the LLM-as-controller rows, where Sol controls its own search, are a new experiment (draft Table 25), and the RTS and ForkPilot rows are from draft Tables 3 and 12. S denotes task score; R and U denote raw and uncached token usage, respectively, normalized to the corresponding RTS baseline within each backbone–benchmark setting. Higher scores and lower token ratios are better. Boldface highlights ForkPilot. † Sequential host schedule; all other rows use the parallel host.

(a) Qwen3.5-27B

Method (Qwen3.5-27B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS28.71.00 / 1.0070.61.00 / 1.00
Efficient RTS / RTS(Sequential), ρ = 0.8†27.30.58 / 0.6369.20.61 / 0.64
Backbone as controller (zero-shot)27.60.93 / 0.9569.70.91 / 0.94
Backbone as controller (few-shot)28.30.85 / 0.8870.40.83 / 0.87
Backbone as controller (cost-aware)27.20.68 / 0.7369.00.68 / 0.71
ForkPilot29.20.61 / 0.6671.00.63 / 0.67

(b) GPT-5.6 Sol

MethodScore (S ↑)R / U ↓
RTS71.831.000 / 1.000
Efficient RTS / RTS(Sequential), ρ = 0.8†60.170.555 / 0.530
LLM-as-controller (zero-shot)69.330.912 / 0.768
LLM-as-controller (few-shot)69.331.123 / 0.895
ForkPilot (parallel)69.000.764 / 0.556
ForkPilot (sequential)†75.000.679 / 0.402

ForkPilot learns fork-level gain and cost estimates from paired outcomes, whereas prompted LLM controllers either over-search (zero-shot, few-shot) or sacrifice task quality (cost-aware). Unlike these alternatives, ForkPilot requires no additional LLM calls per allocation decision. The remaining question is whether its upfront learning cost is justified.

Our source-size experiments show that effective learned allocation does not require full-scale source collection. Across the four frontier settings, full-pool raw-token amortization takes 332–4,687 deployed tasks. On GPT-5.6 Sol, using just 25% of the source pool preserves near-full-pool task quality while reducing raw-token break-even to 60–1,030 tasks. We additionally evaluate 50% and 75% training fractions to characterize source-size sensitivity:

Table 3. Source-size sensitivity and learning-inclusive token amortization on frontier backbones (draft Table 11). ΔS is relative to RTS; break-even extrapolates observed per-task token savings to repeated deployment.

SettingTraining splitΔS vs. RTSSource tokens, raw / uncached (M)Break-even, raw / uncached (tasks)
Sol · AutomationFull−2.83881 / 5644,136 / 2,035
75%−2.71649 / 4173,078 / 1,361
50%−4.83442 / 2821,997 / 993
25%−3.16219 / 1401,030 / 508
Sol · τ³Full−3.101,067 / 359354 / 231
50%−3.10466 / 156143 / 96
25%−2.58203 / 6960 / 42

On Sol / τ³, 25% training achieves 64.95 versus 64.43 with full training (both solve 63/97 tasks), using 9.3% fewer inference raw tokens and 81% fewer source raw tokens. Raw-token break-even consequently falls from 354 to 60 tasks (231 to 42 for uncached tokens). On Automation, 25% training achieves 68.67 versus 69.00 with full training, reducing raw-token break-even from 4,136 to 1,030 tasks. At 75%, Automation reaches 69.12 with 26% fewer source raw tokens than full training.

Together, these results demonstrate that ForkPilot's learned allocation can provide substantial deployment-token savings with considerably less source supervision. The complete sweep also shows that performance is not monotonic in training size. Break-even figures quantify token amortization rather than quality-adjusted utility recovery; full accounting appears in draft Table 11 (App. C.3).

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

the paper asks when a long-horizon llm agent should spend compute on retrospective search, i.e. forking from an earlier state for alternative continuations. it names two pain points, attribution complexity (delayed rewards obscure the effect of a single fork) and adaptation complexity (learned search-value estimates go stale), and frames search value dynamics around the gain-cost tradeoff. forkpilot learns a search-value controller offline from paired fork-vs-skip replays, then runs it closed-loop with an empirical margin to pick full search, a capped probe, or skip.

Critical strengths

the framing is convincing and the paired-replay data construction with cost accounting that charges unselected branches is careful. empirical hygiene is above average too, task-grouped outer folds, feedback-masking and identifier-masking audits, cached vs uncached accounting, and bootstrap intervals in the ablations.

Critical weaknesses

a) theory vs practice. theorem 1 bounds reusing a source estimate at the source input only, while deployment scores a refit predictor at refreshed inputs, and the operational margin targets realized paired outcomes rather than the conditional mean. by the authors' own disclaimers the formal core is a chebyshev union bound plus a triangle decomposition, so imo the svd part is motivation, not a guarantee, and should be positioned as such.

b) missing the closest competitors. the related-work section itself names input-adaptive compute allocation as the nearest line, e.g. damani et al. (learning how hard to think, iclr 2025), certaindex (fu et al., neurips 2025) and learning when to plan (paglieri et al., arxiv 2509.03581, 2025), yet none of these is among the 9 baselines. koh et al. (tree search for language model agents, arxiv 2407.01476, 2024), the published fork-based tree-search agent, only shows up as in-house rts reimplementations.

c) the headline savings ignore the data-collection cost. stage i needs state restoration and paired replays at scale, roughly 11k to 17k accepted pairs per benchmark (tab 6), and the opus 4.8 source-training alone burned 1.541b raw tokens. eq-19 defines the amortized cost and break-even point but reports no actual numbers, and tables 1 to 3 exclude learning cost entirely. the controller is also retrained per benchmark with transfer explicitly disclaimed, so one trained artifact does not go far.

d) the obvious cost-matched competitor is buried. efficientrts appears only in appendix table 20 and paints a mixed picture, e.g. 67.53 vs 64.43 for forkpilot on gpt-5.6 sol $\tau$3-bench, and cheaper than forkpilot in raw tokens on automation. leaving it out of tables 1 to 2 makes the pareto story look better than it is.

please correct me if iwas wrong

Questions for authors

why directly copy the abstract from latex without double-check? e.g., \emph{, \model

as for the rest, please refer to the above weakness

3 comments
AuthorsOpenReview ↗

Rebuttal Part I

Thank you for the review. At equal quality and under the same host schedule, ForkPilot saves 36% of uncached tokens on Sol / Automation relative to the interpolated sequential RTS threshold sweep. Following the suggestions in W2 and W3, we also ran the requested experiments, and ForkPilot is ahead of all four added competitors on both score and cost. On W1, §3.1 states the result's limitations, and the revision renames it Proposition 1 (Diagnostic Decomposition).

W1. Theory vs. practice.

The decomposition does not bound the refreshed predictor's error, and it certifies neither the learned margin nor the deployed controller; §3.1 states both limitations. To make the result's scope clearer, we have renamed it Proposition 1 (Diagnostic Decomposition); it motivates the controller modules but does not certify their prediction error. The ablations test the module that each term motivates:

Table 1. Design implications of Proposition 1 and supporting ablations.

Decomposition termModule it motivatesAblation evidence
Finite-replay sampling errorPaired action–skip targets with a ≥20-task support ruleSource-size curve: 25% of the pool recovers most of the gain (Fig. 2)
Input change ΩHistory-conditioned state with prefix refreshvs. current-score controller: +0.91 / +1.12; vs. frozen prefix: +0.62 / +0.71
Reward-law shiftSupport check and online updatingEnvironment-shift stream: +1.82 (response to WLnn, Q3)
Fitted predictor errorCalibrated operational marginvs. no margin: R −0.081 / −0.089

The operational margin is calibrated on realized paired outcomes. As the submission states, this is not a confidence bound for the conditional mean. We evaluate its effect through held-out rollouts and the no-margin ablation.

AuthorsOpenReview ↗

Rebuttal Part II

W2. Closest competitors.

Thank you for identifying these competitors. We added Damani et al., Certaindex, Learning When to Plan and Koh et al.'s official tree search as new baselines (draft Table 25, App. F.1). Across both backbones and both benchmarks in Table 2, ForkPilot scores higher and uses fewer raw and uncached tokens than all three adaptive allocators and Koh et al.'s official tree search. These comparisons test whether paired estimates of search gain and cost improve allocation beyond input-based budgets, certainty-based stopping and learned replanning. The input-adaptive budget is fixed from the initial context, Certaindex stops when completed branches agree, and Learning When to Plan learns when to retrospect with a fixed allocation. None of them estimates the net value of a specific fork from a restored state. All four run under the same harness, menu and source data:

Table 2. ForkPilot vs. per-query adaptive allocators and tree search. (a) Qwen3.5-27B. (b) Qwen3.5-122B-A10B. R / U are normalized to RTS of the same backbone and benchmark.

(a) Qwen3.5-27B

Method (Qwen3.5-27B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS28.71.00 / 1.0070.61.00 / 1.00
Input-adaptive budget (Damani et al.)26.60.68 / 0.7467.60.73 / 0.75
Certaindex (Fu et al.)26.10.66 / 0.7266.90.69 / 0.73
Learning When to Plan (Paglieri et al.)27.30.75 / 0.7968.70.78 / 0.80
Tree search (Koh et al.)28.01.34 / 1.3069.61.26 / 1.24
ForkPilot29.20.61 / 0.6671.00.63 / 0.67

(b) Qwen3.5-122B-A10B

Method (Qwen3.5-122B-A10B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS29.81.00 / 1.0072.01.00 / 1.00
Input-adaptive budget (Damani et al.)27.90.71 / 0.7769.60.74 / 0.79
Certaindex (Fu et al.)27.50.66 / 0.7369.00.69 / 0.75
Learning When to Plan (Paglieri et al.)28.60.83 / 0.8770.40.85 / 0.88
Tree search (Koh et al.)29.11.38 / 1.3371.21.29 / 1.26
ForkPilot30.00.63 / 0.6872.40.62 / 0.67

None of the allocators matches ForkPilot's score at its cost. On Qwen3.5-122B-A10B / Automation, Certaindex scores 2.5 points below ForkPilot, and Learning When to Plan, the closest allocator, trails by 1.4 points while using 32% more raw tokens. Koh et al.'s tree search comes nearest in score, but it maximizes quality without pricing compute and spends 1.24–1.38× the tokens of RTS.

W3. Data-collection cost and per-benchmark retraining.

Thank you for raising per-benchmark retraining. We ran a new frozen-transfer experiment (draft App. F.4): applying the AutomationBench-trained controller to WorkArena++ without retraining achieves 36.0 at 0.65 / 0.69 raw / uncached token ratios, with a 17.8% fallback rate. This is close to the in-domain controller (36.4 at 0.62 / 0.66) and RTS (35.9), demonstrating that effective allocation can transfer across benchmarks without additional source collection in this setting.

AuthorsOpenReview ↗

Rebuttal Part III

On collection cost, the 1.541B raw tokens highlighted by the reviewer belong to Opus / Automation, whose full-pool break-even is 4,687 tasks. The 59.2% uncached-token saving comes from Sol / τ³, where full-source collection is amortized after 354 / 231 tasks (raw / uncached). Following the reviewer's comment, we instantiate Eq. 19 for all four frontier settings and evaluate source-size sensitivity on GPT-5.6 Sol:

Table 3. Source-size sensitivity and learning-inclusive token amortization on frontier backbones (draft Table 11). ΔS is relative to RTS; break-even extrapolates observed per-task token savings to repeated deployment.

SettingTraining splitΔS vs. RTSSource tokens, raw / uncached (M)Break-even, raw / uncached (tasks)
Sol · AutomationFull−2.83881 / 5644,136 / 2,035
75%−2.71649 / 4173,078 / 1,361
50%−4.83442 / 2821,997 / 993
25%−3.16219 / 1401,030 / 508
Sol · τ³Full−3.101,067 / 359354 / 231
50%−3.10466 / 156143 / 96
25%−2.58203 / 6960 / 42
Opus · AutomationFull−4.161,541 / 4574,687 / 4,544
Opus · τ³Full+3.642,154 / 77332 / 287

Reduced-source training substantially shortens amortization while preserving near-full-pool task quality. On Sol / τ³, 25% training achieves 64.95 versus 64.43 with full training (both solve 63/97 tasks), using 9.3% fewer inference raw tokens and 81% fewer source raw tokens. Raw-token break-even consequently falls from 354 to 60 tasks (231 to 42 for uncached tokens). On Automation, 25% training achieves 68.67 versus 69.00 with full training, reducing raw-token break-even from 4,136 to 1,030 tasks. At 75%, Automation reaches 69.12 with 26% fewer source raw tokens than full training.

Together, these experiments show that per-benchmark retraining is not always necessary and that effective learned allocation does not require exhaustive source supervision. The complete source-size sweep also reveals non-monotonic performance, while the reported break-even figures quantify token amortization rather than quality-adjusted utility recovery. Full accounting appears in draft Table 11 (App. C.3).

W4. Efficient RTS.

At equal quality and under the same host schedule, ForkPilot saves 36% of uncached tokens on Sol / Automation relative to the interpolated sequential RTS threshold sweep. Our original Efficient RTS label omitted that this baseline runs on a sequential host, which launches the next trajectory only after the current one fails, and stops at ρ = 0.8; the revision renames it RTS (sequential). The 64.43 it was compared with is ForkPilot on the default three-way parallel host. ForkPilot on the sequential host is already reported in our draft (App. C.4, draft Table 12): 75.00 on Automation, and 64.95 on τ³ at 0.292 of RTS's uncached cost; we list it here as well. The revision states the schedule wherever the baseline appears, and adds the baseline to the main frontier table (draft Table 3). With the schedule held fixed wherever we have the runs:

Table 4. Efficient RTS / RTS(Sequential), vs. ForkPilot on frontier backbones (draft Tables 3, 12 and 14). On Sol, both methods use the sequential host; on Opus, only parallel ForkPilot runs exist.

SettingForkPilot hostRTS (seq., ρ = 0.8): S ↑RTS (seq., ρ = 0.8): R / U ↓ForkPilot: S ↑ForkPilot: R / U ↓
Sol · Automationsequential (matched)60.170.555 / 0.53075.000.679 / 0.402
Sol · τ³sequential (matched)67.530.711 / 0.73864.950.505 / 0.292
Opus · Automationparallel60.670.513 / 0.54766.670.778 / 0.763
Opus · τ³parallel32.470.761 / 0.68348.310.611 / 0.569

With matched schedules on Sol / Automation, ForkPilot scores 14.8 points higher with 24% fewer uncached tokens, at 22% more raw tokens. On Sol / τ³, it gives up 2.6 points for 29% fewer raw and 60% fewer uncached tokens. The Opus comparisons are not schedule-matched; there ForkPilot scores 6.0 and 15.8 points higher. The matched-quality saving is established on Sol / Automation; the other settings show the score–cost trade-offs reported above.

We would be grateful if the reviewer could take these additions into account in the final assessment.

Q. Abstract formatting.

Thank you for catching this formatting issue. We apologize for the oversight and have corrected the formatting in the revised version.

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

The paper studies how to allocate retrospective search in long-horizon tool-using agents, where a host can restore an earlier environment state and fork alternative continuations. It frames the problem through Search Value Dynamics, which defines the value of a search action as its paired reward gain over skipping minus a cost penalty, and gives a bound on reusing a source estimate at a new input. ForkPilot learns this value from paired replays in a restorable sandbox, using a GRU encoder over structured trajectory events with an ensemble of gain and cost heads and a calibrated margin. At each retrospective opportunity it commits to the action with a positive lower score, otherwise tries a cheap probe with a positive upper score, and otherwise skips; the controller is periodically refitted as completed tasks accumulate.

Experiments cover six agentic benchmarks, a range of open-weight backbones and two proprietary ones, against test-time search, experience-based adaptation and a production harness. On open-weight models ForkPilot matches full-budget retrospective tree search (RTS) within about half a point while using roughly 30–36% fewer raw tokens. On proprietary models it saves 22–41% of raw and 24–59% of uncached tokens, with scores mostly a few points below RTS. Appendix ablations compare it with threshold-based stopping and with variants lacking history, refresh or the margin.

Critical strengths
  1. A useful problem and a learnable target. Deciding when and how much to search is a real cost driver for agents, and turning the value of computation into a paired-replay target that a small controller can learn from is an interesting, practical idea. In matched-cost comparisons the learned controller improves on a validation-tuned stopping threshold by about one point on both audited backbones.

  2. Careful experimental protocol. Task-grouped outer folds, a strict cold-start definition, paired replays with shared exogenous randomness, and mechanism ablations with simultaneous hierarchical intervals make the appendix results more credible than is typical for agent papers.

Critical weaknesses
  1. The headline efficiency claim lacks matched-cost baselines and learning-inclusive accounting. The headline token savings are computed relative to full-budget RTS. In the appendix, a validation-selected stopping threshold reaches the same cost as ForkPilot, where the learned controller adds about one point (Table 13), and Efficient RTS offers another cheaper operating point; neither appears in the main results, so the gain attributable to learning is hard to judge. The reported savings also count deployment only: source collection for Opus 4.8 on AutomationBench used 1.54B raw tokens, against 0.89B for full RTS on the whole test panel, and no numerical break-even is reported. Pairing the largest saving with "comparable performance" is also optimistic, as ForkPilot scores 2.8–4.2 points below RTS in three of the four proprietary settings.

  2. The contribution is narrower than framed. Theorem 1 is a valid but narrow result: it bounds the reuse of a source estimate at a fixed input, which the deployed controller does not do, and the paper notes that it certifies neither the margin nor the deployed policy. The approach combines known ingredients, namely the value of computation from metareasoning (Russell & Wefald, 1991; Hay et al., 2012), Monte Carlo value estimation from restored states, used for training in [1], and tree search with state restoration (Zhou et al., 2024; Koh et al., 2024). Its specific addition, the full learned search-allocation policy, yields about one point at matched cost, and it depends on exact state restoration, which limits where it applies. Typos such as "it cit makes" (§1) and "consistently consistently" (§4); §4.1 lists Qwen3.5 sizes as 4B, 9B, 28B and 122B while the tables use 27B; and App. B.3 points to a no-margin ablation in "Section 4.4" that appears in App. E.

References

  1. Kazemnejad et al. VinePPO: Refining Credit Assignment in RL Training of LLMs. https://proceedings.mlr.press/v267/kazemnejad25a.html
Questions for authors
  1. Inconsistent numbers and labels. For Opus 4.8 on τ³-Bench, Table 3 reports RTS at 44.67 and ForkPilot at 48.31, whereas Tables 19 and 20 report 36.08 and 33.51 with identical token ratios, and App. C.5 states that no complete second-benchmark Opus comparison is available; under the appendix numbers, GHCP would dominate ForkPilot there. In addition, results labeled Qwen3.5-9B and 27B in Tables 4, 8, 13, 15 and 17 match the 4B and 9B rows of Table 2. Which numbers and labels are correct?

  2. Matched-cost baselines and learning cost. Could you report the validation-selected threshold and Efficient RTS in the main results, and the numerical break-even for each setting including source collection and updates?

  3. Backbone-as-controller baseline. How does ForkPilot compare with prompting the backbone itself to decide whether and how much to retrospect, counting its extra calls?

  4. Controller inputs. App. B.1 lists structural features, yet Table 17 masks literal identifiers and changes the results. How do identifiers enter the representation, and does the GRU matter relative to simpler encoders given the same inputs?

5 comments
AuthorsOpenReview ↗

Rebuttal Part I

Thank you for the careful review. At matched raw cost on Qwen, ForkPilot improves on the validation-selected stopping threshold by +0.92 [+0.55, +1.31] points on 4B and +1.03 [+0.63, +1.44] on 9B (draft Table 17, App. D.3; listed below as well).

W1 / Q2. Matched-cost baselines and learning cost.

Table 1 compares ForkPilot with the validation-selected stopping threshold at matched raw-token cost (draft Table 17, App. D.3). ForkPilot improves on that threshold by +0.92 [+0.55, +1.31] points on 4B and +1.03 [+0.63, +1.44] on 9B:

Table 1. Matched-cost comparison with the validation-selected stopping threshold (Qwen, AutomationBench; Table 17 in the draft).

BackboneThreshold: S ↑Threshold: raw / uncached (k per task)ForkPilot: S ↑ForkPilot: raw / uncached (k per task)
Qwen3.5-4B (ρ = 0.85)13.6199.80 / 75.9914.5399.84 / 75.99
Qwen3.5-9B (ρ = 0.75)24.58117.72 / 89.8825.61117.78 / 89.88

On GPT-5.6 Sol / Automation, ForkPilot is 1.0 point above the closest-quality threshold (ρ = 0.9) with 21% fewer raw and 41% fewer uncached tokens, and 14.5 points above ρ = 0.6 at comparable raw cost. The low-cost RTS baseline (formerly Efficient RTS) runs under a sequential host schedule, so we compare it with ForkPilot under the same schedule. There ForkPilot is 14.8 points higher on Automation with 24% fewer uncached tokens:

Table 2. Stopping thresholds applied to RTS vs. ForkPilot on GPT-5.6 Sol, by host schedule (Table 14 in the draft).

GPT-5.6 SolAutomation: S ↑Automation: R / U ↓τ³: S ↑τ³: R / U ↓
Parallel host
RTS, stop at ρ = 0.654.500.791 / 0.77667.530.959 / 0.971
RTS, stop at ρ = 0.861.000.885 / 0.85466.491.023 / 1.047
RTS, stop at ρ = 0.968.000.973 / 0.94168.561.003 / 1.024
ForkPilot69.000.764 / 0.55664.430.588 / 0.408
Sequential host
Efficient RTS / RTS(Sequential), stop at ρ = 0.860.170.555 / 0.53067.530.711 / 0.738
ForkPilot (sequential)75.000.679 / 0.40264.950.505 / 0.292

Both baselines now appear in the revision (draft Tables 3, 14, 17 and 25). On learning cost, following the reviewer's comment, we instantiate Eq. 19 for all four frontier settings, accounting for executed replay arms, failed runs, and state preparation (draft Table 11). The 1.54B raw-token source pool on Opus / Automation, comprising two-thirds of the benchmark, is amortized after 4,687 deployed tasks.

Importantly, full-scale source collection is not necessary to achieve ForkPilot's efficiency gains. On GPT-5.6 Sol, using just 25% of the source pool preserves near-full-pool task quality while reducing raw-token break-even to 60–1,030 deployed tasks. We additionally report the 50% and 75% settings to characterize source-size sensitivity:

Table 3. Source-size sensitivity and learning-inclusive token amortization on frontier backbones (draft Table 11). ΔS is relative to RTS; break-even extrapolates observed per-task token savings to repeated deployment.

SettingTraining splitΔS vs. RTSSource tokens, raw / uncached (M)Break-even, raw / uncached (tasks)
Sol · AutomationFull−2.83881 / 5644,136 / 2,035
75%−2.71649 / 4173,078 / 1,361
50%−4.83442 / 2821,997 / 993
25%−3.16219 / 1401,030 / 508
Sol · τ³Full−3.101,067 / 359354 / 231
50%−3.10466 / 156143 / 96
25%−2.58203 / 6960 / 42

On Sol / τ³, the 25%-source controller slightly improves on full-source training (64.95 vs. 64.43; both solve 63/97 tasks), while using 9.3% fewer inference raw tokens and 81% fewer source raw tokens. Raw-token break-even drops from 354 to 60 tasks (231 to 42 for uncached tokens). On Automation, 25% training achieves 68.67 versus 69.00 with full training, reducing raw-token break-even from 4,136 to 1,030 tasks. The 75%-source setting further reaches 69.12 with 26% fewer source raw tokens than full training.

These results show that effective learned search allocation does not require exhaustive source supervision. Performance is not monotonic in training size, and the reported break-even values quantify token amortization rather than quality-adjusted utility recovery. Full accounting appears in draft Table 11 (App. C.3).

AuthorsOpenReview ↗

Rebuttal Part II

W2. Scope of the contribution.

The contribution is not state restoration or the value-of-computation principle in isolation. It is the learned decision target and unit of allocation: at each history-conditioned retrospective opportunity, ForkPilot uses paired action-versus-skip continuations to estimate the marginal reward gain and token cost of available search budgets, then jointly chooses whether to search and how much.

This differs from input-level budgeting, confidence-based stopping, and fixed-budget replanning, which do not learn the estimated net value of each candidate fork at the refreshed state.

We have added the missing VinePPO citation (Kazemnejad et al., 2025). VinePPO uses restored-state rollouts for RL credit assignment when updating the policy; ForkPilot instead holds the actor fixed and uses paired outcomes to train a test-time search-allocation controller.

On the size of the learned contribution: the one-point figure is the Qwen matched-cost comparison (Table 1 in our response [1/4]), with paired CIs that exclude zero (draft Table 17). On GPT-5.6 Sol / Automation, ForkPilot exceeds the closest-quality threshold (ρ = 0.9) by 1.0 point while using 21% fewer raw and 41% fewer uncached tokens (Table 2 in our response [1/4]). Following the reviewer's suggestion, we also ran new comparisons against adaptive-compute allocators and tree search, under the same harness, action menu and token accounting (draft Table 25, App. F.1):

Table 4. ForkPilot vs. per-query adaptive allocators and tree search. (a) Qwen3.5-27B. (b) Qwen3.5-122B-A10B. R / U are normalized to RTS of the same backbone and benchmark.

(a) Qwen3.5-27B

Method (Qwen3.5-27B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS28.71.00 / 1.0070.61.00 / 1.00
Input-adaptive budget (Damani et al.)26.60.68 / 0.7467.60.73 / 0.75
Certaindex (Fu et al.)26.10.66 / 0.7266.90.69 / 0.73
Learning When to Plan (Paglieri et al.)27.30.75 / 0.7968.70.78 / 0.80
Tree search (Koh et al.)28.01.34 / 1.3069.61.26 / 1.24
ForkPilot29.20.61 / 0.6671.00.63 / 0.67

(b) Qwen3.5-122B-A10B

Method (Qwen3.5-122B-A10B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS29.81.00 / 1.0072.01.00 / 1.00
Input-adaptive budget (Damani et al.)27.90.71 / 0.7769.60.74 / 0.79
Certaindex (Fu et al.)27.50.66 / 0.7369.00.69 / 0.75
Learning When to Plan (Paglieri et al.)28.60.83 / 0.8770.40.85 / 0.88
Tree search (Koh et al.)29.11.38 / 1.3371.21.29 / 1.26
ForkPilot30.00.63 / 0.6872.40.62 / 0.67

The gap between these allocators and ForkPilot is 1.9–3.1 points on 27B Automation and 1.4–2.5 points on 122B Automation, each at higher raw cost than ForkPilot.

Following your suggestion on theoretical framing, Theorem 1 is now presented as Proposition 1 (Diagnostic Decomposition) in §3.1 rather than a standalone mathematical result. It links the decomposition terms to the controller modules: each term isolates a specific failure mode and motivates one of the modules ablated in draft Table 18 (history-conditioned state, prefix refresh, calibrated margin). The state-restoration requirement is now stated in §3.2. Our host satisfies it through session-scoped overlays, with 99.4–99.8% restore agreement (draft Table 6), and the cold-start variant needs no source collection. The typos, the §4.1 model list and the App. B.3 cross-reference are corrected.

AuthorsOpenReview ↗

Rebuttal Part III

Q1. Inconsistent numbers. Thank you for catching this. The final values are RTS 44.67 / ForkPilot 48.31 for Opus τ³, and Qwen3.5-4B / 9B for the two ablation backbones. With the corrected values, GHCP (41.24 at 0.171 / 0.251) no longer dominates ForkPilot on Opus τ³; it scores 7.1 points lower. We have updated the Opus τ³ column from the completed run:

Table 5. Opus 4.8 / τ³ regenerated from the completed scoring run (the five shared rows match draft Tables 3, 23 and 24; the RTS (sequential, ρ = 0.8) row is from draft Table 3 and the same run; absolute totals rounded to 0.1M). † Sequential host schedule, formerly Efficient RTS; all other rows use the parallel host.

Opus 4.8 / τ³S ↑Raw / Uncached (M)R / U ↓
BoN-544.441,838.0 / 166.11.137 / 2.743
RDS29.902,724.0 / 27.51.685 / 0.454
GHCP41.24276.6 / 15.20.171 / 0.251
Efficient RTS / RTS(Sequential), ρ = 0.8†32.471,230.9 / 41.40.761 / 0.683
RTS44.671,616.6 / 60.61.000 / 1.000
ForkPilot48.31987.2 / 34.50.611 / 0.569

Q3. Backbone as controller. Thank you for suggesting the backbone-controller comparison. We ran a new experiment in which the backbone itself (Qwen3.5-27B) controls search, with zero-shot, few-shot and cost-aware prompts (draft Table 25). ForkPilot fits gain and cost estimates from paired outcomes, whereas the prompted baselines receive instructions and, in the few-shot condition, paired examples. In our runs the prompted backbone either over-searches or loses score. Even with few-shot paired examples in the prompt, it runs at R 0.85 on Automation, against 0.61 for ForkPilot. All variants run under the same harness, with every controller-call token charged:

Table 6. Task performance and token usage of ForkPilot, RTS baselines, and LLM-as-controller variants. (a) Qwen3.5-27B on AutomationBench and τ³. (b) GPT-5.6 Sol on AutomationBench with 600 tasks; the LLM-as-controller rows, where Sol controls its own search, are a new experiment (draft Table 25), and the RTS and ForkPilot rows are from draft Tables 3 and 12. S denotes task score; R and U denote raw and uncached token usage, respectively, normalized to the corresponding RTS baseline within each backbone–benchmark setting. Higher scores and lower token ratios are better. Boldface highlights ForkPilot. † Sequential host schedule; all other rows use the parallel host.

(a) Qwen3.5-27B

Method (Qwen3.5-27B)Automation: Score (S ↑)Automation: Raw / Uncached ratio (R / U ↓)τ³: Score (S ↑)τ³: Raw / Uncached ratio (R / U ↓)
RTS28.71.00 / 1.0070.61.00 / 1.00
Efficient RTS / RTS(Sequential), ρ = 0.8†27.30.58 / 0.6369.20.61 / 0.64
Backbone as controller (zero-shot)27.60.93 / 0.9569.70.91 / 0.94
Backbone as controller (few-shot)28.30.85 / 0.8870.40.83 / 0.87
Backbone as controller (cost-aware)27.20.68 / 0.7369.00.68 / 0.71
ForkPilot29.20.61 / 0.6671.00.63 / 0.67

(b) GPT-5.6 Sol

MethodScore (S ↑)R / U ↓
RTS71.831.000 / 1.000
Efficient RTS / RTS(Sequential), ρ = 0.8†60.170.555 / 0.530
LLM-as-controller (zero-shot)69.330.912 / 0.768
LLM-as-controller (few-shot)69.331.123 / 0.895
ForkPilot (parallel)69.000.764 / 0.556
ForkPilot (sequential)†75.000.679 / 0.402
Reviewer_WLnnOpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

ForkPilot learns when and how much retrospective search a long-horizon agent should perform. Paired continuations from restored states provide supervision for incremental reward and cost. A recurrent representation, an ensemble of prediction heads, and an empirical reliability margin determine whether to execute a search allocation, run a bounded probe, or skip the current opportunity. Controller parameters are updated between completed source-task blocks, while inputs and decisions are refreshed within a task. Search Value Dynamics decomposes uncertainty and source-to-current discrepancy under a fixed replay protocol. Experiments report quality/token trade-offs across six benchmarks and multiple open and proprietary backbones, with additional stopping, margin, and refreshed-state ablations.

Critical strengths
  1. The allocation problem is practically relevant, and the method specifies important information boundaries: source/test grouping, parameter freezing within tasks, accounting for unselected branches, and isolation of paired replay arms. The paper also explicitly distinguishes its empirical decision margin from a deployment guarantee supplied by the theorem (Section 3 and Appendices B–C).

  2. The same-host mechanism controls are more informative than comparisons only with full search. The reported learned-stopping, frozen-prefix, current-score, and no-margin controls help isolate what history and reliability modeling contribute; the paired intervals and limited WorkArena++ replication are useful evidence if the experiment identities are reconciled (Tables 13–18).

Critical weaknesses
  1. Several conflicting results prevent a reliable reading of central claims. For Opus 4.8 on τ3-Bench, Table 3 reports RTS/ForkPilot scores of 44.67/48.31, whereas Tables 19–20 report 36.08/33.51 with the same ForkPilot token ratios; the direction of the quality difference reverses. Appendix C.5 additionally says that a complete second-benchmark Opus comparison is unavailable. Model labels also conflict: Table 4 and later ablations assign 14.5/44.2 to Qwen3.5-9B and 25.6/65.0 to 27B, while Table 2 assigns those score pairs to 4B and 9B. These are consequential provenance issues, rather than cosmetic errors.

  2. The headline efficiency claim is stronger than the demonstrated quality-matched, learning-inclusive result. On the mutually consistent proprietary-model entries, ForkPilot loses 2.83 and 3.10 score points for GPT-5.6 Sol and 4.16 points for Opus on AutomationBench relative to RTS. The paper does not establish noninferiority for these comparisons. The 59.2% headline saving refers specifically to uncached deployment tokens, while the reported Opus source-training cost is 1.541 billion raw tokens and 0.457 billion uncached tokens (Appendix C.5). Deployment savings remain useful, but stronger claims require quality-cost curves and explicit amortization at the actual update frequency.

Questions for authors
  1. Essential clarification: Which Opus/τ3-Bench scores and Qwen backbone assignments are correct? Please provide corrected tables linked to exact run manifests and clarify whether differing task panels, model versions, or scoring definitions explain any differences. This directly determines my recommendation.

  2. Validation of the existing claim: At the same task quality, how much raw/uncached token saving remains relative to source-tuned Efficient RTS? Please provide task-paired uncertainty or a prespecified noninferiority analysis for the proprietary-model comparisons.

  3. Accounting clarification: After including paired supervision collection, failed replay arms, and subsequent updates, what is the break-even deployment volume for each evaluated setting? Please distinguish refreshing inputs within a task from evidence that between-task learning adapts to an independently changing environment.

2 comments
AuthorsOpenReview ↗

Rebuttal Part I

Thank you for checking the tables so carefully; it prompted the full audit in draft. With the corrected values, ForkPilot scores 48.31 against 44.67 for RTS on Opus 4.8 / τ³, with 43.1% fewer uncached and 38.9% fewer raw tokens.

W1 / Q1. Which numbers are correct?

For Opus 4.8 on τ³, the correct values are RTS 44.67 and ForkPilot 48.31. For the Qwen backbones, 14.5/44.2 is Qwen3.5-4B and 25.6/65.0 is Qwen3.5-9B. The reviewer's observation that the token ratios were identical across tables was the key clue. The token totals in draft Table 23 (Table 19 in the submission) already came from the completed trajectories, but its score columns had been exported from an interim scoring pass of the same trajectories, before scoring of the RTS arm had finished, and were not refreshed when the appendix was updated. We have updated the full Opus τ³ column from the completed run (below). Every method in this table uses the same 97-task panel, model version and scorer, so none of the corrections reflects a change of panel or scoring:

Table 1. Opus 4.8 / τ³ regenerated from the completed scoring run (the five shared rows match draft Tables 3, 23 and 24; the RTS (sequential, ρ = 0.8) row is from draft Table 3 and the same run; absolute totals rounded to 0.1M). † Sequential host schedule, formerly Efficient RTS; all other rows use the parallel host.

Opus 4.8 / τ³S ↑Raw / Uncached (M)R / U ↓
BoN-544.441,838.0 / 166.11.137 / 2.743
RDS29.902,724.0 / 27.51.685 / 0.454
GHCP41.24276.6 / 15.20.171 / 0.251
Efficient RTS / RTS(Sequential)†32.471,230.9 / 41.40.761 / 0.683
RTS44.671,616.6 / 60.61.000 / 1.000
ForkPilot48.31987.2 / 34.50.611 / 0.569

W2 / Q2. Quality-matched savings and uncertainty.

Thank you for asking about quality-matched savings. We added a schedule-matched iso-quality comparison and task-paired confidence intervals (draft App. F.2). Holding the host schedule fixed and interpolating the sequential RTS threshold sweep to ForkPilot's score of 75.00 on Sol / Automation, ForkPilot saves 36% of uncached tokens at essentially the same raw cost; on Qwen3.5-27B / Automation the iso-quality raw-token saving is 11.4% [7.5, 15.2]. We agree that the headline should say what it measures. The 59.2% figure is the uncached deployment-token saving for GPT-5.6 Sol on τ³, and the abstract now says so. On proprietary backbones, ForkPilot offers a substantially cheaper operating point, and we report each saving together with its task-paired score difference:

Table 2. Task-paired score differences and token savings vs. RTS on proprietary backbones.

SettingΔS vs. RTS [paired 95% CI]Uncached / raw saving
Sol · Automation−2.83 [−5.6, −0.1]44.4% / 23.6%
Sol · τ³−3.10 [−7.4, +1.2]59.2% / 41.2%
Opus · Automation−4.16 [−7.0, −1.3]23.7% / 22.2%
Opus · τ³+3.64 [−1.9, +9.2]43.1% / 38.9%

Three proprietary settings have lower point-estimate scores; for Sol / Automation and Opus / Automation, the paired 95% CIs exclude zero. On Opus / τ³, the observed gain is +3.64 points, but its CI includes zero. We therefore do not claim frontier-backbone noninferiority. Instead, Table 2 reports the measured score–token trade-offs.

In contrast, all 48 open-weight settings pass the prespecified noninferiority test (ε = 1; draft Table 28, App. F.6). On Sol / Automation, interpolating the sequential RTS threshold sweep yields a 36% uncached-token saving at matched score and host schedule. None of the evaluated RTS thresholds dominates ForkPilot on both score and token use.

Table 3. Stopping thresholds applied to RTS vs. ForkPilot on GPT-5.6 Sol, by host schedule (Table 14 in the draft).

GPT-5.6 SolAutomation: S ↑Automation: R / U ↓τ³: S ↑τ³: R / U ↓
Parallel host
RTS, stop at ρ = 0.654.500.791 / 0.77667.530.959 / 0.971
RTS, stop at ρ = 0.861.000.885 / 0.85466.491.023 / 1.047
RTS, stop at ρ = 0.968.000.973 / 0.94168.561.003 / 1.024
ForkPilot69.000.764 / 0.55664.430.588 / 0.408
Sequential host
Efficient RTS / RTS(Sequential), stop at ρ = 0.860.170.555 / 0.53067.530.711 / 0.738
ForkPilot (sequential)75.000.679 / 0.40264.950.505 / 0.292
AuthorsOpenReview ↗

Rebuttal Part II

Q3. Break-even, and between-task adaptation under environment change.

We now report source-collection costs and token amortization for all four frontier settings (draft Table 11, App. C.3), including executed replay arms, failed runs, and state preparation. The 1.541B raw-token source cost highlighted by the reviewer belongs to Opus / Automation, whose break-even is 4,687 deployed tasks. On Sol / τ³, the setting behind the 59.2% uncached-token saving, full-pool source collection costs 1.07B raw / 0.36B uncached tokens and is amortized after 354 / 231 tasks.

Importantly, substantially less source supervision achieves comparable performance with much faster amortization. We evaluate 25%, 50%, and full-source training on both Sol benchmarks, plus 75% on Automation:

Table 4. Source-size sensitivity and learning-inclusive token amortization on frontier backbones (draft Table 11). ΔS is relative to RTS; break-even extrapolates observed per-task token savings to repeated deployment.

SettingTraining splitΔS vs. RTSSource tokens, raw / uncached (M)Break-even, raw / uncached (tasks)
Sol · AutomationFull−2.83881 / 5644,136 / 2,035
75%−2.71649 / 4173,078 / 1,361
50%−4.83442 / 2821,997 / 993
25%−3.16219 / 1401,030 / 508
Sol · τ³Full−3.101,067 / 359354 / 231
50%−3.10466 / 156143 / 96
25%−2.58203 / 6960 / 42

On Sol / τ³, 25% training achieves a slightly higher score than full training (64.95 vs. 64.43; both solve 63/97 tasks), with 9.3% fewer inference raw tokens and 81% fewer source raw tokens. Raw-token break-even falls from 354 to 60 tasks (231 to 42 for uncached tokens). On Automation, 25% training achieves 68.67 versus 69.00 with the full pool while reducing raw-token break-even from 4,136 to 1,030 tasks. The 75%-source controller further reaches 69.12 with 26% lower source raw-token cost than full training.

The complete sweep shows that full-scale source collection is not required for effective learned allocation, and that performance does not improve monotonically with training size. These break-even figures quantify token amortization rather than quality-adjusted utility recovery; the complete accounting appears in draft Table 11.

We agree that within-task refresh and between-task adaptation are distinct claims, and the paper now evaluates them separately. Within-task refresh is already isolated in our draft by the frozen-prefix ablation (ΔS = +0.62 and +0.71, draft Table 18). For between-task adaptation, following the reviewer's suggestion, we ran a new experiment (draft App. F.3). On Qwen3.5-27B / Automation, we inject a fixed environment shift after task 200 of a 400-task stream (renamed schema fields, new error codes, a stricter permission policy), keep within-task refresh on, and compare an updating controller with one frozen at the shift:

Table 5. Updating vs. frozen controller after an injected environment shift (Qwen3.5-27B / Automation).

Tasks 201–400S ↑R ↓Fallback rate ↓
RTS27.161.000—
ForkPilot, frozen at task 20026.000.67231.4%
ForkPilot, updating27.820.6279.2%

When inputs fall outside its source support, the frozen controller falls back to the source-selected RTS (sequential, ρ = 0.8) configuration. Over tasks 201–400, the frozen and updating controllers fall back on 31.4% and 9.2% of decisions, and the updating controller gains +1.82 [+0.89, +2.79] points. It is summarized in §4.6, and the adaptation claim in the introduction now points to it.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

Dear Reviewers and Area Chairs,

We sincerely thank the reviewers for their constructive feedback. We have addressed their concerns individually and added experiments. All revisions are marked in blue.

Recognized Strengths:

We appreciate the reviewers’ recognition of three contributions:

  • Learning when and how much to search. ForkPilot learns the marginal value of retrospective search from paired outcomes, enabling adaptive compute allocation from evolving interaction evidence (nbC6, FC3J).
  • More economical long-horizon agents. Lightweight learned control reduces unnecessary search and improves quality–cost trade-offs, addressing the practical challenge highlighted by WLnn, nbC6, and 3GTD.
  • Evidence for adaptive agent computation. Broad comparisons and controlled ablations clarify the contributions of allocation, history, and uncertainty-aware decisions, informing future agent design (WLnn, 3GTD).

Addressing Reviewer Concerns:

Q1: Does learned allocation outperform existing alternatives? [nbC6, FC3J, 3GTD]

A1: ForkPilot achieves higher scores with fewer raw and uncached tokens than all four added adaptive-compute and tree-search baselines across the evaluated Qwen settings.

  • Comparisons cover input-adaptive budgeting, Certaindex, Learning When to Plan, and official tree search. On Qwen3.5-122B-A10B / Automation, ForkPilot scores 30.0 vs. 28.6 for Learning When to Plan with 24% fewer raw tokens.
  • Against few-shot backbone control on Qwen3.5-27B / Automation, it scores 29.2 vs. 28.3 with 28% fewer raw and 25% fewer uncached tokens, including controller calls (revised Table 25).

Q2: Do gains persist under controlled comparisons? [WLnn, nbC6, FC3J]

A2: ForkPilot improves scores at matched raw-token cost and retains an estimated 36% uncached-token saving at matched quality and host schedule.

  • At matched raw-token cost, gains over validation-selected stopping are +0.92/+1.03 points on Qwen3.5-4B/9B; both confidence intervals exclude zero (revised Table 17).
  • Efficient RTS is now labeled RTS (sequential, ρ = 0.8). Matching its host schedule on Sol / Automation, interpolation of the RTS threshold sweep to ForkPilot’s score of 75.00 gives an estimated 36% uncached-token saving, with nearly identical raw-token usage (revised Fig. 3).

Q3: Can deployment savings recover learning costs? [WLnn, nbC6, FC3J]

A3: Using 25% of the source pool retains near-full-source performance and shortens token amortization on both Sol benchmarks.

  • On Sol / τ³, 25%-source training achieves 64.95 vs. 64.43 with full-source training, and raw/uncached token break-even falls from 354/231 to 60/42 tasks. On Automation, scores are 68.67 vs. 69.00, with raw-token break-even falling from 4,136 to 1,030 tasks (revised Table 11).
  • Accounting includes executed replay arms, failures, and state preparation. Post-task updates reuse logs without additional LLM tokens; Qwen controller fitting takes 0.3–1.2 GPU-hours. Break-even measures token recovery.

Q4: How have reporting inconsistencies and claim scope been addressed? [WLnn, nbC6, FC3J]

A4: We corrected the reporting and clarified the empirical and theoretical scope.

  • Final Opus 4.8 / τ³ scores are RTS 44.67 and ForkPilot 48.31. Interim exports and Qwen labels are corrected, with provenance documented (revised Table 15).
  • The abstract distinguishes 35% average raw-token savings across 48 open-weight settings, with score differences within one point, from 24–59% uncached-token savings on frontier backbones with benchmark-dependent score trade-offs.
  • Theorem 1 becomes Proposition 1 (Diagnostic Decomposition). It motivates controller design without providing a deployment guarantee; controlled ablations evaluate the modules.

With sincere appreciation and best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.