When we think about improving LLMs' skills, our focus often centers on aspects such as improved grammar or more natural-sounding responses. But what sets a helpful LLM apart is its ability to reason. This involves thinking through the problem, breaking it down into steps, making informed decisions, and explaining how it arrived at an answer. Reasoning takes next-token prediction to the next level by adding logic, structure, and goal-oriented thinking.

Without strong reasoning skills, models often skip steps, make confident but incorrect claims (hallucinations), or struggle with tasks that require planning or logic. For any organization, this creates a significant risk, undermining user trust and leading to unreliable outcomes.

The good news is that we can improve reasoning with the right techniques and upgrade a pre-trained LLM with broad knowledge into a valuable tool for real-world tasks that aligns with users' needs. Post-training refines a model's capabilities, teaching it to move beyond simply predicting the next word. This means moving past the first plausible answer and compelling the model to build a more deliberate, logical response. It learns to break down a task, reflect on its outputs, and consult external tools—mimicking a more methodical, human-like reasoning process. This is how we upgrade a generalist LLM into a specialized tool that is more accurate, trustworthy, and aligned with specific business goals.

Post-training reasoning techniques

Let's have a look at some of the well-known post-training methods used to boost the reasoning abilities of a pre-trained LLM. These techniques build on the model's existing knowledge, teaching it to follow instructions more effectively and use tools or feedback to refine its answers. Each method adds a new layer of skill, whether it involves breaking down problems, learning from feedback, or drawing on real-world information, all to bridge the model's reasoning with the human thought process.

Instruction Fine Tuning (IFT)

Core idea:

Start with a pre-trained model, then run a second pass of supervised learning on mini-lessons, each formed as a triple of instruction -> input -> answer, like in the following example:

How it improves reasoning:

Each training example teaches the model how to transform a task description into the steps that solve it. After thousands of such drills, the model learns many small skills and when to switch among them. The steady practice trains it to deliver precise answers that match the instruction rather than sliding into a generic reply.

Empirical clue:

Flan UPaLM 540B, fine-tuned on 1,800 instruction-based tasks, outperformed the original UPaLM 540B model across four benchmarks: MMLU, BBH, TyDiQA, and MGSM, with an average improvement of 8.9%. 

