Roadmap

Agentic AI Masterclass

From Python and LLM fundamentals to shipping autonomous, tool-using agents in production.

17stages127topics~36hours

Curated from the best — MDN · Kubernetes · AWS · OWASP · Google SRE & more

Agentic AI engineers are among the most in-demand roles in 2025+. Every product team is building autonomous agents — you need to understand the full stack from architecture to security to be the person who ships them.

The complete path — 2 of 127 topics have lessons here; the other 125 are marked learn anywhere. We won't pretend we cover everything.

01

Stage 1 / 17 · 9 topics · 1 lessons

Programming & Engineering Foundations

The software-engineering bedrock every agent builder needs before touching models.

Python ProficiencyIdiomatic Python: typing, dataclasses, comprehensions, generators, decorators. Python docs

Async & Concurrencyasyncio, coroutines, tasks, semaphores for concurrent tool calls and I/O. Python docs

Type Hints & PydanticStatic typing and Pydantic models for structured, validated agent I/O. Python docs

Git & Version ControlBranching, PRs, code review, and collaborative workflows. Git docs

HTTP & REST APIsRequests, status codes, auth headers, pagination, rate limits. restfulapi.net

JSON, YAML & SchemasSerialization formats and JSON Schema that drive tool definitions. json.org

Testing & Debuggingrecpytest, mocking external calls, debugging non-deterministic systems.

CLI, Linux & ShellrecFilesystem, processes, env vars, and shell scripting for agent runtimes. The Linux Command Line

TypeScript/Node BasicsoptionalJS/TS fundamentals for the LangChain.js and Vercel AI ecosystems. TypeScript docs

02

Stage 2 / 17 · 10 topics · 0 lessons

ML & LLM Foundations

How language models work under the hood so you reason about agent behavior, not guess.

ML FundamentalsrecTraining vs inference, supervised learning, loss, generalization, overfitting. Hugging Face Agents

Neural Networks & BackpropoptionalLayers, activations, gradient descent at a conceptual level. Dive into Deep Learning

Transformer ArchitectureSelf-attention, positional encoding, why transformers dominate LLMs. Hugging Face

TokenizationBPE, token counting, and how tokens map to cost and context limits. Hugging Face

Pretraining & Fine-tuningNext-token prediction, instruction tuning, RLHF/DPO alignment. Hugging Face

Sampling & DecodingTemperature, top-p, top-k, and how they shape determinism. Hugging Face

EmbeddingsVector representations of meaning that power retrieval and memory. Hugging Face

Context WindowsContext length, lost-in-the-middle effects, and attention costs. Hugging Face

Model LandscaperecFrontier vs open models: GPT, Claude, Gemini, Llama, Mistral, Qwen. Hugging Face

Capabilities & LimitationsHallucination, reasoning limits, knowledge cutoffs, brittleness. Hugging Face

03

Stage 3 / 17 · 9 topics · 0 lessons

Prompt Engineering

Precise control of model behavior — the core skill that makes or breaks an agent.

Prompt AnatomySystem, user, assistant roles and message structure. Cloudflare Learning

Zero-shot & Few-shotIn-context learning with examples to steer outputs. Hugging Face Agents

Chain-of-ThoughtEliciting step-by-step reasoning for harder tasks. Hugging Face Agents

ReAct, ToT & Self-ConsistencyReasoning+acting, tree-of-thought, and majority-vote sampling. System Design Primer

Structured OutputJSON mode, schema-constrained generation, function-call formatting. Hugging Face Agents

System Prompt DesignPersona, constraints, and guardrails for agent identity. Hugging Face

Prompt TemplatingrecVariables, partials, and reusable prompt components. Hugging Face

Prompt ChainingrecDecomposing tasks into sequenced, composable prompts. Hugging Face

Meta & Self-Refine PromptingoptionalModels critiquing and improving their own outputs. Hugging Face

04

Stage 4 / 17 · 8 topics · 0 lessons

Working with LLM APIs

Calling, configuring, and operating model providers programmatically.

