AI curriculum

Course outline for Dynamic and Agentic Workflows

Generate a typed plan and operate it interactively through a coding-agent harness. Inspect dependencies, run selected eligible stages, pause, check results, and re-evaluate the remaining work. When new evidence changes the required work, revise the plan and determine which artifacts remain valid. Keep model-selected stages bounded and compare the adaptive result with a simpler fixed workflow. Approval constrains execution but does not replace planning, compilation, or adaptation.

Dynamic and Agentic Workflows Course Objectives

  • Separate deterministic execution from variable model-generated planning.
  • Generate a typed plan through an actual authorized model call.
  • Validate dependencies, artifact types, available inputs, operations, and limits.
  • Compile an accepted plan into an executable DAG with stable identity.
  • Run selected eligible stages through an interactive coding-agent session.
  • Inspect persisted stage state and artifacts before choosing the next work.
  • Run bounded agent-selected work with observable inputs, outputs, and stop conditions.
  • Replan when new evidence requires changed stages or dependencies.
  • Reuse valid artifacts and invalidate affected downstream results.
  • Stop or request renewed acceptance when adaptation changes scope or authority.

Pre-requisites

  • Basic Python, typed inputs/outputs, JSON, tests, and API use.
  • Agentic AI Foundations or equivalent actual model/tool operation and agent-loop knowledge.
  • Reliable Workflow Execution or equivalent dependency scheduling, checkpointing, and recovery competence.
  • Distinguish a proposed action from authority to execute it.
  • Basic interactive coding-agent use; a guided harness orientation is supplied.
  • The starter supplies infrastructure; learners implement planner/compiler extensions.

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

  • Basic Python, typed inputs/outputs, JSON, tests, and API use.
  • Agentic AI Foundations or equivalent actual model/tool operation and agent-loop knowledge.
  • Reliable Workflow Execution or equivalent dependency scheduling, checkpointing, and recovery competence.
  • Distinguish a proposed action from authority to execute it.
  • Basic interactive coding-agent use; a guided harness orientation is supplied.
  • The starter supplies infrastructure; learners implement planner/compiler extensions.

Can run typed Python stages, use a coding agent, and recover a known workflow. The course introduces its interactive runner adapter before selective execution and graph revision.

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.

One verified interactive coding harness, with Claude Code as the reference route, plus a prepared local runner adapter and a protected control state. Equivalent harnesses need their own tested stage-selection, interruption, and resume procedure. Stable Python environment, test runner, authorized model endpoint with structured output/tool support, schema validator, prepared compiler and durable local runner, synthetic datasets, and a disposable artifact directory. Supply narrowly scoped read and local-output tools; no external write credential or real publication is needed. Preflight compatibility, quotas, data handling, inference costs, runtime budgets, and all failure paths. Stable versions and actual lab output must be recorded before delivery. Provider/library choice remains a delivery decision.

Detailed Course Outline

Module 1: Give the planner a constrained language (2 hours)

  • Planning and execution boundaries: Fixed transformations, stochastic planning, and deterministic validation boundaries.
  • Typed plan language: Plan schemas, typed artifacts, stage identities, and operation registries.
  • Planning inputs and budgets: Goal, evidence, available tools, dependencies, and resource budgets.
  • Actual generated plan: Actual model-generated plans with structured output and captured provenance.
  • Agent-stage contract: Agent-stage input/output contracts and bounded tool choices.
  • Fixed-plan baseline: A fixed-plan baseline for the same report objective.
  • 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: Generate a typed proposal and explain which choices belong to the model, validator, and runtime.

Module 2: Compile only a plan that makes sense (2 hours)

  • Schema and semantic validity: Schema validity versus dependency, type, and policy validity.
  • Invalid graph cases: Missing inputs, unknown operations, cycles, and conflicting output names.
  • Graph compilation: Stage expansion, artifact bindings, and executable graph construction.
  • Immutable plan identity: Immutable plan identity, input versions, and diagnostic messages.
  • Operation and budget limits: Operation allowlists, execution budgets, and version-bound acceptance.
  • Compiler rejection tests: Executed compiler tests with a learner-authored invalid plan.
  • 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: Compile a valid proposal and reject schema-valid plans with invalid dependencies or prohibited operations.

