The Model That Spends 30 Seconds on 2+2

Local open-weight models have quietly crossed the line from novelty to genuinely useful. A 27B model runs on a decent MacBook, handles real coding tasks, and holds its own on math. And yet the same complaint keeps surfacing from people actually running them: ask what 2+2 is, and the thing deliberates for 30 seconds.

One note on scope. Recent community discussion of any single model release is thin enough that pinning this to specific version numbers or benchmark tables would be guesswork. So this is about the pattern instead — the overthinking behavior that has shown up across nearly every reasoning model of the past 18 months, and why it keeps happening.

What a thinking token actually is

Reasoning models don’t answer immediately. They mutter first. “Let me restate the problem. The user wants… actually, wait, reconsidering…” Some interfaces show this stream live, some collapse it behind a toggle. Either way, those are thinking tokens.

On hard problems they earn their keep. Competition math, gnarly multi-file debugging, anything where the first plausible answer is wrong — the muttering genuinely changes the output. The problem is that the model can’t judge difficulty before it starts. Ask it the capital of France and it runs the same procedure, second-guessing whether Paris is a trick question it’s about to fall for.

Where the bill lands

Start with money. Over an API, thinking tokens bill as output tokens. A 20-token answer wrapped in 3,000 tokens of deliberation means you paid roughly 150x the cost of the thing you actually received. Run it locally and the API line item disappears, but the cost reappears as electricity and GPU-hours you can’t use for anything else.

Latency hurts more in practice. Thirty seconds in a chat window is survivable. Thirty seconds attached to every step of an agent loop that makes 20 tool calls is a ten-minute task. And the model deliberates just as earnestly on “read this file and move on” as it does on the one step that mattered.

Then there’s context. If thinking blocks stay in the conversation history, the window fills fast. Most implementations strip prior reasoning on the next turn — but pipelines that don’t will hit the ceiling within a handful of exchanges, usually without an obvious explanation for why.

Why the default is always-on

From the model provider’s side, the incentive is not subtle. It’s benchmarks.

The first thing anyone looks at when weights drop is the eval table. Turn reasoning on and scores climb across most of the hard benchmarks. Meanwhile, there is essentially no standard benchmark for “answers easy questions quickly.” Nobody optimizes a metric nobody measures. Defaults converging on maximum deliberation isn’t a mystery; it’s the scoreboard working as designed.

Training reinforces it. Reasoning capability mostly comes from reinforcement learning: reward the correct answer, and the model learns what leads there. Explicit reward for brevity is rare. So the model concludes that thinking longer is the safe move — the same instinct as a student padding an answer on a high-point exam question because length feels like effort.

What you can actually do about it

The situation isn’t hopeless.

Split your modes. Most current models ship a switch — a control token in the prompt, or a thinking-budget parameter in the API. For tasks where the shape of the answer is fixed — classification, extraction, structured output — turning reasoning off is almost always the right call.

Put a router in front. Cheaply classify incoming difficulty first, then send the easy majority to a smaller model or a non-reasoning mode. The classifier can be small and fast; it doesn’t need to be clever. This is the single biggest bend in the cost curve, and it’s the one most teams skip.

Cap the thinking budget. Don’t let deliberation run unbounded. Set a token ceiling and force an answer from whatever reasoning exists at that point. Accuracy often survives the cut better than you’d expect, because the tail end of the monologue is usually the model re-confirming a conclusion it reached several hundred tokens earlier.

Better models, worse defaults

That open-weight models have gotten this good is unambiguously a win. The catch is that the technique used to raise the ceiling became the default setting, and it dragged along a cost nobody asked for. The configuration that wins benchmarks and the configuration you want running all day were never the same thing.

So when you evaluate a model, “how smart is it” is only half the question. The other half is whether it can be told not to bother. How many seconds does yours spend on 2+2?