AI Agents: Multi-Agent Design and Governance Course

Lesson 1 • Tools, APIs, and External Resources

Covers how agents invoke external tools and APIs to extend their capabilities. Prepares students to design tool-augmented agents.

Lesson 2 • Agent Reasoning Paradigms

Surveys major reasoning approaches including chain-of-thought and ReAct. Grounds students in how agents decide what to do next.

Lesson 3 • Agent Evaluation Fundamentals

Introduces metrics and methods for assessing single-agent performance. Sets the evaluation mindset needed for later multi-agent assessment.

Lesson 4 • Core Agent Architecture Components

Examines the internal structure of an agent: memory, reasoning, and action modules. Connects component roles to agent behaviour outcomes.

Lesson 1 • Handling LLM Failures in Agents

Identifies common LLM failure modes—hallucination, refusal, format errors—and mitigation strategies. Builds resilience into agent reasoning pipelines.

Lesson 2 • Model Selection and Configuration

Guides selection of LLMs based on capability, cost, and latency requirements. Connects model choice to downstream agent reliability.

Lesson 3 • Context Window Management

Addresses how to handle limited context windows in long-running agent tasks. Students apply summarization and retrieval to maintain coherent agent state.

Lesson 4 • LLM Capabilities Relevant to Agents

Maps LLM strengths—instruction following, summarization, code generation—to agent tasks. Clarifies which capabilities matter most for agentic use.

Lesson 1 • Planning and Task Decomposition

Teaches agents to break complex goals into executable subtasks using structured planning. Foundational for orchestrating multi-step workflows.

Lesson 2 • Agent Loop and Control Flow

Implements the observe-think-act loop with termination conditions and guardrails. Ensures agents complete tasks without infinite loops or runaway execution.

Lesson 3 • Memory Architecture Design

Covers episodic, semantic, and procedural memory implementations for agents. Students select and integrate memory stores appropriate to task requirements.

Lesson 4 • Tool Selection and Orchestration

Designs tool registries and dynamic tool selection logic within a single agent. Prepares students for tool-sharing challenges in multi-agent settings.

Lesson 1 • Agent Roles and Specialization

Defines common agent roles—orchestrator, executor, critic, retriever—and their responsibilities. Students assign roles to match task requirements.

Lesson 2 • Why Multi-Agent Systems

Articulates the benefits of parallelism, specialisation, and redundancy in multi-agent designs. Frames the trade-offs against single-agent simplicity.

Lesson 3 • Communication Protocols Between Agents

Covers message formats, routing, and synchronization patterns for inter-agent communication. Establishes the messaging foundation for later orchestration patterns.

Lesson 4 • Shared State and Coordination

Examines shared memory, blackboard systems, and conflict resolution in multi-agent contexts. Students design coordination mechanisms that prevent race conditions.

Lesson 1 • Orchestration Frameworks Overview

Surveys leading orchestration frameworks and their design philosophies without vendor lock-in bias. Students map framework capabilities to topology requirements.

Lesson 2 • Pipeline and Sequential Topologies

Builds linear agent pipelines where output from one agent feeds the next. Optimises handoff quality and handles mid-pipeline failures.

Lesson 3 • Peer-to-Peer Agent Networks

Implements flat networks where agents negotiate and collaborate without a central controller. Addresses consensus, load balancing, and emergent coordination.

Lesson 4 • Hybrid and Dynamic Topologies

Combines hierarchical, peer, and pipeline patterns into adaptive multi-agent architectures. Students design systems that reconfigure topology based on runtime conditions.

Lesson 1 • Safety Constraints and Guardrails

Designs hard and soft constraints that prevent agents from taking harmful or unauthorised actions. Covers constraint enforcement at the agent and system levels.

Lesson 2 • Incident Response for Agent Systems

Builds incident detection, containment, and post-mortem processes for agent failures. Students produce runbooks for common agent safety incidents.

Lesson 3 • Human Oversight and Control

Implements human-in-the-loop approval gates, audit trails, and override mechanisms. Ensures humans retain meaningful control over high-stakes agent decisions.

Lesson 4 • Trust Models in Multi-Agent Systems

Defines trust levels between agents and between agents and humans. Students implement trust-aware communication and permission systems.

Lesson 1 • Tracing Agent Execution Paths

Implements distributed tracing across agent hops to reconstruct full execution paths. Enables root cause identification in complex multi-agent flows.

Lesson 2 • Debugging Multi-Agent Failures

Applies systematic debugging workflows to isolate failures in multi-agent pipelines. Covers replay, isolation, and differential diagnosis techniques.

Lesson 3 • Logging Standards for Agent Systems

Defines structured logging schemas that capture agent decisions, tool calls, and state changes. Standardised logs accelerate debugging and compliance auditing.

Lesson 4 • Continuous Evaluation in Production

Designs ongoing evaluation pipelines that detect performance drift in deployed agents. Connects production metrics to model and prompt improvement cycles.

Lesson 1 • Infrastructure for Multi-Agent Systems

Selects compute, networking, and storage infrastructure suited to multi-agent workloads. Covers containerisation, orchestration platforms, and resource isolation.

Lesson 2 • CI/CD for Agent Systems

Builds continuous integration (CI) and deployment pipelines tailored to agent code and prompt changes. Ensures safe, automated promotion from development to production.

Lesson 3 • Scaling Strategies and Load Management

Implements horizontal and vertical scaling for agent services under variable load. Students design autoscaling policies and load-shedding mechanisms.

Lesson 4 • Cost Optimisation in Production

Applies techniques to reduce LLM API, compute, and storage costs without sacrificing performance. Students build cost dashboards and set budget guardrails.