LLMs Unplugged

Understand AI by building it yourself

Open with the promise: understand AI by building one yourself, by hand. No computers, no maths background needed.

Before you start — four habits that shape how the room experiences this.

Don’t apologise for explaining things. “Sorry, this bit’s a little dry”, “bear with me” — it tells the room the next few minutes are something to be endured, and they’ll oblige. The explanations are the reason they came. Deliver them like it.

Don’t call anything “the fun part”. It’s the same problem in reverse: naming one section fun says the others weren’t. Everything here is the good bit — the tallying, the dice, the arguing about AGI at the end. Say what’s coming next, not how they should feel about it.

Flip questions back before you answer them. There’s real expertise at the front of this room and it’s tempting to use all of it. But a clarifying question (“what draws you to that?”) or a turn to the room (“has anyone else hit this?”) usually gets somewhere more interesting, and it keeps them participants rather than an audience. Answer second, not first — you’ll still get to.

Let them experience it, then ask what came up. The activities do the teaching. After each one there’s a reflection slide; the temptation is to fill the silence with the point you wanted them to reach. Wait instead. Them saying “the training text really shapes what comes out” is worth far more than you saying it.

Acknowledgement of Country

activity

everyone stand up

sit down if you have

never used ChatGPT/Claude

sit down if you haven’t

used it in the last month

sit down if you haven’t

used it in the last week

sit down if you haven’t

used it in the last day

sit down if you haven’t

used it in the last hour

sit down if you haven’t

used it in the last 5 minutes

What is this about?

you’ll build your own language model—from scratch—with just a kids book, pen & paper, and some dice rolling

you’ll learn how language models work by spotting patterns in text to generate new text

llmsunplugged.org

Training

The recipe

walk through your text and tally up which tokens follow which in a grid

Example

“Run, Spot, run. See Spot run.”

after tidying up:

run , spot , run . see spot run .

The empty grid

run,spot,run.seespotrun.

Token	`run`	`,`	`spot`	`.`	`see`
`run`
`,`
`spot`
`.`
`see`

Training: `run` → `,`

run,spot,run.seespotrun.

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|
`,`
`spot`
`.`
`see`

Training: `,` → `spot`

run,spot,run.seespotrun.

Token	`,`	`spot`
`run`	\|
`,`		\|
`spot`
`.`
`see`

Training: `spot` → `,`

run,spot,run.seespotrun.

Token	`,`	`spot`
`run`	\|
`,`		\|
`spot`	\|
`.`
`see`

Training: `,` → `run`

run,spot,run.seespotrun.

Token	`run`	`,`	`spot`
`run`		\|
`,`	\|		\|
`spot`		\|
`.`
`see`

Training: `run` → `.`

run,spot,run.seespotrun.

Token	`run`	`,`	`spot`	`.`
`run`		\|		\|
`,`	\|		\|
`spot`		\|
`.`
`see`

Complete model

run,spot,run.seespotrun.

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

A few more tips

the last token in one sentence is followed by the first token in the next (even over the page)

you can ignore quotation/speech marks (")

work in pairs and divide the labour however you like—but don’t neglect the tally marks

Training

10:00

The language of language models

model
token
weights

Generation

The recipe

use your grid to generate new text, rolling dice to choose each next word

Generation: start with `see`

see spot

one option — no roll needed

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: from `spot`

seespot

2 options — roll the die!

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

How the die chooses: `spot`

spot → ? roll a d10

012345

run 1 tally

6789

, 1 tally

equal tallies → equal chances

How the die chooses: `spot`

spot → ? roll a d10

012345

run 1 tally

6789

, 1 tally

equal tallies → equal chances

rolled 7 → ,

Generation: `spot` → `,`

seespot ,

rolled 7 → ,

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: from `,`

seespot,

2 options — roll the die!

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: `,` → `run`

seespot, run

rolled 2 → run

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: from `run`

seespot,run

2 options — roll the die!

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

How the die chooses: `run`

run → ? roll a d10

0123

, 1 tally

456789

. 2 tallies

more tallies → more faces → more likely

How the die chooses: `run`

run → ? roll a d10

0123

, 1 tally

456789

. 2 tallies

more tallies → more faces → more likely

rolled 6 → .

Generation: `run` → `.`

seespot,run .

rolled 6 → .

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: from `.`

seespot,run. see

one option — no roll needed

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generation: back to `see`

seespot,run.see

one option — no roll needed

Token	`run`	`,`	`spot`	`.`	`see`
`run`		\|		\|\|
`,`	\|		\|
`spot`	\|	\|
`.`					\|
`see`			\|

Generated text

“see spot, run. see”

a new sentence — not in the training data!

Generation

10:00

Shareback

The language of language models

prompt
completion
hallucination

Pre-trained generation

Pre-trained generation

8:00

Shareback

The language of language models

open weight model

Everyday sense first, then ours: the weights are the numbers inside the model — for the booklet, the tallies you’d count to work out what comes next — and open weight means anyone can have a copy of those numbers. The booklet is the clearest version of that we’ll get: take it home, read every number in it, generate from it at the kitchen table, and no-one can switch it off or quietly change it under you. Most of the chatbots they use are the other arrangement — your text goes to someone else’s computer, an answer comes back, and the weights never leave the building. If anyone pushes: open weight isn’t open source (you get the numbers, not the training text or the code that made them), and it isn’t the same as being able to run it — a real open weight model wants a serious machine, where the booklet wants a d10.

Agentic AI

The recipe

an agent is a model that can call tools: pause generation, get information from “outside” the model, and continue

generate from your model as before, but every punctuation token triggers a tool call: a real text message to 3 friends/group chats

Worked example

your text so far is “the cat sat”, and the next dice roll gives you . as the next token—pause, that’s a tool call

text What comes next? "the cat sat..." to 3 friends/group chats; the first reply back might be “down by the river”

write down by the river, then the . you rolled anyway, and continue generating from .

Agentic AI

10:00

Shareback

What did the tool calls add that the bare model couldn’t — fresh, outside information? Did the friends’ words fit the text, or derail it? Invite ~5 groups to share back rather than the whole room. ~5 min.

Worth pushing on if the room is up for it: they have just been the harness — they decided when to pause, who to ask, and what to splice back in. Take that away and you have an agent acting on its own, which is most of what “agentic AI” means in the coverage they’re reading. So what would you be comfortable letting it do without asking you first? Answers get specific fast — booking something, sending an email on their behalf, moving money, writing to a system of record — and the interesting part is usually not the task but where they draw the line and why: reversibility, who gets blamed, whether they’d notice a mistake. Don’t resolve it; a tidy conclusion would waste the question.

The language of language models

agent/agentic loop
tool call

Scaling up

The reassurance beat: what they built isn’t a cartoon of an LLM, it’s the real mechanism at human scale — look at the context, weigh every possible next word, roll the dice, write it down, repeat. So what’s actually different?

Four beats, one slide each: their grid cannot be scaled (one slide of failure, run against their own grid), the one change that fixes it (shared numbers instead of dedicated tallies), the payoff (every dial turned up, and turning them up keeps working), and the one difference that isn’t about size at all (which text, not how much). Then the closer. Don’t land “and that’s the difference” early — the shared-numbers slide is the hinge, and it only pays off if the failure has been left unresolved. Every one of these has a lesson on the website that does it properly — name that rather than explaining. ~5 min.

One slide of failure, and both obvious fixes fail for the same reason, so run them against the grid they built. Open from the moment they just lived: stuck on a comma, rolling dice, because every comma in the text looks identical — one word of context is all a grid gets. Somebody always asks why not look at two words, and you want that question: the price of a second word is the whole vocabulary again, one row per pair of words. The table squares. (Two words is a trigram, you can absolutely build one, and there’s a lesson on the website that runs one with pen and paper.)

So maybe the fix is reading more. This is Frankenstein at true scale — in the 2-hour run it’s the booklet they just generated from, so name it as that; otherwise one clause is enough: a whole novel, about 84,000 words, 7,023 distinct, so 49 million cells. The gold speck is every word in the book. Read the entire novel and you have filled 0.08% of the table — one cell in twelve hundred. The rest are empty, and empty means impossible.

Now the surprise, and it’s measured, not rhetorical — their own tool, run on the first 5% of the novel and then on all of it. Twenty times as much text, and the grid did not get fuller. It got emptier: 0.20% of cells filled, down to 0.08%. Say why, because it’s the whole point: new text brings new words as well as new pairs, and every new word adds a whole row and a whole column. The table grows by squares while the tallies arrive one at a time. That’s a race a grid loses forever — and remember the other fix wanted to square this table.

Leave it broken. The question to walk off with, because the next slide answers it: if reading more can’t fill a table, what is a real model doing instead?

Shared numbers

“it wrote something genuinely new—how?”

Token	`the`	`cat`	`sat`	`.`	`ran`	`dog`
`the`	0.03	\|\| 0.46	0.04	0.02	0.04	\| 0.41
`cat`	0.04	0.01	\| 0.48	0.03	\| 0.42	0.02
`sat`	0.12	0.02	0.01	\|\| 0.78	0.04	0.03
`.`	\|\| 0.82	0.05	0.03	0.02	0.04	0.04
`ran`	0.11	0.03	0.03	\| 0.77	0.02	0.04
`dog`	0.05	0.02	\| 0.46	0.03	0.40	0.04

the dog ran isn’t in this text, so your grid rates it impossible

a real model rates it 0.40—not more numbers, shared numbers

Ask before you explain: has anyone had one of these produce something that genuinely surprised them — something it couldn’t have been copying? Take an example from the room if you get a good one; this slide is the answer to it, and to the question the last slide left hanging.

A different text, so set it up in one breath: three sentences, cat and dog doing exactly the same job. Then the ringed cell. Your grid tallies cat followed by ran but never dog followed by ran, so that cell is empty, and empty means impossible: it will never say “the dog ran”, a sentence you know is perfectly fine. Every cell is its own little island — nothing the grid learnt about cat reaches dog — and that islanding is exactly why reading more didn’t help: every tally you make pays for one cell and no other.

Be precise about what changes, because a tally is a perfectly good parameter — their novel-grid is a model with 49 million of them. The difference isn’t how many numbers you have, it’s what each one is for. A grid gives every number one job: count one pair, serve no other. A transformer spreads every pattern across billions of numbers, each nudged a tiny amount after every wrong guess in training, and because cat and dog turn up in the same kinds of places they end up leaning on the same numbers. One sentence about a cat now pays for a sentence about a dog, and the model can fill a cell it never saw. (The filled-in grid on screen is illustrative, not measured — the shape is the point.)

That sharing is the hinge of the whole section: it’s what turns “more” from useless into worth having, and it’s the reason an LLM isn’t a very large phrasebook — it says things nobody ever wrote. The cost, if it comes up: there’s no longer a cell to point at, so “where does it store the dog ran” has no better answer than “smeared across a few billion numbers, and we’re still working on reading it back”. That’s most of what interpretability research is.

Now turn everything up

context how much it looks at before each guess

1 word the whole conversation

training text how much the model reads

one novel 15 trillion tokens

model size how many learned numbers it contains

49 million cells ~1 trillion parameters

three independent dials · none determines the others

with shared numbers, turning the dials up just keeps working

Ask before you explain, because this slide is where their most common complaint lives: hands up if you’ve told one of these things not to do something and it did it anyway. Take two answers. Then the honest account: your instruction didn’t fall off the end of a one-word window — it’s in the context, all of it, every time. It’s one more stretch of text competing with everything else in the window, weighted rather than obeyed: “it read your instruction and something else won”. What the model is looking at right now is all that shapes what comes next — that much their grid taught them straight.

Then the three dials, briskly, because the bars carry them. Context: one word for their grid, the whole conversation for Claude — and no squared table to pay for it, because there is no table; that’s what shared numbers bought. Training text: fifteen trillion tokens is the published figure for a recent open model’s training run — about 180 million copies of this novel, roughly 5.7 million years at the pace they just worked — and none of it is wasted filling one cell each, because every token nudges numbers shared with everything else. Model size: about a trillion parameters is the right order of magnitude for a frontier model (the exact figure for the closed ones is unpublished, so “about that, and nobody outside will tell you” is the honest answer) — and a trillion parameters is not a trillion-cell grid, which we’ve just seen would be empty.

Then the line the slide is for, and it’s the strangest fact in the section: turning these dials up just keeps working. Make the model bigger, feed it more text, let it look at more — and it gets better in a way you can measure, predictably enough to plan a training run around. Nobody fully knows why that keeps holding, and that measured regularity, more than any single clever idea, is why the last five years of AI happened. Each dial has a lesson on the website that does it properly — name that rather than explaining.

you ask your grid: “what is the capital of France?” “see spot, run. see”

it isn’t refusing to answer—answering isn’t a thing it does

the fix isn’t a bigger dial—it’s more training, on text made of conversations

The dials are done, and this is deliberately not a fourth — it isn’t about how much, it’s about which text. Say that as you arrive: “and one thing that isn’t a matter of size at all”.

No heading — the line is “let’s ask your grid a question”, and the slide just shows what comes back. Feed their model a question and it does what it always does: continues. It isn’t being unhelpful and it isn’t broken; nothing in “tally which word follows which” has any notion of a question and an answer. This is the honest state of a model that has only ever been trained to continue text — and it’s also, near enough, what a frontier model looks like straight out of pre-training: their problem, with better grammar. Turn all three dials to the maximum and you still get this.

Then the second line. What turns it into something that answers you is post-training: a second, much smaller round of the same training on transcripts of conversations, plus feedback on which answers people preferred. Tally text off the web and what follows a question mark is usually another question; tally conversations and what follows it is the start of an answer. The mechanism hasn’t changed — same predict-the-next-word loop, same dice — just different text to learn from, so different habits on top.

One aside, if the room is with you and you’re not behind. “Feedback on which answers people preferred” is where sycophancy comes from: ask who’s had one of these cave the moment they pushed back, agreeing when they were the one who had it wrong. Raters, faced with two replies, tended to prefer the agreeable one, so agreeing got reinforced — and nowhere in any of this is a fact marked true or false. Agreement from one of these is not evidence you were right. It’s a good moment, but it’s a second point; the slide stands without it.

still just tokens in → tokens out

Questions

is there a term you’ve heard—that we haven’t covered?

what new questions do you have about large language models?

how will this change the way you think about and use LLMs in the future?

Three questions, revealed one at a time, easiest first. Don’t put them all up at once — the third one lands differently after the room has already been talking.

Open on the terms question. It’s the lowest-stakes way into the Q&A: naming a word you’ve heard is easier than forming a question, and it surfaces what they’ve actually been reading. Have prompts ready if the room is slow — data centre, the stack, transformer, agent, AGI — and expect AGI, which is worth making room for rather than batting away.

When a term comes up, put it back to the room before you answer it: “does anyone else know this one, or have a sense of what it means?” You get to hear what they think it means, which is usually the more interesting problem, and it keeps the session from collapsing into expert-at-the-front. Then give your answer.

Same move when a question is really an opinion in disguise (is this taking jobs, is the rollout being handled badly, is any of this worth it). A clarifying question first — what draws you to that, is it a particular industry — gets you a much better conversation than a confident answer to the wrong question. You can still give the technical view; give it second.

Bring up the second question once terms thin out, and the third only when the questions are genuinely running down. That last one turns the session outward, from what the grid does to what they’ll do differently on Monday, and it’s the closest thing this workshop has to a point.

anu.au1.qualtrics.com/jfe/form/SV_cA2ioVFWoQRj0KW

Next sessions

Wednesday 16 September 12:00–14:00
Wednesday 25 November 16:00–18:00

Innovation Space, Birch Building, ANU

No public sessions are scheduled right now — get in touch to arrange one.

events.humanitix.com/host/anu-cecc-school-of-cybernetics

LLMs Unplugged#

Understand AI by building it yourself#

Acknowledgement of Country#

What is this about?#

Training#

The recipe#

Example#

The empty grid#

Training: run → ,#

Training: , → spot#

Training: spot → ,#

Training: , → run#

Training: run → .#

Complete model#

A few more tips#

Training#

The language of language models#

Generation#

The recipe#

Generation: start with see#

Generation: from spot#

How the die chooses: spot#

How the die chooses: spot#

Generation: spot → ,#

Generation: from ,#

Generation: , → run#

Generation: from run#

How the die chooses: run#

How the die chooses: run#

Generation: run → .#

Generation: from .#

Generation: back to see#

Generated text#

Generation#

Shareback#

The language of language models#

Pre-trained generation#

Why do it again?#

The recipe#

Pre-trained: start with The#

Pre-trained: from cat#

Pre-trained: from sat#

Pre-trained: from .#

Pre-trained: from The again#

Pre-trained: from dog#

Pre-trained generation#

Shareback#

The language of language models#

Agentic AI#

The recipe#

Worked example#

Agentic AI#

Shareback#

The language of language models#

Scaling up#

Shared numbers#

Now turn everything up#

Questions#

Next sessions

We’re here to help#

LLMs Unplugged

Understand AI by building it yourself

Acknowledgement of Country

What is this about?

Training

The recipe

Example

The empty grid

Training: `run` → `,`

Training: `,` → `spot`

Training: `spot` → `,`

Training: `,` → `run`

Training: `run` → `.`

Complete model

A few more tips

Training

The language of language models

Generation

The recipe

Generation: start with `see`

Generation: from `spot`

How the die chooses: `spot`

How the die chooses: `spot`

Generation: `spot` → `,`

Generation: from `,`

Generation: `,` → `run`

Generation: from `run`

How the die chooses: `run`

How the die chooses: `run`

Generation: `run` → `.`

Generation: from `.`

Generation: back to `see`

Generated text

Generation

Shareback

The language of language models

Pre-trained generation

Why do it again?

The recipe

Pre-trained: start with `The`

Pre-trained: from `cat`

Pre-trained: from `sat`

Pre-trained: from `.`

Pre-trained: from `The` again

Pre-trained: from `dog`

Pre-trained generation

Shareback

The language of language models

Agentic AI

The recipe

Worked example

Agentic AI

Shareback

The language of language models

Scaling up

Shared numbers

Now turn everything up

Questions

We’re here to help