Modern AI products come covered in mode switches. Thinking mode. Tool use. Agent mode. The names make them sound like different AIs, or at least different brains, and the pricing pages encourage the impression. So it is worth saying the quiet part loudly before touring them: these are mostly not different brains. They are different conversation protocols, agreements between the app and the server about what gets sent and what comes back, running on the same weights through the same engine. Plain chat, the protocol this series has described so far, is the simplest agreement: question in, answer out, transcript grows. The last three parts of this series tour the others, starting with the one that looks most like magic.
The scratchpad
Switch on thinking mode and one thing changes: before writing its answer, the model writes a private scratchpad, reasoning text addressed to itself, and only then the reply you see. For our Paris question, the scratch notes might read: "User wants current weather. I cannot know this from my weights, they were frozen months ago. The app has offered a weather tool. I should ask for it." Then, separately, the polished visible answer.
Three plain facts take most of the mystery out of it.
First, thinking mode is often the same model with a switch flipped, not a smarter sibling. Often, not always: some products do route "thinking" requests to a different, larger model, but for many systems, including most open models you can run at home, it is one set of weights either way. The switch largely lives in Part 4's layer: the template wraps a section in thought markers, the way it wraps turns in role markers, and the model, trained on such conversations, fills that section with reasoning before it fills the answer section.
Second, the thoughts are not a different substance from the answer. They are predicted tokens, drawn one at a time from the same ranked lists as everything else in this series. The model is not pausing to think and then writing. Writing is the thinking, in the only sense available to a machine that continues text.
Third, you pay for them. Scratchpad tokens are generated tokens, billed and time-consuming like any others, and for a hard problem the private notes can dwarf the visible answer several times over. This is why thinking modes feel slower and cost more, and why apps handle the awkwardness of showing them differently: some collapse the thoughts behind a "thinking..." panel you can expand, some hide them entirely, some show you a tidied summary rather than the raw notes.
Why does writing notes help a next-word machine at all? The honest one-sentence answer, avoiding claims deeper than anyone can currently prove: writing the intermediate steps down puts them into the text the model conditions on, so each next word is built on the work so far, like doing long division on paper instead of in your head. For once, an analogy with no serious break in it.
The fate of the thoughts
Now for the part that this series exists to explain, because you will struggle to find it explained anywhere else. Part 3 established that the whole conversation is re-sent on every turn. So when your next message goes off, stapled to the transcript as always, a question arises that sounds almost childish: do the scratchpad notes go back too?
Systems disagree, and the disagreement is real engineering, not trivia. At the time of writing, some providers require the thoughts to be sent back while a multi-step job is in progress, Anthropic and DeepSeek among them. One, OpenAI, hides the raw thoughts from the app entirely and handles their persistence itself behind the curtain. And many home-built setups, wired together around the standard plug from Part 5, silently throw the thoughts away, so the transcript that gets re-sent contains only the visible answers.
The plain-language framing: does the assistant keep its scratch notes between steps of a job, or shred them after each reply? Neither policy is free. Keeping them makes the re-sent transcript meaningfully longer every turn, and Part 3 taught you exactly what that does to the desk and to the bill. Shredding them keeps the transcript lean, but during a multi-step task the model loses its own working notes between steps, like a mathematician whose paper is snatched away after every line. Which policy you are living under depends on which provider, app, and settings you happen to be using, and the difference is almost never surfaced to the person typing.
From my own testing: the one-letter loop. A 31-billion-parameter model was building me a small web app and got stuck on a single character, an identifier that needed a capital letter where it had written a lowercase one. It "fixed" the line with an edit identical to the original, was told nothing had changed, and repeated that exact edit more than 30 times in a row. With thinking mode off, this loop appeared in roughly half of my test runs. With thinking mode on: not once in 36 runs. The detail that stayed with me is that keeping the thoughts between steps added nothing measurable. Writing them was what mattered. Two identical files of weights, one invisible switch, and the difference between a tool that works and one that spirals. These systems' reliability can hinge on settings most users will never see.
Notice, too, what the scratch notes for Paris kept mentioning: a weather tool the app had "offered". That phrasing was careful. The model cannot check the weather, and neither can its thoughts. What it can do is ask, and the machinery of asking, the most consequential protocol of the lot, is next.
Next: Tools, Agents, and Other Conversation Tricks: how an AI "does" things when it cannot do anything, why an agent is a loop rather than a new kind of mind, and what is actually happening when models talk to each other.