acceptodds
Under review as a conference paper at ICLR 2027

StepRouter: From Effort Priors to Utility Posteriors

Abstract

Chain-of-Thought (CoT) and related reasoning paradigms rely on historical tokens—intermediate conclusions from prior steps. Not all historical tokens are equally useful, and the lost in the middle phenomenon makes indiscriminate accumulation harmful. We study how to rank and select historical tokens, organizing them at the granularity of steps, which manifest as lemmas in mathematics, TODOs in code, or other domain-specific units. As a first step, we compare two ways to rank candidate steps. The first is an effort prior, which favors steps that look expensive to verify. The second is an ex-post utility score, which measures how much a step improves the final answer per token, judged by a frontier model. Empirically, effort is nearly uncorrelated with true usefulness, while utility-based ranking substantially outperforms effort and other baselines at selecting high-value steps. Despite the simplicity of these signals, we develop StepRouter, a lightweight posterior utility estimator that guides any backbone to rank steps by utility, routing only the top 20% for reuse. The results are surprisingly strong: StepRouter improves all tested models on several reasoning benchmarks, yielding +19.6 pp on LiveCodeBench with DeepSeek-R1, +23.2 pp with Qwen3-8B, and pushing GPT-5 to 97.2% on AIME. Fine-tuning Qwen3-8B with only 166 examples yields +12.2 pp on AIME (68.16%→80.36%), demonstrating that models can internalize effective token utilization.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
LLM Reasoning, Natural Language Processing

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_6TJ3OpenReview ↗
Rating
3
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes STEPROUTER, a lightweight step router for reasoning LLMs. A backbone first sketches a solution and extracts reusable candidate steps; a scorer trained from offline outcome-induced pairwise preferences ranks these steps; the solver receives the original problem plus the top 20% of candidates. The central claim is that verification effort is a poor proxy for downstream usefulness, while learned utility ranking improves inference-time routing across math, science, and code, and that the same utility signal can transfer to SFT. The paper reports gains across GPT-5, DeepSeek-R1, and Qwen3-8B on AIME 2025, GPQA-Diamond, and LiveCodeBench, plus same-pool controls and SFT transfer.

Critical strengths
  • The same-pool controls in Table 2 are strong and directly relevant: random, fixed-order, effort-based, and learned selectors keep the same candidate pool/count, isolating the value of learned ranking rather than just adding context.
  • Large empirical gains in several settings: Qwen3-8B +6.16 pp on AIME and +23.23 pp on LiveCodeBench; DeepSeek-R1 +19.61 pp on LiveCodeBench (Table 1, p.5). The GPT-5 exact-count study reports +3.06 pp over random with a bootstrap interval (Table 3, p.6).
  • Useful robustness checks: judge ablation, scorer-data scaling, zero-shot MMLU-Pro, latency, architecture ablation, and data-scaling for SFT (Secs. 6–7; Tables 5–7; Fig. 3).
Critical weaknesses
  • Scorer is not problem-conditioned. The scorer encodes only candidate step text (Sec. 3.2, Eq. 5, p.3). Since step utility is inherently problem-dependent, this is a conceptual limitation. The paper notes problem information can appear inside the candidate statement, but the original problem is not separately encoded; this may limit generality beyond the tested pools.
  • Evaluation scale is small for broad claims. AIME 2025 is small; the GPT-5 exact-count study uses 30 problems × 12 completions (Table 3, p.6). Several main comparisons in Table 1 do not report confidence intervals or clearly state the number of completions/seeds for each backbone. The paper acknowledges small test sets in Sec. 9, but some claims remain stronger than the uncertainty analysis supports.
  • Main comparisons are not fully compute-matched. Table 1 shows STEPROUTER can use substantially more generated tokens than Direct, e.g., Qwen3-8B/LiveCodeBench 8,356 vs 6,536 (+27.85%, p.5). The same-pool controls help, but an equal-token-budget comparison against Direct/self-consistency/PRM would better isolate whether gains come from better allocation or more compute.
  • Offline supervision cost is not fully analyzed. Utility labels require judge calls and explicit verification runs per candidate (Sec. 3.2; Sec. 7 cost analysis, p.8). These costs are excluded from inference cost and from Table 7d latency. This is a practicality concern for adopting the method, even if not a validity flaw.
