Learn to Build AI Agents

A free, hands-on course that takes you from a single LLM call to a production-shaped agent — tools, retrieval, MCP, traces, evals, guardrails, and multi-agent delegation. Read a lesson, then build it for real in Studio.

Module 1

LLM foundations

Every agent in this lab starts on top of a single building block: a large language model that turns text into text. By the end of this module you will know what an LLM actually does, why a chat app like claude.ai is an agent built on top of one, how the system prompt shapes its behavior, why long conversations cost more, and how temperature trades determinism for variety.

5 lessons 32 minStart

Module 2

Tool use

An LLM by itself can only describe the world; tools let it act on it. By the end of this module you will know what a tool is, how its schema is the contract the model reads, how the model decides when to call one, how the model→tool→model loop produces a grounded answer, and how to route between several tools and handle their failures.

4 lessons 29 minStart

Module 3

Knowledge bases

An LLM only knows what's in its training data and what you fit in the prompt. By the end of this module you will understand why retrieval exists, how a document becomes chunks + embeddings, how the ingestion pipeline assembles them into a searchable index, and you'll build a knowledge base of your own for your agent so it can ground answers in your documents.

4 lessons 26 minStart

Module 4

Vector search & RAG

Module 3 built a knowledge base; this module teaches your agent to actually use it. You will learn what retrieval-augmented generation is, how top-K controls how much context the model sees, how vector and keyword search differ, how hybrid search fuses them with RRF, and how to ground answers with citations the user can click through to the source text.

4 lessons 27 minStart

Module 5

MCP & custom tools

In Module 2 you handed the agent tools you wrote by hand. Real agents reach dozens of services — and writing every tool by hand doesn't scale. The Model Context Protocol (MCP) flips it around: you point the agent at a server and it *discovers* the tools. By the end of this module you'll connect your agent to a live Help Desk two ways — hand-wired HTTP and MCP — run the same agent against both, and see in the trace exactly what MCP does for you.

4 lessons 26 minStart

Module 6

Traces & observability

Every run your agent has ever made was quietly recorded as a trace — a timeline of every LLM call, tool call, and retrieval. This module teaches you to read those traces: what a span is, its anatomy, how to spot the slowest step on a timeline, where latency and cost actually come from, and how to debug a failing run. By the end you can open any run and explain what happened, in order, and why.

5 lessons 30 minStart

Module 7

Evals & quality

"It worked once" is not a quality bar. This module teaches evals — automated tests for your agent. You'll learn why a handful of demo questions hides the long tail of failures, how four different metrics (exact, contains, semantic, and LLM-as-judge) can disagree about the same answer, how to grade judgement calls with a rubric, where good test cases come from, and how comparing runs catches regressions. By the end you can run a suite against your agent, read which cases failed and why, and catch a regression before it ships.

4 lessons 28 minStart

Module 8

Guardrails & safety

An agent that answers every question is not the same as an agent that's safe to ship. This module teaches guardrails — checks that run before or after the LLM to stop the inputs and outputs you don't want. You'll see how input guardrails catch PII, off-topic requests, and prompt-injection before they reach the model, how output guardrails catch toxic or malformed responses before they reach the user, why a blocked guardrail returns a safe fallback instead of silence, and how to choose between blocking, redacting, and warning — and when an LLM-judged guardrail is worth its per-turn cost. By the end you'll harden your own agent against a red-team suite and watch the attacks get blocked, one guardrail at a time.

3 lessons 20 minStart

Module 9

Agent-to-agent

The final module. One agent that tries to do everything gets a bloated prompt, a tangled trace, and tools it rarely uses. The fix is delegation: a router agent that classifies each request and hands it to a focused specialist — billing, technical, whatever the job needs. You'll learn when splitting helps (and when it doesn't), the router / sequential / parallel delegation patterns, how an orchestrator passes context between agents, and the depth, cost, and timeout limits that keep agent-to-agent systems from running away. Then you'll assemble a router with two specialists, watch the nested traces, and ship — completing your production-shaped agent.

3 lessons 22 minStart