Few Word Do Trick

Summary

• Three open model families had their reasoning turn terser through 2026. From the older to the newer release, the share of filler words fell by between a quarter and a half: DeepSeek 26.6% to 13.3%, GLM 18.9% to 13.6%, Kimi 18.0% to 9.8%.
• Shorter wording did not mean fewer tokens. DeepSeek's newer model spends 2.5 times the reasoning tokens of its predecessor; only GLM got cheaper.
• Among today's open models, Kimi K3.1 Pro writes the leanest reasoning (9.8% filler) and Qwen3.8 Flash the wordiest (23.7%).

Why count filler

Reasoning models think and plan in the reasoning prefix to their response, and this “chain of thought” adds to the total token spend as well as time latency, besides increasingly requiring monitors to completely oversee what a LLM is doing. A year ago most open models reasoned in full English sentences: "Let me start by exploring the repository and finding the relevant code." Several of this year's releases write something closer to a note to themselves: "Need inspect repo. grep."

We wanted to measure that shift toward terse reasoning with few filler words directly. If a model drops words which a careful reader would not miss, it should either save tokens, solve more within the same budget, or at least do no worse. We measured the fraction of filler words in the reasoning of open models on agentic coding tasks, compared releases within the same family, and checked what happened to cost and outcomes.

We count five kinds of filler words (fillers, for short), chosen as the words a maximally terse reasoner would drop without losing information:

• Self-talk: "let me", "I'll", "we need", "hmm", "wait", "actually", "okay".
• Articles: the, a, an.
• Helper verbs: forms of be, do and have used as auxiliaries ("is", "does", "have been").
• Connectors: "and", "to" before a verb, "that" before a clause, an empty "there's".
• I, we, me, us: the model referring to itself.

Prepositions, negation, hedges such as "maybe" and connectives such as "but" carry meaning, so we classify these to be non-fillers. Only English sentences count: code blocks, shell commands and code inside a sentence are removed first.

Setup

We run 12 open models on 20 agentic coding tasks in a terminal agent: 8 from SWE-bench Verified, 5 from SWE-bench Pro and 7 from Terminal-Bench 2.1. Each model runs each task once with reasoning effort set to high and temperature 1.0, behind the same 262k-token context cap. We picked tasks these models mostly solve, so that differences in wording are not mixed up with differences in success. Every SWE-bench Pro and Terminal-Bench task we kept was solved by at least 8 of the 10 current models, and 192 of the 200 current-model runs succeeded.

Nine of these models are the newest release in their family: Kimi K3.1 Pro, GLM-5.3-Flash, DeepSeek V4.1 Flash, Reflection Beam 1.0, MiniMax-M3.1-Flash, Inkling 2 Small, Muse Spark Open, MiMo V2.6 Flash and Qwen3.8 Flash. Three older releases give the before-and-after view: Kimi K3, GLM-5.2 and DeepSeek V4 Flash.

Tasks. SWE-bench Verified: django 11099, 11133, 11179, 14089, 16139; scikit-learn 13439; astropy 14995; pytest 7432. SWE-bench Pro: element-web, openlibrary, vuls, qutebrowser, tutanota. Terminal-Bench 2.1: fix-git, prove-plus-comm, constraints-scheduling, crack-7z-hash, kv-store-grpc, nginx-request-logging, cobol-modernization.

Every run, with its full trajectory and score, is in the PatronusAI/few-word-do-trick-traces dataset on Hugging Face.

Open models got terser this year

In all three model families we compared, the newer release writes fewer filler words. DeepSeek halved its filler share between the April and October builds of its Flash model. Kimi K3.1 Pro cut it nearly in half from K3. GLM moved less but in the same direction.

The change is evident in the lines a model writes early on. Here are DeepSeek's two Flash builds reasoning about the same Django bug, where deleting a model instance leaves its primary key set:

The older style is not always verbose, which is part of the reason the average difference looks smaller than the examples might suggest. Kimi K3 opens most tasks in clipped notes and switches to full prose once it starts debugging. K3.1 Pro stays clipped while working through the same bug:

What they dropped

The newer models did not cut down their use of every kind of filler equally. Article use dropped the most, by 93% for Kimi and 85% for DeepSeek, with helper verbs close behind. Self-talk fell much less than articles did. GLM and Kimi cut it by about a third, and DeepSeek's rose slightly, since its clipped style leans on self-talk ("We need… Need… Need…"). Connectors barely moved for GLM and Kimi. Kimi K3.1 Pro also says "I" more than K3 did, from openers like "I need" and "I should". Self-talk may be the one kind of filler that training adds rather than removes. Going back into LLM history, in early 2025, DeepSeek-R1-Zero started writing "Wait, wait. Wait." during reinforcement learning with outcome-only rewards [10], and suppressing markers such as "wait" and "hmm" often costs no accuracy [11]. Self-talk can also be added on purpose: s1 appends "Wait" when a model tries to stop thinking, which makes it check its answer [16].

