One door or the other, you've been sending your words somewhere. This last lesson answers what actually happens to them — so the last of the worry, the whole reason this course exists, can finally go.
This is worth being completely unambiguous about, because it's the single biggest fear this course set out to remove. Go back to Lesson 2: using it teaches it nothing.
The floor is painted once, by the makers, long before it ever reaches you. Talking to it is inference, not training — a coin dropping through a floor that is already finished and dry. It cannot quietly learn your secrets. It cannot rearrange itself around your conversation. The model answering you right now is structurally, mechanically incapable of changing because you used it. That part isn't a policy or a promise. It's just how the model works.
Here's the nuance. The model itself can't learn from you live — but the company running the servers behind whichever door you used can still keep a copy of what you typed, the way any website can log a form submission.
Whether they do, and what they do with it afterward, is a disclosed business choice, not a fact about the model. A copy might be kept briefly for abuse monitoring. It might, per the product's own stated policy, be used later — in bulk, well after the fact — to help shape a future, different model. Or it might never be kept at all. This is exactly why Lesson 9's "which door" question matters here too, not just for price.
You'll see this phrase, or its short form ZDR, on pricing and policy pages. It's a specific, contractual promise: the provider keeps no copy of what passed through after the reply is sent — not for training, not for review, not at all.
It's a stronger guarantee than "we won't sell your data" — it means there is nothing left to sell, review, or leak, because nothing was retained in the first place. This is the standard orqo itself is built on: split-plane by design, so the control plane holds none of your content at rest. The full, detailed version of exactly how is laid out on our security page, if you want it.
One instinct covers almost every case: treat a free public chat tool like a postcard, not a locked drawer, unless you've confirmed otherwise.
Fourteen lessons ago this started with a wooden machine — coins, pegs, a shape that appears on its own. Everything since has been the same model, opened up a little further each time.
That was always the point, more than any single fact in the table above. Not to make you an engineer — to make the mystery smaller than the fascination. A model is a structure. Weights are what it learned. Tokens are its alphabet. Scale is just more of the same idea. A mistake is a stray pick, extended with nothing to check it. A prompt is where you pour. An API is a door. And what you type is safer than the fear made it feel, once you know exactly what "safe" is actually promising.
This course is built to keep growing — new lessons, deeper detours, whenever there's more worth explaining this same way. For now, this is everything, start to finish. Thank you for reading it.
The wooden machine from the first paragraph above is real, and it has its own history worth reading — Francis Galton, 1874, a glass box of falling shot. Visit the Galton board page.
Everything from the lessons before this one, plus what this lesson added.
| The board | The word for it |
|---|---|
| The board and its pegs | The structure — the model |
| A single peg | A neuron |
| A single step from one peg to the next | A connection |
| How red or blue a patch of floor is | A weight — a parameter |
| The whole painted floor | The trained model |
| Boards stacked, one on the next | Layers — "deep" |
| Smearing the floor in, coin by coin | Training |
| Dropping one coin through a finished board | Using it — inference |
| Which slot you pour into | Your input — your prompt |
| The bins, relabelled with tokens | The vocabulary — every token it could pick |
| The tallest pile among the bins | The prediction — the likeliest next token |
| Feeding the growing line back in and running again | The loop — how one guess becomes a sentence |
| One bin's label, precisely | A token — not always a whole word |
| How many bins there are, in total | Vocabulary size — tens of thousands |
| The size of the mountain of text it was shown | Training data — measured in tokens |
| A bin's own address, plotted in space | An embedding — meaning turned into a list of numbers |
| How close two addresses sit | Similarity — how related two things are |
| The measurement's real name, out in the wild | Cosine similarity — same idea as similarity, different name |
| About meaning, not exact spelling | Semantic |
| A neighbourhood of addresses that share a topic | A domain — a cluster of related meaning |
| Scanning every address for whichever one sits closest to a new point | Nearest neighbor — the closest real match to a computed point |
| A small, separate machine that only plots words as points — it never writes a sentence | An embedding model — not the same as a language model |
| The total number of coloured patches, across every board | Parameters — the number people quote |
| How many tokens the funnel can hold in one pour | Input tokens — the context window |
| How many tokens come back out | Output tokens — what it writes back |
| Everything you've met so far, built at real-world size | A Large Language Model — an LLM |
| A shorter pile winning, extended forward with full confidence | A hallucination |
| The point where the training reading stopped | The knowledge cutoff |
| How sharp or blended the colour stays before a coin is poured | Temperature — the dial on how often a stray pick wins |
| Pouring the same slot twice, not always the same pile | Non-deterministic — same input, no guaranteed identical output |
| Background, examples, or a role, added right into the pour | Context |
| Asking for many small steps instead of one big leap | Chain-of-thought prompting |
| A friendly chat window built around the board | A product — like ChatGPT or Claude.ai |
| A door that lets software pour in and read out directly | An API |
| What each million tokens costs to send in or get back | API pricing — pricier for bigger models, and for output |
| Recalling the start of the line instead of re-pouring it | Cached tokens — priced far cheaper than fresh input |
| The board asking the app to go do something real before it answers | Tool use — or function calling |
| One shared shape for listing tools and calling them | MCP — Model Context Protocol |
| A program that speaks that shape and hands back its whole toolbox | An MCP server |
| The loop deciding, acting, and watching what happened, on repeat | An agent — a model with tools, looping until the goal is met |
| Deciding its own steps, and knowing when it's done | Autonomy |
| Reading what just happened before deciding what's next | Reactivity |
| Starting on its own, from a schedule or an event | Pro-activeness |
| Talking to other agents, and to people, not just tools | Social ability |
| Search first, hand the model what you found, then let it answer | RAG — Retrieval-Augmented Generation |
| Folding the search step into the loop, so it can search again if needed | Agentic RAG |
| The first, giant reading pass, before the floor is fine-tuned at all | Pretraining |
| A second, much smaller painting pass, aimed at a narrower target | Post-training — or fine-tuning |
| A person ranking draft answers, best to worst | RLHF — Reinforcement Learning from Human Feedback |
| A small helper trained to predict which answer people prefer | A reward model |
| Making a model's behavior actually match what people want | Alignment |
| + New in this lesson | |
| A promise that nothing sent through is kept, even briefly | Zero Data Retention — ZDR |
| Whether a transcript might later help train a future version | A data-usage policy — check the settings |
53 rows now. It keeps growing as the course goes on.