Reasoning Effort That Adapts to the Request

TL;DR Our recently released Kolibri model lets you choose how long it reasons: none, low, medium or high. Our SFT training data came without effort labels, so we post-hoc annotated every reasoning trace by comparing its length with traces from the same dataset at the same judged difficulty. On 23 of 24 benchmarks our SFT checkpoint reasons longer at medium than at low and longer still at high. At low it keeps 96% of its high score while reasoning 35% as long, and the released model keeps 98% with 76% of the completion tokens.

A Hybrid Reasoning Effort Model

Test time compute helps solve hard problems, and reasoning is one way of doing so: the model writes a derivation, checks its answers, or drafts them before giving the final answer. Reasoning longer is known to raise accuracy on hard problems [1, 2, 3, 4, 5]. However, reasoning for too long impedes user expectations about latency. Ask a reasoning model what 2 + 3 is, and you may get a page of thinking before the model answers with 5 [6].

Prior work trains a model to decide whether to reason at all [7], puts a token budget into the prompt [8], enforces a budget at inference [9], or rewards a length target during RL [10]. For Kolibri, we wanted a reasoning effort behaviour that adapts to the prompt difficulty on its own, and a dial the user can turn when latency matters more than accuracy.

Like Qwen3 [11], Llama-Nemotron [12] and GPT-OSS [13], Kolibri is a single hybrid model [14] that answers directly or reasons at low, medium or high effort, with high as the default. The reasoning_effort parameter becomes one sentence in the system prompt. We picked a sentence over a token because the model can follow it before it has seen a single effort label.

None of our SFT traces records how much effort went into them, so we had to label each one post-hoc by measuring how long it reasoned. The rest of this post works out what that length should be compared against.

How to Measure Reasoning Length

Kolibri Origin, the internal predecessor of Kolibri, measured reasoning in characters. Tokens are the better unit, since the model generates tokens and the user waits for them. One reasoning token carries between 2.43 and 5.69 characters, with math at the low end (Figure 1). Kolibri Origin's 2,000-character threshold therefore meant 822 tokens in one dataset and 351 in another.

For our unit of reasoning we use the term exchange: all reasoning the assistant does between two turns a person writes. A tool loop with twenty calls is one exchange, and harness messages in the user role do not open a new one. A user sets the effort when they write a message, so the effort can only change at a real user turn.

Assigning Reasoning Efforts Based on Reasoning Length

We now need to assign a reasoning effort to a sample given its reasoning length. Apart from none, our model supports three reasoning modes, so each sample goes into one of three groups.

Constant Thresholds

A simple baseline is to partition the dataset by the number of reasoning tokens. Applying this approach to our dataset, we obtained a low bucket for the lowest 30% of reasoning lengths, a medium bucket for the middle 30% - 70%, and a high bucket for responses with a length above the 70th percentile.

This approach is suboptimal because reasoning length depends mostly on the domain: the median chat trace has 310 tokens and the median math trace 8.2K. With the pooled thresholds, 49% of chat becomes low and 83% of math becomes high, so the label mostly tells the model which dataset a trace came from. Figure 2 lets you move both thresholds. We found no position that gives all six domains a usable share of all three efforts.

Dataset-Dependent Thresholds

Datasets can be seen as a cheap stand-in for domain annotations. Thus, we set a threshold for every dataset, at their own 30th and 70th percentiles. Each dataset comes from one source with one task shape.

Figure 3 shows how far apart those thresholds lie. Of the 76 datasets with reasoning in an earlier, larger version of our SFT data pool, the figures show the 74 with at least 200 reasoning exchanges, and their median trace runs from 27 to 90K tokens. In 36% of dataset pairs, one dataset's 30th percentile lies above the other's 70th.

Difficulty-Dependent Thresholds

Per-dataset thresholds still leave a wide spread: in one math dataset, the middle 95% of traces runs from 430 to 79K tokens. Much of that spread comes from how difficult the prompt is.

To measure difficulty we used GLM-5.2 [15] as an LLM judge [16] on 100,000 conversations, grading them easy, medium or hard. We distilled its verdicts into a 2B student model, similar to DEITA [17]. The student grades every conversation four times. We average the four grades and round toward the harder one, because a hard request that gets too little reasoning costs more than an easy one that gets too much. The student agrees with GLM-5.2 84.8% of the time.

Split by difficulty grade, the math dataset's medians are 592, 2.6K and 18K tokens. Across datasets, hard prompts reason up to 31.3 times longer than easy ones. In code and chat the factor is 21, in science 5.5, and tool use and safety barely react (Figure 4).

Accounting for difficulty also improves user experience. If the label ignored difficulty, a user would have to judge how hard their own prompt is before choosing an effort. With thresholds per difficulty, the effort trades quality against latency, and the model works out how much reasoning the request needs.

