Advanced Programme · Module III of CEAL

Build AI agents that do real work.

A hands-on programme that takes your team from understanding AI agents to building live, working automations. No-code first, then low-code, then full-code. Every participant leaves with something deployable on their own workflow.

28 modules 60% hands-on 5 days Live build included STOA certified
Andrej Karpathy
Why this programme exists
"A failure to claim the 10X boost from AI feels decidedly like a skill issue."
Andrej Karpathy · OpenAI co-founder, former Director of AI at Tesla
Duration
5 days
Format
Live online or on site
Next open date
Private cohorts
Fee
On request
includes all materials
For teams
Private cohort from 8 delegates
Schedule a TNA call
Programme overview

What this programme covers.

This five-day programme is built for the managers, analysts and specialists who will design, build and run AI agents on their own work. An AI agent is given a goal rather than a question: it works out the steps, uses tools and company data, and produces a finished result. That moves AI from answering to completing work, and it makes automation a practical skill for the people who own the process. The programme follows a progressive path: no-code workflow automation first, then low-code agent building on a visual canvas, then full-code agents built with a coding agent.

Day one establishes how agents work, how to instruct them with the C.L.E.A.R. framework, and how to map a process and scope an automation use case of three to five steps. Day two builds no-code automations with triggers, AI nodes, document generation and spreadsheet updates, and closes with an agent health and reporting dashboard. Day three moves to a visual agent canvas: a document-grounded agent, a triage and routing agent, a planner and executor pair, and guardrails designed into the flow. Day four introduces coding agents and takes each participant through the function lab closest to their own work, where finance, human resources, sales, marketing, operations, customer support, project management and business analysis each have a case carrying realistic ambiguity and planted edge cases, then covers testing, integration, security and observability. Day five evaluates what has been built: metrics, cost, failure modes and allow, block and escalate guardrails, then governance, the AI Review Board, the pilot definition and the capstone.

Every lab runs in a pre-configured environment opened from a browser, with no software to install. Participants choose a visual build track or a coding-agent track, and each lab is verified against fixed acceptance criteria. Participants leave with a working automation built on their own workflow, a reusable instruction library, an evidence pack of traces and metrics, governance starting points, and a ninety-day plan. The programme closes on where agentic AI is heading: context engineering, loop engineering, graph engineering, agentic retrieval-augmented generation, and the Model Context Protocol.

Who should attend

This programme is designed for managers, analysts and specialists across the business functions who want to build and run AI automations on their own work:

  • Operations, Process Improvement and Business Excellence Managers and Specialists
  • Business Analysts, Data Analysts and Financial Analysts
  • Project Managers, Programme Managers and PMO Leads
  • Team Leads and Line Managers in finance, human resources, sales, marketing, operations and customer support
  • Learning and Development Managers and Human Resources Business Partners
  • IT Managers, Automation Leads and Solution Architects
  • Digital Transformation, Innovation and Strategy Managers
  • Software Developers, Data Engineers and Technical Consultants

Each participant works the function lab closest to their own remit, so a mixed group builds on eight different business cases in the same room.

Learning outcomes

  • Explain how AI agents work and where they differ from assistants and workflow automation
  • Apply the C.L.E.A.R. framework and K-shot prompting to agent instructions
  • Select an automation platform across the no-code, low-code and full-code spectrum
  • Map and redesign a process for automation
  • Design an agent's goal, tools, memory and guardrails
  • Build no-code automations with triggers, AI nodes and document generation
  • Build document-grounded, routing and multi-agent flows on a visual canvas
  • Build a code-based agent with Claude Code in GitHub Codespaces
  • Build a working agent on their own function's work
  • Test, integrate and secure an AI workflow with access controls
  • Instrument an agent and evaluate its traces, metrics, costs and failure modes
  • Configure allow, block and escalate guardrails
  • Apply governance and accountability controls to agent deployment
  • Take an agent from pilot to operations with ownership, monitoring and change control
  • Build a ninety-day plan for their own automation
