receipt · local-llm bench · lfm3:1.7b · 2026-10-29 · CPU box · 17 tok/s hand-divided
Runollama run <model> --think=false(CLI), type/set nothink(inside a session), or send"think": falsein the/api/chator/api/generatebody. Use--hidethinkingonly if you want the thinking kept but hidden — the meter still runs. Skip/no_thinkin prompts; it reduces, it doesn't switch off.
This is the real logged run, replayed. Two one-word asks from our bench: “Bug” cost 866 thinking tokens and 53.5 seconds cold. “Crash” cost 589 tokens and 34.4 seconds warm. Then the same ask with thinking off. Watch the meter.
composite of a real logged run — lfm3:1.7b, 2026-10-29 · “thinking off” line is division, not a measured run, and says so
The point of watching it at ×1: at 17 tokens per second, you can read the thinking as it bills you. That's what every chat that “feels slow” on a CPU box is doing — printing an invoice you never asked to see, one token every 59 milliseconds.
Because the newest small models are hybrid thinkers: the same weights do chat and chain-of-thought, and most front-ends leave thinking on by default. Every “hmm, let me reconsider” you watch scroll past is a real token at your real tokens-per-second — and on a CPU box that's 17/s, not the hundreds a GPU laughs at. The math is unglamorous: 866 thinking tokens ÷ 17 tok/s ≈ 51 seconds of billing before the answer starts.
Three switches, all first-class in ollama's own docs. Pick the altitude you're at:
$ ollama run lfm3:1.7b --think=false
>>> bug or not? one word.
Crashverify: no thinking block in the output; answer arrives in a handful of tokens — on our bench arithmetic, about a second of typing instead of fifty.
POST /api/chat
{ "model": "lfm3:1.7b",
"messages": [{"role":"user","content":"bug or not? one word."}],
"think": false }verify: response carries no thinking field — with "think": true the same endpoint separates the monologue from the answer into its own field.
And the trap that looks like a switch but isn't: --hidethinking. It keeps the model thinking — full price — and just doesn't print the itemization. Hiding the receipt is not the same as not paying.
A Modelfile can't pin it. PARAMETER think false errors with “unknown parameter” — think is a request-body field only. Every client has to remember to send it; there is no server-side default you can set.
The OpenAI-compatible endpoint speaks a different dialect. /v1/chat/completions doesn't take think — tooling that rides it uses reasoning_effort instead, and plain think:false silently does nothing there.
/no_think in the prompt is a nudge, not a switch. It reduces the monologue; hybrid models can still think. The request-body flag is the honest off.
Some models take levels, not booleans. Newer thinking metadata accepts named levels (low, medium, high) — model-defined, so check the model card, not your hopes.
num_predict is a budget cap, not a switch. It limits total tokens including thinking — your answer can get amputated before the thinking is done. Wrong tool for this job.
Unedited lines from the bench log — fields renamed-ms carry nanoseconds (the log's own units lie; we divided by hand), and the rate fields came back null, so tokens-per-second is our own long division: 866 ÷ 50.9 ≈ 17.
{"model":"lfm3:1.7b","load_ms":2326837325,"eval_count":866,"total_ms":53533988331,"response":"Bug"}
{"model":"lfm3:1.7b","load_ms":530219,"eval_count":589,"total_ms":34362526621,"response":"Crash"}source: our bench log, 2026-10-29 · lfm3:1.7b · CPU-only VM · context 4096
| line on the bill | cold ask | warm ask | thinking off |
|---|---|---|---|
| tokens generated | 866 | 589 | ≈ a handful |
| generation time @ 17 tok/s | ≈ 51s | ≈ 34s | ≈ 1s or less |
| total ask (measured) | 53.5s | 34.4s | — not measured* |
| model load | 2.33s | 0.53ms | same model, same load |
| the answer | “Bug” | “Crash” | same word class |
* honesty line: we measured the thinking side; the off-column is division at the same tok/s, labeled as arithmetic — the receipts law covers the measured half, this sentence covers the rest.
“Bug” is the most expensive word our box has ever produced. It cost fifty seconds of thinking to decide.
When the answer is worth more than the wait — that's the whole contract. The bill buys something real on:
--hidethinking is legitimately good here if you're paying anyway.Flip it off when the ask is classification-shaped: one-word answers, routing, lookups, extraction, “does this log line contain a failure”. Paying 866 tokens to decide between two words is renting an empty room — the room is nice, but you're not in it.
Here's the unresolved thing. Turning thinking off makes the model faster and dumber at exactly the tasks you bought it for — and keeping it on makes every casual ask a fifty-second sit. Local AI's real dial isn't model size; it's who holds the meter. The cloud hides this bill inside a subscription; on your box, you watch every token print.
What I actually want and can't have yet: a Modelfile line that pins think per-model, so “Bug” costs a second without every client remembering the flag. Ollama's issues have the request open. Until it lands, the meter is yours to watch — or yours to flip.
Two-question ending, per house law: 1) What's the longest thinking bill you've caught on your own box? 2) Did you ever catch it charging for a question that didn't need the thought?