Contents

This guide has two layers. Parts 1–16 are the core path — read them in order, since each one assumes the last, and they take you from "what is a model" to a working, guarded agent. Parts 17–21 are optional deep-dives — each stands alone, can be read in any order, and isn't required reading to say you've finished the guide; dip into whichever one matches something you're curious about, whenever you want it. The Appendices are reference material — glossary, formulas, cheat sheets — to check back against rather than read front to back.

Part 0 — Start here (read this first)

• 0.1 Who this guide is for · 0.2 The learning flow · 0.3 The roadmap (2 / 6 / 12-week routes) · 0.4 Set up your computer · 0.5 The tiny bit of maths you need · 0.6 How to not get stuck

Part 1 — What is AI, really?

1. Programs vs models: the one idea that starts everything
2. What "data", "features", and "learning" mean here
3. The family tree: AI, ML, deep learning, LLMs
4. Our running example: the Help Desk problem

Part 2 — Era 1: Rules (1950s–1980s) 5. Teaching a computer with IF-THEN rules 6. Building a rule system (a real historical example) 7. Why rules broke down (the five walls)

Part 3 — Era 2: Learning from examples (1990s–2000s) 8. The big switch: from rules to examples 9. Your first model: is this email spam? 10. How a model learns: loss and gradient descent 11. Turning words into numbers: bag-of-words and TF-IDF 12. Predicting the next word by counting (n-grams) — the LLM's ancestor 13. How do you know if a model is any good?

Part 4 — Era 3: Neural networks (2010s) 14. What a neural network actually is 15. How neural networks learn: backpropagation, gently 16. Why "deep" matters 17. Networks that read sequences (RNNs) and why they struggled

Part 5 — Teaching machines what words mean 18. The problem with treating words as symbols 19. word2vec: meaning from company 20. GloVe, FastText, and the family 21. The limit of static vectors, and what came next

Part 6 — The Transformer (the most important part) 22. The problem: reading a sentence all at once 23. Attention explained with a highlighter 24. Self-attention, step by step with real numbers 25. Multiple heads, position, and the full block 26. Hands-on: a tiny Transformer you can run

Part 7 — Tokens 27. Computers don't see words 28. How BPE builds a vocabulary (by hand) 29. Tokens in practice: cost, context, and fairness 30. Special tokens and chat templates

Part 8 — What an LLM actually is 31. An LLM is a next-token guesser (that's genuinely it) 32. Walking through one prediction, end to end 33. How an LLM is trained (pretraining) 34. Making it an assistant (SFT and RLHF/DPO) 35. Why LLMs make things up

Part 9 — How an LLM answers you (inference) 36. From your question to the first word 37. Choosing the next word: temperature, top-p, and friends 38. The memory trick that makes it fast (the KV cache) 39. What it costs, and how to think about it

Part 10 — Build your own LLM 40. What you can realistically build 41. Project 1: train a language model from scratch 42. Project 2: fine-tune a real model with LoRA 43. Teaching preferences (a taste of DPO)

Part 11 — Making LLMs useful 44. Prompting that actually works 45. The context window: your working-memory budget 46. Saving tokens and money 47. Project 3: give the model your own documents (RAG) 48. Tools, structured output, and agents 49. Testing your LLM app

Part 12 — Agents: LLMs that do things 50. What "agentic" actually means (and when you don't need it) 51. The agent loop, spelled out 52. Tools: giving the model hands 53. Memory: how an agent remembers 54. Multi-agent systems and orchestration 55. Why agents fail, and how to tell

Part 13 — MCP: the universal adapter 56. Why MCP exists (the N×M problem) 57. How MCP works: hosts, clients, servers, and primitives 58. Hands-on: build an MCP server and connect it

Part 14 — Guardrails: making it safe 59. Why AI security is different 60. Guardrails: the layered defence 61. Securing prompts, context, and tools

Part 15 — Project 4: a real agent, end to end 62. Build a support agent that can actually do things

Part 16 — Where to go next (the core path's natural end — arrive here from Part 15) 63. What you know now, and the honest gaps 64. A six-month plan after this guide 65. Project ideas by level

Part 17 — Model compression: distillation & small models (deep-dive — optional) 66. What model weights actually are 67. Knowledge distillation: teaching a small model to imitate a big one 68. Project 5: distill a tiny model and run it in the browser (Bengaluru, next 30 days)

Part 18 — Agent frameworks & AI governance (deep-dive — optional) 69. Agent frameworks: LangGraph, CrewAI, and the SDKs 70. AI governance and compliance

Part 19 — Under the hood: optimizers, efficient attention, and quantization (deep-dive — optional) 71. How AdamW actually works 72. GQA: shrinking the KV cache without losing (much) quality 73. Quantization: from float32 to int4, the actual algorithm

Part 20 — Agents in the real world: harnesses, loops, and production (deep-dive — optional, but where the industry is in 2026) 74. The harness: everything around the loop 75. Loops that run for hours: long-horizon agents (Ralph loops, progress files, verifiers) 76. Evaluating agents: "works once" vs "works every time" (pass^k) 77. Deploying agents to production (durable execution, sandboxes, rollouts) 78. Agent interop: AGENTS.md, Skills, MCP, and A2A 79. Project 6: an overnight agent that opens real pull requests

Part 21 — Beyond next-token prediction: decision models and world models (deep-dive — optional) 80. System One models: Jev and "LLM writes, model decides, code acts" 81. JEPA and world models: predicting meaning, not tokens

Appendices

• A. Glossary (plain language)
• B. Math corner (only what you need)
• C. Setup and troubleshooting
• D. Cheat sheets
• E. Master reading list (books, courses, blogs, videos, papers) + how facts were checked
• F. Answers to "Check yourself"