Agentic AI Engineer roadmap

Systems that decide what to do next, act on the world, and keep going without you watching. Everything worth learning to build them and keep them from causing damage.

17 stages265 topics

All roadmaps
0 of 265 done
Essential, don't skip Recommended, skip only with a reason Optional, awareness is enough Course on PracticAI

Assumes the AI engineer basics: Python, LLM APIs, prompting, structured output, and RAG. Section 1 lists the prerequisites - if most of it is unfamiliar, work through the general AI engineer roadmap first.

1

Prerequisites

          2

          Model Behaviour for Agents

                  3

                  Tool Design

                              4

                              Model Context Protocol

                                          5

                                          The Agent Loop

                                                      6

                                                      Planning and Decomposition

                                                              7

                                                              Context Engineering

                                                                      8

                                                                      Memory and State

                                                                              9

                                                                              Retrieval for Agents

                                                                                      10

                                                                                      Environments and Execution

                                                                                                  11

                                                                                                  Multi-Agent Systems

                                                                                                              12

                                                                                                              Safety, Permissions, Oversight

                                                                                                                          13

                                                                                                                          Evaluation

                                                                                                                                  14

                                                                                                                                  Observability and Debugging

                                                                                                                                          15

                                                                                                                                          Runtime and Infrastructure

                                                                                                                                                      16

                                                                                                                                                      Deployment and Operations

                                                                                                                                                              17

                                                                                                                                                              Professional Practice

                                                                                                                                                                      Capstone

                                                                                                                                                                      One agent that does real work on a real system, unattended, and can be trusted with it:

                                                                                                                                                                      • A bounded, well-specified job
                                                                                                                                                                      • Ten to twenty designed tools
                                                                                                                                                                      • MCP servers for external systems
                                                                                                                                                                      • A loop with iteration, time and cost limits
                                                                                                                                                                      • Sandboxed code execution
                                                                                                                                                                      • Durable state and resumability
                                                                                                                                                                      • Compaction for long runs
                                                                                                                                                                      • Approval gates on destructive actions
                                                                                                                                                                      • Full audit trail of every action
                                                                                                                                                                      • A trajectory eval suite that gates deploys
                                                                                                                                                                      • Traces, cost and latency dashboards
                                                                                                                                                                      • A documented rollback and kill switch

                                                                                                                                                                      Then run it against a hostile evaluator. If prompt injection in the data it reads can make it take an action you didn't authorise, it isn't finished.

                                                                                                                                                                      An agent that succeeds 90% of the time and fails silently is worse than one that succeeds 70% of the time and stops loudly. Most of the engineering here is in the second number, not the first.