Anatomy of AI

You type a question into a chatbot and an answer comes back. In between is one machine. This site takes it apart into its 27 parts, explains each one in plain words, and lets you operate all of them rather than only read about them.

No maths, and no background in computing, is needed anywhere. If you already build with these systems, a switch marked Advanced on every part opens the mechanism and the trade-offs underneath it.

What we mean by "AI" here Open this first if "AI" means several different things to you

The word AI covers many machines. This site explains one

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

In the order things happen. Open one to see its parts, and anything marked try it really runs, in your browser.

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

One request, end to end Every part above, working together on one question

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.

The one distinction to keep

If you take one thing from this site, take the split between making the model and using it. Most arguments about what AI can and cannot do turn out to be two people talking about different halves.

Built once

Making the model. Text is read by the ton, and a vast set of numbers is nudged, over and over, until the thing predicts text well. It ran for months, finished before you arrived, and will not run again.

The file in between

What building produces is one file of numbers. It has no memory and it does nothing on its own. Making it and running it are two separate jobs, and this file is the only thing that passes between them.

Run every turn

Using the model. Text is gathered, the file is run over it, and one piece of the answer comes out. Then it happens again for the next piece. All of this repeats from scratch on every turn of every conversation.

01 Build A pile of text becomes a file of numbers. Happens once, months before you arrive, and never again. 8 parts, all operable +

02 Assemble Your question, the standing rules and anything looked up are joined into one long piece of text. 7 parts, all operable +

03 Run The file of numbers runs over that text once and produces the next small piece of the answer. 6 parts, all operable +

04 Loop Ordinary code repeats the whole thing, deciding each time what text goes back in. 4 parts, all operable +

05 Constrain How anyone checks whether the answers are any good, and what stops the system doing harm. 2 parts, all operable +

The one distinction to keep