AI that learns by thinking gains knowledge from its own reasoning instead of new data, by explaining, simulating, comparing and working through steps. A model does it at answer time, as a chain of thought, and in training, when checked reasoning becomes training data. Tania Lombrozo's September 2024 review calls this shared human and machine ability learning by thinking.
This explainer covers what that 2024 paper actually says, how the idea shows up in AI (from chain-of-thought prompting to self-training methods such as STaR and reasoning models such as OpenAI o1 and DeepSeek-R1), what thinking cannot do, including the errors a model reasons itself into, and what all of it means for a business that uses AI.
What learning by thinking means
Most of what we call learning starts outside the mind: you read something, watch something or get told you were wrong. Learning by thinking is the other kind. You gain something new by working on what you already know: explaining it to yourself, running it through in your head, comparing it with a similar case or reasoning from it.
A simple example. You know your office lease ends in March, and you know it requires 90 days' notice. Nobody has told you "decide by December", yet after a moment's thought you know it. No new fact arrived. The conclusion was implicit in two facts you held, and thinking made it explicit and usable.
That raises a real puzzle, and it is the one Lombrozo's paper sets out to resolve: if everything needed was already in the mind, in what sense did the mind learn? Her answer is that minds with limited resources cannot work out every consequence of what they know in advance. They build the representations they need on demand, when a goal makes the effort worthwhile, and learning by thinking is how they build them. The same logic applies to an AI model, which holds far more than any single prompt draws on.
What Lombrozo's 2024 review says
The paper is "Learning by thinking in natural and artificial minds" by Tania Lombrozo, a professor of psychology and co-director of the Natural and Artificial Minds initiative at Princeton University. It was published online on September 18, 2024 in Trends in Cognitive Sciences, a Cell Press review journal, and appears in volume 28, issue 11, pages 1011 to 1022. It is a review of existing research, not a report of a new AI system.
Its abstract makes three claims:
- Learning does not require new observations. It also happens through explaining to oneself, mental simulation, analogical comparison and reasoning.
- AI shows it too. Recent AI systems can self-correct and arrive at new conclusions through the same kind of process, which the paper abbreviates LbT.
- It exists because knowledge is built on demand. Minds that face uncertain environments and changing goals, with limited resources, construct knowledge representations when they need them, and learning by thinking supports that construction.
The Cell Press release that accompanied the paper illustrated each of the four processes with an everyday case, such as discovering the gaps in your understanding while explaining how a microwave works to a child. It also noted what the paper leaves open: where learning ends and reasoning begins, and whether AI systems actually think or only reproduce the outputs of thinking.
The four processes, with a human case and the closest AI technique:
| Process | In people | In AI models |
|---|---|---|
| Explanation | Explaining a process to a new hire, you find the step you never understood | A model that writes feedback on its own draft and revises it (Self-Refine, 2023) |
| Simulation | Walking through a server migration in your head, you see that DNS has to change first | A system that learns from simulated outcomes, such as AlphaZero playing games against itself |
| Analogy | You notice a new pricing problem has the same shape as one you solved last year | A model prompted to recall related problems it knows before solving a new one (analogical prompting, 2023) |
| Reasoning | From the lease and the notice period, you work out the deadline | A model that writes intermediate steps before answering (chain-of-thought prompting, 2022) |
The timing is worth noting. OpenAI announced o1, a model trained with reinforcement learning to reason before it answers, on September 12, 2024, six days before the review appeared. Much of the rest of this post is about models built that way. How well they reason, and where they fail, is the subject of our explainer on logical AI.
Two ways an AI model learns by thinking
For people, what you work out usually stays with you. For an AI model, it depends on where the thinking happens, and the difference matters when you decide what to expect from one.
| Thinking at answer time | Learning from its own thinking | |
|---|---|---|
| What changes | This one answer | The model's weights |
| How long it lasts | This request or conversation only | Every later answer |
| Examples | Chain of thought, self-consistency, reasoning effort | STaR, Constitutional AI, self-play, reinforcement learning on reasoning |
| What it costs | Tokens and waiting time on every request | A training run, paid once by whoever trains the model |
| What checks it | Nothing outside the model, unless you add a check | An answer key, a rulebook, tests or written principles |
Thinking at answer time is the closest match to a person reasoning through a problem on paper. Learning from its own thinking is closer to practice: work that was checked and kept.
Thinking at answer time: chain of thought and test-time compute
In January 2022, researchers at Google Research showed that giving a large language model a few worked examples with the intermediate steps written out, rather than just question and answer, improved its results on arithmetic, commonsense and symbolic reasoning tasks. They called it chain-of-thought prompting, and found that the ability emerged in sufficiently large models. Four months later, Kojima and colleagues showed that no examples were needed: adding "Let's think step by step" before the answer raised an InstructGPT model's accuracy on the MultiArith arithmetic set from 17.7% to 78.7%.
Writing helps even a model that already "knows" the answer, for a mechanical reason. A language model produces one token at a time, and everything it has written becomes input for what it writes next. Written steps give it intermediate results to build on, where a direct answer would have to jump the whole distance at once. That is the closest AI match to explaining something to yourself: the model reads its own explanation and gets further than it could without it.
Two refinements followed quickly. Self-consistency (March 2022) samples several independent reasoning paths for the same question and keeps the answer most of them reach, on the reasoning that a hard problem can be solved several ways but has one right answer. And research on test-time compute asked how far spending more computation per answer can go. A study by Snell and colleagues (August 2024) found that the best strategy depends on how hard the prompt is, that allocating compute per prompt was more than four times as efficient as a simple best-of-N baseline, and that, at equal total compute, extra test-time compute let a smaller model outperform one 14 times larger on problems where the smaller model already had some success.
Today, reasoning models from OpenAI, Anthropic and Google think before they answer, and their APIs let developers set how much. Nothing in the model itself changes, though: the reasoning lives in the context of the conversation, and a new conversation starts from the same model. Keeping the model itself current is a different problem, covered in our explainer on AI continuous learning.
Learning from its own reasoning: STaR, self-play and reasoning models
The second level is where "learns by thinking" is meant literally: the model's own reasoning becomes its training data.
STaR: training on reasoning that reached the right answer
STaR, the Self-Taught Reasoner, came from Stanford researchers in March 2022 and is the loop shown at the top of this page. A model with a few worked examples writes rationales for a large set of questions with known answers. Rationales that reach the right answer are kept. For the questions it missed, the model is given the correct answer and asked to explain it, a step the authors call rationalization, so that it also gets a training signal from problems it could not solve on its own. The model is fine-tuned on the kept rationales, the new model writes the next round, and the loop repeats until results plateau. (Each round fine-tunes the original model on the new set, to avoid overfitting.) On the CommonsenseQA benchmark, the authors report it performed comparably to fine-tuning a model 30 times larger.
The detail that makes it work is the filter. The model does not learn from everything it thinks, only from thinking whose conclusion was checked against an answer it did not produce.
Critique and revision: Constitutional AI
Anthropic's Constitutional AI (December 2022) applies learning by explanation to behaviour rather than arithmetic. The model critiques its own responses against a written list of principles, revises them, and is fine-tuned on the revisions; a later reinforcement learning stage uses a model's judgments instead of human labels. People write the principles; they do not label harmful outputs.
Simulation: learning from games played against itself
The purest case of learning from simulation predates today's large language models. DeepMind's AlphaZero, described in December 2017, started from random play with no domain knowledge except the rules of the game, learned only from games against itself, and reached a superhuman level in chess, shogi and Go within 24 hours.
The rules are what make it learning rather than daydreaming. Every game the system imagines ends in a result nobody can argue with, so each one is a trustworthy lesson.
Reasoning models: reinforcement learning on the chain of thought
OpenAI's o1 announcement on September 12, 2024 described a large-scale reinforcement learning process that teaches the model to use its chain of thought productively: to recognize and correct its mistakes, break tricky steps into simpler ones and try a different approach when one is not working. OpenAI reported that performance improved both with more reinforcement learning (train-time compute) and with more time spent thinking (test-time compute), which ties the two levels together. It also chose not to show users the raw chain of thought, only a model-generated summary.
DeepSeek published a detailed account of how such training works. Its DeepSeek-R1 paper, first posted in January 2025 and published in Nature on September 17, 2025, trained a model with rewards that checked the final answer against a known result and put no constraints on the reasoning itself. The checks were rules: a math answer in a required format compared with the ground truth, or code compiled and run against test cases. No human-written reasoning examples were used for the first version, R1-Zero, yet self-reflection and verification emerged on their own, including a sudden rise in the model writing "wait" as it rechecked its work. The authors name what made it possible: hard reasoning questions, a reliable verifier and enough compute. They also showed that the reasoning of a large model can be used to improve smaller ones.
Every method in this section whose details are public anchors the model's thinking to something the model did not produce: an answer key, a rulebook, a compiler, a written list of principles. That is the difference between a model learning by thinking and a model talking to itself.
What learning by thinking cannot do
The limits are as instructive as the results, and they are where business risk lives.
It cannot create facts
Thinking rearranges and extends what is already there. It cannot tell a model this quarter's prices, a regulation passed after its training data was collected or the terms of your contract with a customer. Asked to reason about a fact it lacks, a model reasons from a guess, and the reasoning can make the guess look sounder than it is. Our post on AI limitations in understanding covers that gap between fluent output and grounded knowledge.
A model can reason itself into an error
An early wrong step does not stay small. Everything after it builds on it, and a model checking its own work re-reads the same flawed step. A study by Google DeepMind and University of Illinois researchers, Large Language Models Cannot Self-Correct Reasoning Yet (ICLR 2024), found that earlier reports of models fixing their own reasoning relied on being told when an answer was wrong. Without that outside signal, performance sometimes fell after self-correction: on a set of math word problems, GPT-3.5 was more likely to change a correct answer to a wrong one than the reverse.
Self-training has its own version of the problem. The STaR authors note that on tasks with a high chance of guessing right, such as yes-or-no decisions, many kept rationales are poor ones that reached the right answer for the wrong reason. The DeepSeek-R1 authors warn that when a model rather than a rule scores the reasoning, training can learn to exploit the scorer, which they call reward hacking.
Written reasoning is not always the real reason
It is tempting to read a model's chain of thought as an account of how it decided. In a NeurIPS 2023 study, researchers biased prompts, for example by always placing the right answer in position (A) in the examples, and models followed the bias without mentioning it, writing plausible explanations for the answers it pushed them toward. Accuracy dropped by as much as 36% across 13 tasks. Anthropic tested reasoning models the same way in April 2025, slipping a hint about the answer into the prompt: on average Claude 3.7 Sonnet mentioned a hint it had used 25% of the time, and DeepSeek R1 39% of the time.
Important
A chain of thought is a useful signal, not an audit trail. For anything that needs to be explained later, log the inputs, the sources the model was given, its output and who approved the result.
More thinking is not always better
A 2025 study, Inverse Scaling in Test-Time Compute, built tasks where letting reasoning models think longer made them less accurate: some became more distracted by irrelevant information, some fit too closely to how a problem was framed, and some drifted from reasonable assumptions to spurious correlations. Vendor documentation is more modest but points the same way: Anthropic describes larger thinking budgets as giving diminishing returns, at the cost of latency.
Unchecked self-training degrades models
A model trained on its own unfiltered output does not keep improving. A 2024 Nature study found that indiscriminate training on model-generated content causes irreversible defects, with the rare parts of the original data disappearing first, and called the effect model collapse. STaR and DeepSeek-R1 do not train on everything the model writes: their training signal comes from answers checked against known results.
What learning by thinking means for businesses using AI
Most businesses will never train a model. What they choose is when to ask a model to think, what to give it to think with, and how to check what comes out. In order:
- Use reasoning for work with steps. OpenAI's documentation names complex problem solving, coding, scientific reasoning and multi-step agentic workflows as where reasoning models work best. A lookup, a short classification or a reply that has to be instant rarely needs it.
- Budget for the thinking. Reasoning tokens are not shown in the OpenAI API but still take space in the context window and are billed as output tokens. Google's Gemini API prices a response as output plus thinking tokens, and Anthropic's API reports how many billed output tokens were reasoning. Each exposes a control, named reasoning effort, thinking level or thinking budget depending on the vendor (as of September 2026). Our Gemini explainer covers Google's model family in more depth.
- Give the model your facts. Thinking will not fill a gap in knowledge. Answers about your products, prices, policies or customers need those sources in the request, retrieved from your own documents and systems at the time of the question.
- Check results outside the model. STaR, AlphaZero and DeepSeek-R1 all learned from thinking that something outside the model had checked, and your system should work the same way: tests for code, rules and calculations for numbers, a comparison with your records for extracted data, and a person for anything that changes data. Code a reasoning model writes still goes through the same review and scanning as any contributor's (secure coding checklist).
- Tell the model what done looks like. OpenAI's advice for its reasoning models is to state the goal, the constraints and the output you expect, define how the model should verify its work, and treat the effort setting as a tuning knob rather than the main way to recover quality.
- Measure before you choose an effort level. Run the same set of real cases at two or three settings and compare accuracy, cost and waiting time. More thinking is not guaranteed to help, and the cheapest setting that passes is the one to ship.
- If you fine-tune on model output, filter it. Keep only examples a check confirmed, and keep real data from your business in the mix.
Tip
A useful test for any AI step: if it gets the answer wrong, what outside the model would notice? If the answer is "nothing", add that check before you add more thinking.
If you are putting a model into a real workflow, our AI and automation service builds assistants that answer from your own pages, documents and live data and cite their sources, keeps an evaluation set built from your real cases that every model, prompt or source change must pass before it goes live, and has a rule you signed off or a named person approve anything that changes data.
