agentic-ai-roadmap

Learning to build AI agents

The path I'd follow if I were starting today, from "what even is an agent" to running one in production. Almost everything here is free.

How to use this

Go in order. Steps marked optional can be skipped without breaking anything later on.

Most steps end with a small build it task. Please actually do them. Watching a course feels like progress, but you only find out what you don't understand when you try to build something.

Every task ends with writing an Agent Skill: a folder with a SKILL.md file that teaches a coding agent how to do what you just learned. By the end you'll have a set of skills you can drop into Claude Code or any other tool that supports them, and writing them down is a good test of whether you really get it. There's a starter template in the skills folder of the repo, and step 4 covers how skills work properly.

  1. 01The mental model
  2. 02A structured course
  3. 03LangGraph & Deep Agents
  4. 04MCP & Agent Skills
  5. 05Tracing & evals
  6. 06Shipping it
  7. 07Safety & governance
  8. 08Two more frameworks
  9. ··Visual builders
  10. ··Going further
01

The mental model

Before touching any code, get a feel for what an agent is and isn't. Watch the three videos in order, then read the three pieces below them. That's a weekend, tops.

watch
then read
build it Write your first skill, agent-patterns. Given a problem description, it should decide whether you need a workflow or an agent and which pattern fits, with a one-line reason. Write it in your own words, without copying from the articles.
02

A structured course optional

If you learn better with lessons and exercises than with reading, pick one of these. Neither ties you to a framework.

03

LangGraph & Deep Agents

LangGraph is the framework I'd learn first. It gives you control over state and flow, and the learning material around it is the best I've found. Deep Agents is LangChain's newer library on top of it, for long-running agents that plan, spin off sub-agents and work with files.

start here
then Deep Agents
LangChain docs · GitHub
Planning tools, sub-agents, a virtual file system and long-term memory, packaged so you don't have to wire them up yourself. Read this once LangGraph feels comfortable.
Project: Deep Agentsoptional
LangChain Academy
A guided project if you'd rather build one end to end than read the docs.
optional, if you want more
build it Build a small LangGraph agent for something you actually do, like sorting your inbox or summarising papers. Then write a langgraph-scaffold skill describing how you set up a new graph: how you shape the state, where the tools live, which checkpointer you use and how you test it.
04

MCP & Agent Skills

These two ideas show up everywhere now. MCP is the standard way to give an agent tools and data. Skills are how you give it know-how: instructions, scripts and references it loads only when it needs them. Read the docs here rather than a third-party tutorial, because they're short and kept up to date.

model context protocol
agent skills
build it Turn one of the tools from your step 3 agent into a FastMCP server and connect it to Claude Desktop, Cursor or whatever you use. Then go back and clean up the skills you wrote earlier using what you now know about the format. The new skill for this step is mcp-server: how to add a tool to your server, test it and register it.
05

Tracing & evals

Agents get things wrong in ways you won't notice from a handful of manual tests. You need to see every step the agent took (tracing), and you need a repeatable way to check it's still good after you change something (evals). People skip this step a lot, and it's usually what separates a demo from a product.

tracing & observability
what to measure
Microsoft Learn · Azure AI Foundry
Clear definitions of each metric and how it's scored. Useful even if you never use Azure. Coherence and fluency are on a separate page.
Ragas metrics
Ragas docs
An open-source library for the same kind of metrics, including agent-specific ones like tool call accuracy.
The four metrics people ask about, in plain words:
Groundedness
Is the answer supported by the sources it was given, or did the model make it up?
Relevance
Does it actually answer what was asked?
Coherence
Does it hang together and read logically?
Explainability
Can you show why the agent did what it did? For agents this mostly comes from your traces: which tools were called, with what inputs, and which documents the answer was based on.
build it Make a dataset of 20 real inputs for your agent, with what a good answer looks like for each. Run it in LangSmith with at least groundedness and relevance, change your prompt, and run it again. Write an eval-checklist skill describing what you run before calling a change done. There's an example of this one in the repo.
06

Shipping it

An agent running in a notebook isn't finished. You need an API in front of it, somewhere to store state, a simple UI so other people can try it, and a place to run it. Don't learn all of these in depth. Learn enough of each to get your agent online.

backend
database
a simple frontend
containers & cloud
You don't need both clouds. Pick whichever one your company (or the company you want to work for) uses. The concepts carry over.
build it Put your agent behind FastAPI, store its state in Postgres, add a Chainlit or Streamlit UI, containerise it and deploy it to one cloud. Send the link to a friend and watch them use it. Your deploy-agent skill should be the exact steps you followed, including the ones that went wrong.
07

Safety & governance

Once your agent can read untrusted input and take real actions, things can go wrong in ways that matter. In a company, someone will eventually ask you how you know it's safe. These are the resources that'll help you answer.

In practice, governance mostly means things you've already set up: traces so you can explain any decision (step 5), evals that track groundedness and relevance over time (step 5), human approval before risky actions (LangGraph's interrupts, step 3), and logs you keep.
build it Run your deployed agent against the OWASP list and fix the worst issue you find. Then write a pre-launch-review skill: the checklist an agent (or you) should go through before anything goes live.
08

Two more frameworks

These are worth your time even if you've been doing this for a while. They do some things better than LangGraph, and knowing them makes you better at choosing a framework.

··

Visual builders optional

Drag-and-drop tools for building agents and automations. You don't need them to be an agent developer, but they're great for quick prototypes and for working with people who don't code. Pick one.

··

Going further

For when you've done the path and want to go wider. Building agents for real ends up being a lot of plain software engineering, especially distributed systems, so the second group here matters more than it looks.

more frameworks
comparing frameworks
distributed systems
worth paying for