Questions for authors
  1. How much does problem-conditioning the scorer matter? Can you report a variant that encodes the problem xx alongside the step, or analyze cases where the same step text has different utility across problems?
  2. For Table 1, what are the number of completions/seeds and confidence intervals for each backbone/task? Can you provide problem-cluster bootstrap intervals for the main gains?
  3. Can you add a compute-matched comparison at equal generated-token budget versus Direct, self-consistency, and PRM, especially for Qwen3-8B/LiveCodeBench where STEPROUTER uses more tokens?
2 comments

Response to Reviewer 6TJ3

Thank you for the careful review. Revisions in the PDF are marked in blue; new results are in Appendix E.

Q1. How much does problem conditioning matter?

Empirically, little. We trained a variant that feeds [E(x);E(s)][E(x);E(s)] to the same MLP, with the same data, split, and loss. On Qwen3-8B/AIME, with the same frozen pools and solver, it reaches 71.39, only 2.35 pp above Random (69.04), whereas the step-only scorer reaches 74.32 (5.28 pp above Random). It is consistent with two properties of the setting: extracted steps restate the problem's objects, quantities, and constraints, and since training pairs and routing are both within a problem, problem-only terms cancel. Step-only encoding also lets one frozen scorer transfer zero-shot to GPQA-D and MMLU-Pro (+5.15 pp, Table 7c). We therefore keep step-only encoding.

Q2. Completions and confidence intervals.

Accuracy is the per-problem mean over completions, averaged over problems (Eq. 6, App. A). Completions per problem in Table 1, for every backbone: 12 on AIME, 2 on GPQA-D, and 1 on LiveCodeBench. New intervals, all on Qwen3-8B:

  • Paired problem-level bootstrap 95% CIs for StepRouter − Effort: +4.07 [+1.3, +6.1] pp on AIME and +2.48 [−0.8, +5.9] pp on GPQA-D. We no longer claim the GPQA-D gap.
  • On LiveCodeBench (989 problems, one completion each), StepRouter exceeds Direct by 23.23 pp and Effort by 10.33 pp.

The paper also reports GPT-5/AIME StepRouter − Random: +3.06 [+0.7, +5.4] pp. The direction is consistent across cells: StepRouter exceeds Effort in all 9 cells of Table 1.

Q3. Compute-matched comparison.

The gains are not bought with tokens. Throughout, Tok in Table 1 counts all generated tokens of the full pipeline, i.e. sketching, candidate extraction, and final solving (Table 1 caption; per-stage breakdown in Table 11), so StepRouter is charged for its extra stages.

  • StepRouter generates fewer tokens than Direct in 7 of 9 cells of Table 1, and fewer than Effort in all 9.
  • On Qwen3-8B/AIME, it uses fewer tokens than Direct (18,532 vs 20,484) and outperforms 3 / 5 / 10-sample self-consistency (70.82 / 72.1 / 73.1 at 61K–203K tokens) and the same-fraction PRM selector (71.36), all of which use more tokens.
  • Spending more tokens on Direct does not help. The S1-like baseline extends the backbone's own reasoning. In all 6 cells where it was run, it generates more tokens than Direct and scores lower, e.g. DeepSeek-R1/LiveCodeBench 65.39 at 20,216 tokens vs 70.00 at 17,642.
  • End-to-end latency is 53.6 s vs 56.8 s for Direct (Table 7d).

StepRouter uses more tokens than Direct in two cells: GPT-5/AIME (9,026 vs 8,449) and Qwen3-8B/LiveCodeBench (+27.85%). In the latter, Effort uses more tokens than StepRouter (13,786 vs 8,356) yet scores 10.33 pp lower, and token-matched compression of all candidates reaches 65.3 vs 80.79 (Table 2). We have not run a token-matched Direct or self-consistency baseline for this cell.

