Online course

Building AI Agents

Design, build and evaluate agents that do real work: when an agent beats a plain workflow, how the loop actually runs, how to design tools a model can use well, how to keep it safe and affordable, and how to know whether it works.

6 hr 6 min · 8 modules · 37 lessons · 5 labs

Not yet reviewed

This content has been authored but not yet reviewed by a qualified subject-matter expert.

What you’ll build

Each lab asks you to produce something real and gives you the checklist to judge it against. Write your answer in the lab, and ask for feedback on it.

Redesign a tool
Rewrite a poorly designed tool declaration so a model can use it correctly first time.
Write the standing brief
Write a system prompt that still governs an agent on its twelfth turn.
Choose the pattern
Select an orchestration pattern for a set of real problems and defend each choice in a sentence.
Find the hole
Threat-model an agent design: sort its actions by reversibility and find the path an attacker would take.
Write the eval set
Turn real production failures into evaluation cases that would catch them again.

What you’ll be able to do

Language model fundamentalsfoundational
Prompt designfoundational
Choosing between a workflow and an agentworking
The agent loopworking
Tool designworking
Context engineeringworking
Retrieval and groundingworking
Agent memoryworking
Orchestration patternsworking
Multi-agent systemsfoundational
Agent evaluationworking
Agent observabilityworking
Failure and recoveryworking
Agent safety and permissionsworking
Prompt injection defenceworking
Cost and latency engineeringworking

Credential

Once an expert has reviewed this course, passing its final exam earns a verified credential that appears on your profile where employers can see it. It has not been reviewed yet, so for now the exam is practice: passing it cannot issue a credential, and each attempt still counts toward your limit. 12 questions, 45 minutes, 75% to pass, up to 3 attempts.

Learning is free, and nothing anywhere on the site is charged today. Certification is where a fee is planned, because that is what makes a credential mean something to an employer.

Course content

1 What an Agent Actually Is
4 lessons · 32 min
Three different things get called an agent. Telling them apart is the first real decision you make.
1. Models, workflows and agents8 min
  Distinguish a single model call, a workflow, and an agent, and say which one a given problem needs.
2. The loop, in one page9 min
  Describe the agent loop end to end and name what terminates it.
3. When not to build an agent8 min
  Apply a test for whether a problem justifies an agent, and pick the simpler option when it does not.
4. What autonomy costs7 min
  Name the three costs autonomy adds and estimate them for a proposed agent before building it.
2 The Loop in Practice
4 lessons · 32 min
The mechanics: how tool calls travel, how errors teach, and how the loop ends.
1. Tool use, mechanically9 min
  Trace one tool call from declaration through the model’s request to the result you send back.
2. Errors are part of the conversation8 min
  Return failures to the model in a form it can recover from, and recognise which failures it must not see.
3. Stopping: budgets, limits and done-ness8 min
  Choose stop conditions for an agent and explain what each one protects against.
4. State between turns7 min
  Decide what belongs in the conversation, what belongs in your own storage, and why.
3 Designing Tools
5 lessons · 52 min · includes a lab
The interface between your systems and a model deserves as much care as the one you design for people.
1. A tool is an interface for a model8 min
  Explain why tool design is interface design, and evaluate a tool from the model’s point of view.
2. Names, descriptions and schemas9 min
  Write a tool description and schema that a model can use correctly first time.
3. Making the wrong call hard8 min
  Redesign a tool so that a plausible mistake becomes impossible rather than merely discouraged.
4. How many tools is too many7 min
  Judge when a tool set has grown too large and apply a strategy for keeping it usable.
5. Lab: redesign a toollab20 min
  Rewrite a poorly designed tool declaration so a model can use it correctly first time.
4 Context Engineering
5 lessons · 53 min · includes a lab
The model knows only what is in front of it. Deciding what that is, on every turn, is most of the craft.
1. The context window is a budget8 min
  Account for what fills a context window during an agent run and explain why quality falls before the limit does.
2. What belongs in a system prompt9 min
  Write a system prompt for an agent that states role, boundaries and process without bloat.
3. Grounding: retrieval and citations8 min
  Design an agent so its factual claims are traceable to something a tool returned.
4. Long tasks: compaction and handoff8 min
  Keep an agent working on a task longer than its context window without losing what matters.
5. Lab: write the standing brieflab20 min
  Write a system prompt that still governs an agent on its twelfth turn.
