This is a learning order for developers and career switchers who know some Python and want to build AI agents. The order is our reading of these sources, not an official curriculum. The sources are Anthropic engineering posts, the Model Context Protocol docs, the OpenAI Agents SDK docs, the OWASP GenAI Security Project, and course pages from Hugging Face, Claude Academy, LangChain Academy, and DeepLearning.AI. Each stage covers what to learn, why it sits at that point in the sequence, one or two linked resources, and a small project. Project ideas are labeled as our suggestion.
What does an AI agent engineer build?
In our reading, an agent engineer builds software around large language model (LLM) API calls. Anthropic calls all variations "agentic systems" and describes the basic building block as the augmented LLM, an LLM enhanced with retrieval, tools, and memory (Building effective agents, published Dec 19, 2024). If that building block is new to you, start with our explainer on what an AI agent is.
In our reading, the work spans writing prompts, deciding what goes into the model's context, implementing and documenting tools, wiring retrieval, orchestrating model calls, measuring behavior with evals, and adding guardrails before shipping. Anthropic recommends "finding the simplest solution possible, and only increasing complexity when needed." It says this might mean not building agentic systems at all.
Workflows vs agents: the first idea to learn
Before any framework, learn the distinction Anthropic draws in Building effective agents. "Workflows are systems where LLMs and tools are orchestrated through predefined code paths." "Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks."
Two consequences follow:
- Many tasks do not need an agent. "For many applications, however, optimizing single LLM calls with retrieval and in-context examples is usually enough."
- Agentic systems often trade latency and cost for better task performance, and Anthropic says to consider when that tradeoff makes sense.
The rest of this roadmap moves from single model calls to the parts you add to them (prompts, tools, retrieval), then to workflows, then to the agent loop, then to the testing and safety work around it.
The roadmap at a glance
- Python and API basics
- Prompts and context
- Tool use
- Retrieval and memory
- Workflow patterns
- The agent loop and frameworks
- MCP
- Evals
- Security and guardrails
- Ship and observe
In our reading, each stage builds on the ones above it.
Stage: Python and API basics
What to learn: enough Python to make HTTP calls, parse JSON, handle errors, and write functions and loops. Then call an LLM API without a wrapper. Anthropic suggests developers start by using LLM APIs directly, and notes that many patterns can be implemented in a few lines of code (Building effective agents). The Hugging Face AI Agents Course lists basic knowledge of Python and basic knowledge of LLMs as its prerequisites.
Why it comes here: every later stage, from tools to evals, is code you write around raw model calls.
Project idea (our suggestion): write a command line script that sends a prompt to a model API and prints the response. Then extend it to carry conversation history across turns.
Stage: Prompts and context
What to learn: context refers to the set of tokens included when sampling from an LLM. Context engineering is iterative: the curation happens each time you decide what to pass to the model, in contrast to the discrete task of writing a prompt (Effective context engineering for AI agents, published Sep 29, 2025). The same post says models remain capable at longer contexts but may show reduced precision for information retrieval and long-range reasoning compared to shorter contexts. For background on that limit, see our explainer on the context window.
Why it comes here: in our reading, context decisions shape every later stage, and Anthropic notes that a single optimized call with retrieval and in-context examples is usually enough for many applications (Building effective agents).
Project idea (our suggestion): build a summarizer for a long document. Compare passing the full text with passing selected sections, and note where the output changes.
Stage: Tool use
What to learn: tools let a model act on systems. Anthropic describes tools as "a new kind of software which reflects a contract between deterministic systems and non-deterministic agents" (Writing effective tools for agents, published Sep 11, 2025). That post lists principles: choosing the right tools to implement (and not to implement), namespacing tools to define clear boundaries, returning meaningful context from tools, optimizing tool responses for token efficiency, and prompt-engineering tool descriptions and specs. Its process: build and test prototypes of your tools, create and run evaluations of the tools with agents, then use agents like Claude Code to improve tool performance.
Building effective agents adds the interface angle: carefully craft the agent-computer interface (ACI) through thorough tool documentation and testing. While building its SWE-bench agent, Anthropic says it spent more time optimizing tools than the overall prompt, and it changed a tool to always require absolute filepaths after the model made mistakes with relative filepaths.
If tool calls themselves are new to you, our explainer on function calling covers how a model asks your app to run a tool and what comes back.
Why it comes here: tools are one of the three augmentations Anthropic names for the augmented LLM, and the agent loop is built on them.
Resources: the Anthropic tools post above, and Claude Academy's Tool use with the Messages API (9 lessons, 1 quiz).
Project idea (our suggestion): give a model two tools, a calculator and a file reader. Log every call and response, then rewrite the tool descriptions based on the errors you see.
Stage: Retrieval and memory
What to learn: retrieval is another of those augmentations (Building effective agents). Learn how RAG works, and note that Anthropic says teams are augmenting embedding-based retrieval with "just in time" context strategies (Effective context engineering for AI agents). For memory, the OpenAI Agents SDK docs list Sessions, a persistent memory layer, and Introduction to LangGraph includes modules on State and Memory and Long-Term Memory.
Why it comes here: retrieval builds directly on the context skills from the Prompts and context stage, and agents in a loop need stored state across turns.
Project idea (our suggestion): build a question-answering script over a folder of notes using embeddings and a vector database. Then add a store that remembers previous answers within a session.
Stage: Workflow patterns
What to learn: Anthropic names five workflow patterns in Building effective agents: prompt chaining, routing, parallelization (sectioning and voting), orchestrator-workers, and evaluator-optimizer. In our reading, because workflows run through predefined code paths, you can build each one in plain Python first. The same post says that if you use a framework, understand the underlying code, because frameworks can create extra layers of abstraction that obscure prompts and responses and make them harder to debug. Agentic AI with Andrew Ng on DeepLearning.AI covers four design patterns: reflection, tool use, planning, and multi-agent.
Why it comes here: workflows let you compose models in a controlled, testable way before you hand control to the model itself in the agent loop.
Project idea (our suggestion): implement a three-step prompt chain without a framework: outline, draft, critique, with each step's output passed to the next.
Stage: The agent loop and frameworks
What to learn: agents "are typically just LLMs using tools based on environmental feedback in a loop" (Building effective agents). The post says agents should gain "ground truth" from the environment at each step, such as tool call results or code execution, and that it is common to include stopping conditions such as a maximum number of iterations. It warns that the autonomous nature of agents means higher costs and the potential for compounding errors, and recommends extensive testing in sandboxed environments with appropriate guardrails. Its three core principles: maintain simplicity in the agent's design, prioritize transparency by explicitly showing the agent's planning steps, and carefully craft the agent-computer interface. A note at the top of the post says much of the tooling landscape it describes has changed since December 2024, and points to how Anthropic built Claude Managed Agents and the Managed Agents documentation.
On frameworks, the OpenAI Agents SDK docs list its primitives: Agents (LLMs equipped with instructions and tools), Agents as tools and Handoffs (delegate to other agents), and Guardrails (validation of agent inputs and outputs), with built-in tracing. Other listed features include Sessions, Human in the loop, MCP server tool calling, Function tools, and Sandbox agents that run specialists inside isolated workspaces. The docs say to use the Responses API directly when you want to own the loop, tool dispatch, and state handling yourself, and to use the SDK when you want the runtime to manage turns, tool execution, guardrails, handoffs, or sessions. The Hugging Face AI Agents Course has units on Agent Fundamentals (tools, thoughts, actions, observations) and Frameworks, and uses smolagents, LlamaIndex, and LangGraph.
Why it comes here: the loop combines tools, retrieval, and orchestration. Writing those parts yourself first makes framework behavior easier to debug.
Project idea (our suggestion): build an agent loop from scratch with a maximum iteration count, print the planning step each turn, and run it inside a sandbox directory.
Stage: MCP
What to learn: "MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems" (MCP docs, which show version 2026-07-28 as latest). It connects AI applications like Claude or ChatGPT to data sources, tools, and workflows. The docs compare it to a USB-C port for AI applications and list clients including Claude, ChatGPT, Visual Studio Code, and Cursor. See also our plain English MCP guide. Claude Academy's Introduction to Model Context Protocol (10 lessons, 1 quiz, 1 hr) covers building MCP servers and clients with the Python SDK, including tools, resources, and prompts.
Why it comes here: MCP standardizes the tool layer you learned to build by hand in the Tool use stage.
Project idea (our suggestion): expose one tool from the Tool use stage as an MCP server, then call it from an MCP client.
Stage: Evals
What to learn: an evaluation ("eval") is a test for an AI system: give an AI an input, then apply grading logic to its output to measure success (Demystifying evals for AI agents, published Jan 9, 2026). The vocabulary from that post: a task is a single test with defined inputs and success criteria, each attempt is a trial, a grader is logic that scores some aspect of performance, a transcript (trace or trajectory) is the complete record of a trial, and the outcome is the final state in the environment. A flight-booking agent may say the flight is booked, but the outcome is whether a reservation exists in the database. On size: "In reality, 20-50 simple tasks drawn from real failures is a great start." Capability evals should start at a low pass rate, and regression evals should have a nearly 100% pass rate. The post's closing advice is to read the transcripts.
Why it comes here: evals measure everything built so far, and the Security and guardrails stage depends on being able to detect failures.
Resources: the Anthropic evals post above, and Claude Academy's Introduction to evals (4 lessons, 1 quiz).
Project idea (our suggestion): collect 20 real failures from your agent runs, write each one as a task with a grader, and rerun the set after every change.
Stage: Security and guardrails
What to learn: the OWASP GenAI Security Project lists prompt injection as LLM01:2025. Prompt injection occurs when user prompts alter the LLM's behavior or output in unintended ways, and indirect prompt injections occur when an LLM accepts input from external sources, such as websites or files (OWASP LLM01:2025). Possible outcomes listed include providing unauthorized access to functions available to the LLM and executing arbitrary commands in connected systems. Mitigations listed include "Enforce privilege control and least privilege access" and "Require human approval for high-risk actions". See our guide to AI agent prompt injection safety. On the framework side, the OpenAI Agents SDK docs list Guardrails, Human in the loop, and Sandbox agents, and Anthropic recommends sandboxed testing with appropriate guardrails.
Why it comes here: an agent that calls tools in a loop can act on injected instructions, so this stage builds on the loop, the tools, and the evals.
Project idea (our suggestion): point your agent at a page containing a hidden instruction that tries to redirect it, record what happens, then add an approval step before any tool that changes data.
Stage: Ship and observe
What to learn: tracing and debugging in production. The OpenAI Agents SDK docs describe built-in tracing to visualize and debug agentic flows. The Hugging Face AI Agents Course includes a bonus unit on agent observability and evaluation. Claude Academy's Building with the Claude API (67 lessons, 8 quizzes, 9 hr) covers prompting, tool use, RAG, agents, MCP, and production patterns.
Why it comes last: shipping depends on every earlier part, and observation is how you keep a running loop inside its stopping conditions, cost budget, and guardrails.
Project idea (our suggestion): add tracing to your agent loop, record tokens and iterations per run, and review one full transcript at a time.
Courses for each stage
- Hugging Face AI Agents Course: the page calls it a "free course" and says the certification process is "completely free", with no deadline for certification. Units: Onboarding, Agent Fundamentals (tools, thoughts, actions, observations), Frameworks, Use Cases, and a Final Assignment where you build an agent for a selected benchmark, with a student leaderboard. Bonus units include fine-tuning an LLM for function-calling and agent observability and evaluation. It uses smolagents, LlamaIndex, and LangGraph, and each chapter is designed for 1 week at approximately 3-4 hours of work per week. It maps to the Tool use stage, The agent loop and frameworks stage, and the Ship and observe stage.
- Claude Academy: the home page says "Free courses, tutorials, and use cases from Anthropic's education team." The Claude Platform list, as of Nov 9, 2026, includes Building with the Claude API, Tool use with the Messages API, Introduction to Model Context Protocol, and Introduction to evals. These map to the Prompts and context, Tool use, MCP, and Evals stages.
- LangChain Academy, Introduction to LangGraph: the page shows "Free", with 55 lessons and 6 hours of video content. Modules include State and Memory, UX and Human-in-the-Loop, Long-Term Memory, and Deployment. It maps to the Retrieval and memory stage through the Ship and observe stage.
- DeepLearning.AI, Agentic AI with Andrew Ng: intermediate level, 9h55m, page says updated Oct 30, 2026, covering reflection, tool use, planning, and multi-agent. The FAQ says you can audit it for free (watch videos, community forum) but without assessments, certificates, or project tools, and that Pro membership costs $25/mo billed annually and $30/mo billed monthly (USD). It maps to the Workflow patterns stage.
How long does it take?
The sources give course lengths, not an overall timeline:
- Hugging Face AI Agents Course: each chapter is designed for 1 week at approximately 3-4 hours of work per week.
- LangChain Academy, Introduction to LangGraph: 55 lessons, 6 hours of video content.
- Claude Academy: Building with the Claude API lists 9 hr, and Introduction to Model Context Protocol lists 1 hr.
- DeepLearning.AI, Agentic AI with Andrew Ng: 9h55m.
None of these sources states a total duration for reaching a working level as an agent engineer, so this article does not estimate one. Project time is on top of course time, and the amount depends on your schedule.
Bottom line
The sequence runs from raw API calls, through prompts and context, tools, and retrieval, into workflow patterns and the agent loop, then out through MCP, evals, security and guardrails, and shipping with observation. Each stage uses skills from the stages before it.
In our reading, the order follows the sources' own stress on simplicity. Anthropic's advice, "finding the simplest solution possible, and only increasing complexity when needed," also fits the roadmap: stay in the Prompts and context stage or the Workflow patterns stage as long as the task allows, and move to autonomous agents only when the simpler options fall short. For deeper reading offline, see our list of books on AI agents. For the wider job picture, see our AI engineer roadmap and our comparison of AI engineer vs ML engineer vs data scientist.
Sources
- Anthropic: Building effective agents
- Anthropic: Writing effective tools for agents
- Anthropic: Effective context engineering for AI agents
- Anthropic: Demystifying evals for AI agents
- Model Context Protocol: What is MCP?
- OpenAI Agents SDK documentation
- OWASP GenAI Security Project: LLM01:2025 Prompt Injection
- Hugging Face AI Agents Course
- Claude Academy and Claude Platform courses
- LangChain Academy: Introduction to LangGraph
- DeepLearning.AI: Agentic AI