Offline cost.

Labels are built once, for the 647 candidates of 126 development problems, and reused without retraining across all backbones and tasks. Following the labeling protocol (Sec. 3.2), this amounts to 647 verification runs, 647 with-step solves, 126 shared no-step solves, and 773 judge calls (Table 13). Half of the labels already beat Effort (71.32 vs 70.25, Table 7b). At inference there is no verification, solving, or judging; only the frozen MLP scores candidates.

Dear Reviewer 6TJ3,

Thank you again for your helpful review. As the discussion period is drawing to a close, we wanted to gently check whether our response has addressed your questions. In brief, we added a problem-conditioned scorer variant, completions per problem and paired problem-level bootstrap CIs, a token accounting showing that StepRouter uses fewer tokens than Effort in all 9 cells (and outperforms 10-sample self-consistency on Qwen3-8B/AIME at about one-eleventh of the tokens), and the offline labeling cost (Table 13).

We would be grateful for any further comments, and are happy to provide additional clarification if helpful. Thank you for your time.

Best regards,

The Authors

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

This paper looks at a practical question in multi-step reasoning: when a model first writes a rough sketch and extracts intermediate steps like math lemmas or code TODOs, which of those steps are actually worth putting back into the prompt for the final solve? The authors compare an effort prior that ranks steps by how hard they look to verify against a small MLP trained to predict how much a step improves the GPT-5 judged answer per verification token. At test time, the backbone model generates up to 16 candidate steps from its sketch, the MLP keeps the top 20%, and the backbone solves the problem with those steps as optional hints. The authors test this pipeline on AIME 2025, GPQA-Diamond, and LiveCodeBench across DeepSeek-R1, GPT-5, and Qwen3-8B, and also fine-tune Qwen3 models on 166 utility-labeled examples so the model can solve problems directly without external hints.

Critical strengths

The paper tackles a real bottleneck in long-context reasoning where reusing all of a model's intermediate scratch work hurts performance. The experiments also include good same-pool controls to test the selection step.

(1) The central empirical finding is clean and useful. In both Table 2 and Table 6, giving the solver all candidate steps from a sketch makes accuracy worse than standard prompting, while filtering down to a small subset gives a solid gain across math, science, and code. Defining step utility by comparing a solve with the step against a solve without it, normalized by verification cost, is a simple way to get step-level preferences without human annotations. Because the router sits outside the LLM, it also works as a plug-in for closed models like GPT-5.

(2) The same-pool controls in Table 2 hold the candidate steps and the solver fixed while varying only the selection rule. The authors compare against random selection, fixed-order selection, token-matched prompt compression, and a post-hoc oracle. This shows that selecting a few steps works better than keeping everything or compressing everything to the same length.

Critical weaknesses

My main concern is that the experiments do not cleanly seperate the value of the learned utility scorer from simpler explanations in either the SFT transfer results or the inference pipeline. Several baseline details and stability checks are also missing.

(1) In Section 6, fine-tuning Qwen3-8B on 166 utility-labeled examples gives a 12-point jump on AIME, while the solution-only SFT baseline stays flat at the base model's score. However, the paper is ambiguous about who wrote the Utility-SFT targets, since Section 6 credits Qwen3-8B with the instances but Section 3.4 only credits it with the sketches and candidate pools, and it never says whether the targets were filtered for correctness or where the reference solutions in the control came from. Prior work like LIMO [1] and s1 showed that fine-tuning on a small set of curated traces can boost AIME by tens of points on its own, whereas fine-tuning a reasoning model on short off-policy solutions often does nothing. To show that the utility labels are what matter, the baseline needs to keep the exact same step-selection prompt format and target generator, and only swap the learned [good] tags for random or effort-based tags, alongside an on-policy baseline trained on the model's own correct solutions [2].