Module 3: Run selected stages through a coding harness (2 hours)

  • Interactive harness orientation: Interactive harness orientation, workspace instructions, and prepared runner tools.
  • Selected-stage preview: Plan inspection, explicit stage selection, dependency checks, and dry-run previews.
  • Bounded tool stage: A bounded model/tool stage with explicit completion criteria.
  • Runtime and scope changes: Runtime decisions inside accepted scope versus scope-changing revisions.
  • Pause and inspect: Pause boundaries, persisted state, artifact inspection, and bounded repair attempts.
  • Independent result checks: Independent result checks beyond the model's completion statement.
  • 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: Ask the harness to run only selected eligible stages, inspect real outputs, and prove that unselected stages did not run.

Module 4: Change the graph when evidence changes (2 hours)

  • Changed dependencies: New information that adds a stage or dependency.
  • Versioned replanning: Replanning proposals with preserved history and budget limits.
  • Interactive re-evaluation: Interactive evidence review, plan differences, and stopping stale completion.
  • Downstream invalidation: Artifact input identity, content hashes, and downstream invalidation.
  • Unaffected artifact reuse: Reuse of unaffected accepted work and recomputation of changed outputs.
  • Feedback around the DAG: Cyclic feedback around an acyclic selected execution plan.
  • 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: Execute a revised graph, preserve one unaffected artifact, and recompute an invalidated dependency chain.

Module 5: Intervene without turning every choice into approval (2 hours)

  • Preauthorized choices: Preauthorized runtime choices and explicit authority-changing boundaries.
  • Human stage selection: Human stage selection, pause, edit, reject, escalation, and resumed acceptance.
  • Version-bound acceptance: Plan/input version changes and invalid previous acceptance.
  • Persisted session resume: Session restart from persisted artifacts rather than conversational claims.
  • Adaptation costs: Outcome, replanning cost, useful adaptation, and review burden.
  • Fixed-plan recommendation: When a fixed graph is safer, cheaper, and easier to maintain.
  • 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: Stop an out-of-scope revision and justify dynamic planning or recommend the fixed baseline using executed evidence.

Interactive harness practice

  • Use one coding-agent session to operate the report workflow. Claude Code is the reference harness, not a required second framework to build. Teach the actual installed version's planning, tool permissions, interruption, and session resume before the exercise. A harness's prose plan is not yet a validated typed plan. The model generates the typed proposal; the validator and compiler check it; the local runner owns durable stage execution; the learner chooses the next permitted slice. The model can choose bounded actions inside an agent stage. These are separate decisions, even when one chat window exposes all of them.
  • The starter must expose inspect, validate, preview-selection, run-selection, pause, compare-plans, and resume operations. These are course adapter operations, not claimed built-in Claude Code commands. Each mutating request names the plan version, input versions, explicit stage IDs, and budget. The runner rejects unready stages or offers a separate prerequisite preview. It never silently expands a selected set to the whole graph. Existing accepted dependencies can be reused after provenance checks. A completed subset is not a completed workflow.
  • Work through these interactions, saving the actual requests and runner receipts:
  • Ask: "Inspect the report task and propose typed plan v1. Show stage IDs, dependencies, inputs, expected outputs, and budgets. Do not execute stages." Check the actual saved proposal, validate it, and inspect the compiled graph. 2. Ask: "Preview only parse_records and load_reference under v1. Show missing prerequisites and effects. Do not run calculate, draft, check, or assemble." The supplied fixture uses these IDs; inspect the actual generated IDs before adapting the request. Validate this selection before granting execution. 3. Ask: "Run only that accepted selection, then stop and show receipts and artifact paths." Check stage records and file contents independently. Verify zero attempts for unselected stages; a missing final report alone is not proof. 4. Ask: "Re-evaluate the results. Which stages are ready, blocked, or unnecessary? Explain the evidence and propose the next slice without running it." Authorize calculate separately, inspect its figures, then run the bounded draft/tool stage. Keep final checking and assembly pending until explicitly selected. 5. Introduce the changed-unit input. Ask: "Propose v2 with conversion and validation before calculation. Show changed edges, reused artifacts, invalidated outputs, and running work to stop. Do not run the proposal." Check the plan difference and independently predict the affected dependency chain before feedback. 6. Accept the checked v2/input versions. Run only the changed eligible stages in bounded slices. Preserve the unchanged reference artifact and receipt. Reject reuse of the old calculation and dependent draft. Inspect converted figures before selecting draft, check, and final assembly under the new plan. 7. Leave one stage pending, close the session at a safe boundary, and resume. Read the persisted plan/state and verify artifacts, rather than reconstructing completion from a chat summary. Finish only currently eligible selected work.
  • Test a request for assembly with an incomplete dependency and a stale v1 run after v2 acceptance. Both must fail without executing the requested stage. Test pause while a stage is running. Distinguish stopping future dispatch from cancelling an in-flight tool. Record whether cancellation succeeded; interruption does not undo completed effects. Reject late stale completion after replanning.
  • The harness must not have unrestricted access to modify the protected runner, policy, acceptance records, evaluator, or authoritative state. Restrict tools and disposable output paths outside model instructions. Exercise an attempted unselected stage call and verify runtime rejection. A stage-selection receipt must bind the allowed subset, not merely approve the whole plan. Keep runner state inspection available independently of the chat and use one execution owner.

