Last week we unpacked “agent”. This week we stay in the same hype cycle and pick up two words that now show up as buttons in the tools you already use: “thinking” and “reasoning”. Your chatbot pauses, tells you it is “thinking”, and hands back a better answer. A vendor sells you a “reasoning model”. Both words borrow heavily from what humans do. With AI systems, neither means what the borrowing implies and you should understand that disconnect before you trust either one with important work.
When a model says it is “thinking”, something real is happening under the hood. It’s just not what the word suggests. The same goes for “reasoning”. These terms are not empty marketing terms, and they are not tiny minds waking up inside your laptop either. Rather, they are labels attached to a couple of genuinely useful engineering tricks. And once you see the tricks, the labels stop being mysterious.
This week we dig into what “thinking” actually refers to, the short history of how computer scientists stumbled into it, how “reasoning” expanded the idea, and which parts of the surrounding hype you can safely ignore.
The Core Idea: “Thinking” Is Output Fed Back In as Input
Let's start with how these models generate text. A language model produces one piece of text at a time (a token), and each piece it produces gets added to what it read before producing the next one. The output becomes part of the input. That detail is the whole story.
Somewhere around 2023, researchers noticed something almost too simple to be interesting. If you let a model write out intermediate steps before committing to a final answer (i.e., “show your work”), the final answer got better, especially on problems that had multiple steps. This wasn’t because the model understood the problem better (remember, it’s a system of equations), but because each intermediate step it wrote became part of the context it read for the next step. The model was, in effect, building itself a better prompt as it went.
This improvement, however, came with a cost. Writing out all those intermediate steps takes more text, and more text takes more time and computation to produce. So users were given a knob. You can spend more time generating intermediate steps and get a better answer or spend less time generating intermediate steps and get a worse answer. That extra generating-before-answering is what eventually got labeled “thinking”. The pause you see is the model producing intermediate text it reads back before it replies.
Behavior analysts should recognize this immediately, because we already have a precise account of it. B. F. Skinner analyzed problem-solving as precurrent behavior. That is, behavior a person emits not to solve the problem directly, but to rearrange their own environment so that the solution response becomes more likely. You write the numbers down before you add them. You restate the question. You make a list. None of those response outputs are the answer. Rather, those behaviors change the stimulus situation so the answer becomes more probable.
That is exactly what “thinking” is here. The model emits precurrent verbal behavior (intermediate tokens) that alters its own stimulus context so the terminal response (the answer) becomes more likely. We have had a name for this since 1966. The name is not “thinking”.
A Short History: A Trick, Then a Product
The prompt-level discovery (2023). The first version of this was just a way of asking. Researchers found that adding a phrase as plain as “let's think step by step”, or showing a few worked examples, reliably pulled better answers out of models that already existed. Nothing about the model changed. The instruction simply got it to generate the intermediate steps that then were fed back into the model before it generated its next set of tokens.
Spending compute at answer-time. Once people saw that more intermediate steps meant better answers, the natural move was to treat computation-at-answer-time as a resource you could dial up or down. Sample several attempts and keep the best. Let the model check its own work and revise. Let it generate a long private scratch-pad before replying. All were variations on the same theme. Have the LLM do more generating before it commits to a final output.
The “thinking” label and reasoning models (2024 onward). The most recent step was training models specifically to do this well and automatically, rather than waiting for a user to prompt for it. Marketers ran with the all-too-easy-to-lean-into label of a “reasoning model”. And the scratch-pad they produce before answering is what interfaces now call "thinking" (sometimes shown to you, sometimes hidden, sometimes metered as a “thinking budget”). The underlying mechanism is still the 2023 trick just industrialized. The output feeds back in as input. It just does it a lot, and on its own.
The through-line: nothing about “thinking” required the machine to acquire an inner life or more “intelligence”. It required engineers to notice that generating more intermediate text before answering usually helped, and then to make that automatic.