Programme outline

Twenty-eight modules. Seventy percent hands-on.

Each module follows the TEA™ framework, twenty percent theory, twenty percent examples, sixty percent hands-on application on your own work scenarios.

Day 1: Agentic AI Foundations and Process Design

01
Day 1 · Module

What Agentic AI Is

  • What is an AI agent?
  • Prompts, assistants, workflow automation and agents
  • The agent loop (goal, observe, reason, act, evaluate, repeat)
  • Agent types (simple reflex, model-based, goal-based, utility-based, learning)
  • Single-agent and multi-agent systems
  • Levels of autonomy and human-in-the-loop
  • Robotic process automation and agentic automation
Live demonstration an agent completing a multi-step business task end to end
02
Day 1 · Module

Inside an Agent

  • Large language model essentials (tokens, context windows, temperature, inference)
  • Reasoning models
  • Tools and function calling
  • Memory (in-context, session, long-term)
  • Retrieval and grounding
  • Hallucination and non-determinism
  • Verification of agent output
Live walkthrough the calculator test
03
Day 1 · Module

Instructing Agents

  • The anatomy of an agent instruction (role, goal, context, tools, constraints, output)
  • The C.L.E.A.R. prompt engineering framework
  • K-shot prompting (zero-shot, one-shot, few-shot, multi-shot)
  • Chain-of-thought and reasoning prompts
  • Structured outputs (JSON, tables, decision summaries, memos)
  • Tool descriptions and wrong tool selection
  • Prompting versus delegating to an agent
  • Instruction libraries and reusable agent skills
Hands-on exercise writing and testing agent instructions on participants' own work
04
Day 1 · Module

The Automation Platform Landscape

  • The build spectrum (no-code, low-code, full-code)
  • Workflow automation platforms (n8n, Zapier, Make)
  • Visual agent builders (LangFlow, Flowise)
  • Enterprise agent platforms (Microsoft Copilot Studio, Microsoft Foundry, Google Gemini Enterprise)
  • Coding agents and developer frameworks (Claude Code, LangChain, LangGraph, OpenAI Agents SDK)
  • Observability platforms (LangSmith)
  • Build, buy or configure
  • Platform selection criteria (integration, data residency, control, cost, exit)
  • The lab environment (GitHub Codespaces, browser-based, pre-configured)
Gamified task placing participants' automation candidates on the no-code, low-code and full-code spectrum
05
Day 1 · Module

Process Thinking for Automation

  • Mapping a workflow step by step (trigger, inputs, steps, decisions, outputs)
  • Deterministic and probabilistic processes
  • Automation candidates and non-candidates
  • High-value work types (documentation, investigation, reconciliation, triage, reporting, analysis, correspondence)
  • The function-level opportunity scan (finance, human resources, sales, marketing, operations, customer support, project management, business analysis)
  • Value, feasibility and risk assessment
Hands-on exercise mapping a real process from participants' own work to the agent loop
06
Day 1 · Module

Designing the Automation Use Case

  • Selecting the personal automation project
  • Inputs, processing steps and outputs
  • Scoping a three-to-five-step automation
  • The agent design brief (goal, tools, memory, guardrails, success criteria)
  • Acceptance criteria and the definition of done
  • Peer review and refinement
Individual and pair work the agent design brief, peer-reviewed

Day 2: Building No-Code Automations

07
Day 2 · Module

The No-Code Workflow Canvas

  • Workflow automation platforms and the n8n canvas
  • Triggers (schedule, webhook, form, email, application events)
  • Nodes, connections and data flow between nodes
  • Credentials and connected applications
  • Executions, run history and debugging
  • Templates and template-based builds
Live demonstration and guided practice a first workflow from trigger to output
08
Day 2 · Module

AI Nodes, Memory and Document Generation

  • AI nodes and model selection inside a workflow
  • Prompts inside nodes and structured JSON output
  • Simple memory and conversation state
  • Web research and summarisation steps
  • Document generation (meeting follow-ups, reports, correspondence)
  • Spreadsheet and record updates
