Log inStart free
← Back to catalog

AI agents and multi-agent systems

Agents, tools, planning and safe autonomous behavior.

Updated: 25 July 2026Editor: Skilvy editorial

22 lessons · 9 h read · 2 free · 4 AI-graded projects

About this course

A course on how a model call grows into an agent — a loop with tools, memory, and control — and when that's worth it versus just being a more expensive pipeline. It covers tool contracts, state management, planning strategies, guardrails, and decision tracing.

Five modules move from defining an agent through tools, state and memory, planning and control, to operations. In "Tools" you build a registry of 4-6 tools with full contracts and tests. In "State and memory" you rework state management and back the result with measurements. In "Planning and control" you build a control loop and validate it against a set of 20 tasks.

For people who've already written code that calls an LLM and want to build systems with autonomy, not just chat wrappers. Requires Python, experience with model APIs, and an understanding of what separates an agent from a single prompt. Bring your own agent or prototype to develop through the course.

What you'll learn

  • Choose between a single prompt, a pipeline, and an agent before you start building
  • Design a tool contract: name, description, parameters, return value
  • Handle tool errors so the agent can recover instead of getting stuck
  • Manage state and compress history without losing needed context
  • Choose between planning ahead and deciding step-by-step for a given task
  • Set guardrails — step budgets, timeouts, stop conditions — against looping
  • Add human-in-the-loop confirmation for irreversible actions
  • Set up tracing and evaluate an agent on a task set by success rate and cost

What you'll end up with

  • A working tool registry for an agent, with validation and tests
  • Reworked state and memory management, backed by measurements
  • A planning and control loop validated against a set of 20 tasks
  • An operational readiness report for your agent (paid tiers include reviewer feedback and a certificate)

Not for you if you want a chatbot-prompting course — this is about building a system with tools, state, and error control.

Course program

Module 1 · What an agent is
1A loop instead of an answer: what an agent adds on top of a model callFree2One prompt, a pipeline or an agent: how to choose before you write any codeFree3Levels of autonomy and the cost of an error at each one4Anatomy of a minimal agent: what must be in the loop from day one
Module 2 · Toolsproject
5The tool contract: name, description, parameters, return value6How the wording of a description changes the agent's decisions7Tool errors: what to return so the agent can get out8Side effects: irreversibility, confirmations, idempotency9Testing tools separately from the agent
Module 3 · State and memoryproject
10What an agent remembers within a single run11Compacting the history: what can be dropped and what is lost12Long-term memory: what to keep between runs and what is harmful13Passing state between steps without bloating the context
Module 4 · Planning and controlproject
14A plan up front or a decision per step: what to choose and on what grounds15Decomposition: how to split a task so that it can be checked16Limiters: steps, budget, timeout, stop conditions17Looping: how to recognise it and how to get the agent out of the loop18Human in the loop: where to put confirmation and how not to devalue it
Module 5 · Operationsproject
19Tracing: what to log so you can reproduce a decision20Evaluating an agent: task set, success metric, cost per task21Security: tool permissions, isolation, injection through data22Several agents: when it helps and when it is simply more expensive
$89
one-time purchase · lifetime access
Or included in Ultra
Start freeGet a subscription
Practical projects
0 / 4 passed
Certificate progress →

What's included

  • Lifetime access
  • Tasks and quizzes
  • Certificate — on a paid plan
  • Updates forever