0:01 One AI model was trained on more text than you could read in hundreds of thousands of years. And it uses all of it for one job. A much bigger version of what your phone keyboard does. Guessing the next word. That one job writes emails, writes code, and runs inside every AI agent you've heard of. But if you think the model itself looks things up, or remembers you, or knows when it's wrong, you'll trust it with the wrong things.
0:33 Like checking your numbers, or this week's news. So how does guessing the next word turn into all of that? Let's open one up.
0:50 What a model is
Here's the plan. What a model is. What goes in, and what comes out. Then where the numbers come from, the settings you control, and one warning. So what is a model, really? It's a file. ChatGPT, Claude and Gemini keep their files locked away. But some you can download, like Google's Gemma. About sixty gigabytes, the size of a big video game.
1:19 And it runs with the Wi-Fi off. Open it up, and there are no words inside, no rules. Just numbers. About thirty-one billion of them. That's the 31B in its name. The biggest open models pass a trillion. These numbers are called parameters, or weights. Think of each one as a tiny dial. Everything the model does comes from how those dials are set.
1:48 To see how, let's follow one question through it.
1:55 What does it actually read?
First, what does it actually read? Take a question. Why did sales drop last month? The model never sees letters, or even quite words. The text is cut into pieces called tokens. Here, each word is a token, and so is the question mark. Seven in all. A rarer word gets cut into parts. Overthinking is two: over, and thinking. On average, a token is about three quarters of a word.
2:27 Each token is then swapped for its number in a fixed list. Gemma's list has about two hundred and sixty thousand tokens. That's its whole vocabulary. Everything it reads, and everything it writes, is made of these. And don't mix this up with the thirty-one billion. Those are the dials that do the choosing. This list is what they choose from, one piece at a time. And pieces join up, so it can still write words that aren't on the list.
2:58 And your question never goes in alone. The app puts it inside a form, with a part for instructions, a part for you, and an empty part for the answer. Your seven tokens become twenty-eight. And look: there's no date anywhere on this form. The model has no clock. Its reading stopped in January 2025, and it knows nothing after that. It only knows today's date if the app writes it in.
3:26 Claude's app does, in its instructions.
3:33 Here's what comes out of the model
So here's what comes out of the model. Not an answer. A score for every token in its list, for how likely it is to come next. Picture a wheel, where each token gets a slice as big as its score. For a question like ours, one token might take most of the wheel. Say, I. Others get slivers. And banana is too thin to see. The wheel spins, and lands on I.
4:01 I goes on the end. Now there's one more token, so the model takes another trip. And out comes a new wheel. This time it's less sure. I'm, I don't, and I can all get big slices. Spin, add, and go again. That's all writing is, for a model. Score, spin, add, repeat, one new token per trip. It stops when the wheel lands on a special end token.
4:32 A long answer is hundreds of trips. Reading your question, all twenty-eight tokens go in together, in one trip. Writing is one token per trip. On one of NVIDIA's desktop AI computers, Gemma read about fifteen hundred tokens a second, and wrote about seven. That's why answers appear word by word. And it's why writing costs more than reading. On Anthropic's price list, five times more.
5:05 How did thirty-one billion dials get set just right?
But how did thirty-one billion dials get set just right? Nobody set them by hand. They start out random. And random dials make a useless wheel. So you train it, with a fill-in-the-blank test. Take some real text, and hide the next word. Let the model spin. Then nudge every dial, very slightly, so the right word's slice grows. Then do it again. And again.
5:36 Google hasn't said how much Gemma 4 read. The Gemma before it read about fourteen trillion tokens. That's the kind of reading from the start of this video. To get good at that test, a model has to learn a lot. To finish, the capital of France is, it needs a fact. To finish a line of code, it needs to know code. So its knowledge isn't a list it looks things up in. It's patterns, stored in its dials.
6:07 But what comes out is a document finisher, called a base model. OpenAI showed this with GPT-3, before its assistant training. Asked to explain the moon landing to a six-year-old, it didn't answer. It wrote more requests just like it. So it's trained again, on examples of good answers, on people choosing the better of two, and on graded practice problems. This second round is called fine-tuning.
6:36 Ask again, and now it answers. Then training stops, and the dials are frozen. From then on, they never change.
6:50 When you build with a model, what can you change?
So when you build with a model, what can you change? Not the thirty-one billion dials inside. Those are locked. You get a few knobs, on the outside. One. Instructions. The top part of the form, called the system prompt. It's where an app says things like, be brief, and where it lists the tools the model can ask for. To the model, it's just more tokens at the front. Two. The conversation.
7:19 The dials are frozen, so the model remembers nothing between messages. Ask a second question, and the app sends the whole conversation again, from the first word, every time. Up to a limit, called the context window, which gets an episode of its own. Three. When to stop. Stopping is a guess too. Remember the end token: when the wheel lands on it, the answer's over. You can also set a maximum length.
7:47 Hit that first, and it stops mid-sentence. Four. Temperature. The wheel is spun, not read off. Ask our question four times, and you can get four different answers. Temperature sets how much chance goes into the spin. Turn it down, and the top slice swallows the wheel. All the way down, and it can get stuck, repeating itself. Turn it up, and the slices even out, so unlikely tokens get picked far more often.
8:18 But on the newest models, this knob is going away. Claude's API now refuses it, OpenAI drops it when its models think, and Google's newest Gemini ignores it. Which is knob five. Thinking. A reasoning model writes out its working before it answers, and you set how much, from low to max. More thinking is slower and costs more, but on hard problems it's a big jump. On a hard math exam, OpenAI's first thinking model scored seventy-four percent.
8:51 The model before it, twelve.
8:57 One last thing, and it's the most important
One last thing, and it's the most important. The wheel picks what's likely, not what's true. There's no step where it checks. In 2023, researchers asked GPT-4 to multiply three-digit numbers. It answered straight away, with numbers that look exactly right. About four times in ten, they were wrong. Today's models get those right. But give them five digits and no thinking, and they still often go wrong.
9:30 Confident, wrong answers like these are called hallucinations. OpenAI's own research says the way models are trained and tested rewards guessing over saying I don't know. So don't ask a model to be a calculator. Give it one. That's what tools are for.
9:53 How does guessing the next word turn into all of that?
So how does guessing the next word turn into all of that? To guess well across trillions of words, a model has to soak up how our writing works. Facts, code, reasoning and all, packed into a file of numbers. Then it runs that file one token at a time. Score, spin, add, repeat. Every answer, every line of code, every agent.
10:22 All of it is that one guess. Next: how a model uses tools.
