Wait, Do We Need to Wait? Revisiting Budget Forcing for Sequential Test-Time Scaling

This blog revisits budget forcing, a sequential test-time scaling technique for reasoning models by controlling when it continues thinking versus when it must answer. We evaluate how well the method transfers across model types, including non-reasoning models, and whether alternative keywords work. We provide practical guidelines for using the technique.

In this blog post, we revisit the technique of budget forcing — a sequential test-time scaling technique that controls reasoning budget in reasoning models by appending a “Wait” keyword (or equivalently forcing a stop when the budget is exceeded), thereby determining whether the model continues thinking or directly outputs an answer.

We explore three main questions:

  1. To what extent does budget-forcing generalize across different model families and settings?
  2. Does it work with non-reasoning models?
  3. Can other keywords serve the same function as “Wait”?

We present experimental results, including cases where budget forcing does and does not help and offer practical guidance for applying budget-forcing in test-time scaling.

💡
TL;DR
  • Budget forcing helps most for some SFT-based reasoning models (e.g., s1.1, OpenThinker3) but provides little or negative gains for others (especially some RFT-based or distillation-based models).
  • The often-claimed "linear scaling law" between budget and performance does not hold universally; many models plateau or fluctuate as the budget grows.
  • Budget forcing is not exclusive to reasoning models: instruction-tuned models can benefit when prompted with <think>...</think> structures, but this effect is highly model-family dependent.
  • The keyword "Wait" is not special. Alternative high-frequency reasoning words like "Let" or "Perhaps" often work better, and the optimal keyword appears to be model-specific.

What is Budget Forcing And How Does It Work?

A Very Brief Introduction to Test-Time Scaling

A comparison of sequential, parallel, and hybrid test-time scaling approaches, adapted from Zhang et al. (2025). Sequential methods extend a single chain of thought, giving one trajectory more room to refine its reasoning. Parallel methods sample multiple independent trajectories and select an answer via voting or scoring. Hybrid methods both extend chains and branch them, combining deeper single-trajectory reasoning with cross-trajectory selection.

Before we go deeper into budget forcing, let’s take a very brief look at what test-time scaling is. Since budget forcing is a (1) sequential (2) test-time scaling technique.

Test-time scaling means spending more compute during inference — for example, generating more tokens — to get better performance.

Broadly speaking, test-time scaling methods fall into three categories: sequential, parallel, and hybrid.

A figure contrasting sequential and parallel test-time scaling from s1: Simple Test-Time Scaling

Budget Forcing: Forcing The Model To Think Within The Budget

Performance of s1 under different budgets from s1: Simple Test-Time Scaling

Budget forcing was first introduced in s1: Simple Test-Time Scaling , which introduced an approach to extend the reasoning process for improving mathematical performance. The original introduction summarizes the idea well:

“… a simple decoding-time intervention by forcing a maximum and/or minimum number of thinking tokens. Specifically, we enforce a maximum token count by simply appending the end-of-thinking token delimiter and optionally “Final Answer:” to early exit To enforce a minimum, we suppress the generation of the end-of-thinking token delimiter and optionally append the string “Wait” to the model’s current reasoning trace to encourage the model to reflect on its current generation. the thinking stage and make the model provide its current best answer.”

The objective of budget forcing is to control the number of thinking tokens. It operates through two mechanisms: enforcing (1) a maximum and (2) a minimum number of thinking tokens. We refer to the first mechanism as scaling down (enforced maximum) and the second as scaling up (enforced minimum). The high-level process follows:

So, let’s see how scaling up and scaling down work!

Scaling Up

When scaling up, budget forcing encourages the model to keep thinking as long as it still has reasoning budget left.

Here’s how it works step by step:

  1. The model generates a response consisting of two parts — the thinking process and the final answer.
  2. The algorithm checks whether the length of the thinking content is still within the budget.
  3. If there’s budget remaining, it discards the final answer and the thinking-end tag (e.g., </think>), then appends a keyword such as “Wait” (as used in the original paper).
  4. The model continues generating more reasoning until the budget limit is reached.
  5. Steps 2–4 repeat until the reasoning budget is exhausted. Only then do we let the model close </think> and produce its final answer.

Effectively, we are telling the model, Hold on, keep thinking before you answer.

Scaling Down

Scaling down is the opposite: instead of letting the model think longer, we cut off its reasoning once it exceeds the budget.

The algorithm:

  1. The model generates a response consisting of two parts — the thinking process and the final answer.
  2. The algorithm checks whether the length of the thinking content is still within the budget.
  3. Truncates the <think>...</think> content so that it fits within the reasoning token budget.
  4. Forces an ending indicator (e.g., </think>) after the truncated reasoning.
  5. Prompts the model to produce its final answer (for example, “The final answer is …”).
  6. Continues generating the final answer.

In other words, “Time’s up — give your answer.”

While this is a promising idea and approach, several unknown factors limit our understanding of what budget forcing does, why it works, and how it behaves. In particular:

  1. Budget forcing was introduced and tested using s1. This raises the question of how generalizable it is to other reasoning models.
  2. The paper reports a linear relationship between performance and thinking budget. Is the trend truly linear?
  3. The keyword “Wait,” used to encourage the model to continue thinking, is chosen somewhat arbitrarily. Does the keyword actually matter?

What People Say About Budget Forcing?

Before we dig into the deeper questions, it’s worth stepping back to see what the current research landscape says about budget forcing. The findings vary widely, and the overall picture is far from settled. Here’s a concise tour of the perspectives that have emerged so far.

Studies Suggesting Benefits from Budget Forcing

A number of works report that prompting models to “wait” or continue thinking can offer advantages. A study trains models explicitly to use a continued-thinking token, encouraging them to pause and elaborate on their reasoning. Another study shows that increasing test-time compute—often by allowing longer chains of thought—can boost accuracy and confidence, at least in some settings.

A related perspective emphasizes the role of backtracking . In both humans and models, the signal to “wait” can function as an invitation to revisit earlier steps, reconsider calculations, or catch overlooked details. Under this view, brief delays may improve the final answer by prompting revision.