(source: https://arxiv.org/abs/2210.11416?)

Domain-Specific Supervised Fine-Tuning

Core idea:

Apply the IFT principle but restrict the corpus to one technical field, such as medicine, law, or finance, saturating the weights with specialist concepts and rules.

How it improves reasoning:

Fine-tuning on domain-specific data enables the model to absorb the field's vocabulary and structural rules, providing it with direct access to specialized concepts that were scarce during pre-training. The model can quickly rule out answers that do not make sense and narrow the search space it explores while reasoning. 

Mastering a domain requires data that captures its unique complexity. To support this type of learning, Toloka has developed a post-training approach that utilizes domain-specific examples, human-labeled edge cases, and diverse training data generated through a hybrid pipeline combining human judgment and AI. This process enhances the model's ability to follow complex instructions, reason across modalities and languages, and avoid common pitfalls like hallucination.

Empirical clue:

In ICD-10 coding, domain SFT catapulted exact-code accuracy from <1 % to ~97% on standard ICD coding (including linguistic and lexical variations) and to 69 % on real clinical notes. (source: https://www.nature.com/articles/s44401-025-00018-3)

Chain-of-Thought (CoT) 

Core idea:

Show the model a worked example that spells out every intermediate step, then ask it to "think step by step". 

How it improves reasoning:

Writing the solution step by step forces the model to reveal its hidden reasoning, making it more likely for logically necessary tokens to appear. Because each step is generated one at a time, the model can inspect its own progress and fix contradictions on the fly.

Empirical clue:

Giving PaLM 540B eight CoT examples improved its accuracy on GSM8K from 18% to 57%. This improvement came entirely from a better prompt, with no changes to the model's weights.

(source: https://arxiv.org/abs/2201.11903)

Tree-of-Thought (ToT) 

Core idea:

Instead of following one chain, let the model branch into multiple reasoning paths, score partial solutions, and expand on the ones that look promising. 

How it improves reasoning:

Deliberate exploration stops the first plausible idea from dominating. ToT lets the model test several lines of reasoning instead of locking onto one. When a branch hits a dead end, it can backtrack to an earlier step and try another idea, something a plain CoT cannot do. The model operates in a deliberate loop: propose, evaluate, and explore. Think of it like a CEO evaluating multiple business strategies; they model several potential outcomes before committing to the most promising one. This prevents over-investing in a flawed initial idea.

Toloka applied this principle in a project to improve a coding agent. Focused on generating pull requests for repository maintenance and bug-fixing tasks across multiple programming languages, our team analyzed over 5,000 coding agent trajectories, evaluating each interaction step-by-step to provide more explicit guidance to the models, enabling them to make better decisions on real coding tasks.languages

Empirical clue:

In the "Game of 24", GPT-4 combined with CoT reasoning solved only 4% of the puzzles. Replacing it with ToT raised the success rate to 74%.(Source)

Reflexion

Core idea:

After each attempt, the model writes a short reflection on what went wrong or could be improved. That remark is stored in memory and included in the next prompt, giving the model a chance to revise its approach on the next try.

How it improves reasoning:

Reflexion turns simple pass/fail signals into meaningful feedback that the model can understand and act on. By reading its own critique before trying again, the model gains short-term memory and avoids repeating past mistakes. This self-monitoring loop of try, reflect, revise guides the model toward better reasoning without changing its weights. Over time, it helps the model adjust its thinking more like a human would, by learning from past mistakes and trying again with a better plan.

Empirical clue:

A GPT-4 agent using Reflexion raised its success rate from 80% to 91% on the HumanEval coding dataset. (Source)

Retrieval-Augmented Generation (RAG)

Core idea:

Before answering, a retriever grabs documents or information relevant to the query and injects them into the context window so the model can reason over fresh evidence. 

How it improves reasoning:

RAG grounds the model in verifiable facts, drastically reducing hallucinations and improving user trust. Instead of relying on potentially outdated or incorrect memorized knowledge, the model reasons over fresh, injected evidence. This is like a lawyer building an argument not from memory, but by citing specific, relevant legal precedents directly in court.

Empirical clues:

The integration of RAG into an enterprise workflow-generation system reduced the rate of hallucinated steps and tables from 21% to 7.5% when evaluated on the HumanEval benchmark.(Source)

Toloka in Action: Improving Multilingual Reasoning with RAG

In a recent project, Toloka was tasked with enhancing an LLM's multilingual reasoning. We used RAG to feed the model verified, multilingual documents at inference time. The results were clear: the model could now answer complex questions in English and German, citing specific evidence from the retrieved text. Every factual claim became traceable, eliminating guesswork and demonstrating a consistent, grounded reasoning process across languages.

Reinforcement Learning from Human Feedback (RLHF)

Core idea:

Take a pre-trained model and generate several answers for real user prompts. Human reviewers rank those answers, a reward model learns these rankings, and the main model is updated to score higher on that reward. This loop optimizes the model to produce outputs humans prefer rather than those that merely score well on next-token likelihood.

How it improves reasoning:

Because humans reward answers that are complete, fact-checked, and well-explained, the model learns to value clear logic over quick guesses. Each reinforcement learning step trains it to produce responses that follow instructions, chain ideas coherently, and avoid unsupported claims, aligning its internal decision-making with human expectations.

Empirical clue:

In the original InstructGPT study, annotators preferred answers from the 175B RLHF-tuned model over the same-size GPT-3 baseline 85% of the time. Even the 1.3B RLHF model outperformed the baseline, despite having 100x fewer parameters. (Source)

Chain-of-Action (CoA)

Core idea:

Decompose a complex query into a reasoning chain interleaved with tool calls (e.g., web search, database lookup, image retrieval) that are executed on the fly and fed into the next thought.

How it improves reasoning:

Each action grounds the chain in verified facts. By using up-to-date information and multi-reference faith scores, the model can remain grounded and make more informed decisions, even when sources disagree. And because it can plug in different tools as needed, it's able to take on more complex tasks that require different data modalities.

Empirical clue:

CoA outperformed the leading CoT and RAG baselines by ~6% on multimodal QA benchmarks, particularly on compositional questions that need both retrieval and reasoning. (Source)

To bring it all together, the table below provides a quick summary of each post-training method, consisting of simplified analogies to the technical concepts, explaining the basic working principles and typical applications.

Combining techniques for optimal performance

Each technique brings its advantages, and the most effective AI systems often combine them. For example, an agent might follow structured prompts (IFT), think through the problem step by step (CoT), refine its answer through self-review (Reflexion), and align its tone based on human feedback (RLHF). This stacked approach is standard in today's leading models: most large LLMs, including GPT-4, are first trained with SFT and then polished with RLHF.

From raw potential to reliable performance

The better a model can reason, the more trustworthy its responses become, which is of the essence in complex tasks. An LLM with strong reasoning skills cuts down on hallucinations and is more reliable across everyday use, professional applications, and scientific work. 

Post-training is how we sharpen that reasoning and tailor a pre-trained model to real-world tasks and user preferences. Techniques such as supervised fine-tuning, reinforcement learning, and preference optimization each play a part: deepening the model's domain expertise, nudging it toward choices people prefer, and helping it select the best answer for any given question. By moving from clever guesses to solid logic, these techniques make AI more reliable, scalable, and ultimately, more valuable.