AI Agent Engineer Learning Roadmap

This is a course map, not a pipeline that everyone must complete from start to finish. Choose a role path by your goal first, then return to the course map for prerequisites. A course is complete when you can deliver and verify its outcome, not merely when you have read its pages.

Roadmap status

This roadmap was checked against the current courses, example tests, and public-site rules on 2026-07-21. For volatile material such as protocols, SDKs, model catalogs, and regulation, use each course’s source_checked date, stable/experimental status, and current official sources.

All 57 top-level courses have been migrated to verifiable v2 IDs, knowledge domains, catalog order, hard prerequisites, and role-track order. The legacy ai_learning_stage/order fields now drive only the local, checkable Dataview stage map; the public homepage and course navigation use v2 fields. Personal completion state stays local and is removed from the public build. See Learning Route Metadata v2 Standard for the field contract.

Course map

Knowledge domain	Learning focus
Engineering and mathematical foundations	AI Foundations Learning Path · Python Fundamentals · Data Structures Fundamentals · JSON Learning Index · API Learning Path · Markdown · Git Learning Path · Linux Commands · Regular Expressions · Probability and Statistics · Linear Algebra · Calculus Fundamentals · Machine Learning · Deep Learning
Models and context	Modern LLM Capabilities and Model Selection · Prompt Engineering · Context Engineering Learning Path · LLM API Integration Learning Path
Retrieval and data	Vector Fundamentals · Data Cleaning · Data Annotation Learning Path · Document Parsing · Knowledge Base Construction · Chunking Strategies · Embeddings · Vector Databases · Semantic Search Learning Path · Reranking · RAG Learning Path
Multimodal systems	Multimodal AI Learning Path · OCR · Speech Recognition · Text to Speech · Real-Time Multimodal Interaction · Image Generation Learning Path · Video Generation Learning Path
Agent runtime	Tool Calling (including Function Calling) · MCP · Agent Core · Environment-based Agents · Agent Skills Learning Path · Agentic Design Patterns · Workflow Automation Learning Path · Multi-Agent Collaboration Learning Path
Framework practice	LangChain · CrewAI Learning Index
Evaluation and reliability	Data Visualization · Evaluation Framework Learning Path · Benchmark Design Learning Path · Synthetic Data
Safety and governance	AI Safety Learning Path · Privacy-Enhancing Technologies Learning Path · AI Governance Learning Path
Production operations	MLOps Learning Path · Runtime Monitoring Learning Path · LLMOps Learning Path
Frontier and reference	A2A Protocol

Four role-based paths

Path	Suggested progression	Primary learning artifact	Evidence of mastery
Agent application development	AI foundations → fill engineering foundations as needed → modern LLMs/prompting/context/API → early milestone → Tool Calling/Agent Core → runtime and frameworks as needed → workflow → data and complete evaluation → LLMOps → safety/privacy → optional multi-agent/A2A	A stateful, approvable, recoverable single agent	Offline tests cover authorization, idempotency, termination, adversarial observations, and failure recovery; can explain when to fall back to a deterministic workflow
RAG and knowledge bases	AI foundations → LLM application foundations → early milestone → data quality/document parsing/knowledge bases → chunking/vectors/embeddings/retrieval/reranking → RAG → visualization and complete evaluation → safety/privacy; multimodal ingestion and LangChain are optional branches	A two-pipeline RAG system with ACLs, citations, updates, and diagnosable failures	Reports ingestion, retrieval, generation, and end-to-end metrics separately; can trace an error sample to the responsible layer
Agent platform and reliability	AI foundations → LLMs and Agent Core → runtime/frameworks as needed → workflow → data quality/evaluation/synthesis/benchmarking → MLOps/LLMOps/monitoring → safety/privacy/governance → multi-agent collaboration → A2A interoperability as needed	An operating platform with traces, release gates, canaries, rollback, and incident drills	Repeated trials have comparable initial and final state; side effects, cost, latency, safety, and recovery all have gates and audit evidence
Multimodal and real-time interaction	AI foundations → modern LLMs → multimodal AI → OCR (recommended) and ASR/TTS (core) → Tool Calling/Agent Core → data and real-time interaction → complete evaluation/safety/privacy → optional generative media and multi-agent systems	An interruptible real-time prototype that can call tools and retain conversational state	Measures time to first token/audio and turn latency, interruption success, and recovery; can explain the trade-offs between cascaded and end-to-end speech designs

