AI curriculum

Course outline for Dynamic and Agentic Workflows

A generated plan can satisfy a schema while proposing unsafe actions or invalid dependencies. Compile a proposed report plan only after checking typed stages, policy, and approval bound to its version. Compare bounded replanning with a simpler fixed workflow.

About Dynamic and Agentic Workflows

A generated plan can satisfy a schema while proposing unsafe actions or invalid dependencies. Compile a proposed report plan only after checking typed stages, policy, and approval bound to its version. Compare bounded replanning with a simpler fixed workflow.

Dynamic and Agentic Workflows Course Objectives

  • Classify stable operations and stochastic planning stages.
  • Validate dependencies, stage contracts, and allowed actions in a generated plan.
  • Compile an accepted plan into a local execution graph.
  • Bind approval to plan and input versions.
  • Stop or request renewed approval when runtime changes invalidate the accepted plan.

Pre-requisites

  • Programming and typed stage input/output contracts.
  • Familiarity with agent tool calls, task dependencies, and checkpointed workflow recovery.
  • Ability to distinguish a proposed action from permission to execute it.

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

Readiness checks

  • Programming and typed stage input/output contracts
  • Basic agent tool calls and task dependencies

Understands agent loops and can recover known workflows before allowing generated plans to alter execution; full hierarchical or multi-agent architecture is not a gate.

Find your place in the learning map

Lab Setup

  • Programming runtime, test runner, supplied validator/compiler starter, and local task-graph runner in a disposable workspace.
  • Synthetic tasks, generated-plan fixtures, mock tools, and approval records; a local model is optional.
  • No external write credentials or live autonomous actions are required.

Detailed Course Outline

Module 1: Treat generated plans as proposals

  • Deterministic vs stochastic stages: Separate stable transformations from variable planning proposals so generated decisions cannot bypass fixed execution and acceptance controls.
  • Plan generation: Express report plans as typed proposals with declared stage inputs, dependencies, and actions rather than immediately executable instructions.
  • Plan validation: Check dependencies, input compatibility, and action policy independently of JSON validity; reject cycles and unauthorized writes.

Practical outcome: Define typed plan constraints and reject schema-valid proposals with invalid dependencies or unauthorized writes.

Module 2: Compile accepted dependencies

  • Dynamic DAG construction: Build an acyclic execution graph only from accepted stages, preserving typed artifact dependencies and validated action boundaries.
  • Agent stages: Bound variable planning work with explicit input and output contracts while keeping stable operations in the local runner.
  • Execution plan compilation: Translate validated proposals into executable stages and bind recorded approval to the plan hash and input version.

Practical outcome: Compile validated stages into a local runner and record approval against the plan hash and input version.

Module 3: Adapt without bypassing acceptance

  • Workflow adaptation: Use failure feedback to propose limited plan revisions, comparing the added complexity with a simpler fixed workflow.
  • Runtime decision-making: Check whether changed inputs or plans invalidate accepted execution and stop before stale approval authorizes changed actions.
  • Human intervention: Request renewed approval for revised plans and inputs, preserving versioned acceptance records before execution can resume.

Practical outcome: Use failure feedback to propose a bounded revision, stop stale execution, and obtain renewed acceptance before changed actions.

Practical exercise

  • Produce typed plan fixtures, a validator, compilation diagnostics, and versioned execution records for a synthetic report task.
  • Accept a valid plan; reject cycles, incompatible stage inputs, and an unauthorized action even when JSON is valid.
  • Execute stable operations in the local runner and verify dependency order and the mock output artifact.
  • Change an input or plan after approval; verify that execution stops until renewed approval, then compare the design with a fixed workflow.

What you will produce

Validate and compile a proposed execution plan with version-bound approval and controlled replanning.

How the work is checked

  • Invalid dependencies, type mismatches, and unauthorized actions are rejected.
  • Accepted execution follows dependencies and produces the expected artifact.
  • Changed inputs or plans invalidate previous approval.
  • The fixed-versus-dynamic comparison identifies a concrete planning benefit or recommends the fixed option.

Six-hour guided plan-compiler prototype; feedback can contain cycles while the selected execution plan is acyclic. No general planner correctness or autonomous self-modification claim.

When another approach is better

  • Prefer a fixed workflow when dependencies and rules are already known.
  • Do not permit runtime adaptation when changed actions cannot be checked or approved within the required response time.

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