Test-time scaling improves the reasoning capability of large language models by generating longer sequential chains of thought. While effective, this approach reaches a bottleneck as computation increases, resulting in a “test-time scaling plateau” where further computation provides only marginal gains. We argue that this ceiling reflects a limitation of the scaling strategy rather than model capability, a phenomenon we term Tunnel Vision, where imperfect early steps can lock the model into a suboptimal reasoning path. Motivated by this observation, we propose ParaThinker, an end-to-end parallel reasoning framework that trains LLMs to generate multiple reasoning paths in parallel and aggregate them into a final answer within a single architecture. By exploring different lines of thought, ParaThinker sidesteps the Tunnel Vision issue and unlocks the model’s reasoning potential. On challenging reasoning benchmarks, ParaThinker achieves accuracy improvements (e.g., 6.5%–20.7% on AIME-24 with a 1.5B model) over sequential-reasoning LLMs under the same budget of decoding tokens. Under matched decoding token budgets and with KV-cache reuse, ParaThinker achieves 38.7%–66.8% lower inference latency than sequential decoding via batched parallel generation. The code is available at https://github.com/MobileLLM/ParaThinker.

Scaling test-time computation improves the reasoning ability of large language models (LLMs), but the resulting latency and cost limit its use in latency- and cost-sensitive scenarios. We present BudgetThinker, a framework for reasoning-budget adherence that provides online control of chain-of-thought (CoT) length during decoding. Rather than relying on a one-shot prompt instruction, BudgetThinker periodically inserts specialized tokens that communicate the remaining reasoning budget. A two-stage training pipeline, consisting of supervised fine-tuning and curriculum-based reinforcement learning, teaches the model to interpret these signals and adapt its reasoning pace. Across the evaluated 1.5B and 7B text backbones, a 7B multimodal backbone, and a 1.5B code-reasoning model evaluated on HumanEval, BudgetThinker improves budget adherence and accuracy–efficiency trade-offs over competitive baselines. The controlled comparisons isolate the contribution of online ratio signaling from the shared training pipeline. Code is available at https://github.com/MobileLLM/BudgetThinker.

Recent work has demonstrated the remarkable potential of Large Language Models (LLMs) in test-time scaling. By making models think before answering, they are able to achieve much higher accuracy with extra inference computation.However, in many real-world scenarios, models are used under time constraints, where an answer should be given within a certain output length. It is unclear whether and how the reasoning ability of different LLMs remain effective under strict constraints.We take a first look at this problem by conducting an in-depth empirical study. Specifically, we test 30 LLMs on common reasoning datasets under a wide range of output length budgets, and we analyze the correlation between the inference accuracy and various properties including model type, model size, prompt style, etc. We also consider the mappings between token budgets and actual on-device latency budgets.The results have demonstrated several interesting findings regarding the budget-aware LLM reasoning ability that differ from the unconstrained situation, e.g. the optimal choices of either model size or prompt style change under different budgets. These findings offer timely evaluation to this area and practical guidance for users to deploy LLMs under real-world latency constraints.