The table is a readable summary. The v2 list below is the verifiable snapshot of each course’s order and core/recommended/optional placement. An arrow means recommended progression, not that every intermediate course must be completed in full. The early safety and evaluation milestone is a small early quality gate assembled from existing chapters, not an invented course, and it does not require completing all of AI Safety or the evaluation framework in advance. Before production release, still complete the remaining safety, evaluation, and governance work proportionate to system risk. Add MCP only when you need standardized connections to external capabilities or context; add A2A only when independent agent applications need cross-framework or cross-organization interoperability. Choose LangChain/LangGraph, CrewAI, or ordinary Python from state, recovery, collaboration, and control needs; none is a hard prerequisite for every project.

Machine-verifiable role paths

The following list is generated from the v2 track metadata at the 57 course entries and is checked byte-for-byte in the public build. Order expresses learning progression in the role path; recommended and optional do not automatically become full-course hard prerequisites.

Agent application development

32 courses: 9 core, 13 recommended, and 10 optional.

Order	Course	Placement
1	AI Foundations Learning Path	Core
2	Python Fundamentals	Recommended
3	JSON Learning Index	Recommended
4	Data Structures Fundamentals	Recommended
5	API Learning Path	Recommended
6	Markdown	Recommended
7	Git Learning Path	Recommended
8	Linux Commands	Optional
9	Regular Expressions	Optional
10	Probability and Statistics	Recommended
11	Machine Learning	Recommended
12	Modern LLM Capabilities and Model Selection	Core
13	Prompt Engineering	Core
14	Context Engineering Learning Path	Core
15	LLM API Integration Learning Path	Core
16	Tool Calling (including Function Calling)	Core
17	Agent Core	Core
18	MCP	Optional
19	Environment-based Agents	Optional
20	Agent Skills Learning Path	Optional
21	Agentic Design Patterns	Optional
22	LangChain	Optional
23	CrewAI Learning Index	Optional
24	Workflow Automation Learning Path	Core
25	Data Annotation Learning Path	Recommended
26	Data Visualization	Recommended
27	Evaluation Framework Learning Path	Recommended
28	LLMOps Learning Path	Recommended
29	AI Safety Learning Path	Core
30	Privacy-Enhancing Technologies Learning Path	Recommended
31	Multi-Agent Collaboration Learning Path	Optional
32	A2A Protocol	Optional

RAG and knowledge bases

35 courses: 17 core, 12 recommended, and 6 optional.

Order	Course	Placement
1	AI Foundations Learning Path	Core
2	Python Fundamentals	Recommended
3	JSON Learning Index	Core
4	Data Structures Fundamentals	Optional
5	API Learning Path	Recommended
6	Markdown	Recommended
7	Git Learning Path	Recommended
8	Linux Commands	Optional
9	Regular Expressions	Recommended
10	Probability and Statistics	Recommended
11	Linear Algebra	Recommended
12	Machine Learning	Recommended
13	Modern LLM Capabilities and Model Selection	Core
14	Prompt Engineering	Core
15	Context Engineering Learning Path	Core
16	LLM API Integration Learning Path	Core
17	Multimodal AI Learning Path	Optional
18	Data Cleaning	Core
19	OCR	Optional
20	Speech Recognition	Optional
21	Document Parsing	Core
22	Knowledge Base Construction	Core
23	Chunking Strategies	Core
24	Vector Fundamentals	Recommended
25	Embeddings	Core
26	Vector Databases	Core
27	Semantic Search Learning Path	Core
28	Data Annotation Learning Path	Recommended
29	Reranking	Core
30	RAG Learning Path	Core
31	Data Visualization	Recommended
32	LangChain	Optional
33	Evaluation Framework Learning Path	Core
34	AI Safety Learning Path	Core
35	Privacy-Enhancing Technologies Learning Path	Recommended

Agent platform and reliability

38 courses: 14 core, 16 recommended, and 8 optional.

