AI Agents tutorial

Learn how AI agents look, think, act and check, and use them for planning, UI design, frontend, backend, review and testing.

Course contents

Agent Basics — What an AI agent is, why it needs boundaries, how it differs from a workflow, the four things it can do, and where agents are used in real work.
Core Pillars — The four parts every agent needs: reasoning, planning, memory and action. See what each one does, and watch an agent fail when one is removed.

System Architecture — The parts inside an agent program: the perception-action cycle, the runtime, inference engine, tool registry and state store, and the input, reasoning, execution and monitoring layers.
State Machines — The named states an agent moves through, the rules for moving between them, how to check a run for illegal moves, how to recover from failure, and how to see it all.
Agent Configuration — How to give an agent a role, a scope, rules and an output standard, how to design forbidden actions and escalation paths, and how to write clear instructions that hold up against edge cases.

Task Decomposition — How an agent breaks a big goal into small tasks, maps which tasks depend on which, plans sequential, parallel and priority order, and tracks progress until every task is proven done.
Planning Strategies — Three ways an agent can plan: ReAct, Plan-and-Execute and Reflexion. See each one run on the same bug, and learn which to pick for a task.
Advanced Planning — How an agent compares several plans before choosing one: Tree of Thoughts, Monte Carlo Tree Search, and dynamic planning that revises the plan, changes priorities and adapts while it runs.

Loop Mechanics — What happens inside one turn of the agent loop: input assembly, inference, tool execution and observation capture, plus iteration tracking, action evaluation and the three runtime logs.
Loop Control and Governance — How to decide when an agent loop stops and how much it may use: stop conditions, step, token, time and cost budgets, soft and hard limits, progress checks, and a clean final report.

Using Tools — How an agent finds the right tool, checks the call against a schema, makes sure it is allowed, runs it in sync, async or background mode, and checks what comes back.
Action Coordination — How an agent runs actions in the right order, runs independent actions in parallel, avoids clashes over shared files, and checks that everything is done before it finishes.

Working Memory — How an agent keeps track of what it knows during a task: a scratchpad, facts versus assumptions, updates, compression, sliding windows with pinned facts, and memory budgets.
State Persistence — How an agent saves its progress so it survives a crash: serialization, snapshots, recovery points, restoring, integrity checks and drift.

Errors and Fallbacks — How an agent notices tool errors, bad output and runtime faults, recovers with retries and other actions, and falls back to partial answers or escalation instead of returning nothing.
Loop Protection — The guards that stop a stuck agent: duplicate and cycle detection, frequency limits, forced exits, timeouts and failure isolation, proved with a 12-case chaos suite.

Planning Agents — How a planning agent turns a feature request into a spec and tasks, with testable acceptance criteria, a dependency map, estimates and owners for other agents.
UI Design Agents — How a UI design agent turns a design task into a layout using only design tokens, and fixes accessibility problems before handing over.
Frontend Development Agents — How a frontend agent changes components until the tests pass: state handling, UI debugging, integration tests, and the right tools and stop rule.
Backend and API Agents — How a backend agent writes the API contract first, then the code, and checks every response against the contract and the speed limit.
Code Review Agents — How a review agent checks a pull request with best-practice and security rules, and how a bug agent goes from a log to a root cause, a failing test and a patch.
Testing Agents — How a testing agent finds untested code, writes and runs tests, and raises coverage, and how an audit agent scans dependencies, patches them and checks the patch.

Agent Teams for Delivery — How specialist agents deliver one feature together: team structures, assigning and merging work, messages and handoffs, deadlock prevention, and docs and deploy agents.

Security Guardrails — How to keep agents safe when what they read is an attack: prompt injection and data isolation, least privilege, human approval gates, output cleaning, read-only mode and audit logs.

Evaluation and Production — How to measure an agent with a fixed benchmark and four core metrics, audit failing traces, monitor it in production, and prove that tuning helped.

AI Agents Cheat Sheet — Every key idea from the AI Agents course on one page: the loop, stop rules, permissions, planning strategies, memory, guards, dev-workflow agent configs, metric formulas and an error index.