Stepwise Inference

The initial mechanism where a complex query is broken down into a sequence of simpler, manageable sub-problems. This is the foundational step that transforms an intractable task into a solvable workflow.

• Key Process: The model identifies dependencies and logical prerequisites within the main problem.
• Example: For the query "If a train leaves Station A at 60 mph and another leaves Station B at 80 mph, when will they meet if the stations are 280 miles apart?", decomposition yields sub-problems: 1) Calculate combined speed, 2) Apply the distance formula.

The system's ability to carry forward the outputs (intermediate states) from one reasoning step as inputs to the next. This creates a causal chain where each step builds upon the last.

• Critical Function: Prevents context fragmentation and ensures logical continuity.
• Implementation: Often managed via an explicit scratchpad in the model's context window or an external memory module. The state can be a numerical value, a logical proposition, or a structured data object.

The mechanism that allows the reasoning chain to pause verbal reasoning and delegate specific operations to external tools for precision and factual grounding. This bridges symbolic reasoning with deterministic computation.

• Common Tools: Calculators, code interpreters, database queries, and web search APIs.
• Frameworks: ReAct and Tool-Augmented Reasoning explicitly interleave 'Thought' and 'Action' steps. The model generates a tool call specification, receives the result, and incorporates it into the next reasoning step.

Mechanisms for the system to evaluate its own intermediate outputs for consistency, factual accuracy, or logical soundness, and to trigger corrective sub-routines if errors are detected.

• Methods: Includes Self-Consistency (sampling multiple paths), Chain-of-Verification (CoVe) (explicit fact-checking plans), and Process Reward Models (PRMs) that score step correctness.
• Purpose: Increases robustness and reduces error propagation through the chain by catching mistakes early.

The mechanism for managing uncertainty by exploring multiple potential reasoning paths in parallel, rather than committing to a single sequential chain. This is essential for problems with ambiguous first steps.

• Algorithms: Tree-of-Thoughts (ToT) implements this using heuristic search (e.g., breadth-first, depth-first) over a tree of intermediate 'thoughts'.
• Process: The model generates several possible next steps, evaluates their promise, and prunes or expands branches based on scoring.

The dual mechanisms for connecting abstract reasoning to concrete instances (grounding) and for lifting detailed computations into high-level plans (abstraction).

• Chain-of-Abstraction (CoA): First creates a plan with placeholders (e.g., [CALCULATE_PROFIT]), then fills them with retrieved facts or tool outputs.
• Role: Ensures reasoning remains both efficient (by planning first) and accurate (by grounding in data).

The seminal prompting technique for eliciting step-by-step reasoning. It involves providing the model with example problems that demonstrate an explicit reasoning process before the final answer. This teaches the model to 'show its work,' improving accuracy on complex arithmetic, commonsense, and symbolic reasoning tasks.

• Mechanism: In-context learning with worked examples.
• Key Benefit: Makes the model's reasoning trace explicit and debuggable.
• Example: For a math word problem, the prompt includes an example where the model's response calculates intermediate values before stating the final sum.

A generalization of Chain-of-Thought that explores multiple reasoning paths in parallel. Instead of a single linear chain, the model generates a 'tree' of possible intermediate steps. A search algorithm (e.g., breadth-first, depth-first) is then used to evaluate and select the most promising path to the solution.

• Core Concept: Treats reasoning as a search problem over a space of 'thoughts'.
• Use Case: Ideal for problems with high branching factors, like strategic game playing or creative brainstorming.
• Advantage: Overcomes the limitation of linear CoT, which can commit to a flawed reasoning path early on.

A framework that interleaves reasoning traces with actionable steps. The model generates a verbal 'Thought' to reason about the problem, then an 'Action' (e.g., a search query, API call, or tool use). It observes the result and repeats the cycle.

• Key Integration: Combines Stepwise Inference with Tool Calling and API Execution.
• Benefit: Enables dynamic interaction with external environments (knowledge bases, calculators, software) to ground reasoning in facts and precise computation.
• Pattern: Thought: I need to find X. Action: Search[X] → Observation: Result is Y. Thought: Now I can calculate...

A decoding and aggregation strategy that improves the reliability of Chain-of-Thought outputs. Instead of generating one reasoning chain, the model samples multiple, diverse chains for the same problem. The final answer is selected via majority voting from the set of chain conclusions.

• Premise: There are multiple valid reasoning paths to a correct answer; consensus reduces error.
• Process: 1. Sample N reasoning paths. 2. Extract the final answer from each. 3. Choose the most frequent answer.
• Result: Significantly boosts performance on mathematical and logical reasoning benchmarks compared to greedy decoding (taking the first chain).

A Chain-of-Thought variant where the model's reasoning steps are expressed as executable code (typically Python). The model writes code that solves the problem, and an external interpreter executes it to produce the final answer.

• Core Idea: Offloads precise computation and algorithmic logic to a deterministic runtime.
• Advantage: Eliminates the language model's frequent errors in arithmetic and symbolic manipulation.
• Example: For a problem about rate and time, the model generates code like distance = speed * time and print(distance) instead of attempting the calculation in natural language.

A training paradigm focused on rewarding correct intermediate reasoning steps, not just the final answer. A Process Reward Model (PRM) is trained to provide feedback on each step in a chain. This is used to fine-tune models via reinforcement learning, encouraging not just accurate answers but faithful and logical reasoning processes.

• Contrasts with Outcome Supervision: Rewards the how, not just the what.
• Goal: Improves Faithfulness Metrics and reduces post-hoc rationalization where steps don't logically support the conclusion.
• Application: Critical for building reliable, auditable agents where the reasoning trace itself must be trustworthy.