Order	Course	Placement
1	AI Foundations Learning Path	Core
2	Python Fundamentals	Recommended
3	JSON Learning Index	Recommended
4	Data Structures Fundamentals	Recommended
5	API Learning Path	Recommended
6	Markdown	Recommended
7	Git Learning Path	Recommended
8	Linux Commands	Recommended
9	Regular Expressions	Optional
10	Probability and Statistics	Recommended
11	Machine Learning	Recommended
12	Modern LLM Capabilities and Model Selection	Core
13	Prompt Engineering	Core
14	Context Engineering Learning Path	Core
15	LLM API Integration Learning Path	Core
16	Tool Calling (including Function Calling)	Core
17	Agent Core	Core
18	MCP	Optional
19	Environment-based Agents	Optional
20	Agent Skills Learning Path	Optional
21	Agentic Design Patterns	Optional
22	LangChain	Optional
23	CrewAI Learning Index	Optional
24	Workflow Automation Learning Path	Core
25	Data Cleaning	Recommended
26	Data Annotation Learning Path	Recommended
27	Data Visualization	Recommended
28	Evaluation Framework Learning Path	Core
29	Synthetic Data	Recommended
30	Benchmark Design Learning Path	Core
31	MLOps Learning Path	Recommended
32	LLMOps Learning Path	Core
33	Runtime Monitoring Learning Path	Core
34	AI Safety Learning Path	Core
35	Privacy-Enhancing Technologies Learning Path	Recommended
36	AI Governance Learning Path	Core
37	Multi-Agent Collaboration Learning Path	Recommended
38	A2A Protocol	Optional

Multimodal and real-time interaction

29 courses: 10 core, 13 recommended, and 6 optional.

Order	Course	Placement
1	AI Foundations Learning Path	Core
2	Python Fundamentals	Recommended
3	JSON Learning Index	Recommended
4	Data Structures Fundamentals	Optional
5	API Learning Path	Recommended
6	Markdown	Recommended
7	Git Learning Path	Recommended
8	Linux Commands	Optional
9	Regular Expressions	Optional
10	Probability and Statistics	Recommended
11	Linear Algebra	Recommended
12	Machine Learning	Recommended
13	Deep Learning	Recommended
14	Modern LLM Capabilities and Model Selection	Core
15	Multimodal AI Learning Path	Core
16	OCR	Recommended
17	Speech Recognition	Core
18	Text to Speech	Core
19	Tool Calling (including Function Calling)	Core
20	Agent Core	Core
21	Data Annotation Learning Path	Recommended
22	Data Visualization	Recommended
23	Real-Time Multimodal Interaction	Core
24	Evaluation Framework Learning Path	Core
25	AI Safety Learning Path	Core
26	Privacy-Enhancing Technologies Learning Path	Recommended
27	Image Generation Learning Path	Optional
28	Video Generation Learning Path	Optional
29	Multi-Agent Collaboration Learning Path	Optional

Early safety and evaluation milestone

This milestone reuses only required chapters from existing courses. Before letting a model read untrusted external content, connect to remote capabilities, or execute tools, complete at least this small loop:

Quality gate	Reused chapters	Completion evidence
Early safety	Assets, Trust Boundaries, and Threat Modeling → Prompt Injection and Indirect Injection → Tool Overreach and Data Exfiltration → Identity and Least Privilege	A threat model showing untrusted inputs, protected assets, identities, authorization points, and the largest possible side effect
Evaluation foundations	Evaluation Objectives and Basic Units → Cases, Datasets, and Stratification → Deterministic Assertions, Metrics, and Scoring Rules	A minimal evaluation card stating the objective, typical/boundary/failure cases, and at least one deterministic assertion

Completion evidence here only permits a learner to begin controlled practice. It is not production security, comprehensive evaluation, penetration testing, or release approval. The full courses remain AI Safety and Evaluation Framework.

Machine-verifiable hard prerequisites

The following diagram shows only hard prerequisites at full-course scope. It does not disguise track recommendation order, the early milestone, or “recommended to learn first” as a dependency. The website build checks prerequisite existence, acyclicity, visibility in the same role, earlier order, and core closure.

flowchart LR
    json["JSON"] --> parsing["Document Parsing"]
    cleaning["Data Cleaning"] --> parsing
    parsing --> kb["Knowledge Base Construction"]
    prompt["Prompt Engineering"] --> context["Context Engineering"]
    tool["Tool Calling"] --> agent["Agent Core"]
    agent --> multi["Multi-Agent Collaboration"]
    evaluation["Evaluation Framework"] --> benchmark["Benchmark Design"]
    evaluation --> llmops["LLMOps"]
    cleaning --> synthetic["Data Synthesis"]
    annotation["Data Annotation"] --> synthetic
    evaluation --> synthetic

