Anatomy of AI

Not a glossary. One machine, in five stages, and what passes between them. Start with the five. Open one when you want its parts. Parts marked try it have something you can operate: run the real arithmetic, break it, and see what happens.

What we mean by "AI" here Start here if the word means several things to you

"AI" now labels a dozen unrelated machines. This one is ours

The word "AI" is applied to spam filters, chess programs, image generators, self-driving cars and chatbots at once. Nothing accurate can be said about all of them together.

This site explains one machine: the system built around a large language model. It has two halves, and confusing them causes most misunderstanding. First the model is made. Text is collected, turned into numbers, and used to adjust an enormous set of values until it predicts text well. That produces a fixed file. Second, that file is run: given text, it produces more text, one piece at a time. Everything else here, the tools and agents and memory, is scaffolding built around the second half.

Not thisNot every automated system is this. Image generation, robotics and classical statistics are different machines with different physics.

The machine · five stages

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

One request, end to end Watch one request go through all of it

Everything you have just met, working at once

Every part has now been examined on its own. None of them is ever used on its own, and a list of parts is not an understanding of a machine.

Follow one request all the way through. A sentence is cut into tokens, joined to a system prompt, a memory lookup and three retrieved passages, and assembled into one string. The file runs over that string and produces tokens until it asks for a tool. A program checks the permission, runs it, and pastes the result back as text. The loop turns four more times. An answer arrives, one token at a time. Nothing in that sequence was magic.

Not thisThere is no step in this trace that is not an ordinary program, a file of numbers, or arithmetic.

Built

How a model comes to exist. Runs once, before you ever touch it.

The junction

An inert file. Everything to the left made it; everything below runs it.

Run

What happens when you press enter. Runs again, in full, every turn.

01 Build Text becomes a file of numbers. Runs once, long before you arrive. 8 to try · 8 parts +

02 Assemble Everything the model will see is gathered into one string. 7 to try · 7 parts +

03 Run The file is run over the context, producing one token. 6 to try · 6 parts +

04 Loop A program repeats the whole thing, deciding what goes back in. 4 to try · 4 parts +

05 Constrain What measures the output, and what limits what it can do. 2 to try · 2 parts +