Skip to content
Agent YAP

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

  1. 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)

    1. Start Here: Foundational Modelling, Explained SimplyFoundational Modelling2 min
    2. The Transformer, the Engine Inside Every Modern ModelFoundational Modelling5 min
    3. Scaling Laws and Chinchilla, How Big Should a Model Be?Foundational Modelling4 min
    4. Alignment, Turning a Text Predictor Into a Helpful AssistantFoundational Modelling5 min
    5. LoRA, Fine-Tuning Giant Models on a BudgetFoundational Modelling4 min
    6. Mixtral and Mixture of Experts, More Brain, Same SpeedFoundational Modelling3 min
  2. 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)

    1. Start Here: Planning and Reasoning, Explained SimplyPlanning and Reasoning2 min
    2. Chain of Thought, Teaching Models to Think Out LoudPlanning and Reasoning4 min
    3. ReAct, Reasoning and Acting TogetherPlanning and Reasoning3 min
    4. Let's Verify Step by Step, Rewarding Good ReasoningPlanning and Reasoning3 min
    5. DeepSeek-R1, Learning to Reason Through Reinforcement LearningPlanning and Reasoning3 min
    6. Recursive Language Models, Thinking Beyond the Memory LimitPlanning and Reasoning4 min
  3. 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.

    1. Anatomy of an AI AgentArchitecture and System Design14 min
    2. The Agent Loop PatternArchitecture and System Design14 min
    3. Tool DesignArchitecture and System Design16 min
    4. Model-Provider Abstraction and Multi-Model StrategyArchitecture and System Design14 min
    5. Prompt ArchitectureArchitecture and System Design4 min
    6. What Is an Agent Harness?Building Coding Agents and Harnesses12 min
    7. The Agent LoopBuilding Coding Agents and Harnesses13 min
  4. 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.

    1. What Context Engineering Is, and Why It Replaced Prompt EngineeringContext Engineering5 min
    2. How Context Goes Wrong: Rot, Pollution, and ConfusionContext Engineering4 min
    3. The Four Moves: Reduce, Offload, Isolate, RetrieveContext Engineering7 min
    4. Practical Lessons from Building ManusContext Engineering5 min
    5. Context Engineering and MemoryArchitecture and System Design14 min
    6. Tokens, Context Windows, and the Quadratic ProblemBuilding Coding Agents and Harnesses13 min
    7. Prompt Caching and Context ManagementBuilding Coding Agents and Harnesses16 min
  5. 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.

    1. Retrieval: RAG vs Tools vs Long ContextArchitecture and System Design4 min
    2. From Naive RAG to Agentic RAG: The EvolutionAgentic RAG4 min
    3. The Building Blocks of Agentic IntelligenceAgentic RAG5 min
    4. The Taxonomy of Agentic RAG SystemsAgentic RAG6 min
    5. Practical Guidance: When and How to Use Agentic RAGAgentic RAG4 min
  6. 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.

    1. Why Memory Matters, and the Write-Manage-Read LoopAgentic Memory4 min
    2. The Four Types of MemoryAgentic Memory5 min
    3. How Memory Is Built and RetrievedAgentic Memory9 min
    4. How Memory FailsAgentic Memory6 min
    5. Governing Evolving Memory (the SSGM Framework)Agentic Memory6 min
    6. Memory Outside the WeightsBuilding Coding Agents and Harnesses5 min
  7. 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.

    1. Single Agent versus Multi-Agent: The Core TradeoffMulti-Agent Systems4 min
    2. The Case For Multi-Agent: Anthropic's Research SystemMulti-Agent Systems7 min
    3. The Case Against: Cognition's "Don't Build Multi-Agents"Multi-Agent Systems6 min
    4. Why Multi-Agent Systems Fail: The MAST TaxonomyMulti-Agent Systems5 min
    5. Reconciling the Debate: It Was Never Single versus MultiMulti-Agent Systems5 min
    6. Subagents and Multi-Agent OrchestrationBuilding Coding Agents and Harnesses6 min
  8. 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.

    1. Building the PromptBuilding Coding Agents and Harnesses15 min
    2. Tools and Tool ExecutionBuilding Coding Agents and Harnesses4 min
    3. Sandboxing, Approvals, and CheckpointsBuilding Coding Agents and Harnesses5 min
    4. Parallelism, the Responses API, and the App ServerBuilding Coding Agents and Harnesses6 min
    5. Skills, MCP, and Deterministic ComputationBuilding Coding Agents and Harnesses6 min
    6. Observability, Hooks, and the Agent SDKBuilding Coding Agents and Harnesses5 min
    7. Code Review and Security AgentsBuilding Coding Agents and Harnesses6 min
    8. Autonomous Task Agents: Manus and CodeActBuilding Coding Agents and Harnesses6 min
    9. Deep Research Agents and How They Are TrainedBuilding Coding Agents and Harnesses7 min
    10. Building the Full Mini-HarnessBuilding Coding Agents and Harnesses4 min
  9. 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.

    1. Streaming and Real-Time UXArchitecture and System Design5 min
    2. Data Modeling for AgentsArchitecture and System Design5 min
    3. Document and File Processing PipelinesArchitecture and System Design5 min
    4. Security, Auth, and Multi-TenancyArchitecture and System Design5 min
    5. Secrets and Bring-Your-Own-KeyArchitecture and System Design4 min
    6. Reliability: Retries, Idempotency, and Failure HandlingArchitecture and System Design5 min
    7. Cost, Latency, and Model TieringArchitecture and System Design5 min
    8. Observability and EvaluationArchitecture and System Design4 min
    9. Scaling and InfrastructureArchitecture and System Design5 min
    10. Domain-Specific and Regulated-Industry AgentsArchitecture and System Design5 min
    11. Production Realities: Economics, Security, and GovernanceBuilding Coding Agents and Harnesses7 min
    12. Reference Architecture and a Design ChecklistArchitecture and System Design5 min
  10. 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)

    1. Judging Models, How Do We Measure Quality?Foundational Modelling3 min
    2. Start Here: Benchmarks, Explained SimplyBenchmarks3 min
    3. BIG-Bench, Testing the Full Breadth of What a Model Can DoBenchmarks4 min
    4. SWE-bench, Can a Model Fix a Real Bug in Real Code?Benchmarks3 min
    5. 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.