What you'll be able to do
Before you start
Course Syllabus
Every module and every lesson. The first three modules are open; the rest open on a click.
Download the full syllabus (PDF) Download the lab pack
Phase 1: Agents That Find
The foundations of every module in the course, one lesson each: how an agent works, fuzzing, LLM application failures, MCP, authority in response, machine learning, software identity, the supply chain, privacy, testing AI, threat intelligence and disclosure.
Show 13 lessonsHide lessons
- 0.10.1 How an Agent WorksPreview
- 0.20.2 Fuzzing FundamentalsPreview
- 0.30.3 How LLM Applications FailPreview
- 0.40.4 Tool Protocols and MCPPreview
- 0.50.5 Autonomy and Authority in ResponsePreview
- 0.60.6 Machine Learning for DefendersPreview
- 0.70.7 Identity for SoftwarePreview
- 0.80.8 Software Supply Chain BasicsPreview
- 0.90.9 Privacy FoundationsPreview
- 0.100.10 Testing AI SystemsPreview
- 0.110.11 Threat Intelligence FoundationsPreview
- 0.120.12 Vulnerability Research and DisclosurePreview
- 0.13Check My KnowledgePreview
A hunting agent built and measured against planted answers: the agent loop and its cost, the schema and query validation, truncation, pivoting and stacking, read-only authority, accounting for every entity, grounding, and self-vouching evidence.
Show 11 lessonsHide lessons
- 1.11.1 A Hunt an Agent Can Run
- 1.21.2 The Agent Loop: Steps, Stopping and Cost
- 1.31.3 What the Model Needs to Know About the Data
- 1.41.4 Validating Model-Written Queries
- 1.51.5 Results That Say What They Left Out
- 1.61.6 Pivoting and Stacking
- 1.71.7 Read-Only Authority and Enrichment
- 1.81.8 Accounting for Every Entity
- 1.91.9 Invention, and Measuring Across Trials
- 1.101.10 Evidence That Vouches for Itself, and the Report
- 1.11Check My Knowledge
A fuzzer for a DNS parser with eight planted bugs: coverage, feedback and oracles, seeds and a generator configuration from a model, a measured comparison on equal budgets, triage by root cause, fixes with regression tests, and an audit of the model.
Show 11 lessonsHide lessons
- 2.12.1 The Target and Its Known Bugs
- 2.22.2 A Baseline Fuzzer
- 2.32.3 Coverage as Feedback
- 2.42.4 Oracles Beyond Crashes
- 2.52.5 Seeds a Model Proposes
- 2.62.6 A Grammar the Model Configures
- 2.72.7 Measuring Against the Baseline
- 2.82.8 Crash Triage by Root Cause
- 2.92.9 Fixing and Regression-Testing
- 2.102.10 What the Model Got Wrong About the Target
- 2.11Check My Knowledge
Phase 2: Securing What You Build
An alert assistant for a SOC, built and secured: attacker text in every alert, injected instructions, output that acts in a browser, a ticket or a query, case data filtered by access, and every guard measured across trials.
Show 8 lessonsHide lessons
- 3.13.1 The Alert Assistant You Will Secure
- 3.23.2 Where Attacker Text Enters a Security Tool
- 3.33.3 Injection Through the Evidence
- 3.43.4 Output That Reaches a Ticket, a Query or a Browser
- 3.53.5 Case Data Only for the Analyst Who May See It
- 3.63.6 Guards That Hold and Guards That Lower the Rate
- 3.73.7 The Attack Suite, Before and After
- 3.8Check My Knowledge
An MCP server for the hunt tools and EDR isolation, built with the Python SDK and secured: descriptions as instructions, authorization on every call, token audience, the confused deputy, a hostile server in the host, and a gate.
Show 8 lessonsHide lessons
- 4.14.1 Exposing Security Tools Over MCP
- 4.24.2 Your Tool Descriptions Are Instructions
- 4.34.3 Authorization on Every Call
- 4.44.4 Tokens: Audience, Scope and No Passthrough
- 4.54.5 The Confused Deputy
- 4.64.6 A Malicious Server in the Agent’s List
- 4.74.7 The Hardened Server, Tested
- 4.8Check My Knowledge
An incident response agent that contains attacks through an EDR, a directory and a firewall, bounded by a policy, approvals bound to the exact action, a check against injected evidence and an action ledger that can undo.
Show 8 lessonsHide lessons
Phase 3: Models, Identities and Data
A detection classifier of your own, attacked by evasion, by poisoning its retrain and by extraction through its scoring service, with each defense measured against what it costs.
Show 8 lessonsHide lessons
- 6.16.1 A Detection Classifier of Your Own
- 6.26.2 Evasion: Moving a Sample Across the Line
- 6.36.3 Evasion an Attacker Could Actually Do
- 6.46.4 Poisoning the Training Data
- 6.56.5 Extraction Through the Model’s Answers
- 6.66.6 Defenses and What They Cost
- 6.76.7 The Robustness Report
- 6.8Check My Knowledge
The identities AI agents act with: an inventory, a local identity provider, short-lived scoped tokens, token exchange for delegation, secrets kept out of the model, revocation mid-run and identity tests for every agent.
Show 8 lessonsHide lessons
What an assistant’s work brings into a repository: its code measured, imports and dependencies gated, models pinned and loaded only as data, detection rules tested, and one gate on every commit.
Personal data in a security agent, measured and controlled: what reaches the model, redaction and what it misses, keyed pseudonyms, differential privacy on released counts, logs without content, and privacy tests for any agent.
Show 8 lessonsHide lessons
Phase 4: Red Teaming, Intelligence and the Capstone
garak and PyRIT against your own alert assistant and IR agent: what a scan proves, findings reproduced and traced, fixes rerun, and a release decision from thresholds set first.
Show 8 lessonsHide lessons
Model extraction from threat reports made safe to publish: a labeled corpus, a pattern baseline, every value checked against its source, techniques against ATT&CK, roles and confidence, STIX 2.1, and a release gate.
The whole loop on a codebase you have not seen: an assistant’s review and bandit, a test per finding, fixes chosen inside a budget, a disclosure per bug, a generated portfolio and a defended release recommendation.
Show 9 lessonsHide lessons
Phase 0: Course Resources
One sheet per component the course builds: the question, the check that settles it as the lab implements it, how to use it and what it does not prove.
Eight runbooks for building an AI security component and proving it works, each built in the lab and checked by its harness.
Show 8 lessonsHide lessons
- 1A Hunting Agent That Reports Only What It Saw
- 2An Assistant That Reads Attacker-Written Text
- 3An Agent That Contains Behind Approvals
- 4An MCP Server That Checks Every Call
- 5An Agent Identity That Expires
- 6A Gate for AI-Written Code and Models
- 7A Scanner Run to a Release Decision
- 8Model-Extracted Intelligence to a Validated Bundle
Installing the SEC410 lab, the packages some lessons add, an optional local model, and checking the lab works before the first exercise.
Show 4 lessonsHide lessons
Three cases worked end to end across the modules, including the wrong turns, each ending in a scorecard, a record and the point that transfers.
Eight playbooks, one per thing that lands on a team running AI security components: what to check first, how to contain it, and what the record must say.
Show 8 lessonsHide lessons
- 1An Agent Reported Something Not in the Data
- 2An Agent Took an Action Nobody Asked For
- 3An Agent Credential Is Exposed
- 4An MCP Server Changed or Appeared
- 5A Dependency or Model Is Suspect
- 6Personal Data Found in an Agent Log
- 7A Vulnerability Reported in a Component
- 8An Extracted Indicator Blocked Something Legitimate
The lab in free mode: every command that runs a course component on its own, outside a check, by module.
Show 1 lessonHide lessons
The standards, protocols and tools the course uses, with the version the lab pins and where each is defined.
Show 2 lessonsHide lessons
Course Completion
AI Security Engineering end-of-course exam: 40 questions in four parts, from the hunting agent to the capstone, ending on a case study.
Show 1 lessonHide lessons
Course overview
Security teams now run AI inside their own work: agents that triage, hunt and respond, pipelines that read threat reports, tools that write detection logic. An assistant will draft any of them in minutes. What it will not tell you is whether the hunting agent missed the planted activity, invented an indicator, or ran a containment action it had no authority to run. This course teaches that judgment, as engineering: build the component, run it against evidence with a known answer, find where it fails, harden it, and rerun.
Module 0 lays the foundations of every module's subject, from how an agent works to vulnerability disclosure. Modules 1 and 2 build a hunting agent and a model-guided fuzzer. Modules 3 to 5 secure an LLM application, build and harden MCP servers, and build an incident response agent that acts only behind approvals. Modules 6 to 9 cover adversarial ML against your own model, agent identity, AI-written code and the AI supply chain, and privacy. Module 10 red-teams what you built with garak and PyRIT, Module 11 builds a threat intelligence pipeline, and Module 12 is the capstone.
How this course works
Build it, then the lab says whether it works. Every module has you build a component and test it against evidence where the answer is known. The check reports what it found, missed and invented, what it did without authority, and what it cost, and it fails until your work holds.
Controls that hold whatever the model decides. A model's decisions are tendencies. Each module shows a failure in a trace, shows the obvious fix failing where it does, and builds the control in code that holds regardless, so you know which of your fixes are guarantees and which only change the odds.
Your own repository. Every module adds to one repository you build across the course: agents, tools, guards and their tests. At the end it is working, tested evidence of what you can build.
What you will learn
What you leave with
One repository, built across the course and checked module by module. Its README is written from the checks as they ran.
Before and after, as the lab measures them. Each module starts from shipped code that fails its check, and ends when your version passes it.
Who this course is for
SOC analysts, detection engineers, incident responders and security engineers who will build and run AI in their security work. The course assumes you write Python, read JSON and HTTP, use git, and have worked an alert, a hunt or an incident; it explains every AI concept it uses where it is first used.
What this course does not cover: exploit development, from fuzzing crashes or any other finding; attacks on models or systems you do not own or are not authorized to test; collecting from criminal markets or handling real leaked credentials; training large models or fine-tuning technique; and jailbreaks for harmful content.
Things you need to know
What are the prerequisites?
Working Python, and hands-on experience with security operations: alerts, hunts or incidents. The course does not re-teach either.
What do I need?
Python 3.10 or later on your own machine. The lab pack needs no other installation and calls no model provider. Modules that teach a named tool install it in their own lesson, and a local open-weight model through Ollama is optional, for running the same checks against a real model.
What will I be able to do after this course?
You'll be able to build the AI components a security team runs and show, with tests against known answers, that each one works: what it finds and misses, that it invents nothing, that it acts only within its authority, and that it holds against the attacks aimed at it.
Usage rights and disclaimer
Course materials: Licensed for individual professional development. The lab pack's code and what you build from it are yours to adapt in your own work. You may not redistribute course content or share account credentials.
Test only what you may test: The course attacks only its own lab and the components you build. Test a real system only with written authorization from its owner.
Fictional examples: The estate, hosts, accounts and people in the course's evidence are fictional. Any resemblance to real organizations or people is coincidental.
End of Course Exam
Complete the course, then answer forty questions, from the hunting agent to the capstone, ending on a case study, in 90 minutes. Pass mark: 70. Earn your certificate with CPE credits.
Answers are checked on the server. Certificate issued on pass.