LoCo: Tencent Researchers Teach a 7B Reasoning Model When to Stop Thinking

Tencent researchers Muyao Yuan, Liyan Xu, Weizhan Zhang, Muyan Jiao, Jiangnan Li, Jinchao Zhang and Jie Zhou published LoCo, a training method that teaches a reasoning model when to stop thinking, reporting completion-length cuts of 41.7 to 45.4 percent on five math benchmarks and 23.4 to 36.3 percent on three code benchmarks with accuracy maintained or improved. The paper, "Think Less, Locally: Local Preference Learning for Reasoning Compression," was published November 3, 2026 and appeared on Hugging Face's daily papers list on November 4; the authors released LoCo-7B weights, built on DeepSeek-R1-Distill-Qwen-7B, plus an MIT-licensed repository with data-construction, training and evaluation scripts. LoCo trains with Direct Preference Optimization on state-conditioned pairs generated from 14,027 self-generated math questions, running 2 epochs on 4 GPUs with DeepSpeed ZeRO-2 and a LoRA adapter merged into the base model; no independent replication has been found yet.

LoCo is a training method that teaches a reasoning model when to stop thinking, and its authors report that it cuts completion length by 41.7 to 45.4 percent on math and 23.4 to 36.3 percent on code while keeping accuracy the same or better. The paper, Think Less, Locally: Local Preference Learning for Reasoning Compression https://huggingface.co/papers/2611.04814?ref=explainx , was published on November 3, 2026 and appeared on Hugging Face's daily papers list on November 4. Authors are Muyao Yuan, Liyan Xu, Weizhan Zhang, Muyan Jiao, Jiangnan Li, Jinchao Zhang and Jie Zhou, and the paper page lists Tencent as the organization. The authors released a model, LoCo-7B https://huggingface.co/MuyaoYuan/LoCo-7B?ref=explainx , and an MIT-licensed repository https://github.com/MuyaoYuan/LoCo?ref=explainx with data-construction, training and evaluation scripts. All numbers below are the authors' own results. TL;DR: questions people ask first | Question | Answer | |---|---| | What does it do? | Teaches a reasoning model to conclude once it has enough information | | Math result | 41.7 to 45.4 percent shorter completions, five benchmarks | | Code result | 23.4 to 36.3 percent shorter, three benchmarks | | Accuracy | Maintained or improved, per the authors | | Base model | DeepSeek-R1-Distill-Qwen-7B | | Released | LoCo-7B weights; code under MIT license | | Training data | Self-generated math traces only 14,027 questions | | Training cost | 4 GPUs, 2 epochs, DeepSpeed ZeRO-2 per the README | | Independent replication | None found yet | The problem: models that keep thinking after they know Large reasoning models write long chains of thought. Often the answer is already reached a few steps earlier, and the rest is re-checking or restating. Each extra token costs time and money, which is why token efficiency has become a standing concern for teams that run these models; our guide to Claude Code token efficiency https://explainx.ai/blog/claude-code-token-efficiency-prompt-cache-sessions-guide-2026 covers the same pressure on the agent side. The paper argues that earlier compression methods work on whole trajectories: they reward shorter answers overall. That can push a model to skip steps it actually needs. LoCo asks a narrower question at each point in the reasoning: given where I am now, do I need to keep going? How LoCo works, step by step The authors describe the method in four moves, and the repository shows them as six scripts. 1. Collect the model's own traces. The base model solves training questions several times. The README generates three rollouts per question and keeps the shortest correct one. 2. Detect overthinking states. A pass flags steps where the model had enough information to stop but kept going. A second judge model re-checks the flagged steps; the README names Qwen3-30B-A3B-Instruct-2507 as the judge. 3. Freeze and regenerate. The reasoning up to that state is frozen. The model then produces eight alternative continuations from the same state, and shorter verified ones are kept. 4. Train with DPO. Pairs are built from the longer original continuation and a shorter verified one, then used for Direct Preference Optimization. Training runs 2 epochs on four GPUs with DeepSpeed ZeRO-2, using a LoRA adapter that is merged into the base model afterward. The key design point is that the preference pairs are conditioned on a state. The model learns that at this point, concluding is better than continuing, rather than learning that shorter is always better. In the authors' words on the paper page, the aim is "adaptive" behavior: the model should consider wrapping up only when it has reached a confident state. Stepping stones leading to a green flag, picturing a reasoning model reaching its answer in fewer steps What the results say The abstract reports that LoCo was evaluated on five mathematical and three code generation benchmarks. It lists these gains: | Domain | Completion length reduction | Accuracy | Other | |---|---|---|---| | Mathematics | 41.7 to 45.4 percent | Maintained or improved | Better accuracy-efficiency trade-off throughout | | Code | 23.4 to 36.3 percent | Maintained or improved | Best AUC across all code benchmarks | The code result is the unusual part. The training pairs come entirely from math, and yet the model also gets shorter on code with no loss in accuracy, which the authors call evidence of cross-domain generality. The abstract does not list per-benchmark scores, so we cannot give a table of accuracy by task. Read the paper for the numbers before you rely on any single benchmark. A question from the paper page, and the authors' answer A Hugging Face user asked whether the model might stop too early on tasks where the extra step is verification, such as checking a test before answering, and said that on modest hardware a 40 percent cut in tokens changes response time a lot. Liyan Xu, who submitted the paper, replied that most of the token savings come from removing redundant verification, but that the method does not remove all verification: preference pairs are built so the model only considers concluding once reasoning has reached a confident state, and necessary checks remain. This is the authors' answer in a comment, not an experiment in the paper, so the risk of too-early stopping on verification-heavy tasks is still something to test yourself. Why "local"? The idea behind the name In a paper-page comment, Liyan Xu says the motivation for local and adaptive steering comes from the team's earlier work, an ICML 2026 paper titled "How Far Ahead Do LLMs Plan? Uncovering the Latent Horizon in Chain-of-Thought Reasoning". Their finding, as Xu summarizes it, is that LLM reasoning is a local transition process rather than the execution of a global roadmap. We have not read that earlier paper, so this is the authors' own description. If that picture holds, it explains the design. A model that does not plan its whole chain in advance cannot be told a global target length and be expected to hit it sensibly. It can, however, learn a local rule: in this state, with this much evidence, stop or continue. Training on pairs that share an identical prefix isolates that single decision. Everything before the branch point is the same, so the preference signal reflects the choice to stop and not differences earlier in the chain. How to judge any reasoning-compression claim Whenever a paper reports shorter reasoning, four checks help. 1. Same accuracy, measured how? Check whether accuracy is the average over several samples or a single run, because reasoning models vary between runs. 2. Which length? Completion length can include or exclude the hidden thinking text. LoCo reports completion length, so compare like with like. 3. Which tasks? A gain on math, where answers are checkable, may not carry over to open-ended work. 4. At what cost? Training needs rollouts, a judge model and DPO. The README's setup is modest, four GPUs for two epochs, but the data pipeline runs a 30B judge model. Applying these to LoCo, the abstract answers the second point and partly the third, and the repository answers the fourth. The first one you can check by running the evaluation scripts. How to try it The README gives the commands. The weights download with the Hugging Face CLI. hf download MuyaoYuan/LoCo-7B --local-dir model/LoCo-7B The README recommends CUDA 12.8 and Python 3.12 and lists pinned versions: PyTorch 2.11.0, vLLM 0.23.0, TRL 0.29.1, Transformers 4.57.6 and PEFT 0.19.1. The code was developed on NVIDIA H20 GPUs. The model card shows the usual DeepSeek-style prompt: ask the model to reason step by step and put the final answer in a boxed expression, with temperature 0.6, top-p 0.95 and up to 32,768 new tokens. To evaluate, the README provides scripts for benchmarks such as MATH-500, AIME 2024 and AIME 2025, reporting accuracy, average completion length and per-sample responses, graded by symbolic equivalence. Run it against the base DeepSeek-R1-Distill-Qwen-7B on the same prompts so the length and accuracy comparison is yours, not only the authors'. How this fits other efficiency work Reasoning efficiency is being attacked from several angles. Architecture work tries to get depth without parameters, for instance NVIDIA's Dory looped 4B model https://explainx.ai/blog/nvidia-nemotron-labs-dory-4b-looped-model-nvfp4-adjustable-loops-swe-bench-2026 and the new SenseNova-Loop-9B-Preview https://explainx.ai/blog/sensenova-loop-9b-preview-looped-multimodal-model-mhc-56-layer-executions-apache-2026 , and our explainer on recurrent looped transformers https://explainx.ai/blog/recurrent-looped-transformer-infinite-reasoning-depth-2026 covers why. Fine-tuning work, like LoCo, changes how long a fixed model thinks. A third route is picking a small model and tuning it for one job, as Coinbase did when its fine-tuned Qwen3.5 9B beat larger models on fraud https://explainx.ai/blog/coinbase-qwen3-5-9b-fraud-agent-beats-opus-4-5-newer-models-regress-owning-intelligence-2026 . These routes combine. A model that thinks less per problem is cheaper to serve whatever its architecture, so a method like LoCo is complementary, not a rival, to looped designs. Limits and open questions - One base model. Results are for a 7B distilled model. Larger or differently trained reasoners may behave differently. - Math-only training. Transfer to code is shown, but other domains, such as long-horizon agent tasks, are not in the abstract. - Self-reported. We found no independent replication. The repository had two commits and two stars when we read it. - Judge dependence. The pipeline uses another model to judge overthinking states, so errors in that judge could shape the data. - Verification-heavy tasks. As the paper-page exchange shows, this is the case to test first. - Task mix. A 40 percent saving on math chains does not translate directly to a 40 percent saving on your workload, which may include non-reasoning output. Should you care? If you serve reasoning models and pay per token, a drop of this size matters, because reasoning tokens often dominate the bill. If you only use hosted APIs, you cannot apply LoCo yourself, but you can expect similar tricks from providers. For researchers, the repository is a clear, runnable example of state-conditioned preference learning. The practical next step is simple: run LoCo-7B and the base model on 50 of your own prompts and compare accuracy and token counts. Related reading Details are accurate as of November 4, 2026. The repository and model card may change.