Learning Paths: Three Routes

This site has dozens of pages. Reading it cover to cover is one way, but it isn't right for everyone. You most likely opened this site for one of three reasons:

1. I need a job — you're interviewing for an Agent role within 1–3 months and need to build a knowledge framework fast, shore up project experience, and anticipate interview questions;
2. I want to learn this properly — you have enough time to understand agents thoroughly, from principles to production, whether you're changing careers or pivoting;
3. I'm already building — you have an agent running right now, and when you hit a problem you want to quickly find "the one page I should read."

The three routes below map onto these three situations. They are not mutually exclusive: a common real-world path is to use Route 3 to solve an immediate problem, let that problem spark enough curiosity to move into Route 2, and finish with a Route 1 sprint. Find the row you belong in, then start.

1. Route Overview: Choose Your Entry Point

Dimension	Route 1: Job Sprint	Route 2: Systematic Deep-Dive	Route 3: Desk Reference
Who it's for	Interviewing for Agent roles within 1–3 months	Engineers who want solid foundations	Working builders with an agent in flight
Time commitment	~2 weeks, 3–4 hours a day	~8 weeks, 6–10 hours a week	On demand, 15–30 minutes per lookup
Reading style	Deep-read the core pages, skim the rest	Week by week, deep-read everything	Only pages relevant to the current problem
Deliverable	Interview-ready knowledge + a portfolio project	A fully self-built agent + study notes	A solution to the problem at hand
Success criterion	Can answer all 20 self-check questions aloud	All weekly milestones met	The problem is solved

One counterintuitive suggestion

Take none of the three routes as "read it all, then build." Agent engineering is an empirical discipline. One of Anthropic's core conclusions in Building Effective Agents is that the most successful implementations tend to use the simplest composable patterns — and that kind of judgment only comes from stepping on rakes, not from reading. Every route has "write code that same day" exercises built in. Do them for real.

2. Route 1: The Job-Hunting Sprint (~2 Weeks)