Lab building a research, summarise and memory workflow
09
Day 2 · Module

Intermediate Automation Patterns

  • Conditional logic and branching workflows
  • Loops, batches and waits
  • Error handling and retry mechanisms
  • Fallback routes and notifications
  • Multi-step automation and sub-workflows
  • Idempotency and duplicate runs
Hands-on exercise adding branching, error handling and retries to the day's workflow
10
Day 2 · Module

Connecting to APIs and External Services

  • Application programming interfaces (APIs) and the HTTP request node
  • Authentication (API keys, OAuth, service accounts)
  • Webhooks in and out
  • Connectors for email, calendars, documents, spreadsheets and chat
  • Rate limits, pagination and payload sizes
  • Testing against a sandbox before a live system
11
Day 2 · Module

Agent Health and Reporting

  • Run logs and execution history
  • Success, failure and retry counts
  • Token use, cost and latency per run
  • The Agent Health Check measures (groundedness, escalation rate, abstention rate, cost, latency, error rate)
  • Thresholds, alerts and owners
  • The management-facing health report
Lab building an agent health and reporting dashboard in n8n

Day 3: Building Agents on a Visual Canvas

12
Day 3 · Module

The Visual Agent Canvas

  • Low-code agent building
  • The Lang family (LangChain, LangGraph, LangFlow, LangSmith)
  • LangFlow components (models, prompts, agents, tools, file loaders, vector stores)
  • Flows, connections and hand-offs
  • Credentials and global variables
  • Running, inspecting and exporting a flow
Lab launching the lab environment and building a first working flow
13
Day 3 · Module

Building a Document-Grounded Agent

  • Retrieval-augmented generation (RAG)
  • Document loading and chunking
  • Embeddings and vector stores
  • Grounded answers and source citation
  • Abstention when the answer is not in the source
  • Testing against a policy document
Lab building a document question-answering agent with abstention
14
Day 3 · Module

Building a Triage and Routing Agent

  • Classification and intent detection
  • Priority and severity scoring
  • Routing rules and destinations
  • Escalation paths
  • Confidence and thresholds
  • Drafting the first response
Lab building an inbox triage and routing agent
15
Day 3 · Module

Multi-Agent Patterns

  • The planner and executor pattern
  • The critic and reviewer pattern
  • Specialist agents and bounded roles
  • Hand-off design and shared state
  • Orchestration and failure containment
  • The case for a second agent and the case against
Lab building a planner and executor hand-off
16
Day 3 · Module

Designing Guardrails Into the Flow

  • Input and output guards
  • Sensitive-topic and out-of-scope handling
  • Allowed and blocked actions
  • Human approval steps
  • Read-only and write permissions
  • Failure behaviour and safe defaults
Hands-on exercise adding input and output guards and a human approval step to participants' own flows

Day 4: Coding Agents and the Function Labs

17
Day 4 · Module

Coding Agents with Claude Code

  • The code or no-code decision framework
  • Coding agents and vibe coding (Claude Code)
  • GitHub Codespaces with zero setup
  • Natural-language build instructions
  • Reading and checking what the agent wrote
  • Iterating towards a working automation
  • Version control basics (commits, branches, rollback)
Live demonstration and guided practice building a first code-based agent by describing it
18
Day 4 · Module

The Function Labs

  • The lab pattern (brief, isolated environment, planted ambiguity, verified end state)
  • The function cases:
    • Finance (invoice and purchase order matching)
    • Human resources (leave request triage against policy)
    • Sales (inbound lead triage and follow-up drafting)
    • Marketing (segmentation and campaign copy)
    • Operations (order and shipment reconciliation)
    • Customer support (ticket triage and priority-one replies)
    • Project management (project health and weekly status reporting)
    • Business analysis (requirements analysis and user stories)
  • The two build tracks (visual canvas, coding agent)
  • Acceptance criteria and verification