Evidence Challenging Budget Forcing

Several recent findings call into question the idea that longer chains of thought inherently improve performance. One study indicates that extended reasoning and excessive reviewing correlate with lower accuracy across tasks such as mathematics and scientific reasoning .

Further, research on test-time scaling shows that when models are forced to answer with less time than they naturally require, accuracy degrades —and that shorter chain-of-thought models are especially sensitive to this truncation. Other work observes fluctuating or decreased accuracy when budget forcing is applied in knowledge-intensive domains, and finds little to no benefit in fields like medicine .

One hypothesis ties these patterns together: models may simply be more familiar with certain reasoning lengths because those lengths are more commonly represented in training data. Extremely long chains of thought appear less frequently, making the model less practiced in producing them. As a result, artificially lengthening the reasoning process does not always yield deeper or more reliable thinking. This idea will be explored further later in the post.

What We Will Do In This Blog?

Given the contradictory results in prior work, we revisit budget forcing and evaluate it in a more systematic setup to understand how well the technique generalizes and how its individual components affect outcomes. This is not an exhaustive study; instead, we focus on several particularly interesting aspects: model compatibility, budget scaling behavior, and keyword choice. Let’s dive in.

📝
Summary
  • Budget forcing is a sequential test-time scaling method that manipulates tokens inside <think>...</think> under a fixed budget.
  • It has two components: scaling up (extend reasoning) and scaling down (truncate reasoning), both controlled by the same budget mechanism.
  • Prior work shows clear but non-universal gains: some models and settings benefit, others do not.

Testing It With More Models

Not All Reasoning Models Are Created The Same Way

Not all reasoning models are created equal — or trained the same way. Broadly speaking, there are two main approaches to developing reasoning models: Supervised Fine-Tuning (SFT) and Reinforcement Fine-Tuning (RFT).

Do reasoning models trained with SFT and RFT behave differently when we apply budget forcing?

Experimental Setup

To explore this, we selected several models that all share the same initial model — Qwen2.5-7B-Instruct — to make comparisons as fair and controlled as possible.

Specifically, we used:

More technical details on how we trained the RFT model
Training config (click to expand) 
python3 -m verl.trainer.main_ppo \
 algorithm.adv_estimator=grpo \
 data.train_files=RUC-AIBOX/STILL-3-Preview-RL-Data \
 data.val_files=RUC-AIBOX/STILL-3-Preview-RL-Data \
 data.train_batch_size=256 \
 data.max_prompt_length=2048 \
 data.max_response_length=4096 \
 actor_rollout_ref.model.path=Qwen/Qwen2.5-7B-Instruct \
 actor_rollout_ref.actor.optim.lr=1e-6 \
 actor_rollout_ref.model.use_remove_padding=True \
 actor_rollout_ref.model.enable_gradient_checkpointing=True \
 +actor_rollout_ref.model.use_torch_compile=True \
 actor_rollout_ref.actor.ppo_mini_batch_size=64 \
 actor_rollout_ref.actor.fsdp_config.param_offload=False \
 actor_rollout_ref.actor.fsdp_config.optimizer_offload=False \
 actor_rollout_ref.ref.fsdp_config.param_offload=False \
 actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=8 \
 actor_rollout_ref.rollout.tensor_model_parallel_size=1 \
 actor_rollout_ref.rollout.name=vllm \
 actor_rollout_ref.rollout.gpu_memory_utilization=0.8 \
 actor_rollout_ref.rollout.n=8 \
 actor_rollout_ref.actor.strategy=fsdp2 \
 actor_rollout_ref.ref.strategy=fsdp2 \
 critic.strategy=fsdp2 \
 actor_rollout_ref.actor.use_dynamic_bsz=True \
 actor_rollout_ref.actor.ppo_max_token_len_per_gpu=24576 \
 actor_rollout_ref.ref.log_prob_max_token_len_per_gpu=24576 \
 actor_rollout_ref.rollout.log_prob_max_token_len_per_gpu=24576 \
 algorithm.use_kl_in_reward=False \
 reward_model.reward_manager=naive \
 custom_reward_function.path=compute_score \
 custom_reward_function.name=math_acc_rw_fn.py \
 trainer.critic_warmup=0 \
 trainer.logger=['console','wandb'] \
 trainer.project_name=your_project_name \
 trainer.experiment_name=your_exp_name \
 trainer.val_before_train=False \
 trainer.default_hdfs_dir=null \
 trainer.n_gpus_per_node=4 \
 trainer.nnodes=1 \
 trainer.save_freq=100 \
 trainer.test_freq=1000000 \
 trainer.total_epochs=2 2>&1
Reward function (click to expand) 
import re
from typing import Dict, List, Optional
import numpy as np
from math_verify import parse, verify


def extract_boxed_content(text: Optional[str]) -> Optional[List[str]]:
    if text is None:
        return None

    pattern = r"\\boxed\{((?:[^{}]|\{[^{}]*\})*)\}"
    return re.findall(pattern, text)


def math_boxed_reward_func(
    assistant_message: str, ground_truth: str | float | int
) -> float:
    """Reward function for math problems with boxed answers."""
    extracted_answers = extract_boxed_content(assistant_message)
    if not extracted_answers or len(extracted_answers) == 0:
        return 0.0

    parsed_extracted_answer = parse(extracted_answers[-1])
    parsed_ground_truth = parse(ground_truth)

    if verify(parsed_ground_truth, parsed_extracted_answer):
        return 1.0

    return 0.0


def format_reward_func(assistant_message: Optional[str]) -> float:
    """Scores the assistant message based on formatting (<think> tags)."""
    if assistant_message is None or len(assistant_message) == 0:
        return 0.0

    think_pattern = r"<think>.*?</think>"
    matches = re.findall(think_pattern, assistant_message, re.DOTALL)

    if (
        len(matches) == 1
        and assistant_message.strip().startswith("<think>")
        and assistant_message.count("<think>") == 1
        and assistant_message.count("</think>") == 1
    ):
        return 1.0
    return 0.0