5 Orchestration Patterns
5 lessons · 51 min · includes a lab
Five arrangements that cover most of what people build, and the honest test for when to reach past one agent.
1. Chaining and routing8 min
  Apply prompt chaining and routing, and say which problems each fits.
2. Doing things at once7 min
  Use sectioning and voting appropriately, and recognise when parallelism is false economy.
3. Orchestrator and workers8 min
  Describe the orchestrator–workers pattern and identify the problems it fits.
4. Evaluator, optimiser, and how many agents8 min
  Apply the evaluator–optimiser loop, and apply an honest test before adding a second agent.
5. Lab: choose the patternlab20 min
  Select an orchestration pattern for a set of real problems and defend each choice in a sentence.
6 Making It Trustworthy
5 lessons · 59 min · includes a lab
An agent that acts on the world needs permission, defences against text that lies to it, and a record of what it did.
1. Permission, and the person in the loop9 min
  Classify an agent’s actions by reversibility and decide which require a person to approve.
2. Untrusted content and prompt injection9 min
  Explain indirect prompt injection and apply the boundary that contains it.
3. Blast radius8 min
  Bound what an agent can affect, so that a bad run is contained by design.
4. Recording what the agent did8 min
  Specify the record an agent run must leave, and explain who each field is for.
5. Lab: find the holelab25 min
  Threat-model an agent design: sort its actions by reversibility and find the path an attacker would take.
7 Knowing It Works
5 lessons · 52 min · includes a lab
Impressions do not survive contact with production. This is how you find out whether your agent is any good.
1. What to measure8 min
  Choose an end-to-end success measure for an agent and avoid measuring the wrong thing.
2. Building an eval set from real failures8 min
  Assemble a small evaluation set that catches regressions, from cases that actually occurred.
3. Using a model as a judge8 min
  Use model-graded evaluation where appropriate and name the failure modes it brings.
4. Cost, latency and shipping8 min
  Plan a first release of an agent that is affordable, observable and reversible.
5. Lab: write the eval setlab20 min
  Turn real production failures into evaluation cases that would catch them again.
8 Case Study: Meridian Tools
4 lessons · 35 min
One team, one agent, six weeks. What they built first, what it cost them, and what actually shipped.
1. The brief, and the first mistake9 min
  Identify, from a realistic brief, the point at which a team over-reached for autonomy.
2. Rebuilding around what is actually known9 min
  Restructure an over-autonomous system into a router with one genuinely agentic branch.
3. The week it went wrong9 min
  Trace three production incidents to the design decisions that permitted them.
4. What shipped, and what the numbers said8 min
  Read an agent programme’s results honestly, including what it did not achieve.

What you’ll build

Each lab asks you to produce something real and gives you the checklist to judge it against. Write your answer in the lab, and ask for feedback on it.

Redesign a tool

Rewrite a poorly designed tool declaration so a model can use it correctly first time.

Write the standing brief

Write a system prompt that still governs an agent on its twelfth turn.

Choose the pattern

Select an orchestration pattern for a set of real problems and defend each choice in a sentence.

Find the hole

Threat-model an agent design: sort its actions by reversibility and find the path an attacker would take.

Write the eval set

Turn real production failures into evaluation cases that would catch them again.

What you’ll be able to do

Language model fundamentalsfoundational

Prompt designfoundational

Choosing between a workflow and an agentworking

The agent loopworking

Tool designworking

Context engineeringworking

Retrieval and groundingworking

Agent memoryworking

Orchestration patternsworking

Multi-agent systemsfoundational

Agent evaluationworking

Agent observabilityworking

Failure and recoveryworking

Agent safety and permissionsworking

Prompt injection defenceworking

Cost and latency engineeringworking

Credential

Learning is free, and nothing anywhere on the site is charged today. Certification is where a fee is planned, because that is what makes a credential mean something to an employer.

Course content

1 What an Agent Actually Is

4 lessons · 32 min

Three different things get called an agent. Telling them apart is the first real decision you make.

Models, workflows and agents8 min
Distinguish a single model call, a workflow, and an agent, and say which one a given problem needs.
The loop, in one page9 min
Describe the agent loop end to end and name what terminates it.
When not to build an agent8 min
Apply a test for whether a problem justifies an agent, and pick the simpler option when it does not.
What autonomy costs7 min
Name the three costs autonomy adds and estimate them for a proposed agent before building it.

