Learn Agentic AI — Free 23-Module Course

A free, guided learning path that takes you from generative AI fundamentals to building and deploying production AI agents across 23 structured modules. The course curates the strongest free material from Microsoft, Google, Anthropic, Hugging Face, and DeepLearning.AI into a single ordered track, so learners can move from first principles to working agentic systems without guessing what to study next. The path is grouped into four parts: foundations, core mechanics, building agents, and production with safety and governance.

Part 1 — Foundations

The vocabulary and mental models everything else depends on. By the end of this part you can say precisely what an agent is and how it differs from a chatbot or a fixed workflow.

  • What is an AI agent versus a chatbot versus a workflow, and why the distinction changes how you design and govern the system.
  • The agent loop: perceive, reason, act, observe, and repeat. The loop is the heart of every agent and the place most failures occur.
  • Large language models as the reasoning engine, what they do well, where they are unreliable, and what that means for trust.
  • Tokens, context windows, and their limits, the practical constraints that shape what an agent can hold in mind at once.
  • Prompting fundamentals for agents, writing instructions that produce consistent, checkable behaviour rather than surprises.

Part 2 — Core Mechanics

The components that turn a language model into a system that can act, remember, and retrieve. This is where an agent stops being a clever chat and starts doing real work.

  • Tool use and function calling, giving an agent the ability to take actions in real systems rather than only producing text.
  • Retrieval-Augmented Generation (RAG), grounding answers in approved sources so the agent cites facts instead of inventing them.
  • Embeddings and vector databases, the representation and storage that make semantic search and retrieval possible.
  • Memory, short-term versus long-term, deciding what an agent should remember within a task and across tasks.
  • Planning and task decomposition, breaking a goal into steps an agent can execute and check.
  • Multi-step reasoning, patterns such as chain-of-thought and ReAct that interleave thinking with acting.
  • The Model Context Protocol (MCP), a standard way to connect agents to tools and data sources cleanly.

Part 3 — Building Agents

Architecture and engineering. How to structure agents, connect them to the world, and keep them reliable and affordable in practice.

  • Single-agent architectures, the simplest reliable pattern and when it is the right choice.
  • Multi-agent orchestration, coordinating several agents without creating chaos or runaway cost.
  • Connecting agents to real systems and APIs, the integration work that makes an agent useful in an organisation.
  • Handling errors, retries, and fallbacks, designing for the failures that are certain to happen.
  • Cost and latency trade-offs, making deliberate choices so the system stays fast enough and cheap enough to run.
  • Evaluating agents, building evals and benchmarks so you can prove an agent works before you trust it.

Part 4 — Production, Safety and Governance

The difference between a demo and a deployed system. This part covers the controls that make an agent safe to run where the consequences are real.

  • Guardrails and human-in-the-loop, placing human review and approval where judgment and rights are at stake.
  • Data protection and PII in agent systems, handling personal and sensitive data lawfully and by design.
  • Governance with the NIST AI Risk Management Framework, applying a recognised structure to govern, map, measure, and manage risk.
  • Deploying under real-world constraints, the Last-Mile AI approach for low connectivity, many languages, and operational pressure.
  • Case study: agentic AI in humanitarian operations, putting the whole path together in a setting where trust and accountability decide success.

How to Use This Path

The path is ordered for a reason. Each part assumes the one before it, so working straight through is the fastest route from no background to a working mental model of how production agents are built and governed. If you already build with language models, you can start at Part 2 and use Part 1 as a reference. If your interest is oversight and policy rather than engineering, Parts 1 and 4 give you enough to ask the right questions of a technical team without writing code yourself.

The course is deliberately built on free, high-quality material from established sources rather than a single proprietary track, so the knowledge transfers across whatever tools you end up using. The aim is not to make you fluent in one vendor's product, but to give you the durable concepts, the agent loop, retrieval, tool use, evaluation, guardrails, and governance, that stay true as the tools change. Treat each module as a question to answer in practice, not a video to finish, and build something small at the end of each part.

Pace matters more than speed. A learner who completes one module a week and builds a small project at the end of each part will understand far more than one who watches all twenty-three in a weekend and retains none of it. The hardest material is concentrated in Parts 2 and 3, where the concepts compound, so slow down there and let each idea settle before moving on. By the end you should be able to read a real agent system, say what each piece does, judge where it could fail, and explain how you would govern it before it reaches users.

For the foundations underneath agents, the free Learn LLMs course explains how large language models and the Transformer work from the ground up, and the LLM architecture explainer walks through the internals step by step. When you have worked through the path, see the principles applied in the AI projects portfolio and the Last-Mile AI delivery framework.