Reasoning models: spend computation before committing

A reasoning model is trained or configured to spend additional computation on solving a task before delivering its answer. That can include generating intermediate steps, revising a solution or evaluating multiple candidates. The term describes a family of behaviours rather than one fixed architecture.

Training can encourage useful reasoning through worked solutions or rewards on verifiable tasks. During use, the system can also allocate more generation or search to a difficult question. These are training-time and inference-time choices, respectively.

Several paths, one answer

Self-consistency is one established inference technique: generate several reasoning paths, extract their final answers and select the most common answer. This small function exposes the aggregation. generate produces one sampled solution; extract_answer converts it to a comparable final answer.

from collections import Counter

def self_consistent(problem, generate, extract_answer, samples=5):
    answers = [extract_answer(generate(problem)) for _ in range(samples)]
    return Counter(answers).most_common(1)[0][0]

Independent paths can arrive at the same conclusion through different intermediate steps. Agreement is useful evidence, but a repeated shared misconception can win the vote too. Self-consistency is one strategy around a model, not a definition of every reasoning model.

Extra work changes the cost balance

A long prompt gives prefill many known tokens to process together. Additional reasoning steps require more generation and may produce several candidate trajectories. Extra time is therefore not simply a larger input window.

The useful question is what the additional work achieves on the task: does a verifier reject bad code, does a revision repair an error, or do extra paths improve the final answer? More tokens alone are not the goal.