Abstract
Large Language Models (LLMs) with chains-of-thought have demonstrated strong performance on an increasing range of tasks, particularly those involving complex logical reasoning. However, excessively long chains can lead to overthinking, causing computational waste and slower responses. This raises a question: can LLMs dynamically adjust the length of their reasoning processes based on task complexity? To address this, we propose the Think in Blocks framework, which enables adaptive reasoning—from zero to deep reasoning—by partitioning the reasoning process into a tunable number of blocks. Our main contributions are: (1) Establishing an explicit block-structured paradigm in which the model first predicts an integer reasoning budget—the number of blocks—and then partitions its reasoning accordingly; (2) Training an adaptive model through a three-stage pipeline—Supervised Fine-Tuning, reward-guided Direct Preference Optimization, and Reinforcement Learning—that adjusts its reasoning depth to problem difficulty; (3) Exploiting the explicit block count to dynamically control reasoning depth at inference time, allowing flexible adjustment of chain-of-thought length during deployment.
Introduction
Modern reasoning models, such as OpenAI’s o1 or DeepSeek-R1, utilize extensive "Chains-of-Thought" (CoT) to solve complex problems. While effective for advanced mathematics or logic, these models often suffer from overthinking—expending significant computational resources on trivial queries where the answer is immediate (e.g., "What is 1+1?"). Current solutions typically offer a binary choice: either the model thinks or it doesn't. There is a clear need for a "dimmer switch" that allows models to distinguish difficulty levels and adapt their reasoning depth dynamically.
The Think in Blocks (TiB) Framework
The Think in Blocks (TiB) framework structures reasoning into discrete, countable segments, allowing the model to allocate a specific "reasoning budget" per task.
Block-Structured Paradigm
Instead of a continuous stream of thought, the model is trained to output a <thought_segments>n</thought_segments> tag first. This integer $n$ represents the predicted number of reasoning blocks required. The model then generates $n$ blocks, separated by <continue_think> markers.
Training Pipeline
The framework employs a three-stage training process:
- Supervised Fine-Tuning (SFT): A curriculum-based approach where the model first learns the block format on medium-difficulty tasks, followed by exposure to "Non-Thinking" (0 blocks) and "Deep-Thinking" (many blocks) examples.
- Direct Preference Optimization (DPO): Fine-tuning using a reward score that favors brevity for simple problems and depth for complex ones.
- Reinforcement Learning (RL): Using algorithms like GRPO to optimize a Lagrangian objective that balances accuracy, format consistency, and reasoning length.
Experimental Evaluation
The study utilizes the DeepMath benchmark. Reference answers were refactored using Qwen3-32B to match the Qwen3-8B base model's style and programmatically segmented into blocks. Evaluation was conducted on a 1k subset stratified by difficulty levels ranging from 2.0 (easy) to 9.0 (difficult).
Key Insights and Results
The TiB framework demonstrates that models can effectively commit to a complexity level before reasoning begins, preventing "token-wasting" loops.
Performance Metrics
The full SFT → DPO → GRPO pipeline achieved significant improvements:
- Efficiency: Average answer length was reduced by 25.1%.
- Accuracy: Overall accuracy remained stable, with only a negligible 0.2% drop.
- Adaptivity: The model successfully transitioned to "no-thinking" (0 blocks) for easy problems while scaling up for difficult ones.
- Control: Users can manually override the block count at inference time to manage latency or energy consumption.
Conclusion and Future Work
Think in Blocks provides a granular method for controlling LLM reasoning depth. While the model occasionally struggles with perfect adherence to the predicted block count, it represents a significant step toward efficient, adaptive AI. Future work will focus on more robust alignment methods and potential architectural modifications to further integrate block-structured logic into the decoding process.
Summary updated