Study plan · 2026
The AI agent engineer roadmap.
10 stages, in order, from what is inside a language model to running agents with real users. Each stage answers one question and lists the chapters that answer it.
70 chapters · 14 papers explained · about 7 hours of reading · Free, no sign-up
Where to start
Stage 01 · about 1 h
How language models work
What is actually inside the model my agent calls?
After this stage you can: Explain attention, why data and parameters have to scale together, how preference tuning differs from pretraining, and what LoRA and mixture of experts change.
Papers explained here: Attention Is All You Need (2017), Scaling laws & Chinchilla (2020 / 2022), InstructGPT & DPO (2022 / 2023), LoRA (2021), Mixtral of Experts (2024)
- Start Here: Foundational Modelling, Explained SimplyFoundational Modelling2 min
- The Transformer, the Engine Inside Every Modern ModelFoundational Modelling5 min
- Scaling Laws and Chinchilla, How Big Should a Model Be?Foundational Modelling4 min
- Alignment, Turning a Text Predictor Into a Helpful AssistantFoundational Modelling5 min
- LoRA, Fine-Tuning Giant Models on a BudgetFoundational Modelling4 min
- Mixtral and Mixture of Experts, More Brain, Same SpeedFoundational Modelling3 min
Stage 02 · about 1 h
From reasoning to action
How does a model go from answering to doing?
After this stage you can: Tell a reasoning trace from an action loop, explain why ReAct feeds observations back in, and compare outcome and process supervision.
Papers explained here: Chain-of-Thought Prompting (2022), ReAct (2022), Let’s Verify Step by Step (2023), DeepSeek-R1 (2025), Recursive Language Models (Preprint)
- Start Here: Planning and Reasoning, Explained SimplyPlanning and Reasoning2 min
- Chain of Thought, Teaching Models to Think Out LoudPlanning and Reasoning4 min
- ReAct, Reasoning and Acting TogetherPlanning and Reasoning3 min
- Let's Verify Step by Step, Rewarding Good ReasoningPlanning and Reasoning3 min
- DeepSeek-R1, Learning to Reason Through Reinforcement LearningPlanning and Reasoning3 min
- Recursive Language Models, Thinking Beyond the Memory LimitPlanning and Reasoning4 min
Stage 03 · about 1 h
The anatomy of an agent
What are the parts of an agent, and how does the loop run?
After this stage you can: Name the parts every agent shares, trace one turn of the loop, design tools a model can use, and keep the model provider swappable.
- Anatomy of an AI AgentArchitecture and System Design14 min
- The Agent Loop PatternArchitecture and System Design14 min
- Tool DesignArchitecture and System Design16 min
- Model-Provider Abstraction and Multi-Model StrategyArchitecture and System Design14 min
- Prompt ArchitectureArchitecture and System Design4 min
- What Is an Agent Harness?Building Coding Agents and Harnesses12 min
- The Agent LoopBuilding Coding Agents and Harnesses13 min
Stage 04 · about 1 h
Context engineering
Why does my agent get worse as the conversation grows?
After this stage you can: Recognize context rot, pollution and confusion, and apply the four moves: reduce, offload, isolate and retrieve.
- What Context Engineering Is, and Why It Replaced Prompt EngineeringContext Engineering5 min
- How Context Goes Wrong: Rot, Pollution, and ConfusionContext Engineering4 min
- The Four Moves: Reduce, Offload, Isolate, RetrieveContext Engineering7 min
- Practical Lessons from Building ManusContext Engineering5 min
- Context Engineering and MemoryArchitecture and System Design14 min
- Tokens, Context Windows, and the Quadratic ProblemBuilding Coding Agents and Harnesses13 min
- Prompt Caching and Context ManagementBuilding Coding Agents and Harnesses16 min
Stage 05 · about 1 h
Retrieval and agentic RAG
When should an agent look things up, and how?
After this stage you can: Choose between RAG, tools and long context, place a system on the path from naive to agentic RAG, and know when agentic RAG is not worth it.
- Retrieval: RAG vs Tools vs Long ContextArchitecture and System Design4 min
- From Naive RAG to Agentic RAG: The EvolutionAgentic RAG4 min
- The Building Blocks of Agentic IntelligenceAgentic RAG5 min
- The Taxonomy of Agentic RAG SystemsAgentic RAG6 min
- Practical Guidance: When and How to Use Agentic RAGAgentic RAG4 min
Stage 06 · about 1 h
Agent memory
How does an agent remember anything between runs?
After this stage you can: Describe the write, manage and read loop, the four memory types, and the ways stored memory drifts, goes stale or gets poisoned.
- Why Memory Matters, and the Write-Manage-Read LoopAgentic Memory4 min
- The Four Types of MemoryAgentic Memory5 min
- How Memory Is Built and RetrievedAgentic Memory9 min
- How Memory FailsAgentic Memory6 min
- Governing Evolving Memory (the SSGM Framework)Agentic Memory6 min
- Memory Outside the WeightsBuilding Coding Agents and Harnesses5 min
Stage 07 · about 1 h
Multi-agent systems
When do several agents beat one?
After this stage you can: Weigh the case for and against multi-agent designs, name the common failure modes, and decide from the task rather than from fashion.
- Single Agent versus Multi-Agent: The Core TradeoffMulti-Agent Systems4 min
- The Case For Multi-Agent: Anthropic's Research SystemMulti-Agent Systems7 min
- The Case Against: Cognition's "Don't Build Multi-Agents"Multi-Agent Systems6 min
- Why Multi-Agent Systems Fail: The MAST TaxonomyMulti-Agent Systems5 min
- Reconciling the Debate: It Was Never Single versus MultiMulti-Agent Systems5 min
- Subagents and Multi-Agent OrchestrationBuilding Coding Agents and Harnesses6 min
Stage 08 · about 1 h
Build a coding agent
How do Claude Code, Codex and Cursor work, and can I build one?
After this stage you can: Assemble a small terminal coding agent: layered prompts, tool execution behind approvals, skills and MCP, hooks, and a subagent.
- Building the PromptBuilding Coding Agents and Harnesses15 min
- Tools and Tool ExecutionBuilding Coding Agents and Harnesses4 min
- Sandboxing, Approvals, and CheckpointsBuilding Coding Agents and Harnesses5 min
- Parallelism, the Responses API, and the App ServerBuilding Coding Agents and Harnesses6 min
- Skills, MCP, and Deterministic ComputationBuilding Coding Agents and Harnesses6 min
- Observability, Hooks, and the Agent SDKBuilding Coding Agents and Harnesses5 min
- Code Review and Security AgentsBuilding Coding Agents and Harnesses6 min
- Autonomous Task Agents: Manus and CodeActBuilding Coding Agents and Harnesses6 min
- Deep Research Agents and How They Are TrainedBuilding Coding Agents and Harnesses7 min
- Building the Full Mini-HarnessBuilding Coding Agents and Harnesses4 min
Stage 09 · about 1 h
Run agents in production
What changes when real users, tenants and bills arrive?
After this stage you can: Plan streaming, data, tenancy, secrets, retries, cost, observability and scaling, then check a design against a reference architecture.
- Streaming and Real-Time UXArchitecture and System Design5 min
- Data Modeling for AgentsArchitecture and System Design5 min
- Document and File Processing PipelinesArchitecture and System Design5 min
- Security, Auth, and Multi-TenancyArchitecture and System Design5 min
- Secrets and Bring-Your-Own-KeyArchitecture and System Design4 min
- Reliability: Retries, Idempotency, and Failure HandlingArchitecture and System Design5 min
- Cost, Latency, and Model TieringArchitecture and System Design5 min
- Observability and EvaluationArchitecture and System Design4 min
- Scaling and InfrastructureArchitecture and System Design5 min
- Domain-Specific and Regulated-Industry AgentsArchitecture and System Design5 min
- Production Realities: Economics, Security, and GovernanceBuilding Coding Agents and Harnesses7 min
- Reference Architecture and a Design ChecklistArchitecture and System Design5 min
Stage 10 · about 1 h
Measure what better means
How do I know a model or an agent actually improved?
After this stage you can: Read a benchmark for what it can and cannot claim, and use LLM judges, executable tests and human preference for the questions each one answers.
Papers explained here: Judging LLM-as-a-Judge (2023), BIG-Bench (2022), SWE-bench (2023), Chatbot Arena (2024)
- Judging Models, How Do We Measure Quality?Foundational Modelling3 min
- Start Here: Benchmarks, Explained SimplyBenchmarks3 min
- BIG-Bench, Testing the Full Breadth of What a Model Can DoBenchmarks4 min
- SWE-bench, Can a Model Fix a Real Bug in Real Code?Benchmarks3 min
- Chatbot Arena, Letting Real People Pick the WinnerBenchmarks4 min
Questions about this roadmap
- How long does it take to learn AI agents?
- Reading this roadmap end to end takes about 7 hours: 70 chapters across 10 stages. Plan for longer, because the build stage asks you to write code and the production stage reads best next to a system you run. Every chapter stands on its own, so you can skip what you already know.
- Do I need machine learning math first?
- No. Stage 1 explains attention, scaling and fine-tuning in plain language. What helps more is reading code: the agent chapters walk through real Python and TypeScript from open-source agents.
- Is this an AI engineer roadmap or a machine learning roadmap?
- It is for engineers who build with models rather than train them. Stages 1, 2 and 10 cover the research you need to reason about model behavior; the other stages are about building, running and evaluating agents.
- Which agent framework should I learn first?
- Learn the mechanisms first. Frameworks wrap the same loop, tools, context and memory that stages 3 to 6 cover, so the ideas carry over to whichever one you pick, and you can see when a framework hides a decision you need to make yourself.
- What should I build to practice?
- Stage 8 ends by assembling a small terminal coding agent of a few hundred lines. It runs the loop, builds layered prompts, manages context, runs tools behind an approval gate, loads project memory and skills, and can delegate to a subagent.
- Is the roadmap free?
- Yes. Every chapter is free to read with no sign-up, as one page or as a sequence of slides.