🤖 AI

DART: Draft-Agreement Routing for Training-Free Adaptive Thinking Budgets in Hybrid Reasoning Models

DART is a training-free routing framework for hybrid reasoning models that dynamically allocates thinking budgets by sampling cheap drafts and using their agreement or entropy to decide between direct answering and extended reasoning, thereby significantly reducing token usage while improving accuracy on complex math and code tasks.

Original authors: Jungseob Lee, Seongtae Hong, Seungjun Lee, Jaehyung Seo, Junyoung Son, Sugyeong Eo, Chanjun Park, Hyeongju Park, Hyeonseok Moon, Heuiseok Lim

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Jungseob Lee, Seongtae Hong, Seungjun Lee, Jaehyung Seo, Junyoung Son, Sugyeong Eo, Chanjun Park, Hyeongju Park, Hyeonseok Moon, Heuiseok Lim

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very smart, but expensive, personal assistant. This assistant has two ways of working:

The "Snap" Mode: They answer your question instantly without thinking. This is fast and cheap, but they might get it wrong if the question is tricky.
The "Deep Dive" Mode: They spend a lot of time and energy (and money) thinking through the problem step-by-step before answering. This is accurate for hard questions but wasteful for simple ones.

The problem is: How do you know which mode to use for every single question?

If you always force the "Deep Dive," you waste money on easy questions (like "What is 2+2?"). If you always use "Snap," you fail on hard questions (like complex math puzzles).

Enter DART: The Smart Traffic Cop

The paper introduces DART (Draft-Agreement Routing for Thinking). Think of DART as a smart traffic cop standing at the entrance of your assistant's office. It doesn't need to be retrained for every new assistant, and it doesn't need a list of "hard" and "easy" questions beforehand. It just watches the assistant work.

Here is how DART works, using a simple two-step process:

Step 1: The "Double-Check" (Stage 1)

Before letting the assistant go into the expensive "Deep Dive" mode, DART asks the assistant to quickly write down two quick, "snap" answers (drafts) without thinking too hard.

If the two drafts agree: DART says, "Great! You both got the same answer. It's probably right. Here is your final answer." The assistant never enters the expensive thinking mode. Result: You save a ton of time and money.
If the two drafts disagree: DART says, "Uh oh, you two can't agree. This must be a hard problem. Go into the 'Deep Dive' mode and think it through properly."

The Analogy: Imagine asking two friends, "What's the capital of France?" If they both immediately say "Paris," you trust them. If one says "Paris" and the other says "London," you know you need to pull out a map (the "Deep Dive") to figure it out.

Step 2: The "Budget" (Stage 2)

If the assistant does have to go into "Deep Dive" mode, DART doesn't just give them unlimited time. It looks at how confused the assistant seemed during those two quick drafts.

High Confusion (High Entropy): The drafts were all over the place. DART says, "This is a really hard one. Here is a big budget of time and tokens to solve it."
Low Confusion: The drafts were mostly similar, just a little off. DART says, "This is tricky, but not impossible. Here is a smaller budget."

This ensures that the hardest problems get the most resources, while the "medium" hard ones don't waste as much energy as they would if you gave them the maximum budget every time.

Why is this a big deal?

The paper claims DART is a "training-free" solution. Usually, to build a system that knows when to think, you need to feed it thousands of labeled examples (telling it, "This was hard, use Deep Dive"). DART doesn't need that. It figures it out on the fly by just checking if the quick drafts agree.

The Results (The "Scoreboard"):

Math: On very hard math problems (like Olympiad level), DART actually got more correct answers than forcing the assistant to always think deeply, while using 15% to 69% fewer thinking tokens (less cost).
Coding: For writing computer code, DART improved accuracy by up to 22.5 points while cutting thinking costs by 51% to 63%.
Efficiency: It's like getting a Ferrari's speed for simple errands and a tank's power for the tough terrain, without paying for the tank's fuel on the simple errands.

The Catch (Limitations)

The paper is honest about where DART might stumble:

Multiple Choice: If you ask a multiple-choice question, the two quick drafts might just guess the same wrong answer by luck. DART would accept that wrong answer. So, DART is designed for open-ended questions (like math or coding), not multiple-choice tests.
The "Agreement" Trap: If the assistant is confidently wrong on both quick drafts, DART will accept the wrong answer. The paper notes this is the main source of errors, but it's still much better than the alternatives.

Summary

DART is a clever, free-to-use tool that acts as a gatekeeper. It uses a quick "double-check" of two cheap answers to decide if a problem is easy or hard. If the quick answers agree, it saves you money. If they disagree, it sends the problem to the expensive thinking mode, but only gives it as much time as it actually needs. It makes AI smarter and cheaper at the same time.

Technical Summary: DART (Draft-Agreement Routing for Training-Free Adaptive Thinking Budgets)

1. Problem Statement

Hybrid reasoning Large Language Models (LLMs) offer two inference modes: NOTHINK (direct response) and THINK (extended chain-of-thought). While THINK mode improves accuracy on complex tasks, applying it universally is inefficient and often detrimental.