(2) On the inference side, it is hard to see how the scorer learns a general utility function from this setup, and the most natural baseline is missing. The scorer only embeds the step text without the problem statement and is trained on a few hundred steps for just 10 full-batch updates in Table 9. Its rank correlation with measured step gain is low in Table 4, yet it captures most of the oracle gain on LiveCodeBench, and there is no analysis of what features of a step the MLP actually picks up on. More importantly, since the extraction prompt already asks the LLM to estimate verification effort for each step, the natural baseline is to ask the LLM in that same prompt to estimate how useful each step is. Finally, within the same pipeline in Table 1, the gap between StepRouter and the Effort baseline on AIME and GPQA is small and has no confidence intervals, which is on the same scale as normal seed-to-seed variance on AIME [3].

ref: [1] Ye et al. LIMO: Less is More for Reasoning. arXiv:2502.03387, 2025. [2] Zelikman et al. STaR: Bootstrapping Reasoning With Reasoning. NeurIPS 2022. [3] Hochlehnert et al. A Sober Look at Progress in Language Model Reasoning: Pitfalls and Paths to Reproducibility. arXiv:2504.07086, 2025.

Questions for authors

(1) In section 6, which model generated the targets for the 166 Utility-SFT examples, were they filtered for correctness, and what are the reference solutions in the solution-only control? Could you run a control that keeps the exact Utility-SFT format with random or effort-based [good] labels, plus an SFT run on Qwen3-8B's own correct solutions?

(2)What happens in Table 2 if you replace the MLP scorer with a zero-shot usefulness rating from the backbone LLM during step extraction, or with a simple step-length heuristic? Also, is Table 9 accurate that the MLP is trained for only 10 full-batch gradient steps in total?

(3)In Eq 2, how many rollouts with and without each step are used to estimate d_i, and how noisy is that label across repeats? For Table 1, could you also report the LiveCodeBench version and problem count, the number of samples per problem for DeepSeek-R1 and GPT-5, and confidence intervals for StepRouter versus the Effort baseline?

2 comments

Response to Reviewer CfVD

Thank you for the detailed and constructive review. In short: the gain comes from the learned scorer. Our main finding is that step usefulness is an outcome property that none of the tested priors can read off the step: not effort, a PRM, length, or the backbone's own rating. It shows up only in with/without-step outcomes, which is exactly what StepRouter learns from.

Selection, not extra context, drives the gain. With pool, solver, and step count fixed (Table 2), swapping Random for StepRouter accounts for 5.28 of the 6.16 pp gain over Direct on AIME and 18.92 of 23.23 pp on LiveCodeBench. Routing all candidates falls below Direct (65.29 / 54.31): extra context hurts unless it is the right context.

Q1. SFT targets and controls. All targets are on-policy Qwen3-8B generations. For each of 166 training problems (disjoint from evaluation), Qwen3-8B writes the target given the scorer's [good] tags, resampled until the final answer is correct (≤4 attempts) and then manually checked: 230 generated, 166 kept, one per problem. The solution-only arm uses Qwen3-8B's own correct solutions to the same 166 problems, filtered the same way. This is the STaR-style on-policy baseline you suggest [2], matched in LoRA setup, steps, and token budget. It stays at base level (68.4 ± 0.5 vs 68.16), while Utility-SFT reaches 79.9 ± 0.6 (three runs each).

Format-matched control. Same format, generator, filter, problems, and budget, with [good] assigned at random (same count per pool): 74.8 on AIME (single run). The 11.5 pp gain therefore splits into a format effect (6.4 pp) and a label effect (5.1 pp); Sec. 6 reports this split, and the abstract cites the control.

Why solution-only SFT does nothing. The split points to the mechanism: Utility-SFT targets make the model weigh each tagged step before solving. In our training targets, 121 of 166 explicitly refer to a step tagged [bad], e.g.:

