Abstract. Large language models generate text by predicting the next token, a process that is fast but not inherently rigorous. Reasoning strategies (structured prompting and inference patterns that force deliberation, verification, or exploration before the model commits to an output) have emerged as the primary practical mechanism for improving accuracy on complex tasks. This paper surveys the major strategy families (single-path, multi-path, self-refinement, decomposition, retrieval-augmented, and abstraction-based), explains how each works and where it breaks down, and provides a six-dimension selection framework for practitioners. It also addresses the emergence of model-native reasoning capabilities and their relationship to prompt-level strategies. All factual claims have been independently verified through a Chain-of-Verification process; a verification summary and limitations note are appended.
Large language models do not reason by default. Without structured prompting, they pattern-match from training data to the nearest plausible-sounding answer and print it. That process is fast and often convincing, but it is not the same as working through a problem. Reasoning strategies are the practical answer to this gap. They are structured prompting and inference patterns that force a model to deliberate, trace its steps, verify its conclusions, or explore alternatives before committing to an output.
The field accelerated sharply in 2022 when Wei et al. demonstrated that providing a language model with a few worked examples containing explicit intermediate reasoning steps, a technique they termed chain-of-thought prompting, produced meaningful accuracy gains on multi-step arithmetic, commonsense, and symbolic reasoning tasks (Wei et al., 2022). In a complementary finding the same year, Kojima et al. (2022) showed that simply appending the phrase "Let's think step by step" to a prompt, with no examples at all, activated similar step-by-step reasoning behavior, establishing that large language models are, in a meaningful sense, zero-shot reasoners. Together, these two papers catalyzed a wave of follow-on research through 2023 and 2024 that has produced a substantial catalog of documented strategies spanning single-path reasoning, multi-path sampling, self-refinement, decomposition, tool integration, and abstraction.
Knowing which strategy to reach for, and why, is now a practical skill for anyone building or deploying AI systems. This paper covers the major strategy families, explains how each one works and where it breaks down, provides a concrete selection framework, and addresses the emerging landscape of model-native reasoning. The goal is not exhaustive coverage but enough depth to make informed decisions.
The underlying problem is that language models are trained to predict the next token, not to be correct. On simple questions they usually converge on the right answer because the correct response is statistically common in training data. On harder problems (multi-step arithmetic, causal reasoning, planning under constraints) that statistical tendency becomes a liability. The model confidently produces text that looks like a correct answer but contains factual errors, logical gaps, or fabricated citations.
Reasoning strategies address this by restructuring the inference process. Instead of one forward pass from prompt to answer, the model is guided through intermediate steps, alternative branches, verification loops, or tool calls. The structure imposes discipline on the generation process and creates checkpoints where errors can surface and be corrected.
Core Principle: Reasoning strategies work by converting a single unchecked generation into a structured process with intermediate checkpoints. The structure is what creates the opportunity for error correction, not the model's innate capability.
From a systems design perspective, there is a real cost to this. More structure means more tokens and more latency. Some strategies (Tree of Thoughts, Self-Consistency) multiply inference cost by a factor of three to ten or more. The value has to justify the overhead, which is why strategy selection matters as much as strategy design.
Figure 1. Conceptual cost-accuracy tradeoff across reasoning strategy families.
Single-path strategies produce one reasoning trace from start to finish. They are the lowest-cost option and the right starting point for most problems.
Chain-of-Thought is the foundation of the field. Wei et al. (2022) demonstrated that inserting a few worked examples with explicit intermediate reasoning steps into a prompt substantially improved performance on multi-step reasoning tasks. The key mechanism is externalization: the model writes out its working, which makes errors visible and catchable. CoT works well for math, logical deduction, structured analysis, and any task where showing the work is itself part of the deliverable. The paper was presented at NeurIPS 2022 and has become one of the most cited works in prompt engineering.
Zero-Shot CoT is the minimal version. Kojima et al. (2022) showed that appending "Let's think step by step" to a prompt, with no examples at all, activates similar reasoning behavior in sufficiently capable models. It costs essentially nothing extra and serves as a sensible default when you have no examples to provide and the task is at least moderately complex. This work, also presented at NeurIPS 2022, established the surprising finding that large language models possess latent reasoning abilities that can be activated with minimal prompting.
Plan-and-Solve (Wang et al., 2023) adds an explicit planning step before execution. The model first writes a structured plan of what it intends to do, then follows that plan. This reduces the problem of mid-reasoning drift, where a model starts down one approach and shifts direction partway through. It is particularly useful for longer, multi-part tasks where coherence across sections matters.
Program-of-Thought (Chen et al., 2023) converts the reasoning problem into executable code, runs the code, and returns the result. For mathematical and algorithmic problems, this is significantly more reliable than natural language reasoning because the execution environment enforces correctness in a way that a language model by itself cannot. If the domain permits code execution, this is often the right tool for any computation-heavy task.
Figure 2. Information flow comparison across single-path reasoning strategies.
When a single reasoning path is not trustworthy enough, multi-path strategies sample several independent paths and aggregate across them. The fundamental insight is statistical: a correct answer is more likely to be reproducible across diverse reasoning approaches than an incorrect one.
Self-Consistency (Wang et al., 2022) generates N independent Chain-of-Thought reasoning paths for the same problem and selects the most frequent final answer by marginalizing over the sampled reasoning paths, effectively a majority vote. The core insight is that correct reasoning is more likely to converge on the same answer across diverse paths than incorrect reasoning. Self-Consistency is expensive (N times the inference cost) but provides a built-in confidence signal: high agreement indicates high confidence, while a close split indicates genuine uncertainty. It is the right choice for high-stakes factual or mathematical tasks where single-path CoT makes errors at an unacceptable rate. The paper appeared on arXiv in March 2022 and was accepted at ICLR 2023.
Tree of Thoughts (Yao et al., 2023) generalizes CoT into a search over branching thought paths. The model generates multiple candidate "thoughts" at each step, evaluates each one using either the model itself or an external heuristic, and extends the most promising branches. Search can proceed via breadth-first or depth-first traversal. This mirrors how a person might work through a hard puzzle: generating several candidate moves, ruling out the weak ones, and going deeper on the strong ones. ToT is expensive and designed for genuinely hard exploratory problems: creative or strategic tasks with no obvious path, and situations where backtracking matters. Using it on a straightforward problem is wasteful. The paper was accepted at NeurIPS 2023.
Graph of Thoughts (Besta et al., 2024) extends the tree structure further by allowing reasoning paths to merge, not just branch. Insights from one branch can combine with insights from another, forming a directed acyclic graph of reasoning operations. This captures a class of problems where the final answer synthesizes multiple independent lines of reasoning rather than following a single branch to its conclusion. GoT is particularly suited to tasks like sorting, set operations, or document merging where partial results from different branches need to be aggregated.
Figure 3. Structural evolution from linear chains to trees to graphs of reasoning.
Self-refinement strategies generate an initial output, evaluate it against quality criteria, and revise through a feedback loop. They trade additional inference rounds for output quality.
Self-Refine (Madaan et al., 2023) cycles through generate, critique, and revise. The model produces a first draft, then critiques that draft against explicit quality criteria, then produces a revised version. This continues until quality is acceptable or a maximum iteration count is reached. Self-Refine is well-suited to writing tasks, code quality improvement, and any output where iterative improvement matters more than first-pass correctness.
Reflexion (Shinn et al., 2023) targets agentic tasks where the model takes actions in an environment and receives clear success or failure signals. After a failed attempt, the model writes a verbal reflection: what went wrong, why, and what to try differently. That reflection is stored in a text-based episodic memory and prepended to the next attempt. The key distinction from Self-Refine is that Reflexion learns across attempts from real failure signals, not from self-critique of a static draft. It is the right strategy for debugging loops, multi-step agent workflows, and any task where early attempts provide genuine information about what does not work. The paper was accepted at NeurIPS 2023.
Chain-of-Verification (Dhuliawala et al., 2023) targets factual accuracy specifically. The process has four stages: (1) the model generates an initial response, (2) it writes a set of verification questions designed to test specific claims in that response, (3) it answers those verification questions independently (crucially, without referencing the original response), and (4) it compares answers to flag discrepancies and produces a corrected final output. CoVe catches a class of errors that simple self-review misses because the model is not re-reading its own reasoning; it is answering independently formulated questions that directly probe each claim.
Decomposition strategies break a complex problem into manageable pieces before attempting a solution. The decomposition itself is a reasoning act that often determines the quality of the final output.
Least-to-Most (Zhou et al., 2023) tackles problems with hierarchical dependencies by solving the simplest subproblem first and using that result to solve the next. The answer to each stage feeds forward into subsequent stages. This mirrors how a competent engineer approaches a complex build: solve the foundational pieces first, then compose upward. It is particularly effective for problems with clear prerequisite structures such as mathematical proofs, multi-step word problems, and compositional generalization tasks.
Skeleton-of-Thought (Ning et al., 2024) generates a structural outline of the full answer before filling in any section. This is the right approach for long-form documents, research reports, and any content where overall structure and completeness matter as much as section-level quality. It prevents the common failure mode where a model writes in great depth on early sections and runs out of coherent material by the end. As a secondary benefit, the skeleton enables parallel generation of independent sections, reducing latency.
When a problem requires information the model does not have, or computation it cannot perform reliably, tool-use strategies integrate external capabilities into the reasoning loop. These strategies bridge the gap between what the model knows and what the task requires.
ReAct (Yao et al., 2022/2023) interleaves explicit reasoning (Thought) with concrete tool actions (Act) and the results of those actions (Observation) in a repeating loop. Before each action, the model writes a thought explaining what it is doing and why. After each action, it records the observation and updates its plan. This grounding in real feedback dramatically reduces hallucination in agentic tasks because the model is reasoning from actual retrieved information rather than from memory alone. ReAct appeared on arXiv in October 2022 and was accepted at ICLR 2023.
ReWOO (Xu et al., 2023) separates planning from execution. The model first writes the entire plan of tool calls upfront, then executes them in sequence without interleaving additional reasoning. This is more token-efficient than ReAct when the full plan is knowable before any results come back. ReWOO is preferred when the task is predictable and sequential; ReAct is preferred when early results need to change later actions.
| Dimension | ReAct | ReWOO |
|---|---|---|
| Planning | Interleaved with execution | Fully upfront |
| Adaptability | High; each step can change the plan | Low; plan is fixed before execution |
| Token efficiency | Lower; context grows with each loop | Higher; no repeated context |
| Best for | Dynamic, exploratory tasks | Predictable, sequential tasks |
Table 1. Comparison of ReAct and ReWOO across key dimensions.
These strategies improve reasoning on complex or novel problems by activating relevant general knowledge before engaging with specifics.
Step-Back Prompting (Zheng et al., 2024) asks the model to first answer a more general version of the question before addressing the specific case. If the question is "How should a retail startup price its API product?", the Step-Back version starts with "What principles govern software product pricing strategy?" This activates relevant general knowledge and provides a coherent framework before diving into specifics. It is particularly effective for complex, novel, or domain-crossing questions where the model benefits from establishing first principles.
Analogical Prompting (Yasunaga et al., 2024) asks the model to generate relevant analogies or similar solved problems before tackling the target problem. Rather than being provided examples by the user (as in few-shot prompting), the model recalls and applies its own relevant examples. This improves performance on novel tasks by activating similar problems the model has encountered in training, without requiring the user to know which examples to provide.
Several newer strategies extend the catalog in important directions.
Contrastive CoT provides the model with both correct and incorrect reasoning examples, explicitly showing why common reasoning errors lead to wrong answers. This has shown improvements on tasks where models consistently make the same type of mistake.
Cumulative Reasoning (Zhang et al., 2024) uses multiple LLM agents (a proposer, a verifier, and a reporter) that collaborate iteratively. The proposer suggests reasoning steps, the verifier checks each one, and the reporter synthesizes confirmed steps into a final answer. This distributes the cognitive load across specialized roles.
Thread of Thought targets scenarios with large, complex contexts (e.g., long documents or extensive retrieved information) by prompting the model to systematically walk through the context, identifying and extracting relevant information before reasoning toward an answer.
Beginning in late 2024, a new class of models emerged that perform extended reasoning internally as part of their inference process, without requiring explicit prompting strategies. OpenAI's o1 and o3 models, Anthropic's Claude models with extended thinking, and Google's Gemini models with thinking capabilities all allocate additional computation to chain-of-thought-like reasoning before producing an answer.
Key distinction: Prompt-level reasoning strategies structure the input to guide the model's generation. Model-native reasoning structures the inference process itself. These are complementary, not competing: a model with native reasoning capabilities can still benefit from well-structured prompts, particularly for decomposition, tool use, and verification.
The practical implication for strategy selection is that model-native reasoning reduces, but does not eliminate, the need for single-path strategies like CoT and Zero-Shot CoT on capable models. Multi-path strategies (Self-Consistency), verification strategies (CoVe), tool-use strategies (ReAct), and decomposition strategies (Least-to-Most) remain valuable even with reasoning-capable models because they address different failure modes: reproducibility, factual accuracy, external information access, and task organization respectively.
Selecting the right strategy is a six-dimension evaluation. The dimensions are worth understanding individually before seeing how they combine into a decision sequence.
The most important gate. Does the task require web search, code execution, API calls, or access to databases? If yes, the strategy must support tool integration. ReAct is the default for dynamic tasks where each result informs the next action. ReWOO is preferred when the full sequence of tool calls is knowable upfront and token efficiency matters. Almost every other strategy assumes the model reasons from its own parameters; if the task requires current information or external computation, tool-use strategies are not optional.
How bad is a wrong answer? For factual content where accuracy is non-negotiable (medical information, legal summaries, research citations), Chain-of-Verification adds a meaningful safety layer. For iterative quality improvement on writing or code, Self-Refine or Reflexion is the appropriate choice. For high-stakes single-answer problems, Self-Consistency provides a confidence signal along with the answer.
Can the task be split into subtasks with dependencies? If the problem is hierarchical (each piece requires prior pieces), Least-to-Most is the natural fit. If the problem is a long document with parallel sections that can be developed independently, Skeleton-of-Thought is more efficient. If the problem requires an upfront plan before execution but is not strictly hierarchical, Plan-and-Solve is sufficient.
Some problems have one correct path; others genuinely benefit from exploring alternatives. Creative and strategic tasks, design decisions with real tradeoffs, and problems with ambiguous starting points all benefit from Tree of Thoughts or Graph of Thoughts. Discipline matters here: ToT and GoT are expensive. Reaching for them on a linear problem because it feels complex is a common and costly mistake.
| Domain | Preferred Strategy | Rationale |
|---|---|---|
| Mathematics and formal logic | Program-of-Thought, Self-Consistency, CoT | Code execution enforces correctness; sampling catches arithmetic errors |
| Code generation and debugging | Program-of-Thought, Reflexion, Plan-and-Solve | Executable feedback enables learning from failures |
| Research and factual questions | ReAct + CoVe, Step-Back + CoT | Tool access grounds claims; verification catches hallucinations |
| Long-form writing and documentation | Skeleton-of-Thought, Self-Refine | Structure-first prevents coherence decay; iteration improves quality |
| Creative and strategic problems | Tree of Thoughts, Self-Refine | Exploration discovers non-obvious solutions; refinement polishes them |
| Novel or abstract concepts | Step-Back, Analogical Prompting | Abstraction activates relevant general knowledge |
| Classification and format matching | Few-Shot Prompting | Examples define the target pattern more precisely than instructions |
| Agentic task loops | ReAct, ReWOO, Reflexion | Real environment feedback grounds reasoning in actual outcomes |
Table 2. Domain-to-strategy mapping with rationale.
If you have well-formed input/output examples that match the target format and quality, few-shot prompting is hard to beat for format consistency. If you have no examples, zero-shot CoT is the pragmatic default. If the model can be asked to generate its own relevant analogies, Analogical Prompting occupies the middle ground.
The six dimensions map to a practical decision sequence:
Does this task require external tools? Yes → start with ReAct or ReWOO. No → continue.
Is factual accuracy the primary risk? Yes → add Chain-of-Verification. No → continue.
Is the task decomposable into subtasks? Yes → evaluate Least-to-Most, Skeleton-of-Thought, or Plan-and-Solve based on the dependency structure. No → continue.
Does exploration of multiple paths add value? Yes → Tree of Thoughts or Self-Consistency. No → continue.
Is the domain math, code, or formal reasoning? Yes → Program-of-Thought or CoT with Self-Consistency. No → continue.
Default: Chain-of-Thought for complex tasks, Zero-Shot CoT for simpler ones.
Figure 4. Strategy selection decision flowchart.
Some tasks span more than one dimension and benefit from pairing two strategies. Common effective combinations include:
ReAct + Chain-of-Verification : for research tasks requiring both tool access and factual accuracy.
Tree of Thoughts + Self-Refine : for creative or strategic problems where both exploration and quality polish matter.
Step-Back + CoT : for novel domain problems where a general principle frame improves the specific reasoning.
Plan-and-Solve + Self-Refine : for complex multi-part writing tasks.
ReWOO + Chain-of-Verification : for agentic pipelines where the output will be presented as fact.
The practical limit is two strategies in combination. Stacking three or more usually signals that the task needs to be decomposed into sub-tasks, each with its own strategy, rather than covered by a more complex strategy stack.
Strategies are not free. Every additional reasoning step costs tokens, and every additional parallel path costs compute time and money. In production systems, this matters directly.
| Strategy Category | Typical Cost Multiplier | When Justified |
|---|---|---|
| Single-path (CoT, Zero-Shot CoT, Plan-and-Solve) | 1.2–1.5× | Almost always for non-trivial tasks |
| Self-Refinement (Self-Refine, CoVe) | 2–4× | When output quality or accuracy is critical |
| Multi-path (Self-Consistency, N paths) | N× | High-stakes single-answer problems |
| Tree/Graph (ToT, GoT) | 3–10× | Genuinely hard exploratory problems only |
| Tool-use (ReAct, ReWOO) | 5–20× (varies with tool calls) | When task requires external information or computation |
Table 3. Approximate cost multipliers by strategy category.
Single-path strategies add modest overhead, typically 20 to 50 percent more tokens than a direct answer. This is almost always worth it for non-trivial tasks.
Self-Consistency and Tree of Thoughts scale linearly with the number of paths sampled. Running three paths triples the inference cost. Running five paths quintuples it. These strategies should be reserved for high-stakes tasks where the cost of a wrong answer exceeds the cost of extra inference.
ReAct and ReWOO costs scale with the number of tool calls and the size of observations retrieved. A research task with six web searches and long retrieved documents can run ten to twenty times the token count of a direct answer. For agentic systems, this is usually acceptable because the task genuinely cannot be done without those tool calls. For tasks that could be done from the model's own knowledge, it is waste.
Design principle: Start with the simplest strategy that has a reasonable chance of producing an acceptable result. Add complexity only when the simpler approach demonstrably fails, not preemptively.
Figure 5. Strategy selection by task complexity and accuracy requirements.
The strategy landscape is evolving rapidly. Several important caveats apply to any survey written in this period.
Benchmark specificity. Most published results come from specific model families on specific task types. A strategy that shows strong gains on GPT-4 on math benchmarks may show different behavior on other models or on domain-specific tasks. Published results are directionally useful but should be validated on the specific model and use case in question.
Prompt sensitivity. Many strategies require careful prompt engineering to activate reliably. Zero-Shot CoT works well on capable frontier models. On smaller or less capable models, few-shot examples may be necessary to achieve the same effect. Strategy selection cannot be fully separated from the capability tier of the model being used.
Evaluation inconsistency. The field has not converged on standard evaluation protocols. Comparing reported accuracy gains across papers is difficult because they use different baselines, different datasets, and different inference budgets. Claims that one strategy is uniformly superior should be treated with skepticism.
Interaction with model-native reasoning. As models increasingly incorporate chain-of-thought reasoning into their inference process, the marginal benefit of prompt-level CoT strategies may diminish for those models. The relationship between prompt-level strategies and model-native reasoning is an active area of research with limited controlled studies to date.
Reasoning strategies are the practical bridge between what language models can produce by default and what they need to produce for real tasks. The core principle is straightforward: structure the inference process, and quality improves. The practical challenge is selecting the right structure for the task at hand without over-engineering.
The six-dimension framework in this paper provides a working starting point: evaluate tool use requirements, verification needs, decomposability, exploration value, domain fit, and example availability. Start simple. Add structure when it is warranted. Combine strategies when a task genuinely spans two dimensions. Measure the cost against the value.
Two developments will shape the field going forward. First, model-native reasoning will continue to absorb some of the work currently done by prompt-level strategies, shifting the practitioner's focus toward orchestration-level concerns: tool use, verification, and decomposition. Second, the strategy catalog will continue to grow, but the underlying selection logic (match the structure of the reasoning strategy to the structure of the problem) will remain stable.
Besta, M., Blach, N., Kubicek, A., Gerstenberger, R., Gianinazzi, L., Gajber, J., Lehmann, T., Niewiadomski, H., Nyczyk, P., & Hoefler, T. (2024). Graph of thoughts: Solving elaborate problems with large language models. Proceedings of the AAAI Conference on Artificial Intelligence, 38(16), 17682–17690. https://arxiv.org/abs/2308.09687
Chen, W., Ma, X., Wang, X., & Cohen, W. W. (2023). Program of thoughts prompting: Disentangling computation from reasoning for numerical reasoning tasks. Transactions on Machine Learning Research. https://arxiv.org/abs/2211.12588
Dhuliawala, S., Komeili, M., Xu, J., Raileanu, R., Li, X., Celikyilmaz, A., & Weston, J. (2023). Chain-of-verification reduces hallucination in large language models. arXiv preprint. https://arxiv.org/abs/2309.11495
Kojima, T., Gu, S. S., Reid, M., Matsuo, Y., & Iwasawa, Y. (2022). Large language models are zero-shot reasoners. Advances in Neural Information Processing Systems, 35 (NeurIPS 2022). https://arxiv.org/abs/2205.11916
Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., Alon, U., Dziri, N., Prabhumoye, S., Yang, Y., Gupta, S., Majumder, B. P., Hermann, K. M., Welleck, S., Yazdanbakhsh, A., & Clark, P. (2023). Self-refine: Iterative refinement with self-feedback. Advances in Neural Information Processing Systems, 36 (NeurIPS 2023). https://arxiv.org/abs/2303.17651
Ning, X., Lin, Z., Zhou, Z., Wang, Z., Yang, H., & Wang, Y. (2024). Skeleton-of-thought: Prompting LLMs for efficient parallel generation. International Conference on Learning Representations (ICLR 2024). https://arxiv.org/abs/2307.15337
Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36 (NeurIPS 2023). https://arxiv.org/abs/2303.11366
Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., Narang, S., Chowdhery, A., & Zhou, D. (2022). Self-consistency improves chain of thought reasoning in language models. International Conference on Learning Representations (ICLR 2023). https://arxiv.org/abs/2203.11171
Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E., Le, Q., & Zhou, D. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35 (NeurIPS 2022). https://arxiv.org/abs/2201.11903
Xu, B., Peng, Z., Lei, B., Muber, S., Litman, D., & Lu, J. (2023). ReWOO: Decoupling reasoning from observations for efficient augmented language models. arXiv preprint. https://arxiv.org/abs/2305.18323
Yao, S., Yu, D., Zhao, J., Shafran, I., Griffiths, T. L., Cao, Y., & Narasimhan, K. (2023). Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems, 36 (NeurIPS 2023). https://arxiv.org/abs/2305.10601
Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023). ReAct: Synergizing reasoning and acting in language models. International Conference on Learning Representations (ICLR 2023). https://arxiv.org/abs/2210.03629
Zhang, Y., Yang, J., Yuan, Y., & Yao, A. C.-C. (2024). Cumulative reasoning with large language models. arXiv preprint. https://arxiv.org/abs/2308.04371
Zheng, H. S., Mishra, S., Chen, X., Cheng, H.-T., Chi, E., Le, Q. V., & Zhou, D. (2024). Take a step back: Evoking reasoning via abstraction in large language models. International Conference on Learning Representations (ICLR 2024). https://arxiv.org/abs/2310.06117
Zhou, D., Schärli, N., Hou, L., Wei, J., Scales, N., Wang, X., Schuurmans, D., Cui, C., Bousquet, O., Le, Q., & Chi, E. (2023). Least-to-most prompting enables complex reasoning in large language models. International Conference on Learning Representations (ICLR 2023). https://arxiv.org/abs/2205.10625
15 claims verified: 12 confirmed ✓, 2 corrected ✗, 1 uncertain ?
Corrections applied:
Uncertain claim: The original paper's assertion of "more than 40 documented strategies" has been replaced with descriptive language ("a substantial catalog") because no single authoritative source confirms a specific count.
This survey reflects knowledge available through early 2025. The reasoning strategy landscape is evolving rapidly, with new techniques published monthly. Specific limitations include:
Publication venues for some papers (particularly Besta et al., Zheng et al., Ning et al.) should be independently confirmed against the latest proceedings, as acceptance decisions may post-date this writing.
The cost multipliers in Table 3 are approximate and vary significantly with model, prompt length, and implementation details. They should be treated as order-of-magnitude guidance, not precise measurements.
The interaction between prompt-level reasoning strategies and model-native reasoning capabilities (e.g., OpenAI's o1/o3, Anthropic's extended thinking, Google's Gemini thinking) is an active research area with limited controlled comparative studies available at time of writing.
Author lists for some references have been reproduced from arXiv metadata and may differ slightly from final published versions.