Give it some text. This page trains a real language model on it — live, in your browser, with no server and no API. Then it opens the machine up and shows you every moving part: how it learns by counting, how it guesses the next word, how probability and proximity work together to produce a sentence. It shares its objective with ChatGPT — predict the next word — and a good deal of its maths. It does not share the architecture, and screen 6 is honest about exactly where the two part ways.
Whatever you write here becomes part of the training data for a language model being built on the screen. Write a few sentences.
Your name and text go to the presenter's screen. Nothing else is collected, and it's deleted within a day.
Whatever ends up here is the training data — the only thing this model will ever know. Same starting point as GPT, just a few thousand words instead of a few trillion. Everything stays in this browser; nothing is uploaded anywhere.
Use this opening drops in just the beginning, so you can add a continuation underneath. Load a full demo adds the opening plus five continuations — enough text for the model to get interesting straight away.
The first three are real books, long out of copyright — feed the model something the room already knows and its output is far easier to judge. The rest are original openings written for this tool.
"Training" sounds mysterious. Here it is literally: chop the text into tokens, then tally which token follows which. That tally is the model. There is no other secret.
A model never sees letters or words the way you do — it sees tokens. Ours are words and punctuation marks. Real models use roughly 4-character chunks, which is why 750 words ≈ 1,000 tokens and why you get billed per token.
Those "rules" are what this model knows. It is a lookup table: every pattern it stores, it saw. A frontier model holds over a trillion parameters, but they are not counts of anything — they are the settings of a function it learned by trial and error. More on that difference in screen 6.
Every square is a pair of words: the row is the first, the column is what followed. The greener the square, the more often that pair appeared. This grid is the model — there is nothing else inside it. Notice how much of it is empty: those are the combinations your text never used, and about which it knows precisely nothing.
This is the same kind of picture people show of a real model's parameters — except a frontier model has over a trillion of them, learned rather than counted, and no one can read any single one of them like this.
Pick any word in the text. This is the model's entire knowledge of that word: a list of what tended to come next, and how often.
An LLM does exactly one thing: look at the words so far and guess the next one. Then it adds its own guess to the words so far, and guesses again. That's it — that's the whole trick, all the way up to the biggest models on earth.
A model doesn't store words as letters — it stores each one as a position in space. Words used in similar company drift together, and nobody labels them: the geometry falls out of the counting. Now watch both halves at once. As it writes, the words it is choosing between light up on the map — so you can see it isn't picking from the whole language, it's picking from a neighbourhood.
Each word sits where the company it keeps puts it — a 2-D squash of a much higher-dimensional space. Real models give every word thousands of dimensions instead of two.
Generate a word and the candidates glow green on the map, sized by how likely each one is.
You just built a working language model. The only real difference between this and the thing on your phone is how much — more text, more patterns, more maths. Here's the gap, measured against your own text.
The numbers people never quite believe.
| ~20 million words | 1 GB | about 250 novels |
| 1,000 GB | 1 TB | ~20 billion words |
| 1,000 TB | 1 PB | ~20 trillion words |
| All of English Wikipedia | ~25 GB | a rounding error to a frontier model |
| A frontier training set | ~50–100 TB | most of the readable public internet |
Everything so far was real. This is a language model — roughly the kind that was state of the art around 2010, and the direct ancestor of what runs today. But it is not a small ChatGPT, and the difference is the most interesting thing on this page.
Don't take this on trust — measure it. Below is the sentence generated on screens 3 and 4, with every run of three words checked against the source text. Anything it truly made up would be a run that appears nowhere in the original.
The tiny model above can only replay what it read. Here the same opening words go to a real instruction-tuned model running on Cloudflare's network — and both answers get put through the identical verbatim check. Watch what happens to the copied-percentage.
| This model | A modern LLM | |
|---|---|---|
| Learns by | Counting what it saw | Adjusting parameters by trial and error |
| Stores | A lookup table | A compressed function |
| Context | The last 2 words | Thousands of words, weighed by attention |
| Can produce | Only what it has seen | Sentences that exist nowhere in its data |
| Word positions | Counted afterwards | Learned, and used to think with |
| Training | One pass, instant, free | Months, thousands of GPUs, millions of dollars |
Everything above is written to be shown on a screen. This tab is just for you — the controls, the order, and the moments that tend to land.
| Control | What it does |
|---|---|
| ← / → | Move between screens without touching the mouse. |
| Space | Generate one more word on the guessing machine. |
| [ and ] | Walk back and forward through the words it generated, one decision at a time. |
| Esc | Stop generating, or drop out of the walk-back. |
| P | Toggle present mode — larger type for projection. |
| Screen | What to do | The point it makes |
|---|---|---|
| 1 · Data | Load an opening, or paste something the room suggests. | A model is made of text somebody wrote. |
| 2 · Learn | Show the tokens, then the counts, then open one word's table. | Training is counting. Nothing was programmed. |
| 3 · Guess | Ask the room to call the next word before you reveal the bars. Then generate, then push temperature to both extremes. Finally walk back through the sentence word by word and ask why it chose each one. | It is a guessing machine, and the dial is its personality. The walk-back shows there was no plan — just one dice roll after another. |
| 4 · Decide | Generate with the map open. The candidates light up where they live. | Probability and proximity are the same machine. |
| 5 · Scale | Read the multiplier off the screen. | Part of the gap is sheer scale. |
| 6 · Limits | Run the verbatim check on the sentence you just generated, then close on "what had to change?" | The rest of the gap is architecture — it stopped counting and started learning. |
Cocoon's AI for Educators programme is built around exactly this approach: teaching AI by taking it apart, not by demoing chatbots. We bring the activities, the framing and the follow-up.