Chain-of-Thought Reasoning

Chain-of-thought reasoning describes what happens when a language model is prompted or trained to work through a problem in visible, sequential steps rather than jumping straight to a final answer. The term comes from a 2022 Google research paper that showed simply adding “let’s think step by step” — or providing few-shot examples that reasoned aloud before answering — produced large accuracy gains on arithmetic, commonsense, and symbolic reasoning benchmarks, particularly for larger models.

The effect is considered emergent because it appears reliably only past a certain model scale; smaller models often produce reasoning steps that look plausible but don’t actually improve their final answers, or sometimes hurt performance by introducing errors mid-chain. Larger models, by contrast, use the intermediate steps as genuine scratch space — each step conditions the next token predictions, effectively letting the model allocate more computation to harder problems.

This observation directly motivated the current generation of “reasoning models” (like OpenAI’s o-series and DeepSeek-R1), which are trained via reinforcement learning to generate long, self-correcting chains of thought before answering, rather than relying on prompting alone to elicit the behavior.

Why It Matters in Practice

Chain-of-thought prompting is one of the cheapest reliability improvements available to LLM application builders — no fine-tuning is required, only a change to the prompt. It’s especially effective for math, multi-step logic, and code debugging tasks where a single forward pass is prone to shortcut errors. The tradeoffs are higher token usage (and therefore latency and cost) and, for tasks with clear ground truth, extra output that needs to be parsed or filtered out of the final user-facing response.

Faithfulness Concerns

An important and actively researched caveat is that a model’s generated chain of thought doesn’t always faithfully reflect the actual computation that produced its final answer — research has found cases where a model reaches a correct or incorrect answer for reasons different from what its stated reasoning steps describe, meaning the visible chain of thought is best understood as a helpful computational aid and a partial window into the model’s process, rather than a fully reliable, literal account of how it arrived at its answer. This has real implications for using chain-of-thought output as an explanation or audit trail in high-stakes applications, where the reasoning trace should be treated as suggestive rather than definitive proof of why a model produced a given answer.