AI curriculum

Course outline for Agent Architecture and Orchestration

Parallel agents can create duplicate completions, conflicting artifacts, and a review queue that grows faster than results can be checked. Design explicit worker ownership, artifact contracts, and coordinator acceptance rules. Simulate worker loss and duplicate delivery before deciding whether multiple agents are better than a single controlled loop.

Technology: Agentic Systems
Duration: 6 hours
Modules: 3 · 2 hours each
Level: Level 3

About Agent Architecture and Orchestration

Agent Architecture and Orchestration Course Objectives

Compare single, supervisory, hierarchical, and multi-agent architectures against a bounded task.
Define worker artifact contracts, ownership, and merge responsibility.
Select independent work units and explicit communication semantics.
Handle duplicate completion and worker loss in a local coordinator simulation.
Bound review-queue growth using concurrency and backpressure rules.
Distinguish finite jobs from long-running or always-on lifecycle requirements.

Pre-requisites

Software Engineering Foundations for AI Engineers and Agentic AI Foundations, or equivalent software-boundary and agent-loop competence.
Basic application architecture and programming skills.
Familiarity with agent loops and tool use; queue/recovery concepts are introduced through supplied local examples.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

Required preparation

Recommended preparation

Understands software boundaries and agent loops before coordinating workers; harness and recovery experience support deeper implementation.

Find your place in the learning map

Lab Setup

Computer with a programming runtime, test runner, and isolated local artifact directories.
Supplied mock workers, deterministic scheduler, queue/capacity fixtures, and synthetic job records.
No distributed broker, hosted always-on service, live parallel model calls, or production credentials are required.

Detailed Course Outline

Module 1: Select an architecture (2 hours)

Single-agent systems: One execution context, shared task state, and simpler coordination; compare its verification costs with isolated drafting and review workers.
Supervisory agents: Task assignment, worker monitoring, and acceptance decisions; distinguish a supervisor's proposed judgment from independently checked artifacts and execution outcomes.
Hierarchical agents: Layered delegation, scoped responsibilities, and escalation paths; compare ownership clarity with extra communication and verification overhead.
Multi-agent systems: Independent contexts, shared contracts, and coordination costs; distinguish communication graphs from dependencies and execution history without treating agreement as correctness.

Practical outcome: Compare one-session and isolated draft/review designs, select an architecture from coordination and verification needs, and distinguish communication, dependency, and execution-history graphs.

Module 2: Delegate and accept independent work (2 hours)

Coordinator-worker patterns: Job identifiers, lease attempts, and centralized acceptance; handle duplicate completion and worker loss while preserving one accepted artifact per job.
Delegation: Input artifacts, expected outputs, allowed scope, and merge ownership; reject malformed, overlapping, or stale-attempt results before acceptance.
Parallel agents: Independent work units, concurrency limits, and review backpressure; choose parallelism from ownership and reviewer capacity rather than worker availability alone.

Practical outcome: Define artifact contracts, isolated ownership, a single merge responsibility, and lease/attempt identifiers; accept one verified completion while handling duplicate delivery and worker loss in a local simulation.

Module 3: Bound the agent lifecycle (2 hours)

Agent communication: Message schemas, correlation identifiers, timeouts, and duplicate delivery; define how replies relate to jobs and permitted state changes.
Long-running agents: Persistent job state, interruption handling, and bounded retries; distinguish finite task recovery from unrestricted continuous execution.
Always-on agents: Event-triggered work, supervision, resource caps, and stop rules; compare continuous lifecycle requirements with finite jobs using supplied operating assumptions.

Practical outcome: Specify message correlation, timeouts, supervision, and stop rules, then cap in-flight work and review backlog using supplied capacity assumptions rather than treating a dependency DAG as every workflow.

Practical exercise

Produce a coordinator-worker simulation, artifact contracts, ownership table, and acceptance trace.
Accept a valid worker artifact once; reject malformed, stale-attempt, and overlapping artifacts and recover a lost worker within the stated retry bound.
Inject duplicate completion and worker loss, verify one accepted result per job, and keep the simulated review queue within a stated limit.
Compare the design with a single-agent alternative and explain why independent verification remains necessary even when workers agree.

What you will produce

Coordinate bounded mock workers with explicit ownership, duplicate-safe acceptance, worker-loss recovery, and a capped review queue.

How the work is checked

Architecture selection accounts for independence, coordination cost, and verification needs.
Ownership and merge responsibility prevent overlapping artifact acceptance.
Duplicate and stale completions do not create multiple accepted results.
Worker-loss recovery and review-queue growth remain within documented bounds.

Six hours extending a deterministic coordinator scaffold with duplicate-safe acceptance and a review-queue limit. Use lease/attempt fixtures, not a production lease service; acceptance once in this simulation is not exactly-once execution of arbitrary external effects. Exercises fit within module time. Distributed messaging and always-on operations require further preparation.

When another approach is better

Use one controlled worker when task dependencies or shared files prevent useful parallel independence.
Do not increase agent concurrency beyond the capacity to verify and merge their outputs.

How we train

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals