The whole machine

27 parts. 35 connections. One page.

If you have not seen any of this before, start on the machine, which opens one stage at a time and explains itself as it goes. This page is the same 27 parts with nothing folded away, for when you want the whole wiring diagram in front of you at once.

Click a part to read it in the panel on the right, which also lights up every connection running into and out of it. Or press Watch a question move through and follow one ordinary question through the machine a step at a time, from pressing enter to the answer arriving, watching the context window grow as it goes.

Follow one typed question all the way from pressing enter to the answer coming back. 21 steps, in four phases, and you can stop at any of them.

The question I have a few days off in November. Where should I go?

Build

A pile of text becomes a file of numbers. Happens once, months before you arrive, and never again.

Assemble

Your question, the standing rules and anything looked up are joined into one long piece of text.

Run

The file of numbers runs over that text once and produces the next small piece of the answer.

Loop

Ordinary code repeats the whole thing, deciding each time what text goes back in.

Constrain

How anyone checks whether the answers are any good, and what stops the system doing harm.

The map needs JavaScript to be explored. Everything it encodes is below: the parts, what flows between them, and what governs that flow.

The parts. 27 components in three regions.
Part	Region	What kind of thing it is	What it is
Training data	Built	A thing that exists and holds state	All the text a model reads while it is being made
Tokens	Built	Changes what passes through it	Text cut into small numbered pieces a computer can count
Embeddings	Built	Changes what passes through it	Each piece becomes a list of numbers. Similar pieces, similar lists
Parameters	Built	A thing that exists and holds state	The billions of numbers inside a model that training adjusts
Training	Built	Changes what passes through it	Guess the next piece of text, measure the miss, adjust everything
Post-training	Built	Changes what passes through it	Extra training that makes it answer you instead of continuing your sentence
Scale	Built	Not in the flow: it shapes the flow	More data, more numbers, more computing, and what that buys
The weights	Junction	A thing that exists and holds state	The finished model: one large file of numbers that never changes
Interfaces	Run	Changes what passes through it	Chat window, API, SDK or MCP: four doors to one model
Markdown files	Run	A thing that exists and holds state	Plain text files of standing instructions, pasted in every turn
The prompt	Run	Changes what passes through it	Everything joined into one block of text, labelled with who said what
Retrieval	Run	Changes what passes through it	Looking up the right paragraphs and pasting them in before answering
Memory	Run	Changes what passes through it	Notes saved after one session and pasted back in at the next
Tools	Run	Changes what passes through it	Functions your own program runs when the model asks for one
The stores	Run	Ordinary storage, read before the model runs	Four ordinary kinds of storage, all of them outside the model
The context window	Run	A thing that exists and holds state	Everything the model can see this turn. Nothing outside it exists
The forward pass	Run	Changes what passes through it	One run through every layer, scoring every possible next piece
Reasoning	Run	Changes what passes through it	Working out loud first, which is more text through the same loop
Sampling	Run	Changes what passes through it	Picking one piece out of the odds, which is why answers vary
Attention	Run	Not in the flow: it shapes the flow	How each piece works out which earlier pieces matter to it
Cost and latency	Run	Not in the flow: it shapes the flow	What you actually pay for, and why it feels slow
Context engineering	Run	Not in the flow: it shapes the flow	Deciding what goes in the window, and what stays out
Context sharding	Run	Not in the flow: it shapes the flow	Splitting the work so no single run has to hold everything
Agents	Run	Not in the flow: it shapes the flow	A model in a loop, with tools and a goal
Orchestration	Run	Not in the flow: it shapes the flow	Arranging many runs, one after another or side by side
Evaluation	Run	Not in the flow: it shapes the flow	How you know it worked, and the ways it fails
Guardrails	Run	Not in the flow: it shapes the flow	Limits on what it may do, so mistakes stay small

What flows. 25 data connections.
From	Carries	To
Training data	raw text	Tokens
Tokens	token ids	Embeddings
Embeddings	vectors	Parameters
Parameters	values to adjust	Training
Training data	text to predict	Training
Training	a trained file	Post-training
Post-training	the file that ships	The weights
The weights	loaded into memory	The forward pass
Tokens	the same vocabulary, applied to your text	The context window
Interfaces	your request	The prompt
Markdown files	standing rules	The prompt
The stores	passages	Retrieval
The stores	saved facts	Memory
The prompt	one flat string	The context window
Retrieval	passages	The context window
Memory	facts	The context window
Tools	tool results	The context window
The context window	the whole sequence	The forward pass
The forward pass	a probability for every token	Sampling
The forward pass	a request to call one	Tools
Sampling	tokens before the answer	Reasoning
Reasoning	the working, appended (a return)	The context window
Sampling	one token, appended (a return)	The context window
Sampling	the answer, streaming (a return)	Interfaces
Memory	what to remember (a return)	The stores

What governs. 10 constraints that shape the flow without being in it.
Part	Relationship	Applies to
Scale	how much of everything	Training
Attention	is the mechanism inside it	The forward pass
Cost and latency	is what you pay for	The context window
Context engineering	decides what goes in	The context window
Context sharding	splits what will not fit	The context window
Agents	runs it in a loop	The forward pass
Agents	chooses and runs them	Tools
Orchestration	arranges many of them	Agents
Evaluation	measures what comes out	Sampling
Guardrails	decides what is allowed	Tools