AI curriculum

Course outline for Agentic AI Foundations

A task may need a fixed workflow rather than an agent that chooses its next step. Simulate a bounded agent loop and distinguish generated advice, tool requests, and actual effects. Evaluate the observed result against a goal and stop or escalate when further action would exceed delegated authority.

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

About Agentic AI Foundations

Agentic AI Foundations Course Objectives

Compare an agent-selected loop with a fixed workflow for the same task.
Identify who selects, authorizes, and executes a tool action.
Sketch a bounded plan and explicit memory policy.
Compare a proposed correction with the observed result rather than trusting reflection.
Define iteration, resource, and authority stop conditions.
Trace a failed outcome through human escalation without causing an unauthorized effect.

Pre-requisites

Artificial Intelligence Foundations or equivalent familiarity with generative AI and its limitations.
Basic understanding of tasks and process steps; coding is optional.

Before this course

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

Required preparation

Artificial Intelligence Foundations

Recommended preparation

Understands generative AI; practical interactions and workflow models help distinguish an agent from a fixed process. Coding is optional.

Find your place in the learning map

Lab Setup

Computer with a browser and a diagram or text editor.
Supplied synthetic tool requests, result fixtures, state cards, and an agent-loop worksheet or optional local simulator.
No coding, real external effects, persistent hosted agent, or paid model is required.

Detailed Course Outline

Module 1: Choose the execution model (2 hours)

What an agent is: Model-selected steps, harness execution, and observable effects; distinguish generating advice from acting through capabilities with delegated authority.
Agents vs workflows: Adaptive step selection versus fixed execution paths; compare flexibility, verification burden, and when a simpler predetermined sequence is sufficient.
Tool-using agents: Capability selection, proposed arguments, executor responsibilities, and tool results; separate access to an operation from permission to perform it.

Practical outcome: Compare agent and fixed-workflow traces for a read, draft, and publish scenario, distinguishing model step selection, harness execution, and authority to cause effects.

Module 2: Make planning and memory explicit (2 hours)

Planning: Finite steps, dependencies, explicit goals, and permitted effects; sketch a bounded plan that stops when evidence or authority is insufficient.
Memory: Persistent facts versus session-only observations; specify what survives a restart and what must be checked against an authoritative record.
Reflection: Critique, proposed corrections, and independently observed results; distinguish a convincing self-assessment from evidence that an error was actually repaired.

Practical outcome: Sketch a finite plan, identify persistent versus session-only facts, and compare critique with independent evidence rather than assuming reflection repairs errors.

Module 3: Close the loop safely (2 hours)

Agent loops: Reference goals, observations, evaluation, and permitted corrections; enforce iteration and resource limits rather than treating continued activity as progress.
Human oversight: Review ownership, delegated actions, and escalation conditions; preserve the distinction between recommendations, approval decisions, and execution authority.
Failure modes: Unsupported conclusions, ineffective corrections, missing evidence, and unauthorized effects; inspect actual outcomes and stop or escalate instead of trusting narration.

Practical outcome: Define a reference goal, inspect observed consequences, select a permitted correction, and stop or escalate at iteration limits, missing evidence, or an approval boundary.

Practical exercise

Produce a simulated agent trace, memory record, goal check, and stop/escalation policy.
Complete a permitted read and draft; detect a failed result and block an unauthorized publication even if the agent claims success.
Walk through at least six scenarios with a maximum of four steps each, recording actual effects separately from proposals.
Compare the result with a simpler fixed workflow and explain which tasks do not benefit from agent-selected steps.

What you will produce

Specify and simulate a bounded agent loop that evaluates observed outcomes and respects stop and escalation rules.

How the work is checked

The comparison explains who chooses steps in each execution model.
Proposals, tool results, and actual effects are recorded separately.
A failed outcome is detected despite a success claim.
The trace stops before unauthorized effects and respects the stated step limit.

Six-hour coding-optional simulation with practice inside module time. Use state cards and a maximum four-step loop, not a deployed autonomous service. Planning, memory, and reflection receive guided comparisons before the failure/authority scenarios; advanced cognitive architectures and distributed recovery remain outside scope.

When another approach is better

Use a fixed workflow when steps and inputs are known and agent selection adds uncertainty without value.
Do not use autonomous execution when consequences cannot be checked or delegated authority is undefined.

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