acceptodds
Under review as a conference paper at ICLR 2027

ODAR: Instance–Compute Alignment for Adaptive Test-Time Reasoning

Abstract

Test-time scaling is commonly framed as allocating more reasoning to more difficult inputs, yet static difficulty need not track the realized benefit of additional computation. We present ODAR, an adaptive reasoning system whose deployed router learns from coarse complexity and Fast-Agent failure signals, while all-path counterfactual outcomes are reserved for evaluation. In an all-path audit, this inexpensive routing proxy predicts positive compute benefit with 0.77 AUROC, compared with 0.58 for input length, 0.68 for predictive uncertainty, and 0.694 for a PRM score. Holding the Simple/Medium/Hard proportions and average calls fixed, within-benchmark permutation lowers audit performance by 4.29 points, isolating instance–compute alignment; frozen-router transfer retains 74.4–87.8% of source-pair gains. Across 22 public benchmarks plus one custom proof stress test, ODAR-API exceeds Self-Consistency on all 23 displayed task-specific metrics while averaging 2.55 model calls. Token-level FEP selection is evaluated in the open-weight configuration, where next-token likelihoods are observable. Together, these results establish realized compute benefit as an informative evaluation target for adaptive inference and show that inexpensive supervision can identify instances that benefit from additional reasoning.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
large language models, test-time scaling, adaptive inference, compute allocation, reasoning, model routing, instance-compute alignment

Reviews

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

This work introduces a method to estimate the benefit of allowing more token budget. Basing on this estimate, the method conducts test-time scaling to most promising queries.

Critical strengths

1, The proposed method seems to achieve strong results on their proposed metrics. 2, The work targets on an important problem: test-time token budge allocation.

Critical weaknesses

1, The writing is hard to follow. Here are some examples:

  • "instance-compute alignment" is introduced as one of the major contributions. However, it is not discussed in the method section.
  • There are several uncommon terminologies and metrics, including: FEP, FEP reliability, oracle-action accuracy, macro score.
  • Eq (14) is defined without defining the notation or any further explanation; the 84.0 was referring to the result in Table 1, without any pointer. 2, The work seem to introduces several new metrics, without justifying. This would make it harder to judge the comparison.
Questions for authors

It is mentioned that macro score is an unweighted average across several metrics. Can you explain how similarity and proof score are definited? Would it be the case that they are not in the same scale?

Reviewer_KJi5OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

ODAR uses complexity proxies and Fast-model failures to train a lightweight router that selects among three compute paths. The API version selects responses without using likelihoods, while the local-model version uses a likelihood-based selector. The study runs all paths on identical queries, shuffles route assignments, varies system components, and tests transfer with the router frozen, to assess whether additional compute is assigned to the queries that benefit from it. In Table 35, shuffling route assignments within each benchmark lowers the audit score by 4.29 points without changing route proportions or the nominal average call count.

Critical strengths
  1. The all-path audit and route-shuffling experiment proved especially helpful to me. By maintaining the route proportions while altering which queries traverse each path, it directly tests the allocation's effectiveness. The factorial ablations and transfer tests also help disentangle the contributions of routing, model heterogeneity, and candidate selection (Tables 34 to 39).

  2. The paper clearly delineates which signals train the router and which counterfactual outcomes are used for evaluation. It also elucidates the differences in answer selection between the API and local-model versions, and documents the separation and deduplication of auxiliary data. Such details facilitate assessing the system's actual information usage (Appendices E and O).

Critical weaknesses
  1. I was unable to reconstruct the central audit from the provided description. The paper needs to specify the value of λc in U=R−λcC and explain its selection, detail the reward and cost units, and describe the composition and size of the audit pool. It also needs to define how the Audit Score is aggregated, as these choices impact which queries are considered to benefit from extra compute and how to interpret the oracle. Furthermore, I did not find uncertainty estimates for the main AUROC and permutation comparisons (Equations 14 to 15; Tables 34 to 40).

  2. I am uncertain if the reported call counts account for tie-breaking. Appendix O.2 (p. 27) states that the API version uses answer-level consensus over the Slow candidates and a deterministic Slow-Agent verification pass to resolve ties. However, Equation (7) on p. 4 and Table 21 on p. 28 count only one Fast plus five Slow calls for the Hard path, giving an overall average of 2.55 calls. If verification requires another request, this additional call is not included in the count. Appendix O.3 indicates that normalized cost is measured from run logs, suggesting it may already include verification; the formula alone does not confirm that API spend or latency is understated. The authors should clarify what each metric encompasses. This also affects the budget comparison: maintaining fixed route proportions does not necessarily keep tie rates fixed. Additionally, the n=5 values in Figure 6 do not align with Table 30. It is unclear if these use different configurations or if one requires correction.

