AI Agents
From the agentic loop to multi-agent orchestration — understand what AI agents are, how they call tools, the design patterns that shape them, and how to coordinate multiple agents.
Why take this course?
The complete guide to AI agents. Learn the perceive-reason-act loop, function calling, workflows vs autonomous agents, and every pattern from single-agent tool use to orchestrator-worker and swarm architectures.
Prerequisites
This course builds on concepts from the following courses. It is recommended to complete them first:
Course Modules
The shift from chatbot to agent: understand the perceive-reason-act loop, the ReAct pattern, single-agent systems, and when one agent is no longer enough.
Learning Goals
- Distinguish an AI agent from a standard LLM API call — the agentic loop is the key difference.
- Explain the ReAct pattern: Thought → Action → Observation interleaving.
- Describe the single-agent system: one model, one prompt, a focused tool set.
- Recognize the signs that a single agent has reached its limits and needs decomposition.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
From Chatbot to Agent
A chatbot takes a message, generates a reply, and forgets everything. It is stateless — one turn in, one turn out. No me…
The Agentic Loop
Every agent — from the simplest single-tool wrapper to the most complex multi-agent swarm — runs the same fundamental lo…
ReAct: Reason + Act
ReAct is the foundational agent pattern. Published by Yao et al. in 2022, it interleaves reasoning traces with **act…
How agents interact with the world: function calling mechanics, tool interface design, selection strategies, and error handling patterns.
Learning Goals
- Explain how function calling works: model outputs structured calls, your code executes them.
- Design clear tool interfaces with specific names, descriptions, and typed parameters.
- Identify tool selection failure modes: overlapping descriptions, too many tools, wrong parameters.
- Apply error handling patterns: retry, fallback, and graceful degradation.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
Why Tools Matter
Without tools, an agent is just an LLM generating text. It can reason, plan, and explain — but it cannot do anything…
How Function Calling Works
Function calling is the protocol that connects the LLM's reasoning to your application's tools. Here is exactly what hap…
Designing Good Tool Interfaces
The model selects tools based on their names and descriptions. Poorly designed tools lead to wrong selections and co…
Workflows vs autonomous agents, sequential and parallel patterns, combining both, and the cost-latency tradeoff that shapes every architecture decision.
Learning Goals
- Distinguish workflows (hardcoded paths) from autonomous agents (model-decided paths).
- Apply the sequential pattern for tasks with data dependencies.
- Apply the parallel pattern for independent sub-tasks to minimize latency.
- Evaluate the cost-latency tradeoff to choose between sequential and parallel execution.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
Workflows vs Autonomous Agents
Before diving into multi-agent patterns, we need to draw a critical distinction that most agent discourse ignores.
**Wo…
The Sequential Pattern
The sequential pattern is the simplest multi-agent workflow: agents execute in a fixed order. The output of one agent be…
The Parallel Pattern
The parallel pattern runs multiple specialized agents simultaneously on the same input. Results are collected and merged…
Loop patterns, review & critique, iterative refinement, exit condition design, and the quality-latency tradeoff in iterative systems.
Learning Goals
- Apply the loop pattern with proper termination conditions to prevent infinite execution.
- Design review & critique systems that separate generation from evaluation.
- Distinguish iterative refinement (progressive improvement) from review & critique (generator + judge).
- Design layered exit conditions: quality thresholds, max iterations, convergence detection.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
The Loop Pattern
The loop pattern is the agent equivalent of a while loop. An agent executes repeatedly until a termination condition i…
Review & Critique
The review & critique pattern introduces a fundamental idea: separate the creator from the evaluator.
Instead of on…
Iterative Refinement
Iterative refinement progressively improves output over multiple cycles. Unlike review & critique (which has distinct ge…
AI-driven coordination: the coordinator pattern, hierarchical task decomposition, swarm architectures, and choosing the right orchestration level.
Learning Goals
- Design coordinator systems where an LLM routes requests to specialized agents at runtime.
- Apply hierarchical task decomposition for complex, ambiguous tasks that need multi-level planning.
- Evaluate swarm tradeoffs: highest quality, highest cost, lowest predictability.
- Use the orchestration spectrum to select the right level of complexity for a given problem.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
The Coordinator Pattern
The coordinator pattern introduces AI-driven orchestration. Instead of hardcoded execution paths, a central agent an…
Hierarchical Task Decomposition
Some tasks are too complex for a single coordinator. They need to be broken down into sub-tasks, and those sub-tasks bro…
The Swarm Pattern
The swarm pattern is the most powerful — and most expensive — multi-agent architecture. Multiple agents collaborate with…
Human-in-the-loop for high-stakes decisions, custom logic patterns, the pattern decision framework, and the principle of starting simple and scaling up.
Learning Goals
- Design human-in-the-loop checkpoints positioned at the point of no return for irreversible actions.
- Apply custom logic patterns that combine deterministic code with agent reasoning.
- Use the pattern decision framework to map problem characteristics to agent design patterns.
- Follow the scaling ladder: start with a single agent, add complexity only when measured failures justify it.
Concept Card Preview
Visuals, diagrams, and micro-interactions you'll see in this module.
Human-in-the-Loop
Some agent decisions are too consequential to automate fully. The human-in-the-loop pattern introduces predefined checkp…
Custom Logic Patterns
Not every system fits a named pattern. Custom logic patterns use code-based orchestration that mixes conditional logic,…
The Pattern Decision Framework
With many patterns in your toolkit, how do you choose? Start with the problem, not the pattern.
Decision matrix:
|…