2 The Loop in Practice

4 lessons · 32 min

The mechanics: how tool calls travel, how errors teach, and how the loop ends.

Tool use, mechanically9 min
Trace one tool call from declaration through the model’s request to the result you send back.
Errors are part of the conversation8 min
Return failures to the model in a form it can recover from, and recognise which failures it must not see.
Stopping: budgets, limits and done-ness8 min
Choose stop conditions for an agent and explain what each one protects against.
State between turns7 min
Decide what belongs in the conversation, what belongs in your own storage, and why.

3 Designing Tools

5 lessons · 52 min · includes a lab

The interface between your systems and a model deserves as much care as the one you design for people.

A tool is an interface for a model8 min
Explain why tool design is interface design, and evaluate a tool from the model’s point of view.
Names, descriptions and schemas9 min
Write a tool description and schema that a model can use correctly first time.
Making the wrong call hard8 min
Redesign a tool so that a plausible mistake becomes impossible rather than merely discouraged.
How many tools is too many7 min
Judge when a tool set has grown too large and apply a strategy for keeping it usable.
Lab: redesign a toollab20 min
Rewrite a poorly designed tool declaration so a model can use it correctly first time.

4 Context Engineering

5 lessons · 53 min · includes a lab

The model knows only what is in front of it. Deciding what that is, on every turn, is most of the craft.

The context window is a budget8 min
Account for what fills a context window during an agent run and explain why quality falls before the limit does.
What belongs in a system prompt9 min
Write a system prompt for an agent that states role, boundaries and process without bloat.
Grounding: retrieval and citations8 min
Design an agent so its factual claims are traceable to something a tool returned.
Long tasks: compaction and handoff8 min
Keep an agent working on a task longer than its context window without losing what matters.
Lab: write the standing brieflab20 min
Write a system prompt that still governs an agent on its twelfth turn.

5 Orchestration Patterns

5 lessons · 51 min · includes a lab

Five arrangements that cover most of what people build, and the honest test for when to reach past one agent.

Chaining and routing8 min
Apply prompt chaining and routing, and say which problems each fits.
Doing things at once7 min
Use sectioning and voting appropriately, and recognise when parallelism is false economy.
Orchestrator and workers8 min
Describe the orchestrator–workers pattern and identify the problems it fits.
Evaluator, optimiser, and how many agents8 min
Apply the evaluator–optimiser loop, and apply an honest test before adding a second agent.
Lab: choose the patternlab20 min
Select an orchestration pattern for a set of real problems and defend each choice in a sentence.

6 Making It Trustworthy

5 lessons · 59 min · includes a lab

An agent that acts on the world needs permission, defences against text that lies to it, and a record of what it did.

Permission, and the person in the loop9 min
Classify an agent’s actions by reversibility and decide which require a person to approve.
Untrusted content and prompt injection9 min
Explain indirect prompt injection and apply the boundary that contains it.
Blast radius8 min
Bound what an agent can affect, so that a bad run is contained by design.
Recording what the agent did8 min
Specify the record an agent run must leave, and explain who each field is for.
Lab: find the holelab25 min
Threat-model an agent design: sort its actions by reversibility and find the path an attacker would take.

7 Knowing It Works

5 lessons · 52 min · includes a lab

Impressions do not survive contact with production. This is how you find out whether your agent is any good.

What to measure8 min
Choose an end-to-end success measure for an agent and avoid measuring the wrong thing.
Building an eval set from real failures8 min
Assemble a small evaluation set that catches regressions, from cases that actually occurred.
Using a model as a judge8 min
Use model-graded evaluation where appropriate and name the failure modes it brings.
Cost, latency and shipping8 min
Plan a first release of an agent that is affordable, observable and reversible.
Lab: write the eval setlab20 min
Turn real production failures into evaluation cases that would catch them again.

8 Case Study: Meridian Tools

4 lessons · 35 min

One team, one agent, six weeks. What they built first, what it cost them, and what actually shipped.

The brief, and the first mistake9 min
Identify, from a realistic brief, the point at which a team over-reached for autonomy.
Rebuilding around what is actually known9 min
Restructure an over-autonomous system into a router with one genuinely agentic branch.
The week it went wrong9 min
Trace three production incidents to the design decisions that permitted them.
What shipped, and what the numbers said8 min
Read an agent programme’s results honestly, including what it did not achieve.