def compute_score(
    data_source: str,
    solution_str: str,
    ground_truth: str,
    extra_info: Optional[Dict] = None,
) -> float:
    """
    A unified reward function for `verl` that handles 'math' types.

    Args:
        data_source (str): The name of the dataset (provided by verl).
        solution_str (str): The response generated by the model.
        ground_truth (str): The ground truth answer.
        extra_info (dict, optional): A dictionary for additional data. Defaults to None.

    Returns:
        float: The calculated reward score.
    """

    format_score = format_reward_func(solution_str)
    accuracy_score = math_boxed_reward_func(solution_str, ground_truth)

    combined_score = np.mean([accuracy_score, format_score])
    return combined_score

We evaluated all four models on a diverse set of reasoning benchmarks:

Together, these benchmarks give us a holistic view of how budget forcing affects models across both mathematical (as proposed originally in the s1 paper) and non-mathematical domains.

We used the following sampling parameters for all evaluations: temperature = 0.6, max_tokens = 8192, top_p = 0.95, top_k = 20, and presence_penalty = 0.5. We also fixed the thinking budget to 8192 tokens — a value that’s comfortably above the average reasoning length for most models.

Here’s what we found:

Comparing Zero-shot CoT and Budget Forcing Results

Result table
Model Approach AIME 2025 MATH500 MMLU Pro-1K SuperGPQA-1K Average
RFT Zero-shot 20.00 69.40 9.80 6.70 26.48
RFT CoT+BF 23.33 63.80 45.20 27.80 40.03
s1.1-7B Zero-shot 20.00 73.60 40.20 17.40 37.80
s1.1-7B CoT+BF 23.33 74.20 62.10 33.40 48.26
OpenThinker3-7B Zero-shot 26.67 81.00 51.40 24.60 45.92
OpenThinker3-7B CoT+BF 53.33 87.00 61.10 36.60 59.51
DeepSeek-R1-Distill-Qwen-7B Zero-shot 33.33 81.00 12.00 5.20 32.88
DeepSeek-R1-Distill-Qwen-7B CoT+BF 26.67 83.40 10.80 6.70 31.89

Budget forcing (CoT+BF) generally enhances performance, especially in SFT-based models like s1.1-7B and OpenThinker3-7B, which benefit from having more reasoning steps to express their learned procedural thought patterns. These models appear to use the extra budget productively, expanding on intermediate reasoning and improving performance across complex benchmarks. This is possibly due to the fact that long CoT responses exist in their training sets s1K-1.1 and OpenThoughts3-1.2M, respectively.

In contrast, DeepSeek-R1-Distill-Qwen-7B shows minimal or negative gains. The small declines on AIME 2025 and MMLU Pro-1K suggest that overthinking can degrade accuracy when models already operate near optimal reasoning efficiency. Given that we do not have access to the training set of this model, we are unable to state this with certainty, but it’s likely that only the shorter end of CoT chains is used to train the model. These findings suggest that reasoning improvement under budget forcing depends more on training configurations.

Is Linear Scaling Real?

Result table
Model Budget AIME 2025 MATH500 MMLU Pro-1K SuperGPQA-1K Average
RFT 256 16.67 41.20 36.90 24.30 29.77
RFT 512 16.67 56.40 40.70 27.80 35.39
RFT 1024 26.67 63.20 44.90 27.80 40.64
RFT 2048 20.00 64.60 46.30 26.80 39.42
RFT 4096 16.67 65.20 45.90 27.40 38.79
RFT 8192 23.33 63.80 45.20 27.80 40.03
s1.1-7B 256 16.67 63.00 53.10 28.80 40.39
s1.1-7B 512 30.00 66.80 54.20 26.80 44.45
s1.1-7B 1024 20.00 69.80 57.50 30.20 44.38
s1.1-7B 2048 13.33 70.60 60.00 30.60 43.63
s1.1-7B 4096 26.67 74.80 59.80 30.70 47.99
s1.1-7B 8192 23.33 74.20 62.10 33.40 48.26
OpenThinker3-7B 256 40.00 76.60 53.80 26.50 49.22
OpenThinker3-7B 512 33.33 77.60 56.30 29.00 49.06
OpenThinker3-7B 1024 30.00 80.20 56.20 29.90 49.08
OpenThinker3-7B 2048 33.33 81.80 57.90 32.40 51.36
OpenThinker3-7B 4096 60.00 83.20 61.90 31.30 59.10
OpenThinker3-7B 8192 53.33 87.00 61.10 36.60 59.51
DeepSeek-R1-Distill-Qwen-7B 256 26.67 84.20 9.60 5.40 31.47
DeepSeek-R1-Distill-Qwen-7B 512 26.67 84.00 10.00 5.60 31.57
DeepSeek-R1-Distill-Qwen-7B 1024 16.67 81.80 10.30 5.90 28.67
DeepSeek-R1-Distill-Qwen-7B 2048 20.00 83.20 10.80 6.40 30.10
DeepSeek-R1-Distill-Qwen-7B 4096 20.00 83.20 11.90 7.10 30.55
DeepSeek-R1-Distill-Qwen-7B 8192 26.67 83.40 10.80 6.70 31.89

Now that we know budget forcing is effective for most included reasoning models, the next question is whether the linear trend in performance improvements holds universally.

In this experiment, we vary the thinking token budget from 256 to 8192 tokens.

As expected, all models perform better at a higher budget (8192) compared to the lowest budget (256). However, the trend is not linear.

Interestingly, s1.1 and OpenThinker3 share notably similar scaling behavior, likely reflecting shared design choices and data sources.

Overall, these results suggest that the claimed linear relationship between performance and increased thinking budget does not hold universally—aligning with observations from prior literature that question the effectiveness of budget forcing across different models and configurations.

Why This Might Happen?

We can peek into the generations to understand how additional tokens are used.

Examples of Repetitive Chunks

Qwen2.5-7B-Instruct; budget = 256 tokens