Chat Completion APIsOpenAI/Anthropic/Gemini SDKs, messages, and response parsing. Hugging Face Agents

Function / Tool CallingNative tool-call APIs that let models invoke functions. Google SRE Book

Streaming ResponsesToken streaming, SSE, and incremental UI updates. Apache Kafka docs

Multimodal InputsrecVision, audio, and document inputs in agent pipelines. Hugging Face Agents

Token & Cost ManagementCounting tokens, budgeting, and model-tier selection. Hugging Face Agents

Prompt Caching & BatchrecCaching, batch APIs, and latency/cost optimizations. Redis docs

Rate Limits & RetriesBackoff, idempotency, and resilient API client design. System Design Primer

Local & Self-Hosted ModelsoptionalOllama, vLLM, and quantization for on-prem inference. Hugging Face Agents

05

Stage 5 / 17 · 8 topics · 0 lessons

Tool Use & Function Calling

Giving agents hands — the defining capability of an agentic system.

Tool DefinitionsDescribing tools with names, descriptions, and JSON schemas. Hugging Face Agents

Tool Dispatch & ExecutionParsing tool calls, executing, and returning results to the model. Hugging Face Agents

Parallel Tool CallsrecConcurrent invocation and result aggregation. Hugging Face Agents

Tool Error HandlingValidation, graceful failures, and self-correction loops. Hugging Face Agents

Code Execution ToolsSandboxed Python/REPL tools for computation and data tasks. Hugging Face Agents

Web Search & BrowsingSearch APIs and headless-browser tools for live information. Hugging Face Agents

Wrapping External APIsTurning third-party REST/GraphQL APIs into agent tools. Hugging Face Agents

Tool Selection & RoutingrecHelping models pick the right tool from large toolsets. Hugging Face Agents

06

Stage 6 / 17 · 5 topics · 0 lessons

Model Context Protocol & Standards

The emerging interoperability layer connecting agents to tools and data.

MCP FundamentalsWhat MCP is and why standardized tool/context interfaces matter. Hugging Face Agents

Building MCP ServersExposing tools, resources, and prompts via an MCP server. Hugging Face Agents

MCP Clients & HostsrecConnecting agents to MCP servers and managing capabilities. Hugging Face Agents

Transports & Authrecstdio, HTTP/SSE transports and securing MCP connections. Hugging Face Agents

Other Interop StandardsoptionalOpenAPI tool specs and agent-to-agent protocols. Hugging Face Agents

07

Stage 7 / 17 · 9 topics · 0 lessons

Retrieval-Augmented Generation

Grounding agents in external knowledge to fight hallucination and stay current.

RAG ArchitectureThe retrieve-then-generate pattern and when to use it. Hugging Face

Chunking StrategiesFixed, semantic, and recursive chunking with overlap. Hugging Face Agents

Embedding ModelsChoosing and evaluating embedding models for retrieval. Hugging Face

Vector DatabasesPinecone, Weaviate, Qdrant, pgvector and ANN indexing. Hugging Face

Hybrid & Keyword SearchrecCombining BM25 with dense retrieval for precision. Hugging Face Agents

RerankingrecCross-encoder rerankers to sharpen retrieved context. Hugging Face Agents

Query TransformationrecQuery rewriting, HyDE, and multi-query expansion. Hugging Face Agents

Agentic & Graph RAGAgents that iteratively retrieve; GraphRAG over knowledge graphs. Hugging Face

RAG EvaluationrecFaithfulness, context precision/recall, and answer relevance. Hugging Face

08

Stage 8 / 17 · 8 topics · 0 lessons

Agent Architectures & Reasoning

The control-flow patterns that turn an LLM into an autonomous agent.

The Agent LoopPerceive-reason-act-observe cycles and termination conditions. Hugging Face Agents

ReAct AgentsInterleaving reasoning traces with tool actions. Hugging Face Agents

Planning & DecompositionTask decomposition, plan-and-execute, and subgoal management. Cloudflare Learning

Reflection & Self-CritiqueReflexion-style loops where agents evaluate and retry. Hugging Face Agents

