Chain-of-thought reasoning.
Ask a person a hard question and they rarely blurt the answer. They think out loud, one step leaning on the last. Chain-of-thought is the simple change that a language model should do the same: show its work, then conclude.
A language model, left alone, tends to reach for the most likely next words and commit to an answer in a single jump, even when the question needs several linked steps to get right. We walk it the way the field is built: what it is, why one-jump answering falls short, how showing the work helps, what it unlocks, and where it is heading, including the honest limits. The papers behind each idea are linked, so you can read the source yourself.
One jump, or work it out.
A language model normally maps a question to an answer in one pass. Chain-of-thought asks it to first write the intermediate steps, in plain language, and only then give the answer.
The steps are written into the model's own output, a working space sometimes called a scratchpad, where partial results can be recorded and reused before the final line. One jump is fine for a fact the model already holds. It breaks down on anything that needs several linked sub-steps, where a single leap has too many places to go wrong.
Take a running example we use across this page, framed as illustration and not as a claim about any product: a sales co-pilot is asked, "should I prioritize the Acme renewal this week." A one-jump answer is a coin flip you cannot inspect. A step-by-step answer combines a few linked facts, the renewal date, recent usage, the main contact, and only then concludes. Two distinctions are worth flagging up front, and they recur below: the visible reasoning is an aid, not proof of how the model really decided, and reasoning in steps changes the model's process, not the boundary of what data it may use.
Count the boxed sensors
3 × 4 = 12Add the spares
12 + 2 = 14Why one-jump answering falls short.
A model that commits immediately leaves itself no room to work. The capability is there, but it has to be drawn out, and even when it shows, the steps need reading with care.
One pass holds no partial result.
Nye et al. (2021) shows that on tasks needing unbounded multi-step computation, such as long addition or executing a small program, models fail in one pass but succeed when allowed to emit intermediate steps into a scratchpad.
The capability has to be elicited.
Wei et al. (2022) shows that providing a few worked examples that include the reasoning steps unlocks reasoning the same model would not otherwise display, an effect that emerges mainly in sufficiently large models. The ability was there; the prompt drew it out.
Even the cue can be one line.
Kojima et al. (2022) shows that adding one instruction, "let's think step by step," raises accuracy on arithmetic and logical tasks with no worked examples at all. A small change to the ask, a large change in the result.
One chain is still one opinion.
A single reasoning path can take a wrong turn early and carry the error all the way to the end. The model needs a way to not bet everything on one line of thought, which sets up self-consistency further down this page.
Visible reasoning can mislead.
Turpin et al. (2023) shows the written steps do not always reflect the real reason for an answer: bias a model's input and it will often produce confident reasoning that supports the biased answer without ever mentioning the bias. A tidy chain is an aid, not a guarantee.
Better answers you can also check.
A buyer assessing any model that gives judgments wants two things: better answers on multi-step questions, and answers whose steps a person can read and check. Chain-of-thought speaks to both, and its limits are part of the honest picture.
How showing the work helps.
Nothing about the model changes. The change is what the model is asked to produce, and the room that gives it to combine sub-results. The variations build from there.
1Show the work in the output
Write the reasoning, then the answer.
The model writes the reasoning as ordinary text before the final line. That text is the scratchpad: a working space where partial results are recorded and reused, the mechanical root of the idea in Nye et al. (2021). The model is the same. What differs is that it now has somewhere to hold a partial result instead of solving in one leap.
Three packs contain four sensors each. Two sensors are held in reserve.
- Count the sensors
3 × 4 = 12
- Subtract the reserve
12 − 2 = 10
2Few-shot chain-of-thought
Show a couple of worked examples.
Wei et al. (2022) is the base technique most others build on. The prompt includes a small number of examples where each answer is shown with its reasoning steps. The model imitates the pattern, reasoning through the new question before answering, rather than mapping straight to a final line.
Example: 2 boxes × 5 parts = 10 parts. Remove 1 spare: 9 available.
Now: 3 boxes × 4 parts, with 2 spares.
3 × 4 = 12; 12 − 2 = 10.
3Zero-shot chain-of-thought
One cue, no examples.
Kojima et al. (2022) needs no examples at all. A single cue such as "let's think step by step" prompts the model to lay out its reasoning first. It is cheaper to apply, and a clear demonstration that the reasoning was already latent and only needed inviting.
Three packs of four sensors, with two in reserve. How many are available? Show the calculation.
3 × 4 = 12
12 − 2 = 104Self-consistency
Sample several paths, keep the consensus.
Wang et al. (2022) stops trusting one chain. Sample several independent reasoning paths for the same question, then take the answer that the most paths agree on. Different valid routes tend to converge on the right answer, while wrong turns scatter. No retraining, applied on top of chain-of-thought prompting, for a steadier result.
| Sample | Final answer |
|---|---|
| Path 1 | 10 |
| Path 2 | 10 |
| Path 3 | 12 |
| Path 4 | 10 |
Three of four sampled paths agree.
5Search over thoughts
Branch, look ahead, back out.
Yao et al. (2023), Tree of Thoughts, treats each reasoning step as a branch the model can evaluate, then looks ahead or backtracks, exploring several partial chains and pruning weak ones instead of committing to a single straight line. It is useful where the problem needs planning, not just a sequence.
- Start
Plan how to fit the required parts within a fixed budget.
- Branch A
Try the first allocation; reject it when it exceeds the budget.
- Branch B
Try a different allocation; keep a feasible intermediate state.
- Continue
Expand promising states until a complete solution is found.
6Reading the steps honestly
An aid to a reader, not a transcript.
Turpin et al. (2023) is the method note that keeps the rest grounded. Treat the written chain as an aid to a human reader and a way to spot some errors, not as a faithful transcript of the model's internal decision. Where the steps drive a real action, the field pairs them with checks rather than trusting them outright.
Written explanation
I chose option B because its evidence is stronger.
Possible influence
- Hidden in the explanation
- The prompt also suggested that B was the preferred answer.
7What stays unchanged
Reasoning stays inside the boundary.
This is general practice in the field, not the design of any one product. Reasoning in steps operates only over the inputs the model is given. Keeping one client's data apart from another's, or limiting an answer to records a given person may see, is enforced at the data and access boundary, which step-by-step reasoning neither relaxes nor bypasses. Showing more work changes how the model uses what it has, not what it is allowed to have.
- Authorize sources
Filter retrieval to records this requester may access.
- Build context
Include only the permitted evidence.
- Generate and check
Produce an answer and verify its claims against that evidence.
What showing the work unlocks.
At the field level: better answers on multi-step questions, and answers a person can actually audit. Reliability through agreement, and planning beyond a single straight line.
Showing the work moves a model from "here is my answer" to "here is how I got there," which is both more accurate and more inspectable. As an illustration, not a product claim: for a sales co-pilot, "at risk because the renewal is near, usage fell, and the contact changed" is a verdict a rep can check against what they know. A bare "at risk" is not.
Better answers on multi-step questions.
Arithmetic, multi-hop questions, and "weigh several factors then conclude" judgments improve when the model works them out rather than guessing in one jump.
Answers a person can audit.
The visible steps let a reader follow the logic and catch a wrong assumption, instead of accepting an unexplained verdict. The faithfulness caveat stays attached: the steps are an aid, not proof.
Reliability through agreement.
Sampling several reasoning paths and keeping the consensus answer trades a little extra computation for a steadier result, with no retraining.
Planning, not just answering.
Searching over thoughts lets a model handle problems that need looking ahead and backtracking, widening the range of tasks beyond single straight-line reasoning.
This explainer covers published research. To see how AI REV Voice helps with sales conversations, explore Prism.
Where the field is heading.
We describe the direction, not a roadmap of our own.
Trained to reason, not just asked.
The field has moved from prompting a model to reason toward training models that reason at length by default, and toward methods that decide how much reasoning a question deserves.
Do the steps match the process?
Turpin et al. (2023) opened a line of work on whether the stated reasoning matches the real process. Expect more attention to measuring and improving that match, since auditability is only worth what the steps honestly reflect.
Think hard on hard questions only.
More steps cost more computation and can wander. Work continues on getting the gain on hard questions without overthinking the easy ones.
Controls matter as much as steps.
As step-by-step models take on judgments that touch real records, the surrounding controls, what data the model may see and what an action requires, matter as much as the reasoning itself. We frame this as a field-wide direction.
The papers behind this page.
- Nye et al. (2021). Show Your Work: Scratchpads for Intermediate Computation with Language Models. arXiv:2112.00114.
- Wei et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. arXiv:2201.11903.
- Kojima et al. (2022). Large Language Models are Zero-Shot Reasoners. arXiv:2205.11916.
- Wang et al. (2022). Self-Consistency Improves Chain of Thought Reasoning in Language Models. arXiv:2203.11171.
- Yao et al. (2023). Tree of Thoughts: Deliberate Problem Solving with Large Language Models. arXiv:2305.10601.
- Turpin et al. (2023). Language Models Don't Always Say What They Think: Unfaithful Explanations in Chain-of-Thought Prompting. arXiv:2305.04388.
Keep reading.
Sibling explainers in the Research section.
Talk. Done.
Reasoning you can read is reasoning you can check, and a verdict with its steps is worth more than a bare one. See it on a real call.
No app required. Just your phone number.