Terser is not cheaper

Fewer words per sentence would save tokens if other aspects of writing style, such as hedging in reasoning and the propensity to explore, stayed equal. It did not. DeepSeek's newer Flash model reasons in shorthand but writes far more of it, a median of 8,387 reasoning tokens per task against 3,421. Kimi K3.1 Pro also spends more than K3, 1,324 against 918. Only GLM's newer model got slightly cheaper.

Outcomes did not change either. The older releases solved 58 of their 60 runs and the newer ones 60 of 60. The tasks are easy for these models, so this shows the terse style costing nothing on simple fixes. It does not show terse reasoning helping on hard ones, and we would not expect a mere change in style to do that.

Who still says lot of words

Across the newest release of each family, filler share ranges from under one word in ten to almost one in four. Articles account for the biggest gap. Kimi K3.1 Pro uses about 4 per 1,000 words, while Qwen3.8 Flash, Inkling 2 Small and MiMo V2.6 Flash use 72 to 90, close to ordinary written English.

For a human reference, we ran the same filler count on the bug reports behind all 500 SWE-bench Verified tasks: engineers describing coding problems in their own words. They come out at 20.8% filler and 86 articles per 1,000 words. The wordiest open models now write about as much filler as a person filing an issue, and Kimi K3.1 Pro uses less than half of it. People spend their filler words differently, though. The issue writers use almost no self-talk (8.5 per 1,000 words), while every model uses 29 or more. A larger comparison of model and human think-aloud traces also finds models using the same reasoning moves as people in different ways [12], and some argue that reading these markers as human-like thinking is misleading [13].

A terse writer is not automatically a cheap one. DeepSeek V4.1 Flash is among the tersest but spends a median 8,387 reasoning tokens per task. Muse Spark Open sits mid-pack on filler but spends 19,153, the most of any model, and repeats its own five-word phrases more than any other model.

Across benchmarks

The ranking holds on each benchmark on its own, with one exception. MiniMax-M3.1-Flash writes like the verbose models on SWE-bench Verified (24.0% filler) but like the terse ones on SWE-bench Pro and Terminal-Bench (about 10.5%). We have not established why.

Why this change might have arisen

We cannot see how these models were trained, so everything in this section is much in the realm of conjecture, or in other words, a hypothesis for why this shift in reasoning language came about.

1. A length penalty during RL

Perhaps reinforcement learning added a penalty on response length, and models learned to drop the cheapest words first. Articles and helper verbs carry almost no information, so they would go before anything else, which is what we see. The token counts don't fit that well. A per-token penalty should shorten reasoning overall, yet DeepSeek's newer model spends 2.5 times as many reasoning tokens and Kimi's spends 44% more. A penalty on each step or sentence would fit better, since it rewards short sentences without capping how many of them a model writes.

2. A different teacher to distill from

Open models are often trained on reasoning traces from stronger closed models, and the student inherits the teacher's style along with its skill. Recent work describes GPT-6 Astra's extracted reasoning as unusually telegraphic and low in redundancy [6], while traces in the style of Claude Opus models typically read as full prose. If open labs moved their distillation data from Opus-style traces to Astra-style traces, terse reasoning would appear across several unrelated families within months, without any lab choosing it on purpose. That fits the timing we can see: GLM's shift landed between its June and August releases, and DeepSeek's Flash model was already terse by its July build. It would also explain why self-talk survives, because a student copies the teacher's habits wholesale, "Need… Need…" included.

Others have noticed the resemblance. In October, Lisan al Gaib posted examples of DeepSeek and Astra making the same compressions, from dropping "to" to joining words and numbers [9]:

Lisan al Gaib@scaling01

very curious that DeepSeek now has the same terse reasoning style as Astra

must be a coincidence

3. Drift from outcome-only rewards

When RL rewards only the final result, nothing rewards readable reasoning, and over long training runs the text can drift toward private shorthand [5]. DeepSeek-R1-Zero showed that outcome-only RL can create a distinctive reasoning style on its own [10]. Under this account the newer models are further along the same path. It predicts that the most heavily RL-trained releases are the tersest, and that the drift continues in the next generation. Andrej Karpathy put the idea memorably (and presciently, one must say) in September 2024: "You can tell the RL is done properly when the models cease to speak English in their chain of thought" [7].

Andrej Karpathy@karpathy

You can tell the RL is done properly when the models cease to speak English in their chain of thought