Inefficiency: Easy queries waste tokens on unnecessary reasoning.
Accuracy Degradation: Recent studies indicate that extended reasoning can sometimes lower accuracy on easier problems compared to direct answers.
Deployment Constraints: Fixed "always-thinking" deployments face operational costs and risk exhausting context windows (truncation) on hard problems before generating a final answer.
Limitations of Existing Routers: Current adaptive routing strategies typically require labeled training data (limiting API-only use) or rely on indirect heuristics (confidence/entropy) that do not directly measure answer-level agreement. Furthermore, single-call evaluations often conflate reasoning budget limits with answer truncation, creating measurement artifacts.

2. Methodology: DART

DART (Draft-Agreement Routing for Thinking) is a training-free, two-stage routing framework designed to optimize the trade-off between accuracy and token efficiency without gradient updates or labeled data.

Stage 1: Self-Consistency Routing (SC-Route)

The primary goal is to determine if a query can be answered directly without invoking the THINK mode.

Mechanism: The system samples $K$ independent drafts in NOTHINK mode (temperature $T$ ).
Decision Logic: An answer extractor normalizes the output of each draft. If all $K$ drafts agree (unanimous agreement) under a pluggable equivalence function $eq$, the system accepts the draft answer immediately.
Escalation: If the drafts disagree, the query is routed to THINK mode.
Design Choice: The authors use strict unanimity with $K=2$ rather than majority voting. This concentrates probability on the dominant answer while keeping costs low and avoiding the overhead of larger $K$ values used in standard self-consistency decoding.
Equivalence Module: This is the only domain-specific component. It can be string normalization for math, sandboxed execution matching for code, or structured-output comparison.

Stage 2: Entropy-Budget Allocation

For queries routed to THINK mode (where drafts disagreed), DART allocates a query-specific thinking budget rather than using a fixed cap.

Uncertainty Signal: The system calculates the draft entropy ( $H(q)$ ) from the $K$ NOTHINK drafts. Higher entropy indicates higher uncertainty/difficulty.
Budget Mapping: Entropy is mapped to a thinking budget $\hat{B}$ using isotonic regression fitted on a held-out calibration set of disagreement queries.
Two-Stage Generation: To avoid the "single-call truncation artifact" (where the model runs out of tokens while reasoning and fails to emit an answer), the reasoning trace and the final answer are generated in separate completion calls. When the reasoning trace reaches the predicted budget $\hat{B}$ , a stop token is injected, and the final answer is generated in a new call.

3. Key Contributions

Draft Unanimity as a Difficulty Proxy: The paper characterizes the agreement between cheap NOTHINK drafts as a strong binary signal for query difficulty, showing a consistent correlation with always-thinking correctness.
Training-Free Router: DART operates without labeled difficulty data or model-specific retraining, making it compatible with text-only API access to closed hybrid models.
Two-Stage Protocol: By separating the thinking trace from the final answer generation, DART eliminates measurement artifacts caused by answer truncation under tight token budgets.
Entropy-Based Budgeting: The framework dynamically allocates reasoning budgets based on draft entropy, concentrating tokens on harder queries while allowing easier routed queries to terminate early.

4. Experimental Results

The framework was evaluated on Qwen3 (8B, 14B, 32B) and DeepSeek-V3.2 across mathematical reasoning (MATH-500, OlympiadBench) and code generation (HumanEval, MBPP).

Accuracy vs. Efficiency: DART matches or exceeds the accuracy of an "always-thinking" (AT) baseline while significantly reducing thinking-token usage.
- Math Reasoning: Accuracy improved by up to +9.0 points on Olympiad-level problems (Qwen3-14B) while reducing thinking tokens by 15–69%.
- Code Reasoning: Accuracy improved by up to +22.5 points on HumanEval (Qwen3-32B) while reducing thinking tokens by 51–63%. The gains in code are attributed to the router correctly identifying that many code queries are better solved via direct answers (NOTHINK) rather than extended reasoning.
Comparison to Baselines:
- DART outperformed supervised routers (MLP, Gradient Boosted Trees) trained on draft features, even when those routers had access to unanimity features.
- It significantly outperformed self-prompted routing and majority-vote aggregation baselines, particularly on code tasks where execution-based agreement is superior to token-level voting.
Generalization: The routing signal (draft unanimity) remained robust across model scales (0.6B to 32B) and different model families.
Latency: DART achieved a 2.3x speedup in wall-clock latency compared to AT, primarily because 78% of queries were resolved via parallel NOTHINK drafts.

5. Significance and Claims

The paper claims that DART provides a practical, deployment-ready solution for hybrid reasoning models that does not require retraining.

Cost Reduction: It demonstrates that significant token savings (up to 69%) can be achieved without sacrificing, and often while improving, accuracy.
Robustness: The method works effectively on both open-weight models and hosted APIs (DeepSeek), proving its utility in real-world deployment scenarios where model weights are inaccessible.
Measurement Integrity: By addressing the "truncation artifact," the paper argues that previous comparisons between routing strategies and always-thinking baselines were often flawed; DART's two-stage protocol provides a fairer comparison, revealing that routing can outperform fixed-budget always-thinking even at matched token budgets.
Error Analysis: The authors identify "false accepts" (where drafts agree on a wrong answer) as the primary remaining error source, suggesting that future improvements could focus on lightweight calibration or selective additional draft rounds rather than complex training.

The work concludes that draft agreement is a domain-agnostic, high-precision signal for routing, enabling adaptive thinking budgets that are both efficient and accurate.