Routing & Orchestrator-WorkerrecRouters and supervisor patterns delegating to specialists. Hugging Face Agents

Graphs & State MachinesModeling agent control flow as explicit graphs and states. GeeksforGeeks

Human-in-the-LoopApproval gates, interrupts, and steering for safety. Hugging Face Agents

Autonomous Goal LoopsoptionalLong-running, self-directed agents (AutoGPT-style) and their risks. Hugging Face Agents

09

Stage 9 / 17 · 6 topics · 0 lessons

Memory & State Management

How agents remember, persist, and manage their working context over time.

Short-Term MemoryConversation history and scratchpad within a context window. Hugging Face Agents

Long-Term MemoryPersistent semantic, episodic, and procedural memory stores. Hugging Face Agents

Context Window ManagementSummarization, truncation, and compaction to fit limits. Hugging Face

State Persistence & CheckpointsDurable state, resumable runs, and crash recovery. Hugging Face Agents

Memory FrameworksrecMem0, Zep, and patterns for entity and fact memory. Hugging Face Agents

Context EngineeringDeliberately curating what enters the context for each step. Hugging Face Agents

10

Stage 10 / 17 · 8 topics · 1 lessons

Agent Frameworks & Orchestration

The production toolkits that let you build agents without reinventing plumbing.

LangChainChains, tools, and the broad LLM-app ecosystem. LangChain docs

LangGraphGraph-based stateful agents with checkpointing and HITL. GeeksforGeeks

LlamaIndexrecData-centric framework for RAG and agentic workflows. Hugging Face Agents

OpenAI Agents SDKrecHandoffs, guardrails, and tracing in OpenAI's agent runtime.

CrewAIrecRole-based multi-agent crews with task delegation. Hugging Face Agents

AutoGen / AG2optionalConversational multi-agent orchestration patterns. Hugging Face Agents

PydanticAI / DSPyoptionalType-safe agents and programmatic prompt optimization. Python docs

Choosing a FrameworkrecTrade-offs vs building from scratch on raw APIs. Cloudflare Learning

11

Stage 11 / 17 · 6 topics · 0 lessons

Multi-Agent Systems

Coordinating multiple specialized agents to solve complex tasks.

Coordination PatternsSupervisor, hierarchical, network, and sequential topologies. Cloudflare Learning

Roles & SpecializationDesigning focused agents with clear responsibilities. Hugging Face Agents

Inter-Agent CommunicationMessage passing, shared state, and blackboard patterns. Hugging Face Agents

Handoffs & DelegationrecTransferring control and context between agents. Hugging Face Agents

Agent-to-Agent ProtocolsoptionalEmerging A2A standards for cross-system agent interop. Cloudflare Learning

Failure ModesrecError compounding, coordination cost, and when single-agent wins. Hugging Face Agents

12

Stage 12 / 17 · 7 topics · 0 lessons

Evaluation & Observability

Measuring, tracing, and trusting non-deterministic agent systems.

Eval FundamentalsWhy agents need evals and how they differ from ML metrics. Hugging Face Agents

Offline EvaluationGolden datasets, regression suites, and task success rates. Hugging Face Agents

LLM-as-JudgeModel-graded eval, rubrics, and bias mitigation. Hugging Face

Trajectory EvaluationrecJudging the path: tool choice, steps, and efficiency. Hugging Face Agents

Tracing & ObservabilityLangSmith, Langfuse, OpenTelemetry for agent runs. OpenTelemetry docs

Online Eval & FeedbackrecProduction monitoring, user feedback, and A/B tests. Hugging Face Agents

Agent BenchmarksrecSWE-bench, GAIA, WebArena, tau-bench and their limits. Hugging Face Agents

13

Stage 13 / 17 · 8 topics · 0 lessons

Safety, Security & Alignment

Keeping autonomous, tool-wielding agents from causing harm.

Prompt InjectionDirect and indirect injection attacks and defenses. Hugging Face