"Wait, why is lemma 2 considered good? … So lemma 2 is correct." / "But why is lemma 3 marked as bad? Maybe because it's just restating … Or perhaps there's a mistake in the lemma?"

Solution-only SFT gives no reason to scrutinize anything, so the model is unchanged. The format elicits this scrutiny even with random tags; correct tags teach the model where to direct it. We believe this habit carries over to question-only evaluation, where the model must scrutinize its own steps. Consistent with LIMO [1], a few demonstrations elicit a latent behavior (here, scrutiny), without any stronger teacher or curated trace.

Q2. Simpler selectors. Same Qwen3-8B AIME pools, solver, and 20% budget:

SelectorAIME
Random69.04
Backbone zero-shot rating (1–10, in extraction prompt)69.72
Effort70.25
Longest steps70.83
Qwen2.5-Math-PRM71.36
StepRouter74.32

Every prior lands within 2.4 pp of Random, including the backbone asked directly. Qwen3-8B cannot foresee which of its own steps will help.

Length. The scorer does favor longer steps (within-pool Spearman ρ = 0.58; its top step is the longest in 62% of pools vs 29% by chance). Yet routing by length alone gives 70.83. Length correlates with usefulness but does not reproduce the gain.

Ten updates; low ρ. Table 9 is accurate: 10 full-batch Adam updates of a 1024→128→1 head on frozen bge-m3 embeddings. The head fits signal, not noise: held-out Pair-Acc rises with label data (0.6431 / 0.6982 / 0.7735 at 25 / 50 / 100%), it beats linear and 4-layer heads (Fig. 3), and it transfers zero-shot to GPQA-D and MMLU-Pro (+5.15 pp). The low global ρ (0.26) is expected: routing keeps at most 4 steps, so only the head of the ranking matters, and there the scorer's top-1 step has mean gain 0.98 vs −0.12 for effort (Table 4).

Q3. Statistics, labels, details. Following [3], we resample problems. Paired problem-level 95% CIs for StepRouter − Effort on Qwen3-8B: AIME +4.07 [+1.3, +6.1] pp (significant); GPQA-D +2.48 [−0.8, +5.9] pp (not significant; we drop this claim). StepRouter beats Effort in all 9 cells of Table 1, by 10.33 pp on LiveCodeBench. On GPT-5/AIME, near ceiling, the gap to Effort is not significant (350 vs 346 of 360), but the gap to Random is (+3.06 [+0.7, +5.4] pp).

Label noise. Each label uses one with-step and one shared no-step solve, each judged once, without repeats. The shared no-step score cancels exactly in the raw gain difference, but not after cost normalization (Eq. 3): a residual term remains, equal to the no-step score times the difference of the two inverse verification costs. That noisy single-rollout labels still yield a scorer that beats every prior above shows how strong the outcome signal is.

Details. LiveCodeBench release_v6. Completions per problem, all backbones: 12 (AIME), 2 (GPQA-D), 1 (LCB).

We now cite LIMO, s1, STaR, and Hochlehnert et al., following your references. Revisions are in blue; new results are in Appendix E.

Dear Reviewer CfVD,

Thank you again for your detailed and constructive review; your suggestions led to several new controls in the revision. As the discussion period is drawing to a close, we would like to gently check whether our response has addressed your concerns. In particular, we added:

  • a format-matched SFT control with random [good] tags (74.8 vs 79.9 for Utility-SFT), separating the format effect from the label effect, and clarified that all SFT targets and the solution-only arm are on-policy Qwen3-8B generations filtered for correctness;
  • the backbone's zero-shot usefulness rating and a step-length heuristic as same-pool selectors (69.72 and 70.83 vs 74.32 for StepRouter);
  • paired problem-level confidence intervals, the LiveCodeBench version and problem count, completions per problem for every backbone, and the labeling protocol for Eq. 2.

If any of your concerns remain, we would very much appreciate hearing them while there is still time to respond. If our response has resolved them, we would be grateful if you would consider updating your assessment. Thank you for your time and effort.

Best regards,

The Authors

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

