Langue: English
AI agents are arriving in defensive security faster than most teams planned for - and most practitioners are meeting them as a vendor product with a "buy" button, not as something they can build, open up, and bend to their own environment. Those are completely different skills. The teams who understand the architecture underneath - what the field now calls harness engineering - are the ones who can adapt agentic systems to their own tooling and threats instead of being locked into whatever capabilities a vendor decides to ship.
This hands-on workshop teaches you to build your own AI security agent from the ground up. Using threat hunting as the running example, you'll assemble a working, model-agnostic agent framework piece by piece: the immutable state core that makes a run traceable and auditable; an agnostic provider seam; the data–agent interface that shapes what the model actually sees; deliberate context-window management; the three ways to give an agent tools - inline functions, CLI wrappers, and MCP; and executable investigation skills, culminating in a detection skill you run against real telemetry from the scenario.
This is not a session about prompting a chatbot to read logs. It's about the engineering decisions behind systems that agents can do real defensive work inside - and you leave with the framework, yours to extend to detection engineering, incident response, vulnerability triage, or any security problem you face. Harness engineering is the kind of capability that compounds; the earlier you invest, the more leverage you carry as the field keeps moving.
Format: 4-hour hands-on workshop. After framing and setup, most sections pair a short theory segment with a practical, code-along lab that adds one component to a framework students build incrementally across the day. Six labs in total. Components are pre-built for students to configure, run, and compose - the focus is architecture and informed decisions, not writing software from scratch.
1 - Introduction, Harness Engineering & The Scenario · ~30 min (theory + setup)
- Introduction to the course - what you'll build over the next four hours and how the pieces fit together.
- Intro to harness engineering - why the leverage in agentic systems lives in the harness, not the prompt or the model, and how that thesis carries across security domains.
- A 9-part map of agentic security engineering - the components that make up a real security agent, and the throughline we follow for the rest of the day.
- The story - the backdrop compromise the agent will investigate, so every lab is chasing a concrete adversary rather than toy data.
- Setup - get everyone's environment, dependencies, and a working model provider running before the first build.
2 - Your First Agent · Lab 01 · ~30 min (theory + lab)
Agents as "model + harness." The immutable, accumulating state pattern (traceable, auditable) and pure-function transitions. Lab 01 - First Agent: build and run a minimal agent framework with typed state and transitions that move information forward through investigation stages.
3 - The Data–Agent Interface · Lab 02 · ~30 min (theory + lab)
The single biggest lever on agent quality: what data you put in front of the model, and how. Designing the interface between raw, high-volume security telemetry and the agent - and distillation, reducing noise into the signal an agent can actually reason over. Lab 02 - Distillation: build a distillation step and watch how shaping the input changes what the agent can find.
4 - The Context Window · Lab 03 · ~25 min (theory + lab)
How the context window really behaves, why it's the scarcest resource in an agentic system, and the failure modes when you mismanage it. Lab 03 - Context Window: instrument and manage context across a multi-step investigation.
- Break · ~10 min -
5 - Tools · Lab 04 · ~30 min (theory + lab)
Giving an agent the ability to act. The first two ways to wire tools - inline functions and CLI wrappers - and when each is the right call. Lab 04 - Tools: equip the agent with tools and run an interactive triage step against the scenario.
6 - MCP · Lab 05 · ~30 min (theory + lab)
The Model Context Protocol: the emerging standard for exposing tools and data to an agent, and how it differs from inline and CLI integration. Lab 05 - MCP: integrate an MCP server into the framework and call it from the agent.
7 - Skills & Detection Skills · Lab 06 · ~40 min (theory + lab)
What a "skill" is, how skills differ from one-shot prompts, and why narrow, testable skills make systems composable and trustworthy - then detection skills specifically, formalizing an investigation procedure as a reusable, testable unit. Lab 06 - Skills Detection: author and invoke a detection skill against the scenario telemetry. This is where the framework built across the day comes together into a working agent that produces a real finding.
8 - Conclusion & Where to Go From Here · ~15 min (theory + Q&A)
A recap of the components you assembled, how to adapt the framework to other domains (detection engineering, incident response, vulnerability triage), how to evaluate and improve an agent over time, and when to graduate from a DIY framework to a production-grade orchestration library.
WHO SHOULD TAKE THIS WORKSHOP
- Security practitioners curious about building their own AI agents rather than relying on black-box vendor tools
- Threat hunters and detection engineers who want to understand the architecture behind agentic hunting
- SOC analysts looking to move beyond alert triage toward proactive or semi-autonomous tooling
- Security engineers responsible for evaluating or integrating AI capabilities into internal tooling
- Blue-team leads and security architects exploring how agentic AI fits their defensive strategy
- Anyone who has hit the limits of off-the-shelf AI security tools and wants to build their own - one they can adapt, extend, and trust
- Security generalists wanting a hands-on introduction to agentic AI principles that carry across domains
AUDIENCE SKILL LEVEL
Beginner to Intermediate.
The workshop assumes working familiarity with security operations concepts (what telemetry is, what a detection rule does, what incident response looks like) and basic comfort on a command line.
Some exposure to code is helpful - but no programming experience is required. The workshop provides pre-built components that students configure, run, and compose rather than write from scratch; the focus is on understanding the architecture and making informed decisions, not on software development.
If you're newer to security and willing to put in the effort, you can still keep up. The workshop is structured progressively - each module builds on the last, and concepts are taught before they're applied.
Faan Rossouw (Val-David, QC) is a security researcher focused on the intersection of security engineering, threat hunting, and agentic AI. Faan is currently working on aionsec.ai, a complete educational ecosystem that helps defenders master AI agents – from using them effectively, to building their own, to securing them. In his free time, Faan likes to hang out with his family, practice Brazilian Jiujitsu, and go for forest runs with his dog.