AI curriculum

Course outline for Agent Architecture and Orchestration

Design how agents divide work, communicate, and share only the context each task needs. Compare supervisors, hierarchical teams, handoffs, parallel workers, and shared-conversation systems. Build a small coordinated team, then extend it into an event-driven service that continues across sessions. Keep durable task state separate from each model's limited context window.

Agent Architecture and Orchestration Course Objectives

  • Compare architectures by control flow, communication, context ownership, and lifecycle.
  • Define and exercise task, result, clarification, and handoff messages.
  • Build a coordinator and hierarchical delegation with explicit responsibilities.
  • Run parallel workers and compare them with single-agent and shared-conversation alternatives.
  • Control per-agent context, durable records, summaries, retrieval, and memory updates.
  • Operate an event-driven service across context resets and process restarts.
  • Evaluate coordination quality, information loss, latency, inference use, and review effort.

Pre-requisites

  • Agentic AI Foundations or equivalent ability to build and run a small tool-using agent.
  • Basic Python, JSON, functions, asynchronous calls, files, and tests.
  • Building Applications with LLMs or equivalent familiarity with model calls and application-owned state.
  • LangChain basics from revised Agentic AI Foundations help; a short scaffold orientation is provided.
  • No message-broker administration, distributed-systems expertise, or Agent Platforms and Frameworks attendance is required.

Before this course

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

Required preparation

Readiness checks

  • Agentic AI Foundations or equivalent ability to build and run a small tool-using agent.
  • Basic Python, JSON, functions, asynchronous calls, files, and tests.
  • Building Applications with LLMs or equivalent familiarity with model calls and application-owned state.
  • LangChain basics from revised Agentic AI Foundations help; a short scaffold orientation is provided.
  • No message-broker administration, distributed-systems expertise, or Agent Platforms and Frameworks attendance is required.

Agentic AI Foundations or equivalent ability to build and run a small tool-using agent.

Find your place in the learning map

Lab Setup

Delivery requirements: this environment, access, and the exercise materials must be prepared and verified before delivery. This outline does not certify that a lab package is ready.

Prepared Python/LangChain environment continuing Agentic AI Foundations, authorized inference access, an instrumented supervisor/hierarchy scaffold, a runnable handoff or shared-conversation comparison, local queue/event source, persistent task store, artifact directories, and tests. Provide explicit context assembly and reset controls, source revisions, and failure fixtures. Use a small bounded agent registry and at most two concurrent leaf workers in the main experiment. Choose supported stable APIs; do not depend on the unmaintained langgraph-supervisor package or an unverified preview orchestration feature. No production broker, cloud deployment, or permanent hosted service is required.

Detailed Course Outline

Module 1: Choose an agent architecture (2 hours)

  • Single-agent baseline: Single agent with tools or skills as the baseline.
  • Pipelines and routers: Sequential pipelines, routers, and parallel fan-out/fan-in.
  • Supervisor and orchestrator: Supervisor-worker systems and dynamic orchestrator-worker planning.
  • Hierarchy and shared work: Hierarchical teams, peer handoffs, shared conversations, and shared workspaces.
  • Generator and reviewer: Generator-reviewer loops and the limits of voting or agreement.
  • Topology and lifecycle: Control topology, communication topology, context scope, and runtime lifecycle.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Map the same task into alternative designs and justify where extra agents help.

Module 2: Make agent communication explicit (2 hours)

  • Communication mechanisms: Direct calls, agents as tools, queued messages, and event notifications.
  • Request/reply and background work: Blocking request/reply versus background work and later result delivery.
  • Task message types: Task briefs, clarification requests, progress updates, results, and cancellation.
  • Correlation and artifacts: Sender/recipient, task identity, correlation, attempts, status, and artifact references.
  • Delegation and handoff: Delegating a subtask versus handing over conversational control.
  • Message failures: Message validation, partial results, timeouts, duplicates, and late replies.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run a request/reply and background exchange, including a clarification and correlated result.

Module 3: Build coordinators and hierarchical teams (2 hours)

  • Coordinator responsibilities: Router, stateful supervisor, deterministic scheduler, and model planner responsibilities.
  • Assignment briefs: Goal decomposition, role descriptions, capability discovery, and assignment briefs.
  • Team hierarchy: Lead, section lead, and specialist workers in a bounded hierarchy.
  • Depth and budgets: Delegation depth, local budgets, return paths, and escalation.
  • Summaries and source loss: Upward summaries, source artifacts, synthesis, and information loss.
  • Final ownership: Coordinator bottlenecks, conflicting findings, acceptance, and final ownership.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Extend a flat supervisor into a small hierarchy and trace delegation and results across levels.