Relationship	Evidence boundary
JSON + Data Cleaning → Document Parsing	The Document Parsing entry explicitly requires both first; both are core and earlier in the RAG track
Document Parsing → Knowledge Base Construction	The Knowledge Base Construction entry explicitly requires Document Parsing first
Prompt Engineering → Context Engineering	The Context Engineering entry uses strong “complete first” language; Embeddings/RAG are later connections, not hard prerequisites
Tool Calling → Agent Core	A hard prerequisite for the two Agent main lines and the multimodal tool path
Evaluation Framework → LLMOps	A hard prerequisite for LLMOps release gates and regression evidence
Evaluation Framework → Benchmark Design	The Benchmark Design entry explicitly requires case, grader, and regression contracts
Data Cleaning + Data Annotation + Evaluation Framework → Data Synthesis	The Data Synthesis entry uses strong “learn first” language; all three are visible and earlier in the platform track
Agent Core → Multi-Agent Collaboration	The multi-agent entry explicitly requires Agent Core first. Workflow is recommended order and individual frameworks are optional

Every other course uses hard_prerequisites: [] to mean that page-by-page review found no universal, course-level hard prerequisite. Role tracks then represent recommended progression. All 57 entries have received that decision: “recommended to learn first,” a local capability, or a step that normally comes earlier in a project is not silently upgraded to a full-course dependency.

RAG role order is not a hard-dependency graph

Chunking, embeddings, vector databases, semantic search, and reranking have been reviewed page by page and included in the RAG track. They have a stable system-integration order, but each course entry only asks learners to review relevant capabilities as needed; courses can be learned independently, implementations can be swapped, and work can proceed in parallel. They are therefore not elevated to hard edges requiring a learner to complete the entire preceding course.

flowchart LR
    kb["Knowledge Base Construction"] --> chunking["Chunking"]
    chunking --> embedding["Embeddings"]
    embedding --> vector_db["Vector Databases"]
    vector_db --> semantic_search["Semantic Search"]
    semantic_search --> reranking["Reranking"]
    reranking --> rag["RAG"]
    rag --> evaluation["Evaluation Framework"]

Arrows in this diagram represent recommended order in the RAG role path; they do not enter the course-level hard-prerequisite DAG. Real projects often iterate chunking, representation, recall, reranking, and evaluation in parallel, and a learner may enter any one module for specialized engineering.

Content levels

Level	Use	Current representative material
Core courses	Build transferable Agent-engineering contracts; learn first	Modern LLM Capabilities and Model Selection, Prompt Engineering, Context Engineering, LLM APIs, Tool Calling, Agent Core, Evaluation Framework, AI Safety
Advanced courses	Choose around role or system boundary	Full RAG pipeline, MCP, Environment-based Agents, Workflow Automation, LLMOps, Runtime Monitoring, multi-agent systems, multimodal and real-time interaction
Frontier topics	Record the standards baseline, adoption status, and compatibility strategy; not stable prerequisites	A2A 1.0 is an optional course; MCP extensions and Apps, experimental Tasks, AG-UI, and new benchmark designs remain at the observation layer
Practical projects	Turn concepts into runnable evidence	Offline projects, fixtures, negative tests, and evaluation graphs at the end of each course
Reference material	Consult as needed without drowning the original learning path	Complete historical Python/deep-learning tutorials, framework and official-documentation reference layers, and specialist material for generative modalities

Content provenance and status

This knowledge base uses content_origin to distinguish original explanations, curated material, and third-party material, and content_status to distinguish validated, dynamic, review-pending, and frozen reference content. A missing field means a historical page has not yet been classified; it does not mean original or validated by default. Definitions, license boundaries, and the deep-review process are in Content Quality and Source Labeling Standard.

For product/API snapshots in courses, also consult source_checked, versions, and actual test reading. Where full third-party reproduction has no public redistribution evidence, preserve it only in the local reference layer and publish a source-notice page instead of the body.

Learning loop

When completing a course, leave at least five kinds of evidence:

1. A diagram that makes the system boundary, state, or data flow clear, or an equivalent structural explanation.
2. A small but real implementation with explicit inputs, outputs, permissions, and failure semantics.
3. At least one expected-failure case, not merely a successful demo.
4. Reproducible validation commands and a record of their results.
5. A decision boundary explaining when the technology should not be used.

If a course entry has stricter mastery criteria, use those. Frameworks, vendors, and models are implementation examples only; the core judgment should transfer to other implementations.

Evidence loop from framework to production feedback

A framework is only an optional implementation layer that expresses existing contracts in code: choosing ordinary Python, LangChain, or CrewAI does not remove responsibility for tool authorization, state recovery, evaluation, release, or operations. The diagram shows how a project turns one implementation into a traceable long-term improvement loop. It is not a course-level hard-prerequisite graph and does not imply that any framework automatically supplies security, correctness, or production reliability.