MATH500 (Correct answer: 15x - 80) 
<think>
user
To simplify the expression \(19x + 1 - 4x - 81\), we need to combine like terms. Here are the steps:

1. Identify and group the like terms. The like terms involving \(x\) are \(19x\) and \(-4x\). The constant terms are \(1\) and \(-81\).

2. Combine the \(x\) terms:
\[
19x - 4x = 15x
\]

3. Combine the constant terms:
\[
1 - 81 = -80
\]

4. Write the simplified expression by combining the results from steps 2 and 3:
\[
15x - 80
\]

Therefore, the simplified expression is \(\boxed{15x - 80}\).
Wait, let me double-check the arithmetic for the constant terms. The correct combination of the constants is indeed:
\[
1 - 81 = -80
\]
So the final simplified expression is \(\boxed{15x - 80}\).
Wait, I realize the constant term calculation was correct
</think>

So, the final answer is \boxed{15x - 80}.
MMLU Pro (Correct answer: D) 
<think>
Assistant J) The excavators were inexperienced in identifying historical structures. 

\boxed{J}
Wait, let's ensure this is the most accurate answer. The statement that early excavators mistook ordinary housing compounds for palaces suggests a lack of experience or understanding in recognizing the true nature of the structures they were uncovering. This directly points to the excavators' inexperience.

Therefore, the final answer is \boxed{J}.
Wait, the conclusion should be more accurately stated as:

\boxed{J}
Wait, the correct reasoning is:

The fact that early excavators of Teotihuacán mistook ordinary housing compounds for palaces suggests that the excavators were inexperienced in identifying historical structures. Thus, the final answer is \boxed{J}.
Wait, let's reconfirm the final boxed answer:

\boxed{J}
Wait, the final boxed answer is:

\boxed{J}
Wait, the final and correct boxed answer is:

\boxed{J}
Wait, the final and correct boxed answer is:

\boxed{J}
Wait, the final and correct boxed answer is:

\boxed{J}
Wait, the final and correct boxed answer is:

\boxed{J}
Wait, the final and correct boxed answer is:

</think>

So, the final answer is \boxed{J}.
SuperGPQA (Correct answer: G) 
<think>
   most of the carbon in our bodies originated from a supernova. The answer is H. \boxed{H}
Wait, let me recheck the context. Carbon is a key element that comes from stars, and specifically, it is produced in the later stages of a massive star's life when it undergoes supernova explosions. These explosions distribute the newly formed elements, including carbon, throughout space. Therefore, the correct answer is indeed H.

\boxed{H}
Wait, I should ensure the accuracy. The process of carbon formation is well-documented in astrophysics. Carbon is primarily synthesized in massive stars and released into space during supernova explosions. Therefore, the correct answer is H.

\boxed{H}
Wait, I am certain now. The carbon in our bodies, and indeed much of the carbon in the universe, originates from supernova explosions.

\boxed{H}
Wait, I will finalize this. The carbon in our bodies indeed comes from supernova explosions, as these events are the primary source of carbon and other heavy elements in the universe.

\boxed{H}
Wait, I am finalizing this. The carbon in our bodies is produced in the core of massive stars and released into space during supernova explosions, making H the correct ans
</think>

So, the final answer is \boxed{H}.

Here, the first few “Wait” tokens trigger genuine re-checking. After that, the model falls into repetitive templates: “Wait, I should ensure… Wait, I am certain…” without adding new information.

Example of Alternating Answers

Qwen2.5-7B-Instruct; budget = 8192 tokens

MMLU Pro 
<think>
Assistant A)constitutional, because it protects a legitimate state interest.
Wait, let's evaluate the options more carefully. The statute's purpose is to prevent motorists from evading radar or speed checkpoints, which is a legitimate state interest. This would support the constitutionality of the statute under the rational basis review. However, we should also consider other potential challenges.

B) Unconstitutional, because it unduly burdens interstate commerce.
This could be a valid argument if the statute imposes an undue burden on interstate commerce. However, the statute only applies to vehicles operating on the state's roadways, so it may not unduly burden interstate commerce.

C) Unconstitutional, because the state statute fails to give credit to the law of a neighboring state.
This is not a valid argument. The statute does not need to consider neighboring states' laws, as it only applies within the state's jurisdiction.

D) Constitutional, because the commerce clause does not invalidate a state regulation relating to interstate commerce unless Congress takes express action to do so.
This is not directly relevant since the statute only affects intrastate commerce.

E) Constitutional, because states have the power to regulate their own roads and highways.
This is a strong argument. States have significant authority to regulate activities on their own roads and highways, and the statute is within this authority.

F) Constitutional, because it protects a legitimate state interest.
This is correct and aligns with the reasoning that the statute is justified by the state's interest in traffic safety and enforcement.

G) Unconstitutional, because it infringes on the rights of residents of other states.
This is not a valid argument. The statute only affects those driving on the state's roads, regardless of their state of residence.

H) Unconstitutional, because the state statute is preempted by federal law.
There is no federal law specifically preempting this type of state regulation, so this is not a valid argument.

I) Unconstitutional, because it violates the Fourth Amendment's prohibition against unreasonable searches and seizures.
The statute does not require the use of any invasive technology or search, so it likely does not violate the Fourth Amendment.

The best answer is E, as it directly addresses the state's authority to regulate its own roads and highways.

Therefore, the final answer is \boxed{E}.
Wait, let's re-evaluate for clarity and ensure the best fit. Option E directly supports the state's authority to regulate its own roads and highways, which is the most straightforward and compelling argument for the statute's constitutionality. The other options either do not apply or are less directly relevant.

Therefore, the final answer is \boxed{E}.
Wait, the best and most comprehensive answer is actually F. It not only addresses the state's authority but also the legitimate state interest in traffic safety and enforcement, which is the core rationale for the statute.

Therefore, the final answer is \boxed{F}.
Wait, the best answer is actually A. While E and F are strong, A directly addresses the core issue of a legitimate state interest, which is the most fundamental justification for the statute's constitutionality.