Guardrails & ValidationInput/output filters, content policies, and schema enforcement. Hugging Face Agents

Sandboxing & Least PrivilegeIsolating code execution and scoping tool permissions. OWASP

Data Leakage & PIIPreventing exfiltration and protecting sensitive data. Hugging Face Agents

Auth & Secrets ManagementScoped credentials, OAuth, and secret handling for tools. HashiCorp Vault docs

Action AuthorizationApproval policies and confirmation for high-risk actions. Linux man pages

Red-Teaming AgentsrecAdversarial testing of tool misuse and jailbreaks. Hugging Face Agents

OWASP LLM Top 10recStandard threat model for LLM and agent applications. OWASP

14

Stage 14 / 17 · 6 topics · 0 lessons

Adaptation & Fine-Tuning

Specializing models for agentic tasks when prompting isn't enough.

When to Fine-TunePrompting vs RAG vs fine-tuning decision framework. Hugging Face

Supervised Fine-TuningrecBuilding datasets and SFT for task specialization. The Linux Command Line

PEFT & LoRArecParameter-efficient tuning and adapters. Hugging Face Agents

Tool-Use Fine-TuningoptionalTraining models to call tools reliably. Hugging Face

RL for AgentsoptionalRLHF, DPO, and RL fine-tuning for agentic behavior. Hugging Face Agents

Distillation & Small ModelsoptionalDistilling capable small models for cost and latency. Hugging Face Agents

15

Stage 15 / 17 · 8 topics · 0 lessons

Production Engineering & Deployment

Shipping agents as reliable, scalable services.

Serving AgentsFastAPI endpoints, async workers, and streaming responses. Hugging Face Agents

Long-Running & Async JobsQueues, workers, and durable execution for slow agent runs. Hugging Face Agents

Docker & DeploymentContainerizing agents and deploying to cloud/Kubernetes. Kubernetes docs

Caching & Cost ControlsrecSemantic caching, budgets, and spend guardrails in prod. Redis docs

Scaling & ConcurrencyrecHandling many concurrent sessions and rate-limit pooling. Hugging Face Agents

Reliability & FallbacksTimeouts, retries, circuit breakers, and model fallbacks. Google SRE Book

CI/CD for AgentsrecEval-gated deploys, prompt versioning, and rollbacks. GitHub Actions docs

Monitoring & Incident ResponserecLatency/cost/quality dashboards and on-call for agents. Google SRE Book

16

Stage 16 / 17 · 5 topics · 0 lessons

Agentic UX & Interfaces

Designing the human-facing surface where agents earn trust.

Streaming & Progress UXShowing reasoning, tool calls, and partial output live. The Linux Command Line

Transparency & CitationsrecSurfacing sources, confidence, and agent reasoning. Hugging Face Agents

Control & InterruptibilityrecLetting users pause, edit, and redirect the agent. OSTEP (free book)

Generative UIoptionalAgents rendering interactive components and forms. Hugging Face Agents

Feedback CapturerecThumbs, corrections, and feeding signal back into evals. Ubuntu docs

17

Stage 17 / 17 · 7 topics · 0 lessons

Capstone Projects & Career

Proving job-readiness with portfolio-grade agents and interview prep.

Project: RAG Knowledge AgentProduction RAG agent with citations, eval, and observability. Hugging Face

Project: Coding AgentAutonomous code agent that edits files and runs tests. Hugging Face Agents

Project: Multi-Agent WorkflowrecOrchestrated crew automating a real end-to-end business task. Hugging Face Agents

Project: MCP Tool ServerrecCustom MCP server integrating a real third-party system. Hugging Face Agents

Agent System DesignInterview-ready design of scalable, safe agent architectures. Hugging Face Agents

Portfolio & WritingrecDemos, write-ups, and open-source contributions that get hired. Hugging Face Agents

Staying CurrentrecTracking papers, releases, and the fast-moving agent ecosystem. Hugging Face Agents

You're job-ready.

Clear every stage, earn the certificate, and walk into interviews prepared. The complete path — nothing hidden, no gaps.

Destination reached