When the Model Gets It Wrong, Make It Think Longer: 8 Inference-Enhancement Methods and Their Costs

Test-time compute has moved over the past two years from a corner of research papers to the engineering front line. After the curves of training-side scaling laws flattened out, people began looking at another path: keep model parameters fixed, but give it more compute at inference time—can that raise answer quality?

Daily Dose of Data Science posted a tweet listing 8 methods for improving LLM reasoning at inference time, along with a video:

First, let's be clear about what problem each of these 8 methods solves. They are not at the same level: some are a single prompt, while others are an entire search framework.

1. Chain-of-Thought
Proposed by Wei et al. in 2022, it has the model write out intermediate steps before giving an answer. It improves math and logic problems noticeably. The cost is longer outputs, and errors propagate down the chain: if one step is wrong, everything after it goes wrong.

2. Self-Consistency
Wang et al.'s 2023 approach: sample multiple reasoning paths for the same problem and vote on the final answer. It bets that the correct answer is more likely than incorrect ones to be hit by multiple paths. The cost is N times the inference overhead, where N is usually 5 to 40.

3. Tree of Thoughts
Yao et al. break reasoning into tree nodes, allowing multiple candidates to be generated at a step, evaluated, and backtracked. It suits problems that require trial and error, such as planning and puzzles. In engineering, you have to write the search loop yourself, which is fairly complex.

4. Least-to-Most
Zhou et al.'s prompting strategy: first have the model break the big problem into subproblems, then solve them one by one starting from the simplest. It is more effective than asking directly on compositional problems.

5. Reflexion
Shinn et al.'s framework has the model inspect its own output, write down the reasons for failure, and retry in the next round with those reflections. It works well for code and tasks with unit tests; on open-ended questions, the model tends to feel good about itself and can revise for a long time while still being wrong.

6. ReAct
Yao et al.'s 2022 work alternates reasoning and acting: think one step, call a tool (retrieval, calculator, code execution), look at the result, and continue thinking. In essence, it outsources the model's weaknesses to external systems.

7. Best-of-N with a Verifier
Sample N candidate answers, score them with a reward model, unit tests, or rules, and pick the highest-scoring one. In math and code settings, this type of method has the best cost-effectiveness because verifiers are relatively reliable. Without a verifier, this trick degenerates into a random lottery.

8. Process Reward Model-Guided Search (MCTS / PRM)
Search at each step of reasoning, use a process reward model (PRM) to score intermediate steps, and then use methods such as Monte Carlo tree search to find a path. AlphaCode used a similar search idea; OpenAI's o1 series also treats inference-time compute as a selling point. The compute overhead is large, and it depends heavily on the training quality of the PRM.

Looking at these 8 methods spread out, one finds a not-so-romantic fact: the categories that reliably work all rely on external signals. Voting requires answers to be comparable, verifiers need to be able to judge right from wrong, and tool calls require an available environment. Pure 'let the model think longer' often just makes the model repeat its own mistakes more confidently when there is no verifier.

Another easily overlooked thing is the bill. Sampling 40 paths for self-consistency means 40x latency and cost; MCTS expands at the step level, so the overhead is even higher. In online services, a user waiting 3 seconds and waiting 30 seconds are two different things. After converting paper accuracy gains into benefit per unit cost, the ranking changes.

The video in that tweet demonstrates the effect comparison of these methods; the link is here: https://x.com/DailyDoseOfDS_/status/2118637028393021896

If you were to pick just one to start with, begin with step-by-step prompting plus sampling-based verification. It requires the smallest engineering change, and the benefits are easiest to measure.