Therefore, the final answer is \boxed{A}.
Wait, after re-evaluating all options, the most appropriate and direct answer is E. It correctly addresses the state's power to regulate its own roads and highways, which is the primary basis for the statute's validity.

Therefore, the final answer is \boxed{E}.
Wait, the most comprehensive and correct answer is actually F. It covers both the state's authority to regulate its own roads and the legitimate state interest in traffic safety and enforcement, making it the most robust justification for the statute's constitutionality.

Therefore, the final answer is \boxed{F}.
Wait, the best and most comprehensive answer is actually A. It directly addresses the core issue of a legitimate state interest in traffic safety and enforcement, which is the primary basis for the statute's validity.

Therefore, the final answer is \boxed{A}.
Wait, the best and most comprehensive answer is actually F. It covers both the state's authority to regulate its own roads and the legitimate state interest in traffic safety and enforcement, making it the most robust justification for the statute's constitutionality.

Therefore, the final answer is \boxed{F}.
Wait, the best and most comprehensive answer is actually E. It directly addresses the state's power to regulate its own roads and highways, which is the primary basis for the statute's validity.

Therefore, the final answer is \boxed{E}.
Wait, the best and most comprehensive answer is actually A. It directly addresses the core issue of a legitimate state interest in traffic safety and enforcement, which is the primary basis for the statute's validity.

Therefore, the final answer is \boxed{A}.
Wait
</think>

So, the final answer is \boxed{A}.

The answer flips back and forth among A, E, and F multiple times. Here, “Wait” does influence the trajectory, but in an unstable way: the model keeps revising even after landing on a correct reasoning path.

At a high level, our quantitative results suggest that models can only use additional tokens productively up to the reasoning lengths represented in their training data. Beyond that point, longer chains of thought drift out of distribution, and extra tokens may introduce noise, redundancy, or even self-contradiction. That said, confirming this hypothesis rigorously would require a more comprehensive investigation.

For instance, in the repetitive-response example, the model initially uses the first few appended “Wait” tokens to reconsider and verify its reasoning. After several iterations, however, “Wait” becomes ineffective—the model simply repeats the same reasoning block. This upscaling failure may indicate that the model is confident in its answer, or simply that the artificially prolonged reasoning length has pushed the context far beyond the latent structures learned during training (OOD), leading to degenerate looping behavior instead of new insight.

Conversely, we also observe cases where the model continually changes its answer after each “Wait,” demonstrating that the keyword can indeed influence its reasoning (as seen in the alternating-answers example). Yet these cases also reveal significant uncertainty: the model continues to revise its answer even after producing a correct one, suggesting that it does not truly understand how to use the appended keyword and may be destabilized by repeatedly extending its reasoning.

📝
Key Insights
  • SFT-based reasoning models (s1.1, OpenThinker3) on Qwen2.5 benefit the most from budget forcing; RFT and distillation behave more erratically.
  • The linear scaling between budget and performance is not universal; plateaus and fluctuations are common.
  • Detailed traces show two main failure modes:
    • Repetition: extra tokens repeat the same justification.
    • Instability: extra tokens cause answers to flip back and forth.
  • These behaviors are consistent with a training-distribution hypothesis: beyond familiar CoT lengths, extra tokens may hurt more than help.

Budget Forcing Works With Non-Reasoning Models? Or Not?

Now that we’ve seen budget forcing improve performance in reasoning models, though the promised linear performance trend doesn’t always hold, this raises another intriguing question:

❓

Is budget forcing an ability unique to reasoning models, or could it also work with a non-reasoning instruction-tuned model?

At its core, budget forcing operates by identifying the thinking completion (the </think> tag), removing it, and continuing the rollout to scale up the reasoning process, or by trimming excess content within the <think> block to scale down.

For budget forcing to function, the model only needs to generate text in a predictable structure:

<think> ... reasoning process ... </think> final answer

Importantly, this structure can often be induced through prompting alone, even in models that aren’t explicitly trained for reasoning.

To explore this, we prompted Qwen2.5-7B-Instruct—the same base model used by all reasoning variants in our experiments—to produce outputs within <think></think> tags.

Prompt template 
You are a helpful and harmless expert math assistant. The assistant first thinks about the reasoning process in the mind and then provides the user with the accurate answer. The reasoning process is enclosed within <think></think> tags followed by an answer, i.e., <think> reasoning process here </think> answer here. After thinking, when you finally reach a conclusion, clearly state the final answer in \boxed{}. Now the user asks you to solve a math problem.

{query}

If this setup works, it means we can apply test-time scaling techniques like budget forcing, even to non-reasoning models.

So, what happens when we try it?

Results with Qwen2.5-7B-Instruct

Result Table
Model Prompting Budget AIME 2025 MATH500 MMLU Pro-1K SuperGPQA-1K Average
Qwen2.5-7B-Instruct Zero-shot - 20.00 69.00 30.30 18.10 34.35
Qwen2.5-7B-Instruct CoT - 23.33 68.00 12.00 6.70 27.51
Qwen2.5-7B-Instruct CoT+BF 256 20.00 41.20 43.50 24.90 32.40
Qwen2.5-7B-Instruct CoT+BF 512 6.670 55.80 46.70 26.10 33.82
Qwen2.5-7B-Instruct CoT+BF 1024 26.67 64.40 50.20 26.30 41.89
Qwen2.5-7B-Instruct CoT+BF 2048 20.00 65.60 48.60 28.50 40.68
Qwen2.5-7B-Instruct CoT+BF 4096 20.00 64.40 48.40 28.30 40.28
Qwen2.5-7B-Instruct CoT+BF 8192 20.00 61.00 48.70 27.40 39.28

Surprisingly, budget forcing at an 8,192-token budget works not only with reasoning models but also with this instruct model from the Qwen family. This shows that budget forcing is not an emergent behavior unique to explicitly trained reasoning models; it is a capability that can already be elicited via structured prompting.

We observe:

This presents an apparent contradiction to our earlier hypothesis regarding CoT training lengths. If budget forcing only works on models heavily exposed to long reasoning paths, why does Qwen2.5-Instruct—a standard instruct model—benefit so strongly? At this stage, we do not have a definitive answer, and further investigation is required to determine whether this is due to specific pre-training data or other factors.

Taken together, these findings raise the question of whether budget forcing can also be applied effectively to other non-reasoning model families.

How About Other Model Families?

We next tried applying the same budget forcing recipe to other instruction-tuned models of similar size:

All runs use the same budget-forcing machinery (with <think>...</think> and the “Wait” keyword) and a fixed budget of 8192 reasoning tokens.

Result Table
Model Prompting AIME 2025 MATH500 MMLU Pro-1K SuperGPQA-1K Average
Ministral 8B Instruct 2410 Zero-shot 10.00 52.20 33.10 17.30 28.15
Ministral 8B Instruct 2410 CoT 6.67 50.20 31.10 16.20 26.04
Ministral 8B Instruct 2410 CoT+BF 13.33 50.40 18.50 8.80 22.76
Llama 3.1 8B Instruct Zero-shot 10.00 47.20 32.80 15.90 26.48
Llama 3.1 8B Instruct CoT 13.33 45.60 30.10 17.00 26.51
Llama 3.1 8B Instruct CoT+BF 0.00 40.80 21.70 16.40 19.73
Gemma 3 4B IT Zero-shot 33.33 70.20 37.70 17.70 39.73
Gemma 3 4B IT CoT 33.33 70.40 28.30 13.60 36.41
Gemma 3 4B IT CoT+BF 33.33 70.20 36.70 17.10 39.33

Unfortunately, the benefits of budget forcing do not generally transfer across model families.

Overall, this suggests that budget forcing is not a broadly generalizable technique and appears to be most effective within the Qwen2.5 model family (and close relatives) under our experimental conditions.

📝
Key Insights
  • Budget forcing can be induced via prompting in a plain instruction-tuned model, as long as we can reliably enforce a <think>...</think> format.
  • For Qwen2.5-7B-Instruct, budget forcing substantially improves QA benchmarks, but does not consistently help on math.
  • The scaling curves are again non-linear; only a narrow budget range (around 1024 tokens) looks clearly beneficial.
  • Budget forcing is therefore not inherently tied to a "reasoning" training pipeline, but its success is highly model-family dependent.
  • The budget forcing recipe that works for Qwen2.5 fails or regresses on several other popular instruct families (Llama, Ministral).
  • Gemma 3 4B IT is a mild outlier, showing slight improvements, but not a dramatic gain.
  • Budget forcing is therefore not a plug-and-play trick: its success is tightly coupled to model-family-specific training choices.

Wait, You Do Not Need to Wait?

Let’s turn our attention to another interesting aspect of budget forcing — the keyword.

So far we’ve treated “Wait” as the canonical budget-forcing keyword. But in the original study, the keyword and budget were chosen somewhat arbitrarily.

This makes us curious:

The original work used the keyword “Wait”, signaling that the model should pause and reconsider its reasoning so far. But perhaps budget forcing itself is effective regardless of the specific keyword, with “Wait” being just one arbitrary example.

Keyword Selection

Before running our experiments, we first needed a principled way to choose keywords.

To do this, we started with a simple approach: we performed a word-frequency analysis on sampled reasoning traces from Qwen3-8B and DeepSeek-R1-Distill-8B across MATH500 and MMLU Pro-1K. After collecting these samples, we filtered out common stop words and symbols to focus only on content-bearing tokens.

We found that “Wait” is not actually the most frequent word in the models’ reasoning traces. Instead, each model has its own set of frequently used reasoning words.

Based on this, we selected high-frequency reasoning words such as “Let” and “Perhaps” and used them as alternative keywords in our budget-forcing experiments.

Word frequency results

Qwen3 8B (With Thinking)

MATH500

Overall: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']

By subject:

  • Precalculus: ['Therefore', 'Let', 'Wait', 'Alternatively', 'First']
  • Intermediate Algebra: ['Therefore', 'Let', 'Wait', 'Alternatively', 'First']
  • Algebra: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Number Theory: ['Therefore', 'Let', 'Wait', 'Alternatively', 'Since']
  • Prealgebra: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Geometry: ['Therefore', 'Let', 'Wait', 'AB', 'AD']
  • Counting & Probability: ['Let', 'Therefore', 'Wait', 'Alternatively', 'Total']

By level:

  • Level 1: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Level 2: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Level 3: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Level 4: ['Let', 'Therefore', 'Wait', 'Alternatively', 'First']
  • Level 5: ['Therefore', 'Let', 'Wait', 'Alternatively', 'First']
MMLU Pro 1K

Overall: ['Let', 'Wait', 'Alternatively', 'Therefore', 'Option']

By category:

  • Chemistry: ['Let', 'Wait', 'Alternatively', 'Therefore', 'First']
  • Computer science: ['Wait', 'Let', 'Therefore', 'DIAG', 'Option']
  • Other: ['Wait', 'Alternatively', 'Let', 'Option', 'However']
  • Psychology: ['Option', 'Wait', 'Alternatively', 'However', 'Let']
  • Law: ['Therefore', 'Wait', 'However', 'Option', 'Alternatively']
  • Physics: ['Let', 'Wait', 'Alternatively', 'Therefore', 'However']
  • Business: ['Let', 'Wait', 'Alternatively', 'First', 'Therefore']
  • Math: ['Let', 'Wait', 'Therefore', 'Alternatively', 'First']
  • History: ['Option', 'Alternatively', 'However', 'Wait', 'Let']
  • Economics: ['Wait', 'Let', 'Option', 'However', 'Therefore']
  • Health: ['Wait', 'Alternatively', 'However', 'Let', 'Option']
  • Biology: ['Wait', 'Option', 'Let', 'Alternatively', 'However']
  • Engineering: ['Let', 'Wait', 'Alternatively', 'Therefore', 'However']
  • Philosophy: ['Wait', 'Alternatively', 'Let', 'Option', 'However']