Controlled group discussion selecting the lab and defining a good result
19
Day 4 · Module

The Function Lab Build

  • The lab brief and the supplied data
  • Rules, policies and exceptions
  • Structured output (JSON schema, evidence references, exception flags, escalation route)
  • Output files and formats
  • Iteration against the acceptance criteria
Lab building the function agent end to end
20
Day 4 · Module

Edge Cases, Escalation and Verification

  • Planted edge cases and how they surface
  • Missing, conflicting and out-of-policy data
  • Abstention and escalation behaviour
  • Human review points
  • Silent failure in agent output
  • Testing strategies for AI-powered workflows
  • End-state verification and automated checking of results
  • Evidence for a reviewer
Hands-on exercise finding and handling the planted edge cases, then running verification against the acceptance criteria
21
Day 4 · Module

Integration and Security

  • Connecting automations to real-world tools
  • Integration, access and permissions
  • Security considerations and access controls:
    • Credentials and secrets management
    • Least privilege for agent tools
    • Prompt injection and data leakage
    • Fictional data and approved environments
Hands-on exercise connecting the function agent to an approved tool with least-privilege credentials
22
Day 4 · Module

Agent Observability

  • Observability for AI agents
  • Traces, spans and runs
  • LangSmith projects and tracing
  • Trace contents (prompt, retrieval, tool calls, model response, tokens, latency, cost)
  • Reading a trace without reading code
  • Masking, redaction and retention in tracing
Lab instrumenting the function agent and inspecting its traces

Day 5: Evaluation, Governance and the Capstone

23
Day 5 · Module

Metrics, Failure Modes and Optimisation

  • The metrics baseline (latency, token use, cost per run, success rate)
  • Cost drivers, runaway runs and loop detection
  • Agent failure modes (wrong tool, wrong data, fabricated result, silent failure, loops, refusal)
  • Failure-mode probes, test sets and expected results
  • Evaluation-driven improvement and regression checking
  • Optimisation levers (instruction, retrieval settings, model choice, tool set, task decomposition)
  • Measured before-and-after comparison
Lab a failure-mode probe and an optimisation challenge measured trace to trace
24
Day 5 · Module

Guardrails and Controlled Decisions

  • The allow, block and escalate pattern
  • Sensitive-term and out-of-scope controls
  • Supported and unsupported topics
  • Decision paths in the trace
  • Evidence that a blocked request reached neither the model nor the data
  • Budgets, limits and cost controls
Lab configuring guardrails and testing the allow, block and escalate routes
25
Day 5 · Module

Governance and the AI Review Board

  • The AI governance toolkit:
    • Acceptable-use policy for agents
    • Human oversight and approval points
    • Tool and vendor due diligence
    • Logging and audit trails
  • The agent register and change control
  • Data privacy, confidentiality and residency
  • Accountability for agent actions
  • The regulatory and standards direction (ISO/IEC 42001, the EU AI Act, the NIST AI Risk Management Framework, national AI guidelines)
  • The go or no-go memo (conditions, limits, review points)
  • Team rollout and capability building across functions
Case study analysis the AI Review Board, judging a deployed agent's work and issuing a go or no-go memo
26
Day 5 · Module

From Pilot to Operations

  • Pilot scope and success criteria
  • Ownership and the support model
  • Production access and permissions
  • Deployment options (hosted, self-hosted, enterprise platform)
  • Monitoring in production
  • Change control and model updates
Individual and pair work the pilot definition for the function agent
27
Day 5 · Module

Emerging Methods

  • Context engineering
  • Loop engineering and graph engineering
  • Agentic retrieval-augmented generation (RAG)
  • The Model Context Protocol (MCP) and tool ecosystems
  • Computer use and browser agents
Live demonstration an agent using external tools through the Model Context Protocol
28
Day 5 · Module

