AI Compass
Compass

Models that compute before they answer

Why letting a model think first helps: chains of thought, test-time compute, and when the surcharge is worth it.

·2 min read·By Fachredaktion Technik
DETAIL
3 sections

The idea

A language model has a fixed amount of computation available per token. Answering a hard question in a single token is therefore structurally hard, however good the model is.

Let it write twenty intermediate steps instead and it gets twenty times the computation. The intermediate steps are also a notepad on which partial results stay put.

When it helps

TaskGain
Multi-step arithmeticlarge
Code with edge caseslarge
Logical checks, contract termslarge
Planning with dependenciesmedium
Summarisingsmall
Rephrasing, translatingnone
Looking up factsnone, that needs retrieval

The methods

MethodPrincipleExtra cost
Chain of thought in the prompt"Think step by step"small
Few examples with worked stepsA model in the promptsmall
Self-consistencyCompute several times, take the majority5 to 20 times
Trained reasoning modelThinking steps were trained in3 to 30 times
Tool useHand the arithmetic to a calculatorsmall, more reliable

The last row is often overlooked and is the best answer for arithmetic: a model that delegates a calculation to a calculator is more reliable and cheaper than one that works it out.

Self-consistency

from collections import Counter

def self_consistent(question, model, n=8):
    # Compute several times at temperature > 0 and take the most common answer.
    answers = [model(question, temperature=0.7)["final"] for _ in range(n)]
    counts = Counter(answers)
    best, freq = counts.most_common(1)[0]
    return best, freq / n          # the second value is a confidence measure

The second return value is the real gain: it is an empirical confidence measure. Below about 60 percent agreement, the case belongs in human review.

Test-time compute

Scaling with answer length

C ≈ 2 · N · (T_think + T_answer)

Compute per request grows linearly with total generated tokens, thinking steps included.

N
parameter count
T_think
number of thinking tokens
T_answer
length of the actual answer

At 2,000 thinking tokens and a 200-token answer, cost is eleven times that of a direct answer. Empirically, accuracy on multi-step tasks improves roughly logarithmically in T_think: doubling thinking time yields a roughly constant increment until saturation.

The chain of thought is not a log

This is the most important caveat for any evidence purpose. The printed chain is itself generated text and need not match the computation that produced the answer. Studies show cases where a model demonstrably uses a hint in the prompt and does not mention it in its chain.

For practice that means:

  • Treat the chain as a working aid, not a justification in the legal sense.
  • For evidence, log the result, the inputs, the model version and the parameters.
  • Where a justification is required, check it against the actual sources, not against the model's narrative.
  • For high-risk applications, point human oversight at the result, not at the chain.

See Duties by role and Logging.

When the cost pays

Break-even against human rework

worth it when: Δp · k_error > k_think

The extra compute pays when the avoided error cost exceeds the extra cost per request.

k_think
extra cost per request from thinking steps
Δp
improvement in accuracy
k_error
cost of an error, including rework

Worked through: extra cost 0.02 EUR per request, accuracy improvement 6 percentage points, error cost 15 EUR. Then 0.06 × 15 = 0.90 EUR > 0.02 EUR: the surcharge pays back 45 times over. On a task with no error cost, such as rephrasing a text, it never pays.

Related courses and sources

PaperFreeEN

Chain-of-Thought Prompting

Intermediate steps in the prompt markedly improve multi-step tasks. The basis of today's models with reasoning steps.

For anyone writing prompts: the paper behind the intermediate-steps pattern.

Was this page helpful?
Models that compute before they answer