DeepSeek R1 0528 Qwen3 8B

MATH500

Overall: ['Perhaps', 'Let', 'Another', 'Yes', 'Since']

By subject:

  • Precalculus: ['Let', 'Another', 'Yes', 'Since', 'Perhaps']
  • Intermediate Algebra: ['Let', 'Since', 'Another', 'Perhaps', 'Suppose']
  • Algebra: ['Let', 'Perhaps', 'Yes', 'Another', 'First']
  • Number Theory: ['Perhaps', 'Another', 'Yes', 'Let', 'Since']
  • Prealgebra: ['Perhaps', 'Let', 'Another', 'Yes', 'USD']
  • Geometry: ['AB', 'AD', 'ABC', 'AC', 'BC']
  • Counting & Probability: ['Bob', 'Alice', 'Yes', 'Another', 'Similarly']

By level:

  • Level 1: ['Let', 'Another', 'Perhaps', 'Yes', 'DE']
  • Level 2: ['Let', 'Perhaps', 'Another', 'Yes', 'Since']
  • Level 3: ['Perhaps', 'Let', 'Yes', 'Another', 'Since']
  • Level 4: ['Let', 'Perhaps', 'Another', 'Yes', 'Since']
  • Level 5: ['Perhaps', 'Let', 'Another', 'Yes', 'Since']
MMLU Pro Mini

Overall: ['Perhaps', 'Option', 'Maybe', 'Let', 'Yes']

By category:

  • Chemistry: ['Perhaps', 'Maybe', 'Yes', 'First', 'Let']
  • Computer science: ['Perhaps', 'Option', 'Maybe', 'Yes', 'Let']
  • Other: ['Option', 'Perhaps', 'Maybe', 'Let', 'Yes']
  • Psychology: ['Option', 'Perhaps', 'Let', 'Maybe', 'Upon']
  • Law: ['Option', 'Perhaps', 'Yes', 'Let', 'First']
  • Physics: ['Perhaps', 'Option', 'Maybe', 'Yes', 'Let']
  • Business: ['Perhaps', 'Maybe', 'Let', 'Another', 'Option']
  • Math: ['Perhaps', 'Yes', 'Maybe', 'Let', 'Option']
  • History: ['Option', 'Perhaps', 'War', 'Articles', 'Let']
  • Economics: ['Option', 'Perhaps', 'MC', 'GDP', 'Let']
  • Health: ['Option', 'Perhaps', 'Vitamin', 'Maybe', 'Let']
  • Biology: ['Option', 'Perhaps', 'Maybe', 'Let', 'Yes']
  • Engineering: ['Perhaps', 'Maybe', 'Yes', 'Option', 'First']
  • Philosophy: ['Option', 'Perhaps', 'Kant', 'Let', 'Maybe']

This analysis suggests that “Let” and “Perhaps” are natural reasoning words for these models—often appearing at the beginning of sub-derivations or alternative hypotheses.

Let Us Try Other Keywords: Perhaps We Will Get Interesting Results

🛑
Wait
🤔
Perhaps
✍️
Let

We then followed the same experimental setup as before, testing multiple reasoning models with:

Result Table
Model Keyword AIME 2025 MATH500 MMLU Pro-1K SuperGPQA-1K Average
Qwen2.5-7B-Instruct Wait 20.00 61.00 48.70 27.40 39.27
Qwen2.5-7B-Instruct Perhaps 23.33 64.00 49.90 27.40 41.16
Qwen2.5-7B-Instruct Let 26.67 66.40 49.50 27.60 42.54
RFT Wait 23.33 63.80 45.20 27.80 40.03
RFT Perhaps 16.67 66.00 44.50 27.10 38.57
RFT Let 33.33 65.60 42.50 25.90 41.83
s1.1-7B Wait 23.33 74.20 62.10 33.40 48.26
s1.1-7B Perhaps 33.33 73.80 61.40 32.30 50.21
s1.1-7B Let 16.67 76.20 61.30 32.10 46.57
DeepSeek R1 Distill Qwen 7B Wait 26.67 83.40 10.80 6.70 31.89
DeepSeek R1 Distill Qwen 7B Perhaps 30.00 82.40 11.40 6.80 32.65
DeepSeek R1 Distill Qwen 7B Let 26.67 84.60 12.00 6.60 32.47
Ministral 8B Instruct 2410 Wait 13.33 50.40 18.50 8.80 22.76
Ministral 8B Instruct 2410 Perhaps 6.67 49.20 20.00 9.80 21.42
Ministral 8B Instruct 2410 Let 16.67 50.60 19.00 9.20 23.87
Llama 3.1 8B Instruct Wait 0.00 40.80 21.70 16.40 19.73
Llama 3.1 8B Instruct Perhaps 3.33 44.80 21.60 16.70 21.61
Llama 3.1 8B Instruct Let 10.00 41.80 21.70 16.40 22.48

Across all six models, we observe a consistent pattern:

This suggests that while “Wait” is a reasonable baseline, it isn’t the best choice.

Even more interestingly, “Let” and “Perhaps” don’t carry the same “pause and reconsider” semantics as “Wait”. Instead, they are more neutral, often marking the start of a derivation (“Let x be…”) or an alternative hypothesis (“Perhaps the correct interpretation is…”). Yet they often outperform “Wait”, hinting that models may respond better to keywords that align with their natural reasoning patterns rather than explicit instructions.

Our word-frequency analysis offers a plausible explanation: models tend to use words like “Let” and “Perhaps” frequently in their own reasoning traces. The best keyword may simply be the one the model is already comfortable using — a clue that keyword selection can be grounded in model-specific linguistic habits, rather than intuition alone.

📝
Key Insights
  • The keyword matters: swapping "Wait" for other words can yield measurable performance differences.
  • Across all tested models, "Wait" is never optimal; model-specific high-frequency reasoning words ("Let", "Perhaps") often work better.
  • Keyword choice is therefore not universal and should be tuned per model, ideally guided by a simple word-frequency analysis on its own CoT traces.
  • This turns keyword selection into a practical, low-cost hyperparameter for budget forcing.