Practical exercise

  • Build a report planner over synthetic operational records. A real model proposes typed stages from an allowlisted registry. Stable stages parse, calculate, and assemble; one bounded agent stage reads permitted reference material and drafts an explanation through actual model/tool operation. Extend a prepared validator, compiler, and local runner rather than building every infrastructure layer.
  • Generate and save actual proposals with model configuration, inputs, and plan identity. Execute a valid plan. Independently attempt a cyclic plan, missing artifact, incompatible type, unknown operation, output collision, and forbidden write. Include crafted fixtures for repeatable rejection tests, but do not use fixtures instead of model generation or actual graph execution.
  • Introduce a revised data source whose units no longer match the calculation's contract. The revised plan must insert a conversion/validation stage and change the consuming dependency, not merely update an approval signature. Stop stale affected attempts and inspect plan differences. Reuse an unchanged reference artifact, invalidate the old calculated result and dependent explanation, then run the revised path and independently check the converted figures. A hash records identity; reuse also requires compatible contracts and dependency provenance.
  • Exercise an in-scope runtime choice without unnecessary reapproval, then propose a new destination or forbidden operation that needs rejection or an explicit authority decision. Bind renewed acceptance to the actual revised plan and input versions. Resume only under current acceptance. Compare with a working fixed-plan baseline, including output correctness, attempts, inference use, and review effort.
  • Harness orientation and pause/resume basics occur in Module 3 before graph adaptation. The protected adapter, policy controls, state store, and inspection tools are supplied. Learners extend plan validation/compilation and operate the interactive session. They run supplied rejection tests and author one invalid plan independently. No adapter-security platform is built from scratch.

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

Operate a generated dependency plan interactively, run selected stages, and revise it without reusing invalid results.

How the work is checked

  • A real model produces the typed proposal and a bounded stage uses actual tools.
  • The compiler rejects structural, semantic, resource, and policy violations.
  • Execution follows compiled dependencies and produces independently checked artifacts.
  • A real interactive session executes only the accepted stage subset and pauses.
  • Unselected, unready, and stale-version stage requests are rejected by the runner.
  • Inspection and re-evaluation determine the next slice and changed dependency path.
  • Session resume reads checked persisted state and does not rerun accepted work.
  • New evidence causes an observed change to stages or dependencies.
  • Reuse and invalidation reflect input identity and downstream provenance.
  • A stale attempt cannot silently complete against the accepted revised state.
  • Scope-changing adaptation cannot inherit approval for a different plan/input version.
  • The comparison identifies a concrete adaptation benefit or recommends fixed execution.

10 guided hours. A protected prepared runner exposes stage selection through one verified interactive coding harness, with Claude Code as the reference route. Learners extend planning, validation, and compilation; they do not build a new coding harness. Actual model-generated plans, bounded tool use, graph execution, and dependency-changing adaptation are required. Prompts alone do not enforce authority; interruption does not undo completed effects. A fixed plan remains a valid simpler recommendation.

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