Questions for authors
  1. How is the audit pool defined, and how are rewards normalized and the Audit Score aggregated? Please provide the value of λc and the cost units, and demonstrate the sensitivity of the results to λc and generation randomness.
  2. In O.2, does tie-breaking necessitate a new Slow-Agent request, or is it part of an existing counted call? For each comparison scenario, report the frequency of Hard-path queries requiring this step and the number of tokens used. Is this step included in the Avg. Calls, normalized cost, API spend, and end-to-end P50/P95 latency metrics? After all requests are accounted for, do the budgets match, and does ODAR retain its advantage as shown in Table 35?
  3. Are the models, samples, and evaluation protocols consistent between Figure 6 and Table 30? Please clarify the discrepancies in values and provide paired uncertainty estimates for the main AUROC and permutation comparison.
Reviewer_QsWGOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces ODAR, an adaptive test time reasoning framework that adjusts inference computation based on the estimated difficulty of each query. It uses a lightweight Difficulty Estimator (DE), trained using complexity and Fast Agent failure signals (Eq. 1), to classify queries into three difficulty levels. Simple queries require 1 call, Medium queries require 2 calls, and Hard queries require 6 calls. The framework uses fixed thresholds to determine which execution path each query follows.

Critical strengths
  1. Evaluation focused on compute benefits: The paper clearly distinguishes between how difficult a query is and how much it actually benefits from additional computation. It uses counterfactual utilities to measure the potential benefit of allocating more computation to each query.

  2. Broad experimental evaluation and compute efficiency: ODAR-API outperforms Self-Consistency across all 23 reported task specific metrics. Open-ODAR also improves the unweighted macro score from 82.0 to 84.4 while reducing normalized cost from 25.0x to approximately 4.5x. These results suggest that ODAR can improve overall performance while using substantially less computation.

Critical weaknesses
  1. Limited methodological novelty: The Difficulty Estimator (DE) combines complexity and Fast-Agent failure signals using a weighted score, logistic prediction, and fixed routing thresholds. These components are similar to existing difficulty based adaptive inference methods. Therefore, the main contribution appears to be the counterfactual evaluation framework rather than a new routing or optimization algorithm.

  2. Mismatch between the optimization objective and training: Although the paper motivates routing using marginal utility Ua(x)=R(ya(x))−λcCaU_a(x)=R(y_a(x))-\lambda_c C_a (Eq. 14), the DE is trained only on complexity and Fast-Agent failure signals. It does not directly learn which execution path provides the greatest benefit relative to its cost, particularly when choosing between Medium and Hard execution.

  3. Limited evidence for the contribution of FEP: FEP is used only in Open-ODAR, while the main ODAR-API experiments rely on likelihood free verification. On fixed candidate pools, FEP improves average selection accuracy by only 1.2 points compared with average log probability. Therefore, the overall performance improvements do not clearly demonstrate how much FEP contributes or whether it is necessary.

  4. Incomplete comparisons under equal computational budgets: Table 3 compares ODAR using 2.55 calls with Park style IAS using 3.45 calls and Self-Consistency using 5.00 calls. Since these methods use different numbers of calls, the comparison does not fully isolate performance differences under the same computational budget.

  5. Limited flexibility and routing robustness: ODAR uses only three fixed execution budgets of 1, 2, and 6 calls, which limits its ability to adjust computation more precisely based on query difficulty. In addition, complexity injection increases computation by 154% while reducing accuracy by 0.2 points. This suggests that the routing mechanism is sensitive to superficial changes in the input.

  6. Formatting issue: Table 6 contains a formatting issue that should be corrected to improve readability and presentation.

Questions for authors
  1. Direct supervision based on compute benefits: Eq. 14 defines the intended utility, but Eq. 1 trains the router using only complexity and Fast-Agent failure signals. Have the authors compared the DE with a router trained directly to predict ΔUM(x)\Delta U_M(x) and ΔUH(x)\Delta U_H(x)? How much could this approach reduce the remaining performance gap between ODAR and the oracle?

  2. Novelty compared with existing adaptive routing methods: Apart from evaluating all execution paths through counterfactual analysis, what is the main algorithmic contribution of ODAR compared with existing routing methods based on difficulty or uncertainty, especially since it uses a linear estimator and fixed thresholds?

  3. Independent contribution of FEP: Can the authors report the overall Open-ODAR performance when FEP is replaced with average log probability or majority voting, while keeping routing and candidate generation identical? Does the 1.2 point improvement in selection accuracy reported in Table 14 lead to meaningful improvements in overall performance?

  4. Routing flexibility and robustness: How does ODAR perform when using more flexible or continuous compute budgets instead of three fixed levels? Can robustness training reduce the increase in computation caused by complexity injection while maintaining accuracy?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.