Capstone: Build Your Own Agent

  • The capstone build on the participant's own use case
  • Track selection (no-code, low-code, full-code)
  • Build, test and verify against the design brief
  • Peer showcase and feedback
  • The agent portfolio and sequencing for the team
  • The ninety-day plan (next steps, priority use case, timeline, owners)
Personal action planning each participant's ninety-day plan to take their automation from the lab to their team
Day 5 · Course closing

Course closing

  • Course debrief and key takeaways
  • Final Q&A
  • Official closing ceremony and award of certificates
  • Group photo
Learning path

Think. Build. Code. Deploy.

A progressive five-day path. Every participant can follow along at their technical level, and everyone leaves with something deployable.

Day 1
Think
Understand & design

Agent foundations, the C.L.E.A.R. framework, process mapping. Identify and design your automation use case.

Days 2 – 3
Build
No-code and visual canvas

No-code automations with triggers, AI nodes and document generation, then document-grounded, routing and multi-agent flows on a visual canvas.

Day 4
Code
Coding agents and the function labs

GitHub Codespaces, Claude Code, integration and security. Build the agent for your own function and instrument it.

Day 5
Deploy
Evaluate, govern & deploy

Metrics, failure modes and guardrails, the AI Review Board, the pilot definition and your capstone build.

Our training methodology

Three frameworks behind every programme.

Whatever programme you choose, it follows three proven instructional frameworks, from design to delivery to evaluation.

Delivery

TEA™ Delivery Framework

  • T Theory, core concepts & frameworks
  • E Examples, live demos & case studies
  • A Application, hands-on exercises & practice

Our signature approach structures every module into three phases for maximum retention and practical application.

Design

ADDIE Instructional Design

  • A Analyse, assess learner needs
  • D Design, structure the learning path
  • D Develop, build materials & activities
  • I Implement, deliver the programme
  • E Evaluate, measure outcomes & refine

The industry-standard model for course design and learning alignment.

Evaluation

Kirkpatrick Model

  • L1 Reaction, participant satisfaction
  • L2 Learning, knowledge & skills gained
  • L3 Behaviour, on-the-job application
  • L4 Results, business impact & ROI

The globally recognised four-level framework for measuring training effectiveness, from initial reaction to long-lasting post-training effects.

Upcoming sessions

Choose your date.

Open-enrolment dates below. Need a private session for your team? Schedule a TNA call, custom proposal within 48 hours, delivery in as little as three weeks.

Date
Format
Duration
Price
Private cohorts run on request.
Live virtual or On-site
1/2 to 5 days
Custom
What every participant gets

You keep everything.

No vendor lock-in, no paywalled materials. Every delegate leaves with the working files, the templates, and the post-programme support to actually use them.

Working automation

A live, deployable automation built on your own workflow during the programme.

GitHub Codespaces lab

Pre-configured development environment with all tools, templates, and code ready to use.

Process mapping templates

Frameworks for identifying and designing automation candidates in any department.

Learning materials

Full soft copy of all materials, automation blueprints, handouts, and reference guides.

STOA certificate

Certificate of Completion plus a guided step-by-step pathway to the Google Agentic AI certificate.

30-day support

Post-programme Q&A availability and implementation guidance for your automation.

Delivery options

Choose how your team learns.

In-Person

Instructor-led on-site

Delivered at your offices or venue. Maximum engagement for teams of 8 – 20 participants. All exercises use your team's actual work scenarios.

Live Online

Virtual instructor-led

Real-time delivery via Zoom, Meet, or Teams. Interactive breakout rooms, same content depth as in-person. Ideal for distributed teams.

Hybrid

Blended approach

Combine in-person and virtual sessions. Flexible scheduling across time zones. Pre-work materials and follow-up resources included.

Training catalogue

104 courses in nine families, overview level, methodology up front.

Download the catalogue
Ready to build

Stop talking about AI. Start building with it.

Join the next open session or book a private programme for your team. Custom proposal within 48 hours. Delivery in as little as three weeks.