Hands-On AI Agent Engineering for Developers

Habits for safe, explainable, domain-grounded AI agent engineering

(Available in half-day, full day, or multi-day formats; in-person and remote)

Get in touch

AI agents are moving from novelty to necessity, but building them safely, predictably, and observably requires more than clever prompts.

This workshop gives developers a practical introduction to AI agent engineering, with an emphasis on the habits, patterns, and mental models needed to design trustworthy agents in real systems.

In this workshop you’ll learn how to ground agents in strong domain models (DICE), design goal-driven behaviours (GOAP), enforce safety through invariants and preconditions, and make every action explainable through observability.

You’ll run and inspect a fully working reference agent, extend its domain, add new actions, and validate behaviour through explainable planning logs. You'll explore how to select and deploy models tuned to provide the best and most cost-effective agent behaviour for your users. You’ll harness tools such as Claude Code to build your agents fast and to specification.

Whether you’re designing workflow agents, platform automations, or domain-specific assistants, this workshop gives you the practical skills and engineering discipline to build agents that behave safely and reason predictably — fit for production, and even fit for regulated environments.

Reach out to find out more

Workshop Flow

  • Session 1: Foundations, Mental Models & the Habit Stack

    Explore the core mental models (DICE + GOAP)

    Understand why habits matter

    Habit 1: Ground everything in typed domain models (DICE)

    Habit 2: Design goal-oriented behaviours (GOAP)

    Habit 3: Guard every action with invariants and preconditions

    Habit 4: Trace → inspect → adjust loops

    Exercises include: Getting hands-on with the reference agent

  • Session 2: Safe, Predictable Behaviour Through GOAP, Preconditions & Invariants

    Designing behaviour you can reason about — and trust

    Design new behaviours safely, and validate them through planning traces

    Explore GOAP composability: decomposable goals, reusable actions

    Explore Preconditions as contract boundaries

    Explore Invariants as organisational guardrails

    Explore common pitfalls: emergent chaos, ambiguous states, implicit actions

    Explore Observability 2.0 for agents: every decision is logged, every action is traceable

    Exercises include: Extending an agent with new actions and running through a complete debug loop

  • Session 3: Extending the Domain: Scaling Safely Without Breaking Existing Flows

    Evolution, refactoring, and long-term maintainability

    How to safely evolve a domain model (types, relationships, constraints)

    Adding new domain objects: how to avoid “concept drift”

    Updating the planner configuration

    Using tests, traces and invariants as change-detection tools

  • Session 4: Production Habits: Model Selection, Cost, Deployment & Platform Integration

    Learn operational, economic, safety, and DX considerations for real deployments

    Selecting and tuning LLMs for agent behaviour (latency, cost, stability)

    Model evals & behavioural regression testing

    Observability patterns for agents (decision traces, action logs, invariant violations)

    Integrating agents with workflows & platforms (IDPs, event buses, schedulers)

    Safety hardening: permissions, sandboxing, scoping, rate limits

    Accelerating safe Agent development using Claude Code (and similar tools) to generate code to spec safely

Whether you’re designing workflow agents, platform automations, or domain-specific assistants, this workshop gives you the practical skills and engineering discipline to build agents that behave safely and reason predictably — fit for development, production, and even fit for regulated environments

You’ll leave this workshop with:

  • ✺

    A mental scaffolding for the rest of the course: agents behave, plan, and succeed only as well as the domain they stand on.

  • ✺

    The habits to build predictable agents that are designed, not hoped for. Explainability logs become your debugger

  • ✺

    The habits to manage safe Agent evolution through a grounding in typed domain models

  • ✺

    The habits to build production-ready Agents through discipline, not magic: strong domains, explainable actions, good model selection, and continuous trace-driven improvement