Yesterday you watched the whole trip: your question in, an answer out. Today we open the box in the middle — the part that actually decides what to say.
Yesterday you watched the whole trip: your question in, an answer out. Today we open the box in the middle — the part that actually decides what to say.
Yesterday we walked the whole trip from your question to an answer. Today we stop inside one box — the guessing machine — and find out how it actually decides what comes next.
Every connection between the dots has a strength — turn it up or down and it changes what comes out the other side. Those adjustable strengths are what we’ll spend the rest of today on.
Artificial neurons borrow a loose idea from biology. They are mathematical functions, not little brain cells in a computer.
Somewhere in there are billions of tiny dials called weights. Training turns them, a little at a time, until useful patterns get more likely. No single dial holds a fact, a sentence, or a page of your textbook — the sentence isn’t “in” the machine anywhere you could point to. A study helper built this way couldn’t quote your textbook back to you word for word, even though it learned an enormous amount from books like it.
The proper word for one of these dials is a parameter. When people say a model has “70 billion parameters,” that’s what they mean — 70 billion dials, all tuned during training.
stores the exact words, you can pull them back out unchanged
stores a pattern spread across millions of dials, not the exact words
That’s the whole training loop. Show it an example, let it guess, tell it how wrong it was, and nudge every dial a hair in a better direction. One nudge barely matters. Billions of nudges is how a machine ends up sounding like it knows what it’s talking about.
The plain version is above. The technical version: it works out which direction of nudge would have made the guess less wrong, then moves the dials that way, just a little. That method has a name — gradient descent — because the error signal points “downhill” toward less-wrong, and training just keeps walking downhill.
Training room
billions of times, before you ever showed up
Answering room
just now, once
A toy version of the machine guessed the wrong word. It doesn’t scrap itself and start over — same as if your tank turret aimed off-target, you wouldn’t rebuild the whole gun, you’d adjust one gear a notch. Guess which dial you’d nudge, and which way, before we show you.
Point at the dial you’d turn, before we reveal which one actually moves.
Only the dial connected to that particular guess moves, and only a little. Training nudges one small piece at a time, never a full rebuild after one wrong answer.
Imagine sorting every word you know onto a floor — not alphabetically, but by what it means — so “wolf” ends up near “dog,” and “bicycle” ends up somewhere else entirely. That’s roughly what the model does with every piece of your sentence, except its floor has hundreds of directions instead of two.
The spot on the map is really a long list of numbers — hundreds or thousands of them. That list is called a vector, and giving something this kind of numeric address is called an embedding.
King and queen land close together. So do prince and princess. Banana sits off on its own, because it isn’t used the same way in sentences. That’s the whole idea — closeness on the map means “used similarly,” not “looks similar.”
The address for each word is really a list of hundreds or thousands of numbers. Each number is one direction on the map — the whole list is called a vector, and each number in it is a dimension. Word-arithmetic tricks you may have heard about (king − man + woman ≈ queen) are a fun but oversimplified way people talk about this.
Just a simplified picture. The real map has far more room to spread out than a flat page does.
Lay out word cards — wolf, dog, bicycle, car, happy, furious — on the floor, so words with similar meanings end up standing closer together.
Most rooms put wolf near dog, and bicycle near car, without agreeing on exact distances. Relative closeness is the real answer, not any one fixed layout.
Same words, different order, totally different meaning — “the tank fired before it moved” isn’t “the tank moved before it fired.” The machine has to track order, not just which word-pieces showed up. To do that, it tags every piece with a position marker — a bit of extra number-information glued onto that piece’s spot on the meaning map, saying “you’re 1st,” “you’re 2nd,” and so on.
When you read “The animal didn’t cross the street because it was tired,” you instantly know “it” means the animal, not the street. The machine has to work that out too — for every word, not just pronouns. The trick it uses is called attention: each piece looks back at every earlier piece and decides how much each one matters to it, right now.
In technical terms, a token produces something called a query; earlier tokens expose keys and values. The query gets compared against every key, and whichever ones look similar get more weight. The weighted mix of values becomes this token’s new, richer understanding of itself.
“The trophy would not fit in the suitcase because it was too large.” Now swap “large” for “small.” Say out loud which one “it” means, before we check — and notice your answer flips even though only one word changed.
This is exactly the kind of call attention makes inside the model. Flip back to the attention slide if you want the mechanism, not just the fact that it happens.
The trophywould not fitin the suitcasebecauseitwas toowas toolarge.
The trophywould not fitin the suitcasebecauseitwas toowas toosmall.
Most people flip their answer the moment “large” becomes “small.” That flip is the point: the model has to track meaning, not just grammar, to get pronouns right.
It doesn’t just ask one question about your sentence — it asks several different questions about it in parallel. One pass might track grammar, another might track which noun a pronoun points back to, another might just track position. Each of these parallel questions is called an attention head.
A transformer — the design most language models use — takes its current understanding of the sentence, mixes in the attention connections, reshapes it a bit, and hands a richer version to the next round. It does this dozens of times before it ever picks a word.
That “running memory” has a name — the residual stream. Each pass writes updates into it without erasing what was there before, so early information doesn’t just get overwritten and lost.
That’s the whole trip, start to finish. Split the text into pieces, give each piece a spot on the meaning map, let the trained dials weigh in on what fits, score the options, and pick one. Then do the entire thing again for the next piece.
The proper names, if you want them: the pieces are tokens, the map-spot is an embedding stored as a vector, the dial-checking step (attention plus repeated passes) happens inside something called a transformer, and the scores are called logits.
the cat sat
Vectors
Transformer layers
Scores
mat
All those dial-checks and nudges eventually turn into one very boring-sounding operation, done an enormous number of times: multiplying a grid of numbers by another grid of numbers. Special chips exist just to do that specific job, over and over, insanely fast.
That operation is called matrix multiplication, and a “matrix” is just the grid. AI chips are built to do many of these multiplications and additions in parallel — which is why a chip’s design ends up mattering almost as much as the model’s design.
More data, more computing power, more dials can make a model noticeably better — sometimes at things smaller versions of it couldn’t do at all. A better score on a test still doesn’t tell you whether anything like experience is happening in there.
task performance changes with model, data, training, and compute
whether what’s happening inside adds up to anything like human understanding
Researchers can trace some of the signals inside and find out what a particular pathway responds to. Nobody can yet walk through a very large model step by step, the way they can walk through code someone wrote by hand.
The plain version is above. The research field trying to change that is called mechanistic interpretability — it studies activations and features and runs deliberate experiments to work out what’s happening inside. The map is still nowhere near complete.
This is the whole trip inside the model. Cover the arrows and explain each stop yourself, in your own words — if you can do that, the black box is a lot less black.
Hang onto that question — it’s the right one. Tomorrow: how to pick the right machine for the job you actually have.