Fast Reflex versus Slow Thinking
When you ask a classic language model a hard question, you are watching an extraordinarily fast reflex: based on the statistics of the vast text it has seen, the model predicts the next word, then the next, and pours out the answer in one pass, without pausing to think. That works beautifully for simple questions. But for a multi-step math problem, a twisty logic puzzle, or a layered piece of legal reasoning, blurting out the first word that comes to mind usually leads to the wrong answer.
People are the same. We answer 'two plus two' without thinking; but asked to 'multiply seventeen by twenty-three,' we stop, put the intermediate steps on paper, and work through them one at a time. The psychologist Daniel Kahneman calls this 'fast' versus 'slow' thinking. Reasoning models are precisely an attempt to give AI that slow thinking: instead of answering immediately, running an internal thinking process first.
What 'Thinking' Really Is: Chain-of-Thought
A reasoning model's 'thinking' is not magic; at its core it is the model producing a series of intermediate steps for itself before reaching an answer. This is called chain-of-thought. The model breaks the problem into parts, solves each in turn, checks the intermediate results, and only at the end of this chain delivers a final answer. It produces more words — but most of those words are aimed at its own reasoning, not at you.
The best analogy is a student following the instruction to 'show your work.' A student who writes only the result cannot catch a slip in one step; a student who writes every step can re-read their own work and spot the error. Reasoning models likewise feed the intermediate steps they generate back in as input for the next step. As the chain of thought grows, the model gains a foundation it can build its own logic upon.
Test-Time Compute: More Computation to Think More
The key concept here is 'test-time compute' (also called inference-time compute). In the classic approach, the way to make a model smarter was to make it bigger and train it on more data — all the investment went into training. Reasoning models use a different lever: keep the model the same, but give it more thinking time (more computation) while it is producing the answer.
The logic is this: on a hard question, telling the model to 'take your time, think longer' often delivers a bigger accuracy gain — more cheaply — than making it larger. The model can try several solution paths, review its own answer, abandon a dead end and take another route. Just as a person says 'let me sleep on it' before a hard decision, the extra computation given to the model becomes the real source of quality. That is why these models answer more slowly but more accurately.
How Are These Models Trained?
The secret to teaching a model to 'think well' lies largely in reinforcement learning. The model is given a problem, allowed to produce its own chain of thought, and rewarded when the answer it reaches is correct, penalized when it is wrong. This is especially powerful in domains like math and code where the answer can be verified: because correctness can be checked exactly, the model gradually discovers for itself which kinds of thinking steps lead to the right answer.
What is striking is this: the model is not told 'think like so' step by step. Through trial and error it finds the reasoning strategies that work; it develops, on its own, the habits of breaking the problem down, going back to check, and trying alternative routes. Training reinforces good thinking habits with reward; what the model internalizes is not a memorized answer but a reasoning reflex.
Strengths, Cost, and Limits
Reasoning models are markedly better at multi-step, logic-heavy tasks: hard math, complex code, scientific problem-solving, planning, and analysis that requires layered reasoning. In these areas the chain of thought reduces errors and yields more reliable results. But this ability is not free. Thinking longer means more computation, more time, and more cost; answers come more slowly and the price per query goes up.
So the crucial point is: not every task needs reasoning. For single-step tasks like 'summarize this email' or 'fix this sentence,' running a thinking model is both wasteful and needlessly slow; classic fast models do the job more cheaply and instantly. The right engineering decision is to recognize the task: simple, direct work goes to a fast model; multi-step, low-error-tolerance work goes to a thinking model. Mature systems usually use both, choosing by the job at hand.
Multi-Step Reasoning in Law, and İçtiHub
Law is a textbook example of multi-step reasoning. The answer to a legal question is rarely written in a single provision; it usually requires weighing several pieces of legislation, exceptions, case law, and the specifics of the concrete situation together. This is exactly the kind of reasoning where a chain of thought helps: first isolate the relevant rules, then apply them to the facts, weigh conflicting provisions, check the exception, and only then reach a conclusion.
At İçtiHub, the legal AI we build at EcoFluxion, the principle that matters for us is this: as important as the power of the reasoning is, every step must have a basis. However well a model 'thinks,' in law the answer must be tied to the actual legislation and case law retrieved; otherwise a confident but unsupported line of reasoning is the most dangerous outcome. That is why for us reasoning works hand in hand with RAG (retrieval-augmented generation): the chain of thought builds the analysis, the retrieval layer grounds each step in a verifiable source. For the foundations, see our guide on how large language models work.