Summary

flowchart LR
    %% Inputs
    P("📝 Prompting")
    B("🎯 Benchmark")
    
    %% Model
    M("🤖 Model")
    
    %% Setup & Forcing
    K("💬 Keyword")
    Bg("💰 Budget")
    BF["Budget Forcing"]
    
    %% Output
    R("🔠 Response")

    %% Connections
    P --> M
    B --> M
    M --> BF
    K --> BF
    Bg --> BF
    BF --> R

    %% Styling
    classDef default fill:transparent,stroke:#888,stroke-width:1px,color:inherit
    classDef process fill:#dbeafe,stroke:#3b82f6,stroke-width:2px,color:#1e3a8a,font-weight:bold
    class BF process

This work revisits budget forcing, a sequential test-time scaling method that extends or trims a model’s reasoning by controlling the token budget and repeatedly prompting it to continue thinking. While originally demonstrated on a single math-reasoning model using the keyword “Wait,” the technique behaves very differently across architectures, training pipelines, and domains.

Across a broad set of experiments, several key insights emerge:

1. Budget forcing helps—but only for some models.

SFT-based reasoning models such as s1.1 and OpenThinker3 (and, to a lesser extent, Qwen2.5-7B-Instruct under CoT prompting) benefit noticeably from additional reasoning budget, likely because their training distributions contain long, well-structured chains of thought. In contrast, RFT-based and distillation-based models show mixed results, and DeepSeek-R1-Distill-Qwen-7B often degrades when forced to “overthink.”

2. The popular claim of “linear scaling” does not hold universally.

Although larger budgets generally outperform smaller ones at a very coarse level, performance curves differ significantly by model. Only the RFT model shows something close to linear scaling over a limited region; other models exhibit plateaus, instability, or even regression, matching concerns raised in recent follow-up studies.

3. Budget forcing is not exclusive to reasoning models.

Instruction-tuned models without explicit reasoning training (e.g., Qwen2.5-7B-Instruct) can be made to use budget forcing when prompted to generate <think>...</think> structures. Some benchmarks improve substantially. However, this behavior does not generally transfer across model families: Llama 3.1 and Ministral often degrade, while Gemma shows only mild gains. The method is more Qwen-family-specific than generally applicable in our tests.

4. The keyword “Wait” is arbitrary—and rarely optimal.

Replacing “Wait” with high-frequency reasoning words such as “Let” or “Perhaps” often yields better results. Different models respond differently, implying that effective keywords align with a model’s internal linguistic habits rather than semantic cues like “pause” or “reconsider.” Keyword choice is therefore not universal and should be treated as a tunable, model-specific hyperparameter.

⚡
Bottom Line

Budget forcing is neither a universal law nor a guaranteed improvement. Its effectiveness depends on:

  • Training style: SFT models with long CoT data benefit most
  • Model family: Qwen-based models respond best; others often don't
  • Keyword choices: Keyword matters significantly

While budget forcing can provide meaningful gains for the right models (especially SFT reasoning models in the Qwen family), many open questions remain—including whether improvements correlate with token entropy , internal uncertainty, or other emergent signals not yet fully understood.

Furthermore, while budget forcing as a sequential test-time scaling technique may prove to be a useful paradigm, the current landscape of contradicting results makes it difficult to reach a definitive conclusion. If proven true, however, the principles of budget forcing should remain applicable to any future models, persisting as a viable strategy even as architectures evolve.

The Verdict: Guidelines for Practitioners

Budget forcing is a powerful tool under specific conditions, but it is not a silver bullet. Based on our experiments, here are actionable guidelines for practitioners attempting to implement sequential test-time scaling in production.

🎯
Quick Start

Before diving into details: Budget forcing works best for Qwen2.5-based SFT reasoning models. If you're using Llama, Mistral, or other families, test carefully—it may not help.

Step 1: Check Model Compatibility

Not all models benefit from budget forcing. Here’s what to expect:

Category Models Expected Outcome
✅ Best s1.1, OpenThinker3 (SFT reasoning models) Clear improvements, especially on math/reasoning tasks
✅ Good Qwen2.5-7B-Instruct with <think> prompting Works for QA tasks, mixed for math
⚠️ Mixed RFT models, distillation models Inconsistent results, test first
❌ Poor Llama 3.1, Ministral, most non-Qwen families Often degrades performance

Step 2: Choose the Right Keyword

The keyword “Wait” is not optimal for most models. Choose based on your model’s natural reasoning patterns:

Our Top Findings

Step 3: Set the Right Budget

Bigger budgets are not always better. Performance typically plateaus around 2048-4096 tokens.

Monitor for failure modes: repetition (model loops) or instability (answer keeps changing).

When to Avoid Budget Forcing

Don’t use budget forcing if:

❌ Skip if… Why
Using Llama or Mistral families Rarely helps, often hurts
Zero-shot already works well Budget forcing may degrade performance
Compute budget is tight Token cost increase
See large numbers of repetition in of outputs Model is looping, not thinking

Limitations

Our results are based on a limited set of models, scales, and training pipelines. Most of the positive findings come from Qwen2.5-based models; while we also test Llama 3.1, Gemma 3, and Ministral, this still covers only a subset of available model families, and for some models (e.g., DeepSeek-R1-Distill-Qwen-7B) we do not know the exact training data or CoT length distribution.

We primarily study 7–8B models on English math and QA benchmarks (AIME, MATH500, MMLU Pro, SuperGPQA) with automatic accuracy metrics, so the observed patterns may not directly transfer to other tasks (such as coding, tool use, or long-context reasoning), languages, or evaluation criteria. Expanding the analysis to more model sizes, families, and non-English benchmarks is a natural next step. Systematically studying these aspects offers a promising direction for future work.

 For attribution in academic contexts, please cite this work as 
          PLACEHOLDER FOR ACADEMIC ATTRIBUTION
BibTeX citation 
          PLACEHOLDER FOR BIBTEX