The paper proposes StepRouter which learns to rank intermediate reasoning steps by downstream utility instead of estimated effort. It shows strong gains across math science and coding with several backbones and also transfers the utility signal through SFT.

Critical strengths

The results are quite strong and consistent across several models and tasks. I also like the same pool controls which show the gain is really from selecting useful steps rather than just adding more context.

Critical weaknesses

The scorer only looks at the step text and does not condition directly on the problem. It also scores steps independently so interactions between useful steps are ignored which could limit more complex settings.

Questions for authors

Did you try a problem conditioned scorer that jointly sees the question and candidate step? Also how much improvement is left if interactions between selected steps are modeled?

2 comments

Response to Reviewer CWJc

Thank you for the positive assessment. Both of your questions correspond to limitations we state in Sec. 9. We answer both with new experiments. We have uploaded a revised PDF; changes are marked in blue, and new results are in Appendix E.

Q1. Did you try a problem-conditioned scorer?

Yes. We trained a variant that feeds the concatenation [E(x);E(s)][E(x);E(s)] of problem and step embeddings to the same MLP, keeping the frozen bge-m3 encoder, the 647 candidates, the problem-grouped split, and the pairwise loss. On Qwen3-8B/AIME, with the same frozen pools, solver, and 20% budget, the problem-conditioned scorer reaches 71.39, only 2.35 pp above Random (69.04). The step-only scorer reaches 74.32, 5.28 pp above Random. Conditioning on the problem does not help here; this is consistent with three properties of the setting.

  • The steps already carry the problem. Candidates are extracted from a sketch of a specific problem and restate its objects, quantities, and constraints (e.g. "the six terms form an arithmetic sequence a,a+d,…a, a+d, \dots"). The step embedding thus already encodes the problem information that matters for ranking.
  • Problem-only terms cancel. Training pairs are formed within a problem (Sec. 3.2), and routing selects within one problem's pool, so any term that depends only on xx cancels in both the loss and the top-kk. What remains is a problem–step interaction, learned from a 126-problem development corpus; on unseen problems the extra 1,024 input dimensions add little usable signal and likely lead to overfitting.
  • Step-only encoding generalizes. On held-out problems, the step-only scorer ranks the best candidate first in 56% of held-out LiveCodeBench problems (Recall@1, Table 10), and its top-ranked step has a mean gain of 0.98, against −0.12 for effort (Table 4). The same frozen scorer transfers zero-shot to GPQA-D and MMLU-Pro (+5.15 pp, Table 7c) and serves three backbones without retraining.

The revised PDF reports this variant (Appendix E), and we keep step-only encoding.

Q2. How much improvement is left if step interactions are modeled?

We tested the most direct way to model interactions within our pipeline. On Qwen3-8B/AIME, with the same frozen pools, solver, and 20% budget, the backbone selects the routed steps itself: it sees each candidate's StepRouter score and is asked to choose steps that complement each other. Accuracy drops by 3.9 pp relative to StepRouter's independent top-20%. We find this negative result interesting and see two plausible reasons.

  • Selector bias. Judging complementarity requires the same foresight as judging usefulness, which the backbone lacks: its zero-shot usefulness ratings route no better than Random (69.72 vs 69.04; see our response to CfVD). Its choice of "complementary" steps is pulled toward its own preferences rather than toward steps that help the solve.
  • Over-reliance on coherent sets. Steps chosen to fit together tend to form a self-consistent partial argument. The solver then treats them as an answer to follow rather than as optional hints, and inherits any error they contain; a weaker solver such as Qwen3-8B is especially prone to this. Independently ranked steps are less coupled, so the solver is more likely to check them against the problem.