The Label-Assignment Rule

We assign reasoning effort labels based on a sample's length relative to thresholds. We therefore fit thresholds per group, where a group is one dataset at one difficulty grade. 176 groups in 69 datasets reach the 200 exchanges we require, and each gets its own 30th and 70th percentile. Smaller groups and ungraded conversations fall back to their dataset's thresholds. Figure 5 lays out every group of a domain.

A hard cut at the two percentiles would have a side effect: every trace in a group would switch label at the same token count, and a model could learn that count as the place to stop thinking. So we soften the edge. A trace's length is placed on the interval from 0 to 1 by interpolating in log space through the group's two percentiles, and the label is drawn with a probability that falls off as a Gaussian with the distance from each bucket's centre.

With $\beta = 0.15$, neighbouring efforts hand over across a band of tokens, and each group ends up close to 30% low, 40% medium and 30% high. Figure 6 lets you change $\beta$. The draw is seeded per row, and a trace without reasoning gets none.

Because the thresholds are local, one label means different lengths in different groups: in the math dataset, low on a hard prompt has a median of 4.1K tokens, more than the 2.3K of high on an easy prompt. We want it that way, since the label describes reasoning relative to similar requests.

Training on the Labels

Each training row carries the inferred effort on its user messages, and the trainer turns it into the system prompt sentence. Kolibri's chat template drops the reasoning of earlier assistant turns, so we split each conversation into one sample per user turn, with loss on the last assistant turn only. On average a conversation yields 2.27 samples.

Samples cut from one conversation can open with different effort sentences, as in the example below.

An illustrative conversation constructed for this post. The split and the sentences follow the trainer.

Evaluating the SFT'd Model

We evaluated Kolibri's SFT checkpoint once per effort. Median reasoning length orders low < medium < high on 23 of 24 benchmarks. The mean score over 14 benchmarks is 38.4 without reasoning, then 64.9, 67.1 and 67.8. The first step buys almost all of the gain (Figure 7). For most requests low is a good setting.

Difficulty keeps its effect at evaluation time: with the effort held fixed, hard prompts get 32.5 times the reasoning of easy ones, and low to high multiplies the length by 1.4 to 3.7 (Figure 8).

What RL Adds

Our post-training pipeline has an RL stage after SFT. It samples a random effort for each group of rollouts, focusing on high. A format signal keeps the efforts apart: past 0.2, 0.4, or 0.8 of its budget, a completion's format score falls with length. Validation completions stay ordered by effort on 99% of the 1,000 steps (Figure 9).

The released model keeps the behaviour of the SFT checkpoint. Its mean over the six benchmarks rises from 58.1 without reasoning to 81.4, 82.2 and 82.7, and the median benchmark takes 7.7K, 8.5K and 10K completion tokens (Figure 10). At none it still writes out a derivation on math.

Limits

Our SFT reasoning effort labels are assigned post-hoc. Reasoning length depends on the prompt, so a model could predict length from the prompt and ignore the effort. Figure 8 shows that Kolibri follows the sentence, though at a fixed difficulty the effect is smaller than the labels ask for. Completions of different lengths for the same prompt mitigate this. The dataset is only a proxy for the domain, and a 2B judge will sometimes grade difficulty wrong.

We have not worked on reasoning efficiency yet. Each trace keeps the reasoning its source model wrote, so even at low the model can spend tokens that change nothing about the answer.

Future Work

During RL, every reasoning effort currently gets longer. We would like RL to bring the mean reasoning length down while scores keep rising. Rewards that penalise overspending a stated budget [18] are one way to get there.

On the SFT side, clusters of prompt embeddings could replace the dataset as the domain stand-in, and difficulty could be graded per exchange. Holding a prompt fixed and changing only the effort sentence would measure how much of the length the sentence controls.

Acknowledgements

Thanks to the SFT team, Niklas Finken, Garwin Lechner, Dylan Rodriquez, Simon Thel and Irina Vidal Migallón, for the data pipeline, the training runs and many reviews of this work, and to Niklas Finken for the difficulty judge behind every label. We also thank Bastian Boll, Niklas Freymuth and Jaisidh Singh for their reviews of this post.

Citation