Who this is for: You already write Python/TypeScript and have basic hands-on LLM experience (you've called an API), but you haven't built agents systematically — and you have interviews within 1–3 months.

Core strategy: Interviews test breadth far more than depth. Two weeks won't make you an expert, but it's enough to let you "explain clearly what it is, why it matters, and what pitfalls to expect" on every high-frequency topic. The goal is no blind spots, not exceptional depth in one spot.

Week 1: See the Whole Picture + Master the Core Components

Day 1 (Concept literacy, ~4 hours)

• Read What Is an AI Agent, Concept Clarification, and A Brief History.
• Exercise: without looking anything up, explain to an imaginary coworker in 3 minutes how a workflow differs from an agent, and why "a chatbot that can call tools" isn't an agent. If it doesn't come out smoothly, go back and reread.
• Before bed, skim the glossary and flag every term you can't explain.

Day 2 (Full anatomy, ~4 hours)

• Read Agent System Anatomy, then redraw the agent component diagram from memory on paper: Agent Loop, planning, tools, memory, context — plus the data flow between them.
• Exercise: open any agent product you've used (Claude Code or Cursor works) and point at each component in your diagram and show what it looks like in that product.

Day 3–4 (Agent Loop + prompts + context, ~8 hours)

• Read Agent Loop, Prompt Engineering, and Context Engineering — the highest-frequency trio in interviews.
• Exercise (mandatory, hands-on): using raw API calls and no framework, write a minimal 30–50 line agent loop — a while loop + tool-call dispatch + termination conditions. If you can't write it, you haven't understood it; go back and reread. The step-by-step tutorial has a complete reference.

Day 5 (Tools & MCP, ~4 hours)

• Read Tools & MCP.
• Exercise: add a tool to your minimal agent (weather lookup, file reading — anything), then answer this: what specific problem does MCP solve, and when is plain function calling enough? This is the classic 2026 interview question that separates "actually understands it" from "memorized it."

Day 6 (RAG + memory, ~4 hours)

• Read RAG and Memory Systems.
• Exercise: articulate the trade-off boundary between RAG and "just stuff the material into the context"; articulate what short-term and long-term memory concretely mean in this site's terminology.

Day 7 (Review day, ~3 hours)

• Reread the weak spots you flagged on Days 1–6.
• Do an oral self-test with the first 10 questions of the self-check list; go back and patch whatever you can't answer.

Week 2: Advanced Topics + Wiring Up the Job Search

Day 8 (Advanced architecture, ~4 hours)

• Read Multi-Agent Architectures and Human-in-the-Loop.
• Burn this one-line judgment into memory: multi-agent is over-engineering in most cases — get context engineering solid on a single agent first. Passing means you can also give the counterexamples (when multi-agent genuinely is needed).

Day 9 (The engineering trifecta, ~4 hours)

• Read Evaluation, Observability, and Cost Optimization; skim Security.
• A perennial interview question: "How do you know your agent got better?" The canonical answer runs through evals + traces — see Evals in Practice.

Day 10 (Frameworks and products, ~4 hours)

• Read Choosing a Framework, then deep-read the one framework page that matches your target job's stack (LangGraph and the OpenAI Agents SDK are frequent flyers in 2026 job descriptions).
• Pick 2–3 product case studies: Claude Code, Cursor, and Devin first — interviewers very likely use them as conversation openers.

Day 11–12 (Portfolio project, ~8 hours)

• Pick a project from Portfolio Projects that you can turn into a demo in two days — and build it. Without an agent project on your résumé, everything above is armchair theory.
• In parallel, read Build Your Own and upgrade the toy loop you wrote on Days 3–4 into a project whose design trade-offs you can narrate.

Day 13 (Résumé and the job market, ~4 hours)

• Read The Job Landscape, JD Breakdowns, and Résumé Review; revise your résumé against the standards there.
• Use the Knowledge Map to check for any remaining blind spots.

Day 14 (Mock interviews, ~3 hours)

• Drill the Interview Question Bank: answer each question out loud first, then check the reference answer.
• Finish all 20 self-check questions. If you can't answer 16 or more, push the interview back a week.

The most common way this sprint fails

Spending the whole two weeks reading and writing zero code. One question from the interviewer — "in your project, how does the agent's loop terminate?" — punctures a read-only candidate. The hands-on blocks on Days 3–4 and Days 11–12 are not skippable.

3. Route 2: Systematic Deep-Dive (~8 Weeks)

Who this is for: Engineers who want agents as a medium-term career direction. 6–10 hours a week, reading plus hands-on practice. The final deliverable of this route is a self-built agent where you understand every line, plus notes/code good enough to show publicly.

The project that runs through all 8 weeks: starting in week 2, you keep iterating on one personal agent project (see Portfolio Projects for topic ideas), folding in what you learned that week. This works far better than building a new toy every week.

Week 1: Concepts and History

• Read: What Is an AI Agent, Concept Clarification, A Brief History, Agent System Anatomy.
• Milestones: can explain the architectural line between workflow and agent; can draw the full agent component diagram and state each component's inputs and outputs; can say what ReAct, tool calling, and MCP each solved, roughly in order of appearance.

Week 2: Agent Loop and Prompts

• Read: Agent Loop, Prompt Engineering.
• Build: write a minimal agent loop on the raw API (see the step-by-step tutorial) — this becomes v0.1 of your main project.
• Milestones: can write a working loop with no framework; can explain the role and the cost of every category of content in a system prompt (persona, tool descriptions, boundaries, few-shots).

Week 3: Context Engineering

• Read: Context Engineering. This has been the industry's main theme since the second half of 2025, and Anthropic's Effective Context Engineering for AI Agents (see References) is worth reading in the original.
• Build: add context management to your main project — compaction, structured notes, trimming to a token budget; implement at least one.
• Milestones: can explain the "context rot" phenomenon; can say when compaction should fire and what it keeps vs. discards; can explain why context is the first lever on agent quality.

Week 4: Tools, MCP, and RAG

• Read: Tools & MCP, RAG.
• Build: wire 2–3 real tools into your main project; connect an MCP server to Claude Code or your own agent.
• Milestones: can write a tool definition that meets the "agent-computer interface" bar (self-explanatory parameters, actionable error messages); can state what MCP's client/server can and cannot do; can judge whether a scenario calls for RAG or just stuffing context.

Week 5: Memory and Planning

• Read: Memory Systems, Planning & Reasoning.
• Build: add a memory layer (file-based or vector-based, your pick) and an explicit planning step to your main project.
• Milestones: can distinguish short-term/long-term memory implementations and name each one's failure modes; can articulate the trade-offs between plan-and-execute and pure ReAct.

Week 6: Advanced Architecture

• Read: Multi-Agent Architectures, Human-in-the-Loop, Security.
• Build: add a human-approval gate to your main project (pause before high-risk tool calls and wait for confirmation).
• Milestones: can explain that sub-agent architectures solve context isolation, not "division of cognitive labor"; can enumerate the main attack surfaces of agent systems (prompt injection, tool misuse, data exfiltration) and their corresponding mitigations.

Week 7: Evaluation, Observability, and Cost

• Read: Evaluation, Observability, Cost Optimization, Evals in Practice.
• Build: create a 20–50 case eval set for your main project and run a baseline; wire up tracing (LangSmith, Langfuse, or your own logs all work); compute the cost per task.
• Milestones: can explain which of the three scorer types (code assertions, model grading, human review) fits which situation; can locate the exact turn where an agent went off the rails from a single trace; can rank cost levers (caching, routing to smaller models, compacting context) by priority.

Week 8: Frameworks, Products, and Portfolio Wrap-Up

• Read: Choosing a Framework plus the page for your chosen framework; three product case studies (Claude Code, Devin, Manus cover three representative shapes); read all of Design Principles and Common Pitfalls.
• Build: turn your main project into a public-ready repo — README, architecture diagram, AGENTS.md, eval report.
• Milestones: can walk a stranger through 10 minutes of design trade-offs without dead air; 18 or more of the 20 self-check questions answered.

Do you need to read papers?

The 8-week route doesn't force papers — build the engineering feel first. When you do want to go deeper, follow Paper Guides and the Core Papers list in the order laid out in Paper Reading Paths: ReAct → Toolformer → the work that followed. Far more efficient than randomly grazing arXiv.

4. Route 3: Desk Reference (Working Builders)

Who this is for: You have an agent running (or under construction) and a specific problem; you want to locate "the page I should read" fast. You're not chasing a complete curriculum — you want an executable next step within 15 minutes.

How to use it: find the row in the tables below that best matches your symptom, then read the listed pages in order. Every page opens with a problem definition, so within 30 seconds you can tell whether it's your problem. If not, move to the next page.

Behavioral Problems

Symptom	Read first	Then read
Agent wanders off, forgets the goal mid-task	Context Engineering	Planning & Reasoning
Infinite loop, calls the same tool over and over	Agent Loop	Common Pitfalls
Won't stop — the task is done but it keeps working	Agent Loop (termination section)	Prompt Engineering
Picks the wrong tool, fills in parameters wrong	Tools & MCP (tool definitions section)	Common Pitfalls
Quality collapses halfway through a long task	Context Engineering (compaction)	Memory Systems
Multi-step plans don't hold up; the plan diverges from reality	Planning & Reasoning	Design Principles

Engineering Problems

Symptom	Read first	Then read
Don't know whether to adopt a framework, or which one	Choosing a Framework	The framework's page (e.g. LangGraph)
After a change, can't tell whether things got better or worse	Evaluation	Evals in Practice
A production incident; can't localize which step failed	Observability	Evaluation
Token bill exploding	Cost Optimization	Context Engineering
Worried about prompt injection / data exfiltration	Security	Human-in-the-Loop
Poor retrieval; RAG answers the wrong question	RAG	Context Engineering
Can't remember user preferences across sessions	Memory Systems	Context Engineering
One agent can't cope; thinking about splitting into many	Multi-Agent Architectures	Design Principles
Need human review of critical actions without breaking the flow	Human-in-the-Loop	Security

Orientation Problems

Symptom	Read first
Drowning in jargon (Agentic RAG, Computer Use, Harness…)	Concept Clarification, Glossary
Want to see how the benchmark products do it	Product cases: Claude Code, Cursor, Devin, Manus, Perplexity
Want a side project to practice on	Portfolio Projects
Need to write an AGENTS.md for your agent project	Writing AGENTS.md
Want to track the research frontier	Paper Guides, Frontier Watch
Want curated off-site resources	Awesome Resources

The hidden use of the desk-reference route

When you look the same problem up a second time, it's no longer a one-off — it's a structural gap. That's the moment to stop, find the corresponding week in Route 2, and do a proper systematic pass. Quick lookups treat symptoms; the systematic track cures the disease.

5. Self-Check: 20 Questions

Once you've finished the site (by any route), you should be able to answer the following out loud, no notes. The first 10 are the floor for the job sprint; all 20 are the graduation bar for the systematic track. For anything you can't answer, the page to reread is in brackets.

Concepts and the big picture

1. What's the architectural difference between a workflow and an agent, and why does the distinction matter in practice? (Concept Clarification)
2. What components make up a complete agent, and how does data flow between them? (Agent System Anatomy)
3. Why is "most use cases shouldn't use an agent" the mainstream engineering consensus? (What Is an AI Agent)

Core components

4. What happens in each turn of the Agent Loop? What termination designs exist? (Agent Loop)
5. What's the biggest difference between writing an agent's system prompt and writing an ordinary prompt? (Prompt Engineering)
6. What is context rot? When should compaction fire? (Context Engineering)
7. What does a good tool definition look like? Why does Anthropic say to treat ACI the way we treat HCI? (Tools & MCP)
8. What problem does MCP solve? Where is its client/server boundary? When is it simpler to write plain function calls? (Tools & MCP)
9. In which scenarios should you use RAG, and when should you just put the material into the context? (RAG)
10. What are the implementation options and failure modes of short-term and long-term memory? (Memory Systems)

Advanced architecture

11. Plan-and-execute vs. a pure ReAct loop — which tasks suit each? (Planning & Reasoning)
12. What problem do multi-agent architectures actually solve, and why are they usually over-engineering? (Multi-Agent Architectures)
13. Which operations require human approval inside an agent flow, and how do you add them without wrecking the experience? (Human-in-the-Loop)
14. What are the main attack surfaces of an agent system, and how is each mitigated? (Security)

Engineering practice

15. "How do you know the agent got better?" — how do you build your eval system, and how do you choose among the three scorer types? (Evaluation)
16. Given a failed trace, what's your debugging sequence? (Observability)
17. What are the levers for reducing agent cost, and how do you prioritize them? (Cost Optimization)

Ecosystem and shipping

18. What are the design philosophies and best-fit scenarios of LangGraph, the OpenAI Agents SDK, and the Claude Agent SDK? (Choosing a Framework)
19. What are the representative architectural differences among Claude Code, Devin, and Manus? (Claude Code, Devin, Manus)
20. If you started a brand-new agent project tomorrow, what would your technology choices and week-one plan be? (Build Your Own, Design Principles)

How to use this list

Don't self-test silently — say each answer out loud (or write it down) for at least 90 seconds. The gap between "understanding it" and "explaining it" is exactly what interviews and engineering practice test. For any question that won't come out smoothly, open the bracketed page and reread the relevant section — you don't need the whole page.

References

• Building Effective Agents — Anthropic Engineering — the classic reference on agentic patterns; the workflow-vs-agent distinction originates here. Read the original on Route 1 Day 1 and Route 2 Week 1.
• Effective Context Engineering for AI Agents — Anthropic Engineering — published September 2025; the authoritative statement on context engineering and required reading for Route 2 Week 3.
• A Practical Guide to Building Agents — OpenAI — OpenAI's agent-building guide (34-page PDF); its breakdown of the model/tools/instructions triad is a good beginner companion.
• Introducing the Model Context Protocol — Anthropic — the original MCP announcement; first-hand material on its design motivation.
• MCP Interview Questions: Beginner to Advanced (2026) — DataCamp — MCP interview questions from a 2026 vantage point; useful as a supplementary self-test in sprint week 2.
• start-ai-engineering — GitHub — a curated collection of off-site AI-engineering learning resources, for reading beyond this site.