Three further results indicate where interactions can matter at the current budget. (i) The budget is small. With k=max⁡(1,⌈0.2N⌉)k=\max(1,\lceil 0.2N\rceil) and N≤16N\le 16, at most 4 steps are routed. Pools of 5 or fewer route a single step, so no interaction is possible; this is the case for about 60% of problems. (ii) More steps are not better. On Qwen3-8B/AIME, accuracy peaks at 20% routing, falls to 72.55 at 50% (69.11 at 10%), and tokens rise to 29,752 at 50% (Fig. 2), consistent with redundancy or conflict among selected steps. (iii) Measurable headroom lies in individual ranking. The individual-gain oracle (Table 2), which also ignores interactions, is 3.58 / 4.61 pp above StepRouter on AIME / LiveCodeBench.

This does not rule out gains from a learned joint selector, and interactions are likely to matter more at larger budgets. The revised Sec. 9 says so, and Appendix E reports the LLM-selection result.

Dear Reviewer CWJc,

Thank you again for your thoughtful review. As the discussion period is drawing to a close, we wanted to gently check whether our response has addressed your questions. In brief, we added (i) a problem-conditioned scorer on [E(x);E(s)][E(x);E(s)], which reaches 71.39 vs 74.32 for the step-only scorer on Qwen3-8B/AIME, and (ii) a joint-selection experiment for step interactions, together with an analysis of where the remaining headroom lies (Appendix E).

We would be grateful for any further comments, and we are happy to clarify anything that remains unclear. Thank you for your time.

Best regards,

The Authors

Comments on the paper

1 comment

Dear Area Chair and Reviewers,

Thank you again for your time and for the constructive reviews of Submission 58150. As the discussion period is drawing to a close and we have not yet heard back from the reviewers, we would like to briefly summarize our rebuttal, and kindly ask whether our responses have addressed your concerns. We fully understand how busy this period is, and we would be grateful for any feedback.

Summary of the rebuttal. We addressed every question raised, with new experiments where needed (Appendix E of the revised PDF; changes in blue):

  • Is the SFT gain just from training on curated solutions? (CfVD) All SFT targets, and the solution-only baseline, are on-policy Qwen3-8B generations filtered for correctness; the solution-only arm stays at base level (68.4 vs 68.16). A new format-matched control with random [good] tags reaches 74.8 vs 79.9 for Utility-SFT, so the utility labels contribute beyond the format.
  • Can simpler priors select steps as well? (CfVD) On the same pools, solver, and budget, the backbone's own zero-shot usefulness rating (69.72), effort (70.25), the longest steps (70.83), and a PRM (71.36) all stay within 2.4 pp of Random (69.04), whereas StepRouter reaches 74.32.
  • Problem-conditioned scorer (CWJc, 6TJ3). A scorer on [E(x);E(s)][E(x);E(s)] reaches 71.39 vs 74.32 for the step-only scorer; we explain why problem-only information adds little in within-problem ranking.
  • Step interactions (CWJc). Letting the backbone choose complementary steps lowers AIME accuracy by 3.9 pp; the measurable headroom lies in individual ranking (oracle +3.58 / +4.61 pp on AIME / LiveCodeBench).
  • Uncertainty and evaluation details (CfVD, 6TJ3). We now report completions per problem for every backbone, the LiveCodeBench version (release_v6, 989 problems), the labeling protocol behind Eq. 2, and paired problem-level bootstrap CIs. The AIME gain over Effort is significant (+4.07 [+1.3, +6.1] pp); the GPQA-D gap is not, and we have withdrawn that claim.
  • Compute (6TJ3). Table 1 counts all pipeline tokens. StepRouter uses fewer tokens than Effort in all 9 cells and fewer than Direct in 7 of 9, and outperforms 10-sample self-consistency on Qwen3-8B/AIME at about one-eleventh of the tokens. We also report the one-time offline labeling cost (Table 13).

To the reviewers: if any concern remains, we would very much appreciate hearing it while there is still time for us to respond; if our responses have resolved your concerns, we would be grateful if you would consider updating your assessment. To the Area Chair: we would appreciate it if the rebuttal and the new results could be taken into account in the discussion.

Thank you very much for your time and effort.

Sincerely,

The Authors of Submission 58150

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.