4. Pressure from agent formats

Agent harnesses ask for strict output such as JSON commands, and several models open by reminding themselves of it: "We need respond JSON only." Training on more agentic data could push planning toward compact notes. This hypothesis is the easiest to check, because it predicts the same models write fuller prose on plain chat or math tasks. There is already a hint that the harness matters. Tim Hua ran GLM-5.3 on the same code review in two agent harnesses, and its thinking reads as full prose in one and as clipped notes in the other [8]. The second panel is labeled a reasoning summary, so it may not be the raw reasoning.

Tim Hua@Tim_Hua_

GLM-5.3’s chain of thought when you use it with the Claude Code scaffold vs. when you use it with the codex scaffold.

How to tell these hypotheses apart

A few measurements would separate these. Comparing each model's phrasing with traces from candidate teachers would test distillation directly, since distilled students share distinctive phrases as well as terseness. Running the same models on non-agentic tasks would test format pressure. Tracking sentence length against total reasoning length across checkpoints would distinguish a per-response length penalty from a per-sentence one.

The three families

Each chart set below ranks the newest open models on filler share and on each kind of filler, and shades one family's older and newer release. The arrow is green where the newer release uses less of that kind and red where it uses more.

Related work

Compressing reasoning on purpose is an active area. Chain of Draft and Sketch-of-Thought prompt models to reason in short drafts and report large token savings on math and question answering [1, 2]. TokenSkip trains models to skip low-value tokens, which tend to be function words much like our filler kinds [3]. NoWait suppresses "wait" and "hmm" at decoding time and shortens reasoning by 27 to 51% [4]. These methods change the model; we measure how released models already write.

The closest observational work studies legibility. Jose finds that reasoning from models trained with outcome-based reinforcement learning is often hard to read [5], and Luo et al. describe one closed model's extracted reasoning as telegraphic [6]. Two recent studies sit close to our token findings. Concise-9B finds that 54 to 64% of a reasoning model's thinking tokens come after its answer has already settled [14], and rewriting earlier reasoning into compact notes shortens what open-weight models write next [15]. We found no published comparison of filler-word fractions across successive releases of open models, broken down by the five kinds of filler word, or any such measurement on agentic coding tasks.

1. Xu et al., Chain of Draft: Thinking Faster by Writing Less, 2025.
2. Aytes et al., Sketch-of-Thought, 2025.
3. Xia et al., TokenSkip, 2025.
4. Wang et al., Wait, We Don't Need to "Wait"!, 2025.
5. Jose, Reasoning Models Sometimes Output Illegible Chains of Thought, 2025.
6. Luo et al., Capable yet Parsimonious: Extracting and Characterizing Hidden CoT, 2026.
7. Andrej Karpathy, post on X, September 2024.
8. Tim Hua, post on X, November 1, 2026.
9. Lisan al Gaib, post on X, October 17, 2026.
10. DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning, 2025.
11. Yu et al., Revisiting Anthropomorphic Reflection Markers in Large Language Model Reasoning, 2026.
12. Li et al., Cognitive Foundations for Reasoning and Their Manifestation in LLMs, 2025.
13. Kambhampati et al., Stop Anthropomorphizing Intermediate Tokens as Reasoning/Thinking Traces!, 2025.
14. Lorup et al., Concise-9B: Removing the Slack from a Reasoning Model's Thinking, 2026.
15. Hristov et al., Why Pay for Long Reasoning When Rewrite Do Trick?, 2026.
16. Muennighoff et al., s1: Simple test-time scaling, 2025.

Limitations

• The tasks are easy for these models. The results describe how models write on simple fixes, not on long or hard problems.
• Failed runs are included. Eight of the 200 current-model runs failed, and a struggling run may end up reasoning differently, meandering in ways distinct from a successful one. Nonetheless, since we chose the easier end of examples, this factor would have limited impact even if it is a confounder.
• The filler rule is a word-level heuristic. We checked it by hand on several hundred sentences, but it will misjudge some words in context.
• Reflection Beam 1.0's providers require its earlier reasoning to be sent back on each turn, so it saw its own past reasoning and the other models did not.
• Reasoning effort was set to high. Some models offer other settings, such as a higher xhigh or lower ones, at which this observation may not hold.

Citation

Please cite this work as:

Or use the BibTeX entry:

@misc{datar2026fewword,
  title        = {Few Word Do Trick: Open Models Cut the Filler from Their Reasoning},
  author       = {Datar, Arnhav and Gangal, Varun and Jolley, Evan},
  year         = {2026},
  month        = {nov},
  howpublished = {Patronus AI},
  url          = {https://www.patronus.ai/blog/few-word-do-trick}
}