Every team that uses AI develops the same reflex within a month. The answer comes back wrong, so someone turns up the thinking. Reasoning effort from medium to high. A bigger thinking budget. The model that "thinks longer."
Sometimes that works. Often you pay more, wait longer and get the same wrong answer.
It's hard to see why while "thinking" stays a vague word for whatever the model does before it replies. This autumn NVIDIA shipped a model that turns thinking into something you can count, and the reason becomes obvious.
Thinking, as a number
The model is called Dory. It has four billion parameters and one unusual setting: how many times to run its middle layers.
Its layout is 8 input layers, a 20-layer core and 8 output layers. Every token passes through the input layers once, the core as many times as you choose, and the output layers once.
- 1 loop: 36 layers stored, 36 executed
- 2 loops: 36 layers stored, 56 executed
- 4 loops: 36 layers stored, 96 executed
This design is a looped transformer. With two or more loops, Dory's authors report better average results than selected larger models across twelve benchmarks.
Two things about those numbers are worth a second look.
First, thinking harder is no longer a metaphor here. It's 20 layers, run again.
Second, the stored number never moves. The weights on the fourth pass are the weights on the first. If you could put a counter on them it would read: used 4 times, changed 0 times. The model isn't learning anything while it loops. It's refining a working state that it throws away when the answer is done.
So a looped model gets more computation per token. It doesn't get one extra fact.

The Alice test
Here's the fastest way I know to feel what that means. Two facts:
Alice finished the race before Bob. Bob finished before Cara.
Now two questions.
- Who finished first? The answer is in the input, but it has to be assembled. A wrong answer is fixed by more computation.
- What was Alice's finishing time? The answer is not in the input. A wrong answer is fixed only by a lookup.
For the first question, more passes help. The model has to connect two facts, and connecting is what computation does.
For the second, you can loop four times or forty. The working state gets more refined. The missing fact stays missing. One query against a results table answers it in milliseconds.
Loops add computation, not information. I call the check the Alice test: before you raise the thinking level, ask whether the answer is already in what the model has.
It sounds too simple to matter until you sort a week of real failures with it. The model didn't know the current price. It quoted the old contract version. It guessed what was in the logs. Every one of those fails the Alice test, and every one of them gets "fixed" by somebody turning thinking up.
That's the expensive mistake: paying for effort that can't succeed.

The receipt
Even when thinking is the right tool, it isn't free. One of this month's reports is useful precisely because it priced the trade.
Fastino looped two bands of middle layers in its 27B decision model and published what happened:
- Gain: +0.56 points on a held-out test, with a 95% confidence interval of 0.27 to 0.89. Small, and real.
- Cost: median latency from 83 to 112 ms. About 35% slower.
- Limit: a third pass made a causal-reasoning benchmark worse.
- Effort: around 110 configurations tried, several failed designs, no clear gain below one billion parameters.
I'd frame that list and hang it next to every AI procurement decision. A small gain, a measured cost, and a point past which more thinking does damage. That's what an honest result looks like.
It also kills a comfortable assumption. More thinking isn't a ramp that only goes up. An extra pass can improve an answer, change nothing, or degrade a state that was already right. The only line that always rises is the bill.

Four loops, four bills
Part of the confusion is that "loop" means four different things in AI, and each one invoices you differently.
- Looped transformer: runs inside one forward pass, leaves nothing behind, costs compute and latency per token.
- Chain of thought: runs in generated text, leaves a transcript, costs output tokens.
- Agent loop: runs around the model with tools, leaves side effects and logs, costs calls, tool time and retries.
- Recursive self-improvement: runs across versions of the system, leaves a better system, costs research compute.
Of these, only the agent loop brings in new information, because only tools reach outside the model. The first two are thinking. If your failure is a missing fact, they can't save you, however much of them you buy.
Before you buy more thinking
Four questions, in this order:
- Does it pass the Alice test? If the answer is in the input, more thinking is a fair experiment. If it isn't, fetch the fact.
- Is it an exactness problem? Arithmetic and exact strings belong in a calculator or code, not in another pass.
- Where does the gain flatten? If one to two loops helps and two to four doesn't, two is your setting.
- What does one correct, checked answer cost? Not per token. Per verified result, retries included.
Looped transformers are a real advance: depth as a dial instead of a bigger file. Pointed at the right failure, that's cheap capability. Pointed at a missing fact, it's a slower and more expensive way to be wrong.
I'm Michał Piszczek, CTO at Archdesk. I measure what AI work costs, in milliseconds and joules, and publish the data.
This story is the argument. The evidence is in my original guide on piszczek.pl, with every source linked and seven interactive labs: run Dory's loop at one to four passes, play the Alice puzzle and watch extra passes fail, and see the bill update per loop. Looped Transformers Explained.