Module 4: Coordinate parallel and collaborative agents (2 hours)

  • Parallel work units: Independent work units, bounded parallelism, shared inputs, and isolated outputs.
  • Fan-out and reassignment: Fan-out/fan-in versus dynamic reassignment and follow-up questions.
  • Peer and manager communication: Peer handoffs versus manager-led shared conversation and turn selection.
  • Shared workspace: Shared workspace or blackboard-style artifacts and controlled state updates.
  • Feedback and disagreement: Generator-reviewer feedback, disagreement, termination, and independent checks.
  • Coordination cost: Coordination latency, context duplication, inference use, and review effort.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Run two workers concurrently and compare a supplied handoff/shared-conversation variant on the same task.

Module 5: Manage context across agents and sessions (2 hours)

  • Context and durable records: Per-call context, conversation history, task state, artifacts, and durable memory.
  • Context inheritance: Context isolation versus deliberately inherited or forked history.
  • Minimal task packets: Minimal task packets, selected messages, source references, and on-demand retrieval.
  • Token budgets and summaries: Token budgets, tool-result trimming, compaction, and summary fidelity checks.
  • Memory ownership: Memory write ownership, provenance, stale facts, conflicts, and scope separation.
  • Fresh-session reconstruction: Fresh-session reconstruction with open questions, decisions, progress, and next actions.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Rebuild a worker/coordinator context from durable records and recover an omitted critical fact.

Module 6: Operate long-running and always-on agents (2 hours)

  • Jobs and ambient services: Finite jobs, long-horizon sessions, scheduled agents, and event-driven ambient services.
  • Waiting and busy loops: Waiting for events versus continuous model calls and busy-loop inference.
  • Durable inbox: Durable inbox/event cursor, task identity, external records, and transient workers.
  • Context rotation: Context rotation, wake-up packets, changed sources, and memory refresh.
  • Process restart: Checkpoints, process restart, in-flight work, and uncertain completed effects.
  • Admission and shutdown: Admission, review backpressure, monitoring, human intervention, and graceful shutdown.
  • Guided-time allocation: 0.5 hours for explanation and a worked example, 0.75 hours for guided and independent practice, 0.5 hours for checks and feedback, and 0.25 hours for questions and contingency.

Practical outcome: Resume a local event-driven team after context reset and process restart without losing a pending task.

Practical exercise

  • Build a small research desk that maintains a report from synthetic source documents and incoming updates. Use one task and common acceptance criteria throughout. First run a single-agent baseline, then configure a LangChain supervisor that invokes specialists as tools. Add a section lead to create one explicit hierarchical path. Keep nesting and worker concurrency bounded. The learner extends the coordination code, task briefs, and context selection; model, event-delivery, and storage adapters are supplied.
  • Define messages for assignment, clarification, result, and handoff. Return source-backed artifacts and compact summaries rather than every worker transcript. Run two actual model-backed workers concurrently. Compare the hierarchy with a provided runnable handoff or shared-conversation variant. Inspect who holds control and which context each agent receives; a new role label alone is not a different architecture. Use independent checks when specialists disagree.
  • Give the coordinator a limited context budget. Persist the plan, decisions, open questions, task status, and source references outside the model context. Reset the conversation and reconstruct only the needed working context. Introduce a source revision and a summary that omits a critical fact. Retrieve the original evidence, correct the memory, and check the revised report.
  • Finally process a finite stream of update events through a local always-on service scaffold. Wait without repeated model calls when no work exists. Restart the process with a pending task, reconstruct context, and continue. Inject one duplicate completion or late reply and check the accepted result. Observe review-backlog admission and graceful shutdown. Compare output quality, information loss, calls/tokens where available, wall time, and review effort. These bounded observations do not prove production-scale reliability.

Delivery and timing

  • Guided hours include explanations, demonstrations, learner practice, checks, feedback, questions, and contingency as allocated above. Breaks, bulk downloads, and prerequisite account/environment setup are additional. These allocations require a timed pilot before delivery; they are not measured completion times.

What you will produce

Build a coordinated agent team and verify communication, shared context, hierarchy, and continuity across restart.

How the work is checked

  • The architecture comparison separates control, communication, context, and lifecycle choices.
  • Actual messages show assignment, clarification, handoff/return, and correlated results.
  • A model-backed hierarchy delegates across levels and returns inspected source-backed artifacts.
  • The coordinator retains explicit synthesis and acceptance responsibility.
  • Actual parallel worker execution is visible; a comparison variant changes the control or context flow.
  • Per-agent inputs respect the context policy without losing required task evidence.
  • A fresh context reconstructs the task and corrects stale or incomplete memory from original sources.
  • Restart uses durable task/event records rather than an assumed preserved conversation.
  • Idle operation avoids busy-loop inference; admission and shutdown controls are observable.
  • Duplicate or stale completion handling does not masquerade as exactly-once external execution.
  • The final recommendation uses task evidence, not agent agreement or a vendor feature list.

12 guided hours. A scaffolded research-desk team with actual model-backed communication, hierarchy, parallel work, context recovery, and restart. A supplied event/store adapter supports a bounded always-on demonstration. This does not establish indefinite autonomous operation, universal architecture superiority, or production fault tolerance.

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

Contact us for full course details, including duration, delivery options and lab requirements.

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