From LLMs to Agents

What the model is, how it is built, and how it begins to act

This site supports a 30-minute conceptual talk and a standalone learning resource for readers who are comfortable following mathematical ideas but may not use them every day, prepared as background for a later, more applied Claude Code workshop. It is co-produced with Claude Code under human review: Claude Code drafts and runs deterministic checks; a human reviewer approves substantive choices, final wording, and every commit.

Working draft for review

Feedback on clarity, examples, diagrams, and factual errors is welcome. Suggest a correction on the repository’s issues page. The presentation has not yet been given to an audience.

The course follows one route, and every page belongs to one stage of it:

raw data
curated training corpus
tokenizer
pretraining
base model
post-training
post-trained model
inference-time context
tools, external state, and the loop
agentic system

The whole route in one line: raw data is curated into a training corpus and tokenized; pretraining produces a base model; post-training produces the post-trained model that products build on. At use time, the surrounding system supplies the model's inference-time context, and software outside the model adds tools, external state, and retrieval, which brings information into that context; software that calls the model in a loop with those pieces is an agentic system. Colors mark the five kinds of thing involved: data, training, the model, context, and the software around it.

How the two products relate

The website is the primary, standalone learning product. Someone who never attends the talk should be able to learn the material from the site alone, with the full mathematics, worked examples, and an interactive laboratory. The live talk is a carefully selected, lower-math path through this material: about 30 minutes, naming and defining every required term, but carrying no required live equation and no required live demonstration — both live in full on the site, which the talk points to rather than reproduces.

Start here

The short story — the whole course in about twenty minutes: one mental model from the text you type to a system that uses tools, with a link into the lesson that develops each step. Start here.

Learn: the main path, in order

From text to numbers — what has to happen before a language model can learn from text: tokens, token IDs, embedding vectors, and next-token targets, traced through one sentence.
Neurons, layers, and learning — a complete, standalone module on parameterized functions, gradient descent, and backpropagation, with a fully worked and independently numerically-checked example.
Why transformers — a complete, standalone module on the sequence-processing problem self-attention was built to solve, with a worked example checked against the original paper’s own stated bounds.
How pretraining works — the autoregressive objective, negative log-likelihood, the optimization loop, what pretraining does and does not teach, and how it differs from post-training and from inference-time context.
Post-training — how a pretrained model becomes an assistant: supervised instruction tuning, preference-based methods (reward-model and direct routes), model-generated feedback, reasoning-oriented reinforcement learning, and why none of it is a system prompt.
From assistant to agent — what a tool call actually is, the workflow-versus-agent distinction, the agent loop, state and memory, reusable procedures, verification, and permissions, with a coding agent as the running example.
Using models well — the practical guide: task selection, task specification, context, source of truth, tools, verification, bounded units, handoffs, model selection, and an operating checklist, each tied to a mechanism taught earlier.

Deep dives: optional technical pages

Deep dive: tokens, embeddings, and the context window — optional; why models use subword units, what the embedding table does and does not encode, and what a finite context window implies in practice.
Deep dive: how self-attention moves information — optional; queries, keys, values, causal masking, multi-head attention, and where attention sits inside a transformer block, with a worked numerical example.
Deep dive: softmax, sampling, and temperature — a complete, standalone learning module, including a live softmax-and- sampling laboratory and a no-JavaScript fallback.

Reference

Milestones — a selective timeline, from the perceptron to reasoning-oriented reinforcement learning, for locating each of the course’s concepts in time.
Glossary — the technical terms the course uses, defined as the course uses it, with the distinction most likely to cause confusion and a link to the lesson that teaches it.
Resources — a curated learning library: what to read or watch next, by part of the course, with a caveat for each.

Presentation

Presentation — the 30-minute presentation: 24 slides in the prepared route plus one backup slide, from what a runnable model is to a coding agent, built from the same figures and sources as the site.
Speaking guide — one section per slide: objective, timing, what to say, and where the deeper lesson is.

Sources

Every substantive factual claim on this site carries a claim ID that resolves in sources/claims.csv, described in prose in sources/source-map.md. Both files are checked automatically against the rendered pages.