@misc{alephalpha2026kolibri,
  title         = {Kolibri: A Sovereign European Model on the Pareto Frontier},
  author        = {{Aleph Alpha} and Moritz Althaus and Artur Baranowski and Michael Barlow and Fabien C. Y. Benureau and Felix Berkenkamp and Amrita Bhattacherjee and Lukas Blübaum and Duncan Blythe and Augustijn de Boer and Bastian Boll and Thomas F. Burns and Björn Deiseroth and Niko Dürr and Béni Balázs Egressy and Niklas Finken and Niklas Freymuth and Fabian Gebhart and Max Hammer and Bastian Harren and Andreas Hartel and Johann Higl and Steffen Hirschmann and Pablo Iyu Guerrero and Yasser Jadidi and Andreas Jagusch and Mitja Kleider and Markus Klein and Jonas Knupp and Murali Kondragunta and Garwin Lechner and Dominik Lê-Kellner and Jurek Leonhardt and Jiaze Li and Sohir Maskey and Omar Mehio and Pit Neitemeier and Letitia Parcalabescu and Alejandro Petry Pacheco and Pranav Ragupathy and Martin Reinhardt and Peter Rodenkirch Nfissi and Dylan Rodriquez and Leonard Salewski and Raziye Sari and Jordan Sassoon and Ivo Schaper and Ilhan Scheer and Frank Schneider and Philipp Scholl and Lukas Schott and Eric Schreiber and Pablo Schumacher and Alessio Serra and Philipp Siedler and Prabhu Teja Sivaprasad and Mohamed Soliman and Till Speicher and Volker Stampa and Simon Thel and Serge Thilges and Irina Vidal Migallón and Denis Waßmann and Samuel Weinbach and Sascha Wirges and Michael Wüthrich and Alexei Zacharov},
  year          = {2026},
  eprint        = {2610.31945},
  archiveprefix = {arXiv},
  primaryclass  = {cs.CL},
  url           = {https://arxiv.org/abs/2610.31945}
}

References

At medium effort the post cites all 18 works.

1. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, Denny Zhou. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models . Advances in Neural Information Processing Systems, 2022.
2. Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, Yusuke Iwasawa. Large Language Models are Zero-Shot Reasoners . Advances in Neural Information Processing Systems, 2022.
3. OpenAI. OpenAI o1 System Card . arXiv:2412.16720, 2024.
4. Charlie Snell, Jaehoon Lee, Kelvin Xu, Aviral Kumar. Scaling LLM Test-Time Compute Optimally Can be More Effective than Scaling Model Parameters . International Conference on Learning Representations, 2025.
5. DeepSeek-AI. DeepSeek-R1 Incentivizes Reasoning in LLMs through Reinforcement Learning . Nature 645, 633–638, 2025.
6. Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, Rui Wang, Zhaopeng Tu, Haitao Mi, Dong Yu. Do NOT Think That Much for 2+3=? On the Overthinking of o1-Like LLMs . arXiv:2412.21187, 2024.
7. Jiajie Zhang, Nianyi Lin, Lei Hou, Ling Feng, Juanzi Li. AdaptThink: Reasoning Models Can Learn When to Think . arXiv:2505.13417, 2025.
8. Tingxu Han, Zhenting Wang, Chunrong Fang, Shiyu Zhao, Shiqing Ma, Zhenyu Chen. Token-Budget-Aware LLM Reasoning . arXiv:2412.18547, 2024.
9. Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, Tatsunori Hashimoto. s1: Simple Test-Time Scaling . arXiv:2501.19393, 2025.
10. Pranjal Aggarwal, Sean Welleck. L1: Controlling How Long a Reasoning Model Thinks with Reinforcement Learning . arXiv:2503.04697, 2025.
11. Qwen Team. Qwen3 Technical Report . arXiv:2505.09388, 2025.
12. Akhiad Bercovich, Itay Levy, Izik Golan, Mohammad Dabbah, Ran El-Yaniv, Omri Puny, Ido Galil, Zach Moshe, Tomer Ronen, Najeeb Nabwani, et al.. Llama-Nemotron: Efficient Reasoning Models . arXiv:2505.00949, 2025.
13. OpenAI. gpt-oss-120b & gpt-oss-20b Model Card . arXiv:2508.10925, 2025.
14. Aleph Alpha, Moritz Althaus, Artur Baranowski, et al.. Kolibri: A Sovereign European Model on the Pareto Frontier . arXiv:2610.31945, 2026.
15. Z.ai. GLM-5.2 . Blog post, 2026.
16. Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, et al.. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena . Advances in Neural Information Processing Systems, Datasets and Benchmarks Track, 2023.
17. Wei Liu, Weihao Zeng, Keqing He, Yong Jiang, Junxian He. What Makes Good Data for Alignment? A Comprehensive Study of Automatic Data Selection in Instruction Tuning . International Conference on Learning Representations, 2024.
18. Tom A. Lamb, Adam Golinski, Eleonora Gualdoni, Sinead Williamson, Michael Kirchhof. Rewards for Budget-Aware Multi-Turn Agents That Adapt to Arbitrary Test-Time Constraints . arXiv:2610.28409, 2026.