AI-AGENT · Path 4: Build and operate
Agentic Systems Engineering
An agent allowed to act before passing its gates is not automation, it is an operational risk with API access.
- Duration
- 4 days
- Group
- up to 12 people
- Format
- In-house · Open enrollment · In the lab
- Language
- German or English
- Price
- €31,600 flat, plus VAT
Who this track is for
Experienced developers and architects tasked with connecting agents to real business processes and systems. Right for teams that want to move from chat assistants to systems that actually execute tasks with tools.
Who it is not for
Not an entry point into AI engineering, AI-RAG and AI-EVAL are the preceding stages. Leaders who want to govern agents rather than build them belong in AI-LEAD.
Starting situation
The first agent demos in the company look impressive, until an agent fires 400 API calls in a loop or executes a booking nobody approved. Between demo and responsibility, what is missing are a state model, gates, abort logic and proof that the agent fails in a controlled way under fault conditions.
This exists after the track
- A running agentic workflow on the lab environment: planning, tool calls, result verification, built by your own team
- An explicit state model with defined transitions instead of implicit loops, including persistable state for resumption
- Implemented human-in-the-loop gates: which actions the agent may propose and which execute only after approval
- Abort and escalation logic with budget limits for steps, cost and time, and defined escalation recipients
- An evaluation and sign-off protocol documenting under which conditions the agent may take responsibility and under which it may not
Prerequisites
Confident programming practice in Python and API experience. Prior knowledge from AI-RAG or AI-EVAL helps, especially a basic understanding of evaluation.
Preparation before the track
In advance you describe one real process from your organization as an agent candidate: steps, systems involved, decision points, damage potential of failures, in the provided profile format. A 30-minute setup check ensures lab access.
What's included
- 4 training days with Dino Bordonaro, on site or in our lab
- A personal lab environment with a training process, mock systems and locally hosted models, plus 14 days of continued access
- A code repository with reference architecture, state model templates and sample solutions per day stage
- A gate catalog and sign-off protocol template for transfer to your own processes
- Certificates of attendance and training documentation for your compliance archive
- A 90-minute remote office hour 4 weeks after the training to review your own agent design
Agenda
Day 1
Autopsy of an agent failure
Live in the lab: a naive agent gets stuck in a tool loop and visibly burns budget. Root cause analysis and derivation of the architecture principles: explicit state, bounded autonomy, verifiable steps.
Anatomy of a dependable agent
Architecture walkthrough: planner, tool layer, memory, verification layer. Scoping question for every process profile brought along: does this need an agent, or is a workflow with one LLM step enough?
Designing tools a model can operate safely
Hands-on: tool definitions with tight schemas, idempotency, error returns, least-privilege access. Everyone builds the first two tools of the training process and tests them in isolation.
The first end-to-end run
Your agent executes the training process end to end against the mock systems for the first time, still without gates. Observation task: where does it make assumptions nobody has verified?
Day result: running agent with a findings list
Each person demonstrates the running walkthrough and presents a findings list: at least three observed unverified assumptions or risk points. This list is worked off systematically on Days 2 and 3.
Day 2
Making state explicit
From prompt memory to a state model: states, transitions, allowed actions per state. Everyone models their training process as a graph before writing more code.
Implementing the state model
Hands-on: orchestration with persisted state, resumption after a crash, deterministic transitions. Test: abort the process midway and resume it correctly.
Context and memory strategy
What the agent must know per step and what it must not: working context, long-term knowledge via RAG integration, context budget. Measurement exercise: context discipline versus full context in a cost and quality comparison.
Failure paths first
Exercise on the mock systems with injected faults: timeouts, contradictory data, half-finished transactions. The agent must transfer every failure path into a defined state instead of improvising.
Day result: controlled handling of faults
Sign-off per person: the agent runs through a fault scenario and demonstrably lands in defined states, documented in the state log. Improvised continuation counts as failed.
Day 3
Responsibility only after gates
The core principle of this track in detail: action classes from read-only to irreversible, one gate type per class. Workshop on your own process profile: which action gets which gate, and who approves?
Implementing human-in-the-loop
Hands-on: an approval step with a preview of the planned action, the agent's reasoning and an explicit approve or reject. The agent demonstrably waits instead of proceeding when no answer comes.
Abort and escalation logic
Implementing budget limits for steps, cost and runtime, detection of loops and goal drift, escalation to defined recipients with state handover. Test: the looping agent from Day 1 against the new limits.
Security at the tool boundary
Exercise: prompt injection via tool returns and document content designed to lure the agent into unplanned actions. Hardening through input sanitization, action validation and mandatory gates for sensitive classes.
Day result: gates under fire
Sign-off per person: three prepared fault and disturbance scenarios run against your own agent. You pass if every critical action demonstrably stops at the gate and escalation triggers correctly.
Day 4
Evaluating agents: trajectories instead of answers
Evaluation design for multi-step systems: success criteria per process goal, scoring of action paths, cost per successful run. Building the evaluation set for your own training agent.
The evaluation run
Hands-on: an automated run with success rate, gate triggers, abort reasons and cost per run. Analysis: which failure class dominates, and which architecture change addresses it?
The sign-off protocol
Workshop: each team writes the sign-off protocol for its agent: gates passed, evaluation results, residual risks, conditions for granting responsibility and for withdrawing it. Honesty is the grading criterion.
Transfer to your own process
Back to the profile you brought: architecture sketch, gate mapping and effort estimate for the real case in your organization. Peer review of the sketches in pairs with documented objections.
Day result: sign-off in the stress test
Finale per person: a live run of the agent in front of the group including a fault scenario not known in advance, then handover of sign-off protocol and transfer sketch. The group's checklist decides the sign-off.
Exercises and lab share
Around two thirds of the time is implementation on your own lab environment: building tools, implementing the state model, wiring gates and escalation, passing attack and fault scenarios. The finale is a live stress test in front of the group.
Platforms
You build with open-source orchestration and locally hosted models on our lab environment against mock systems, no customer data is used. The patterns transfer to Azure and on-premises target environments, platform services in the respective available version. Our Sovereign Agents serve as a reference for production implementations.
Transfer evidence
The transfer proof is the passed stress test on Day 4 together with the sign-off protocol: gates hold under fault conditions, escalation triggers, residual risks are honestly documented. Attendance and results are documented in an audit-proof way.
Artifacts you take home
- Your own agentic workflow with state model, gates and escalation logic, exportable from the lab environment
- A code repository with reference architecture and sample solutions per day stage
- A gate catalog with action classes as a template for your own processes
- A trajectory evaluation set with a measured success and cost baseline
- A sign-off protocol and transfer sketch for the real process in your own organization
Optional extensions
- Sovereign AI Platform Engineering (AI-PLATFORM) for the platform agents run on in a sovereign setup
- Secure GenAI and Agent Threat Modeling (AI-SEC) for the systematic threat analysis before going live
- Sovereign Agents as the project path if we are to build your first production agent together with you
Boundaries
This track builds a training agent and enables your team to design its own. It connects no production systems and replaces neither threat modeling (AI-SEC) nor an implementation project, for those we talk about Sovereign Agents.
Frequently asked questions
Four days and €31,600 is a statement. Why not a two-day framework class?
Because the framework is the smallest part. State model, gates, escalation and trajectory evaluation are what lies between demo and responsibility, and they need implementation and stress-test time.
Which agent framework do you teach?
The architecture patterns come first and are implemented with lean open-source orchestration, so every decision stays visible. What you build transfers to common frameworks, and the sign-off logic is framework-independent.
May our agents act in production after the training?
Your gates decide that, not the certificate. This track takes a clear line: an agent earns responsibility only after passed gates and a documented sign-off, starting with proposing actions. The sign-off protocol gives you exactly that framework.