Ask a reasoning model a hard question and it pauses, works, and only then answers. The pause has a vocabulary now, and it shows up in two places you may already know from this site: the ReAct paper, where a model alternates thinking with acting, and Claude’s effort dial, which is a reasoning budget wearing a product name. This lesson collects the reasoning model terms behind both, eleven entries in three groups.
The long chain and its budget
Four terms for what the model does while you wait.
- Long chain-of-thought: The scratchpad a reasoning model writes before committing to an answer, often thousands of tokens of drafting, checking, and revising that stay hidden from the reply. Length is the feature, since the model spends words where earlier generations spent parameters. The prompting trick from lesson 05 asks any model to show its steps; the long version is trained in and runs ten times further.
- Budget forcing: The serving-side cap on how many thinking tokens one question may consume. Tighten it and answers arrive fast but shallow; loosen it and accuracy climbs on hard problems while latency and cost climb beside it. An effort setting on a consumer product is this same dial with friendlier labeling.
- Overthinking: What a generous budget does to an easy question: the model re-derives an answer it produced correctly at step one, and occasionally argues itself out of it. The useful systems know when to stop as well as when to persist.
- Inference-time scaling laws: The measured rule that extra compute spent while answering, through longer chains, repeated attempts, or a verifier that picks among them, buys accuracy in the way bigger training runs once did. The surprise of the o1 generation was how far the curve bends before it flattens.
Teaching the model to reason
Four terms for where the ability comes from.
- STaR: Short for self-taught reasoner, a bootstrapping recipe: let the model attempt full solutions, keep only attempts that end in the right answer, train on the survivors, and repeat. A hint pass rescues questions the model never gets right unaided. The result is reasoning training data from plain unlabeled problems, with no human writing explanations.
- Cold-start data: The small curated set of well-formed reasoning traces gathered before reinforcement learning starts. RL with verifiable rewards can amplify a behavior that exists, yet it struggles to invent the whole format from nothing, so a few thousand good examples give the amplification something to grip.
- Reasoning distillation: Training a small model on the thinking traces of a large one so the student reproduces similar intermediate steps at a fraction of the serving cost. The student copies the style reliably; whether it inherits the competence is something you measure rather than assume.
- Self-correction: A model catching its own error mid-thought and redoing the step with no outside checker involved. Prompted self-review tends to rubber-stamp the first attempt, so the dependable versions are trained, usually against rewards a verifier can grade.
Checking the work
Three terms for verifying the reasoning instead of trusting it. Verification earned its central role for a blunt reason: a chain that reads well can still land on the wrong answer, and somebody has to be able to tell the difference at scale.
- Verifier-guided search: Generate several candidate solutions and let a scorer choose among them, or steer the generation step by step. A process verifier grades each partial step, an outcome verifier grades only the final answer, and either one converts a single attempt into a search with a judge attached.
- Chain-of-thought faithfulness: Whether the written reasoning actually caused the answer or is a tidy reconstruction composed afterwards. An unfaithful trace can read beautifully while the real computation followed a shortcut, which matters a great deal once you start auditing the trace.
- Latent reasoning: Doing the multi-step work in continuous hidden-state vectors rather than written words, so deliberation consumes no output tokens. Experiments in this line keep the machinery of thinking and drop the readable transcript, trading auditability for economy.
Common confusions
Three pairs that sound interchangeable and are not.
- Long chain-of-thought vs chain-of-thought prompting: One is a trained behavior with lengths in the thousands; the other is a sentence in a prompt that any model can receive. Confusing them leads to expecting o1-style depth from a prompt trick.
- Overthinking vs self-correction: Self-correction redoes a step that was wrong. Overthinking redoes a step that was right. Same visible behavior, opposite value.
- Inference-time scaling vs training-time scaling: One buys accuracy per question, the other bakes it in for every question. The bill arrives per request either way, which is why the two budgets get argued over together.
Further reading
Three papers that anchor the groups above.
- Scaling LLM Test-Time Compute Optimally, the measurements behind inference-time scaling laws, including when a smaller model with more answer-time compute beats a larger one.
- STaR: Bootstrapping Reasoning, the recipe that turned unlabeled questions into reasoning training data.
- Large Language Monkeys, the study of repeated sampling with verification that made “infer, then verify” a standard serving pattern.
This is lesson 14 of the AI glossary. Lesson 13 covered the AI safety terms in Safety, Security and Interpretability, and chain-of-thought faithfulness is exactly the audit question that lesson’s interpretability program asks. For reasoning put to work, the ReAct walkthrough shows the thinking loop driving tool use. With these reasoning model terms in hand, the next lesson steps outside text entirely: multimodal, speech, and multilingual AI.