The whole machine

27 parts. 35 connections. One page.

The machine opens one stage at a time, which is the right way in. This is the other view: everything at once, wired up. Hover a part to light what flows through it, or run a request and follow it from the moment you press enter to the moment the answer comes back.

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

Text becomes a file of numbers. Runs once, long before you arrive.

Assemble

Everything the model will see is gathered into one string.

Run

The file is run over the context, producing one token.

Loop

A program repeats the whole thing, deciding what goes back in.

Constrain

What measures the output, and what limits what it can do.

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	Kind	What it is
The corpus	Built	artifact	Text, gathered at a scale no person could read
Tokens	Built	process	Text cut into pieces a machine can count
Embeddings	Built	process	Meaning stored as position in space
Parameters	Built	artifact	The adjustable numbers, and the shape they sit in
Training	Built	process	Guess, measure the error, nudge every number
Post-training	Built	process	Why it answers you instead of continuing your sentence
Scale	Built	governs	More data, more parameters, more compute. What that buys, and what it does not
The weights	Junction	artifact	A file of numbers, and nothing else
Interfaces	Run	process	Chat, API, SDK, MCP. The same machine, four doors
Markdown files	Run	artifact	Why plain text became the interface for instructions
The prompt	Run	process	Roles, and the fact that it is all one string
Retrieval	Run	process	Fetching the right paragraph before answering
Memory	Run	process	What persists between runs, and where it lives
Tools	Run	process	How a text machine acts on the world
The stores	Run	store	Four kinds of store, and what each is for
The context window	Run	artifact	Everything the model can see. There is nothing else.
The forward pass	Run	process	One token at a time, from a standing start, every time
Reasoning	Run	process	Thinking out loud is more tokens through the same loop
Sampling	Run	process	Why the same question gives different answers
Attention	Run	governs	How each token decides which others matter
Cost and latency	Run	governs	What you actually pay for, and why it feels slow
Context engineering	Run	governs	Deciding what goes in the window, and what stays out
Context sharding	Run	governs	Splitting work so no one context holds it all
Agents	Run	governs	A model in a loop, with tools and a goal
Orchestration	Run	governs	Arranging many runs: in sequence, in parallel
Evaluation	Run	governs	How you know it worked, and the ways it fails
Guardrails	Run	governs	Limits, accountability, and where they belong

What flows. 25 data connections.
From	Carries	To
The corpus	raw text	Tokens
Tokens	token ids	Embeddings
Embeddings	vectors	Parameters
Parameters	values to adjust	Training
The corpus	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