Full Curriculum
Twenty-seven parts and a capstone, 184 pages, five difficulty levels, and about 126 hours of time on task including labs, projects and the capstone.
The five levels
Section titled “The five levels”Levels are a dependency graph rather than parallel tracks. Level 3 assumes Level 2 because you cannot evaluate a fine-tune you cannot serve.
Level 1 — AI Literate
Explain how a language model works, what its numbers mean, what a licence allows, and which model fits which machine.
0 of 4 parts started
Level 2 — Local Operator
Install, run, serve, benchmark and put to work open-weight models on your own hardware with the major engines.
0 of 6 parts started
Level 3 — Model Builder
Pretrain a small model, fine-tune, align with preferences and reinforcement learning, distil, quantise and evaluate honestly.
0 of 7 parts started
Level 4 — Cluster Architect
Run models bigger than one machine, split prefill from decode, and operate the result as a service.
0 of 6 parts started
Level 5 — Agentic Engineer
Drive coding agents and build agent systems on local models, then improve the models with what the agents produce.
0 of 5 parts started
Page types
Section titled “Page types”| Type | What it is |
|---|---|
| Lesson | Teaches something, with a quiz where there is anything worth testing |
| Lab | You run something on your track and record the result |
| Project | You build a complete, reusable piece of your platform |
| Challenge | Something is broken; you diagnose it with evidence before reading the solution |
| Reality check | A popular claim about local AI, made measurable and measured |
| Overview | A part’s introduction and contents |
Hands-on pages carry their platform tracks, their memory floor and, where the primary path needs two or more machines, a cluster badge. Every cluster page has a single-machine path.
The whole course
Section titled “The whole course”Part 1Machine Learning Foundations for LLM WorkLevel 1 · AI Literate2.8 h
The handful of ideas from machine learning that every later decision rests on: loss, gradients, generalisation, tensors and precision.
- LessonWhat Learning Means: Data, Loss and Gradient Descent25 min
- LessonNeural Networks, Activations and Backpropagation28 min
- LessonGeneralisation: Train, Validation, Test and Overfitting25 min
- LessonTensors, GPUs and Precision: Why Matrix Multiplication Is Everything30 min
- LabLab: Your Python Environment and a First Trained Model 8 GB60 min
Part 2What a Language Model IsLevel 1 · AI Literate3.4 h
Next-token prediction, tokens, embeddings, attention and the transformer, taught so that the reader can look at a checkpoint and know what every number is for.
- LessonFrom Autocomplete to Assistant: Next-Token Prediction28 min
- LessonTokens, Tokenisers and Vocabulary30 min
- LessonEmbeddings: Meaning as Geometry25 min
- LessonAttention and the Transformer35 min
- LessonParameters, Layers and Model Size28 min
- LabLab: Look Inside a Model 8 GB60 min
Part 3How Models Are Made and ImprovedLevel 1 · AI Literate3.1 h
Pretraining, post-training, the small-model toolkit, inference physics, and the licences that decide what you may do with the result.
- LessonPretraining: Learning from Trillions of Tokens28 min
- LessonPost-Training: SFT, Preference Tuning and Reinforcement Learning30 min
- LessonDistillation, Pruning and Quantisation: How Small Models Get Good28 min
- LessonInference: Prefill, Decode and Why Memory Bandwidth Rules30 min
- LessonOpen Weights, Open Source and Licences28 min
- Reality checkReality Check: 'A Small Local Model Is as Good as the Frontier' 12 GB45 min
Part 4The Open-Weight Model LandscapeLevel 1 · AI Literate3.3 h
Who publishes what, how to read a model name, a model card and a benchmark, and how to pick a model that fits a memory budget.
- LessonModel Families and Who Makes Them30 min
- LessonDense, Mixture-of-Experts and Hybrid Architectures28 min
- LessonBase, Instruct, Thinking, Coder, Vision, Embedding: Reading a Model Name25 min
- LessonReading a Model Card and a Benchmark30 min
- LessonChoosing a Model for a Memory Budget35 min
- LabLab: Build Your Model Shortlist 8 GB50 min
Part 5Your Hardware: Four Platforms, One CourseLevel 2 · Local Operator4.5 h
The four machine classes the labs are written for, what makes each different, and how to get each one ready and measured.
- LessonWhy Memory, Not FLOPS, Decides What You Can Run28 min
- LessonNVIDIA DGX Spark: GB10, DGX OS and the aarch64 Caveat30 min
- LessonAMD Ryzen AI Max+ 395: Strix Halo, ROCm and Vulkan32 min
- LessonApple Silicon: Unified Memory, Metal and MLX28 min
- LessonNVIDIA Desktops and Laptops: VRAM Tiers, CUDA and WSL230 min
- LabLab: Prepare Your Machine 8 GB75 min
- LabLab: Measure Your Memory Bandwidth and Compute 8 GB45 min
Part 6First Inference with llama.cppLevel 2 · Local Operator4.3 h
The engine that runs on every one of the four platforms, its file format, its quantisation types, its server, and the flags that actually matter.
- Lessonllama.cpp: The Engine That Runs Everywhere25 min
- LessonInstalling and Building llama.cpp on Your Platform35 min
- LessonGGUF and Quantisation Types30 min
- Lessonllama-cli and llama-server35 min
- LessonSampling: Temperature, Top-p, Min-p, Repetition and Determinism25 min
- LabLab: Run and Benchmark the Course Reference Models 8 GB60 min
- ChallengeChallenge: The Model That Runs at Two Tokens per Second 8 GB45 min
Part 7Ollama, LM Studio and the Desktop ExperienceLevel 2 · Local Operator3.5 h
The two tools most people start with, what they do on top of llama.cpp and MLX, the front-ends that sit on them, and a private chat service for your home network.
- LessonOllama: Models as a Service30 min
- LessonLM Studio: GUI, MLX and Headless Serving28 min
- LessonFront-Ends: Open WebUI and Friends25 min
- LessonManaging a Model Library: Storage, Naming and Versions25 min
- LabLab: A Private Chat Service for Your Home Network 8 GB60 min
- Reality checkReality Check: 'The Default Context Is Enough' 8 GB40 min
Part 8Platform-Native Engines: MLX, TensorRT-LLM and ROCmLevel 2 · Local Operator3.0 h
The engines built by or for each platform vendor, when they beat the portable ones, and the specialist engines for specific problems.
- LessonMLX and mlx-lm: Apple's Native Path30 min
- LessonTensorRT-LLM, NIM and the DGX Spark Playbooks30 min
- LessonAMD-Native: ROCm Builds, Lemonade Server and the NPU Question30 min
- LessonSpecialist Engines: ExLlamaV3, ktransformers and mistral.rs28 min
- LabLab: Same Model, Every Engine 12 GB60 min
Part 9Serving at Scale: vLLM and SGLangLevel 2 · Local Operator5.2 h
The engines built for many users at once: batching, paged attention, prefix caching, server-side tool calling, speculative decoding, and a gateway project that the rest of the course builds on.
- LessonWhy a Second Kind of Engine: Batching, Paged Attention and Throughput28 min
- LessonInstalling vLLM: x86 CUDA, DGX Spark, ROCm and What Does Not Work35 min
- LessonServing with vLLM: Quantised Weights, Context, Memory and Multi-GPU35 min
- LessonSGLang: When to Choose It25 min
- LessonTool Calling and Structured Output on the Server Side30 min
- LessonSpeculative Decoding: Draft Models, EAGLE and n-gram25 min
- LabLab: Serve a Model to Twenty Concurrent Users 16 GB60 min
- ProjectProject: Your Local Model Gateway 8 GB75 min
Part 10Putting Models to WorkLevel 2 · Local Operator5.2 h
Prompting local models properly, structured output, coding assistance in the editor, retrieval-augmented generation, multimodal inputs, safety beyond localhost, and the evaluation harness the rest of the course uses.
- LessonPrompting That Works Locally: System Prompts, Chat Templates and Thinking Modes30 min
- LessonStructured Output and JSON Mode25 min
- LessonLocal Coding Assistants: Autocomplete and Chat in Your Editor30 min
- LessonRetrieval-Augmented Generation: Embeddings, Chunking and Vector Stores35 min
- LessonVision, Speech and Documents: Multimodal Locally30 min
- LessonPrivacy, Security and Serving Beyond localhost28 min
- ProjectProject: A Private Document Question-Answering Service 8 GB75 min
- LabLab: Benchmark Local Models on Your Own Tasks 8 GB60 min
Part 11The Training ToolchainLevel 3 · Model Builder3.5 h
PyTorch, the Hugging Face libraries, a working training environment on each platform, the memory arithmetic of training, dataset handling, and reproducible experiments.
- LessonPyTorch, Transformers, Datasets and the Hugging Face Ecosystem28 min
- LessonSetting Up a Training Environment on Each Platform35 min
- LessonMemory Arithmetic for Training: Weights, Gradients, Optimiser States and Activations30 min
- LessonDatasets: Formats, Chat Templates, Tokenisation and Packing30 min
- LessonExperiment Tracking and Reproducibility25 min
- LabLab: Your First Training Run 8 GB60 min
Part 12Pretraining a Small Model from ScratchLevel 3 · Model Builder4.7 h
The full pipeline from raw text to a model that can complete a sentence, run at a scale that fits one machine and one afternoon.
- LessonWhat Pretraining Teaches You That Fine-Tuning Cannot22 min
- LessonAnatomy of a Training Loop: nanochat Line by Line35 min
- LessonData for Pretraining: FineWeb-Edu, Cosmopedia and Training a Tokeniser30 min
- LessonScaling Laws and Compute Budgets at Home28 min
- LabLab: Train a 10M to 125M Parameter Model in an Afternoon 8 GB75 min
- ProjectProject: A Domain Micro-Model 8 GB90 min
Part 13Supervised Fine-Tuning: LoRA, QLoRA and Full Fine-TunesLevel 3 · Model Builder6.5 h
Teaching a model a format, a style or a domain with labelled examples, using adapters when memory is tight, and exporting the result to every engine.
- LessonWhat Fine-Tuning Changes and What It Cannot25 min
- LessonLoRA and QLoRA Explained30 min
- LessonBuilding an SFT Dataset30 min
- LessonFine-Tuning with TRL and PEFT35 min
- LessonUnsloth, Axolotl, LLaMA-Factory and mlx-lm: Higher-Level Tools30 min
- LessonMerging, Exporting and Quantising a Fine-Tuned Model28 min
- LabLab: Fine-Tune a 1B to 4B Model to Follow Your Format 12 GB75 min
- ProjectProject: A Specialist Assistant 16 GB90 min
- ChallengeChallenge: The Fine-Tune That Got Worse 12 GB45 min
Part 14Preference Optimisation and Reinforcement LearningLevel 3 · Model Builder5.5 h
From imitating examples to optimising for what you prefer, and then to reinforcement learning with rewards a program can verify.
- LessonFrom Imitation to Preferences: Why Ranking Beats Copying28 min
- LessonDPO and Its Family: IPO, KTO, ORPO and SimPO30 min
- LabLab: DPO a Model to Prefer Your Style 16 GB60 min
- LessonReinforcement Learning with Verifiable Rewards: GRPO Explained35 min
- LessonReward Functions: Maths, Code Tests, Format and Length28 min
- LessonThe RL Toolchain: TRL, Unsloth, verl, OpenRLHF and vLLM Rollouts28 min
- LabLab: GRPO on a Maths or Code Task on One Machine 16 GB75 min
- Reality checkReality Check: 'RL Makes Small Models Reason' 16 GB45 min
Part 15Knowledge Distillation: Big Teacher, Small StudentLevel 3 · Model Builder6.8 h
Moving capability from a model that fits your 128 GB machine into one that fits your laptop, by logits, by sequences and by on-policy correction.
- LessonWhy Distillation Works25 min
- LessonThree Kinds of Distillation: Logit, Sequence and On-Policy32 min
- LessonReasoning Distillation: Teacher Traces as Training Data28 min
- LessonGenerating Synthetic Data with a Local Teacher30 min
- LabLab: Sequence-Level Distillation of a 30B-Class Teacher into a 4B Student 12 GB75 min
- LabLab: Logit Distillation with TRL's Distillation Trainers 24 GB60 min
- LessonPruning and Compression: Prune-and-Distil25 min
- ChallengeChallenge: The Student That Learned the Teacher's Mistakes 12 GB45 min
- ProjectProject: The Distillation Pipeline 12 GB90 min
Part 16Quantisation and Evaluation, ProperlyLevel 3 · Model Builder5.1 h
The methods that shrink a model, the precision formats of current hardware, and the measurements that say what was lost.
- LessonPost-Training Quantisation in Depth: GPTQ, AWQ, K-quants, imatrix and HQQ30 min
- LessonQuantisation-Aware Training and the Blackwell Formats: FP8, NVFP4 and MXFP428 min
- LessonMeasuring Quantisation Damage: Perplexity, KL Divergence and Task Evaluations28 min
- LessonEvaluation Harnesses: lm-evaluation-harness, lighteval, EvalPlus and Your Own30 min
- LessonLLM-as-Judge, Contamination and Honest Reporting25 min
- LabLab: Quantise Your Fine-Tune Five Ways and Measure Each 12 GB60 min
- LabLab: Run a Standard Benchmark Suite on Your Model 8 GB60 min
- ChallengeChallenge: The Benchmark That Lied 8 GB45 min
Part 17Faster Inference: Speculative Decoding, Caching and Draft ModelsLevel 3 · Model Builder2.5 h
The techniques that make a served model faster without changing its answers, including training your own draft model.
- LessonSpeculative Decoding Revisited: Acceptance Rates and When It Pays25 min
- LessonPrefix Caching and KV Reuse25 min
- LessonTraining a Draft Model: Medusa and EAGLE at Home28 min
- LabLab: Train and Deploy a Draft for Your Model 24 GB75 min
Part 18Beyond One Machine: Parallelism and NetworksLevel 4 · Cluster Architect2.9 h
Why one box runs out, the five kinds of parallelism and what network each needs, home-cluster networking from 2.5 GbE to RDMA, and the reference cluster the rest of the level is built on.
- LessonWhy One Box Runs Out: The Memory Wall and the Bandwidth Wall25 min
- LessonTensor, Pipeline, Expert, Data and Sequence Parallelism32 min
- LessonNetworking for Home Clusters: 2.5 GbE to 200 GbE, Thunderbolt 5 and RDMA30 min
- LessonThe Course Reference Cluster and the Single-Machine Path25 min
- LabLab: Build and Measure Your Cluster Network 8 GB Cluster60 min
Part 19Clustering with llama.cpp RPCLevel 4 · Cluster Architect3.9 h
The cross-platform way to run a model across machines: rpc-server on every box, one client, a model bigger than any single one of them, over TCP or RDMA.
- Lessonllama.cpp RPC: Layers Across Machines30 min
- LessonRDMA Transport, Tuning and Measuring the Split25 min
- LabLab: Run a Model Bigger Than Any One Machine 128 GB Cluster75 min
- LabLab: A Mixed-Platform Cluster 16 GB Cluster60 min
- ChallengeChallenge: The Cluster That Is Slower Than One Machine 16 GB Cluster45 min
Part 20NVIDIA Clusters: DGX Spark Pairs, vLLM Multi-Node and Multi-GPU DesktopsLevel 4 · Cluster Architect3.4 h
The NVIDIA path to models beyond one machine: two Sparks over ConnectX-7 with the official playbooks, vLLM across nodes with Ray, and what a multi-GPU desktop can and cannot do without NVLink.
- LessonConnecting Two DGX Sparks over ConnectX-730 min
- LessonvLLM Multi-Node with Ray: Tensor Parallel Inside, Pipeline Parallel Across32 min
- LessonMulti-GPU Desktops: PCIe, Tensor Parallel Without NVLink and Expert Parallel28 min
- LessonTensorRT-LLM and Dynamo on Spark Pairs25 min
- LabLab: Serve a 400B-Class Model on Two DGX SparksS N 128 GB Cluster90 min
Part 21Apple Clusters: MLX Distributed and exo over Thunderbolt 5Level 4 · Cluster Architect2.9 h
Two or more Macs as one model server: MLX's distributed backends, RDMA over Thunderbolt 5 on macOS 26.2 and later, exo's automatic partitioning, and a fair comparison with a GPU box.
- Lessonmlx.distributed: Ring, MPI and RDMA over Thunderbolt 528 min
- Lessonexo: Automatic Partitioning Across Your Macs25 min
- LabLab: A Two-Mac Cluster over Thunderbolt 5M 32 GB Cluster75 min
- Reality checkReality Check: 'Four Mac Studios Replace a GPU Server'M 32 GB45 min
Part 22Disaggregated Serving: Prefill Machines and Decode MachinesLevel 4 · Cluster Architect6.0 h
Separating the compute-heavy prompt phase from the bandwidth-heavy generation phase onto different machines, moving the KV cache between them, and measuring whether it helped.
- LessonWhy Prefill and Decode Want Different Hardware30 min
- LessonThe KV Cache as a Transferable Object: Mooncake, LMCache and NIXL28 min
- LessonvLLM Disaggregated Prefill: Connectors and the Proxy32 min
- LessonSGLang PD Disaggregation and NVIDIA Dynamo28 min
- LabLab: Two-Machine Prefill and Decode with vLLM 24 GB Cluster90 min
- LabLab: KV Cache Offload and Sharing 16 GB60 min
- ProjectProject: A Tiered Inference Architecture 16 GB90 min
Part 23Operating a Local AI ServiceLevel 4 · Cluster Architect4.1 h
Routing, observability, capacity and cost, security, backup and upgrades: running what you built as a service other people depend on.
- LessonRouting and Model Management: llama-swap, LiteLLM, NGINX and Health Checks28 min
- LessonObservability: Metrics, Logs and Traces for LLM Serving30 min
- LessonCapacity Planning and Cost per Million Tokens at Home28 min
- LessonSecurity for Exposed Endpoints and the Model Supply Chain30 min
- LessonBackup, Upgrades and Reproducibility of a Model Estate25 min
- LabLab: Dashboards for Your Cluster 8 GB60 min
- ChallengeChallenge: The 3 a.m. Out-of-Memory 8 GB45 min
Part 24Tool Calling, MCP and the Agent LoopLevel 5 · Agentic Engineer4.3 h
What an agent is, function calling end to end on local engines, the Model Context Protocol, reasoning models in loops, context engineering, and a minimal agent built by hand.
- LessonWhat an Agent Is: The Loop, Tools and State25 min
- LessonFunction Calling End to End on Local Engines32 min
- LessonModel Context Protocol: Servers, Clients and Transports30 min
- LessonReasoning Models in Agent Loops25 min
- LessonContext Engineering: Memory, Compaction and the KV Budget28 min
- LabLab: A Minimal Agent from Scratch 8 GB60 min
- LabLab: Write and Connect an MCP Server 8 GB60 min
Part 25Coding Agents on Local ModelsLevel 5 · Agentic Engineer7.8 h
The agentic coding tools of 2026, which local models can drive them, how each is pointed at a local endpoint, sandboxing, and a workstation the reader keeps.
- LessonThe Landscape: Terminal, Editor and Autonomous Agents28 min
- LessonWhich Local Models Can Actually Drive an Agent30 min
- LessonAider with Local Models28 min
- LessonOpenAI Codex CLI and OpenCode with Local Models30 min
- LessonClaude Code with a Local Endpoint28 min
- LessonEditor Agents: Cline, Kilo Code, Continue and the Proprietary Editors28 min
- LessonGoose and OpenHands: Autonomous Agents and Sandboxing25 min
- LabLab: One Task, Six Agents 16 GB75 min
- LabLab: Sandbox Your Agent: Containers, Permissions and Secrets 8 GB60 min
- ChallengeChallenge: The Agent That Escaped the Sandbox 8 GB45 min
- ProjectProject: A Local Agentic Coding Workstation 16 GB90 min
Part 26Building Agent SystemsLevel 5 · Agentic Engineer4.7 h
Frameworks, multi-agent patterns, agentic retrieval, evaluation, safety, and a system that uses a big model on the cluster and a small one for routing.
- LessonAgent Frameworks Compared30 min
- LessonMulti-Agent Patterns: Router, Planner and Executor, Critic, Parallel Fan-Out28 min
- LessonAgentic Retrieval and Research Agents28 min
- LessonEvaluating Agents: Trajectories, Success Rates and Cost28 min
- LessonSafety: Prompt Injection, Tool Permissions and Human-in-the-Loop30 min
- ProjectProject: A Multi-Agent System on Your Cluster 16 GB90 min
- Reality checkReality Check: 'Agents Are Just Loops' 16 GB45 min
Part 27Improving a Model for Your AgentsLevel 5 · Agentic Engineer3.1 h
Closing the loop: the trajectories your agents produce become training data, the tests they run become rewards, and a big agent model becomes a small local one.
- LessonCollecting Trajectories from Your Agents25 min
- LessonFine-Tuning for Tool Use and Your Codebase30 min
- LessonReinforcement Learning on Agent Tasks: Tests as Rewards30 min
- LessonDistilling a Big Agent Model into a Small Local One25 min
- LabLab: Fine-Tune a Small Model on Your Own Agent Trajectories and Measure the Gain 16 GB75 min
CapstoneCapstone: Build and Defend Your Own Local AI PlatformLevel 5 · Agentic Engineer10.3 h
A complete local AI platform on the reader's own hardware, with measured numbers, an improved small model, an agentic workstation, and a report that says what worked and what did not.
- LessonCapstone Overview and Assessment Criteria20 min
- ProjectCapstone 1: Hardware and Model Plan 8 GB60 min
- ProjectCapstone 2: The Inference Service 8 GB90 min
- ProjectCapstone 3: Cluster or Tiered Deployment 16 GB Cluster120 min
- ProjectCapstone 4: Improve a Small Model 12 GB150 min
- ProjectCapstone 5: The Agentic Workstation 16 GB90 min
- ProjectCapstone 6: The Report 8 GB90 min