Building AI agents
This course teaches you how to design, evaluate, and govern production AI agents.
No account or install is needed to begin. This browser saves your place as you read.
- Modules
- 34
- Reading time
- ~19 hours
It follows the natural progression of an engineering craft: first you master the tools to build the system, then you assemble the empirical evidence that proves the system is reliable, and finally you inspect the computational mechanics underneath it all.
Part 1 — Foundations of Agents
You begin by examining what a language model actually computes and running open weights locally on your own hardware. From there, you write modular system prompts that commit a general model to one operational purpose, refining prompt rules directly against the agent’s observed failures. You conclude the part by connecting these components into your first multi-agent workflow.
- 1.01
The Architecture of Prediction
How a model predicts the next token
- 1.02
Foundational failures of LLMs
Three ways a fluent answer goes wrong, and two loops that catch it
- 1.03
Open weights run on your own machine
What open weights give you, and what a local model can carry
- 1.04
The system prompt shapes the agent's persona
Four sentences make an agent with personality
- 1.05
The block anatomy of system prompts
What turns a model into an agent: the instruction, block by block
- 1.06
The agent loop's four surfaces
Goals, actions, observation, adaptation: one turn through the loop
- 1.07
Diagnosing prompt failures by variable
Five variables, one changed at a time
- 1.08
An independent critic scores each draft
The drafter and critic loop, run on your machine
- 1.09
Four topologies for delegating work
Solo, router, decomposer, council: who delegates to whom
- 1.10
Voice as countable register laws
Rules a transcript passes or fails
Part 2 — Agent Design and Evaluation
You scale your agents into production systems by declaring a whole team of agents in one configuration file. Across these modules, you build persistent memory, extend agent reach with tools over MCP, construct multi-agent verification pipelines, and run the agentic coding loop against a working codebase. You then evaluate the system on real test cases with calibrated judge models, record every production turn in an append-only ledger, and set deployment gates that stop a release when accuracy regresses.
- 2.02
Routing requests to specialists and providers
Compose or route: where each request lands
- 2.03
Storing and recalling agent memory
One fact from the transcript to a recalled record
- 2.04
Governing a long-term memory store
Provenance, supersession, contradiction, silence
- 2.05
Runtime tool discovery over MCP
One URL line becomes live tools
- 2.06
The trust boundary around MCP tools
Reads, writes, and the guards outside the model
- 2.07
The specification-first image pipeline
The contract is written before anything renders
- 2.08
Grading an image without priming the reviewer
The blind inventory and the conformance score
- 2.09
Separating claim gathering from judgment
Two collectors, one tool-free arbiter
- 2.10
Gating claims into a sourced answer
The corroboration gate and the sourced line
- 2.11
The agentic coding loop verified by execution
Plan, edit, run, verify, commit
- 2.12
The repository instruments that carry an agent's context
Rules file, skill, knowledge doc, plan artifact
- 2.13
Grading agents with eval suites
Cases, variants, judges, and a confidence interval
- 2.14
The production ledger and the deploy gate
What a ledger row records, and what a replay proves
Part 3 — Mastering the Principles of LLMs
You open the engine to the arithmetic of vectors and dot products, tracing how a single prediction vector combines its embedding baseline, attention over the context, and the feed-forward layers’ stored patterns. You see why models drop steps in long reasoning, how small prompt changes shift the probability distribution across the vocabulary, and where a fact should live: the prompt, retrieval, a tool, memory, or the weights. Confabulation, prompt injection, and retrieval conflicts stop looking like separate bugs and read as predictable behavior of the mechanism your agents were built to manage.
- 3.01
Three sources of the thought state
Where a token's vector comes from
- 3.02
How the next token is chosen
Logits, softmax, temperature, and the draw
- 3.03
Every score is a dot product
The one operation under every comparison
- 3.04
The weights hold more than facts
Procedures, world models, and the prior
- 3.05
How attention builds the context term
Query, keys, shares, and the blended value
- 3.06
How the memory term competes with context
The MLP's write, and three votes in one logit
- 3.07
Six ways to ask one question
How context transforms a query
- 3.08
The fixed depth of a single pass
What one pass cannot hold
- 3.09
How reasoning models write their working down
Supervision, ladders, and the scratchpad
- 3.10
Six layers that hold a fact
Prompt, retrieval, tool, memory, fine-tune, pretraining
- 3.11
Choosing a layer for a fact
Cost, trust and reversibility decide
What you need
-
To read the course
Nothing. No account, no key, no install: every module here is prose and figures.
-
To practise it
The free Melchizedek app, coming soon, will hold the same course with its checks, its traces and a hands-on run in every module. Part 1's runs need no key; Part 2's run on keys you bring, kept on your machine; Part 3 needs nothing.
Part by part, the detail is on the syllabus.
Why this course
Most AI tutorials stop at the chat interface. This curriculum teaches what happens when you step behind it: every module studies a working agent configuration, and you read the definition beside the mechanism it puts into practice. The full introduction, who the course is written for and what it draws on, is on the syllabus, alongside every chapter in teaching order.