flowchart LR
    contract["Framework-independent contracts: tools, state, authorization, recovery"] --> implementation["Optional implementation: Python, LangChain, or CrewAI"]
    implementation --> offline["Offline evaluation: frozen cases, trials, and gates"]
    offline --> release["Release unit: manifest, approval, and canary"]
    release --> operation["Operational evidence: traces, SLOs, alerts, and incidents"]
    operation --> feedback["Confirmed, de-identified, deduplicated failures and feedback"]
    feedback --> offline
    security["Security and governance: threat models, identity, audit"] -. constrains .-> contract
    security -. constrains .-> release
    security -. constrains .-> operation

Figure 3. Evidence loop from framework to production feedback. Text alternative: first define tools, state, authorization, and recovery as framework-independent contracts; then implement with Python or an optional framework. Frozen offline cases, trials, and gates support a traceable release unit. After canary deployment, traces, SLOs, alerts, and incidents supply observation evidence. Only confirmed, de-identified, deduplicated, and versioned failures feed back into evaluation. Security and governance constrain contracts, release, and operations. The Mermaid source is the regeneration method.

Start the implementation layer with Tool Calling and Agent Core, then select LangChain or CrewAI by control needs. Learn fields, summaries, and human handoff from evaluation through operations in Offline-to-Online Evidence Handoff and Regression Loop, then deepen through LLMOps and Runtime Monitoring. AI Safety and AI Governance constrain the entire chain rather than adding a checklist only at the end of deployment.

Advanced and research directions

Direction	When to learn it	Boundary
Model adaptation and private deployment	Prompting, RAG, tools, and model selection still cannot meet quality, privacy, or cost constraints	Establish task-level evaluation and a reversible baseline before comparing fine-tuning, LoRA, quantization, and inference serving
Alignment and reinforcement learning	You need to study preference optimization, model training, or behavior control	Not a prerequisite for ordinary Agent application development
Protocol and systems frontier	You can distinguish stable specifications, extensions, and candidate versions and can take responsibility for compatibility validation	Record version, implementation support, and adoption evidence; do not present drafts as stable conclusions
AGI/general-systems research	As research perspective	Maintain it separately from deliverable Agent-engineering courses

Stage-audit and trade-off records:

• 2026-07-18 Content Audit and Restructuring Record
• 2026-07-19 Phase 2 Content Deep Review Record
• 2026-07-19 Phase 3 Framework Recovery and Learning-Route Metadata Record
• 2026-07-19 Phase 4 RAG, Evaluation, Safety, and Production Evidence-Chain Record
• 2026-07-19 Phase 5 Provenance, MCP, and Tool-Result Evidence-Chain Record
• 2026-07-19 Phase 6 Cross-Module Transport and Persistence Evidence-Chain Record
• 2026-07-19 Phase 7 External Provenance, Artifact, and Route-Portability Record
• 2026-07-19 Phase 8 Three-Provider Contract and Streaming State-Machine Record
• 2026-07-20 Phase 9 Dynamic-Material Publication Gates and Runtime-Audit Record
• 2026-07-20 Phase 10 Source, License, Route-Metadata, and OpenAI Dynamic-Pages Record
• 2026-07-21 Phase 11 Retrieval Provenance, MCP, and Route-Metadata Record
• 2026-07-21 Phase 12 Full Route-Metadata and Consumer-Convergence Record
• Evaluation Production Deep Review Record
• 2026-07-21 Phase 14 Agent Runtime and Context Trusted-Control-Plane Deep Review Record
• 2026-07-21 Phase 15 Prompt, API, and Retrieval State-Contract Deep Review Record
• 2026-07-21 Phase 16 Tool Protocol and RAG Lifecycle Deep Review Record
• 2026-07-21 Phase 17 Framework Runtime and Production Feedback-Loop Deep Review Record
• 2026-07-22 Phase 18 Decision Evidence, Retrieval Control Plane, and Collaboration Recovery Deep Review
• 2026-07-22 Phase 19 Ingestion, Data, Multimodal, and Real-Time Contract Deep Review
• 2026-07-22 Phase 20 Protocol, Media, Machine Learning, and Workflow Contract Deep Review
• 2026-07-22 Phase 21 Deep Learning, Speech, Data Annotation, and Provider API Contract Deep Review
• 2026-07-22 Phase 22 Real-Time, Environment, and Multi-Agent Control Plane Deep Review
• Governance Control, Offline Evaluation, Release Gate, and Runtime Monitoring Evidence-Chain Deep Review
• LangGraph Contract Deep Review

Source-notice pages do not contain the body or assets of excluded documents. This statement does not replace the original author’s copyright and license files and is not legal advice.