AI Security Engineering

Build the AI Your Security Work Runs On, and Prove It Works.

Build a hunting agent, an incident response agent, MCP servers, a model-guided fuzzer and a threat intelligence pipeline. Test each one against evidence where the answer is known, find where it misses, invents or acts without authority, and harden it until the check passes. Then attack what you built, with adversarial ML and automated red teaming, and secure its identity, its supply chain and the data it reads.

Every component runs in a Python lab on your own machine, with no model provider required.

What you'll be able to do

✓Build hunting and incident response agents that report only what the evidence shows, stay within their authority and always finish within budget
✓Build and secure MCP servers that expose security tools, with authorization on every call and token validation
✓Use a model to guide fuzzing, triage crashes by root cause, and measure whether the model helped
✓Attack a model you trained with evasion, poisoning and extraction, and measure what each defense costs
✓Give agents scoped, short-lived identities, gate AI-written code and model dependencies, and keep personal data out of what a model reads
✓Red-team your own AI with garak and PyRIT, and build a threat intelligence pipeline that catches indicators a model invented
SEC410 | Included with Specialist, from $29/month | 12 modules and an orientation | 38–42 hours at your own pace | 40 CPE credits

Before you start

Prerequisites
Python, and experience working alerts, hunts or incidents
Hands-on setup
Python on your own machine, for the lab pack. The Lab Setup module walks you through it.
Optional
A local open-weight model through Ollama, for repeated trials on a real model
Learning paths

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

Module 2AI-Guided Fuzzing and Crash Triage

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
  1. 2.12.1 The Target and Its Known Bugs
  2. 2.22.2 A Baseline Fuzzer
  3. 2.32.3 Coverage as Feedback
  4. 2.42.4 Oracles Beyond Crashes
  5. 2.52.5 Seeds a Model Proposes
  6. 2.62.6 A Grammar the Model Configures
  7. 2.72.7 Measuring Against the Baseline
  8. 2.82.8 Crash Triage by Root Cause
  9. 2.92.9 Fixing and Regression-Testing
  10. 2.102.10 What the Model Got Wrong About the Target
  11. 2.11Check My Knowledge

Phase 2: Securing What You Build

Module 4Building and Securing MCP Servers

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
  1. 4.14.1 Exposing Security Tools Over MCP
  2. 4.24.2 Your Tool Descriptions Are Instructions
  3. 4.34.3 Authorization on Every Call
  4. 4.44.4 Tokens: Audience, Scope and No Passthrough
  5. 4.54.5 The Confused Deputy
  6. 4.64.6 A Malicious Server in the Agent’s List
  7. 4.74.7 The Hardened Server, Tested
  8. 4.8Check My Knowledge
Module 5Building an IR Agent

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
  1. 5.15.1 What an IR Agent May Do
  2. 5.25.2 Triage Tools and the Evidence Bundle
  3. 5.35.3 Containment Tools
  4. 5.45.4 Approving a Containment Action
  5. 5.55.5 Acting on Injected Evidence
  6. 5.65.6 Rollback and the Action Ledger
  7. 5.75.7 The IR Agent Against a Full Incident
  8. 5.8Check My Knowledge

Phase 3: Models, Identities and Data

Module 7Non-Human Identity and Agent Authentication

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
  1. 7.17.1 The Identities Your Agents Already Have
  2. 7.27.2 A Local Identity Provider
  3. 7.37.3 Short-Lived, Scoped Credentials
  4. 7.47.4 Acting for a User: Token Exchange
  5. 7.57.5 Secrets the Model Must Never Read
  6. 7.67.6 Revocation in the Middle of a Run
  7. 7.77.7 The Identity Tests
  8. 7.8Check My Knowledge
Module 8AI-Written Code and the AI Supply Chain

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.

Show 8 lessonsHide lessons
  1. 8.18.1 Measuring Your Own Assistant's Code
  2. 8.28.2 Packages That Do Not Exist
  3. 8.38.3 A Dependency Gate
  4. 8.48.4 Models as Dependencies
  5. 8.58.5 Model Formats That Run Code
  6. 8.68.6 Reviewing AI-Written Detection Logic
  7. 8.78.7 The Gate in the Pipeline
  8. 8.8Check My Knowledge
Module 9Privacy-Preserving AI

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
  1. 9.19.1 What Personal Data Reaches the Model
  2. 9.29.2 Redaction Before the Model
  3. 9.39.3 What Redaction Misses
  4. 9.49.4 Pseudonymization That Still Lets You Hunt
  5. 9.59.5 Differential Privacy on Aggregates
  6. 9.69.6 Logging Without Keeping the Prompt
  7. 9.79.7 The Privacy Tests
  8. 9.8Check My Knowledge

Phase 4: Red Teaming, Intelligence and the Capstone

Module 10Automated AI Red Teaming

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
  1. 10.110.1 What an Automated Scan Can Prove
  2. 10.210.2 garak Against Your Alert Assistant
  3. 10.310.3 PyRIT: Targets, Converters and Scorers
  4. 10.410.4 Multi-Turn Attacks
  5. 10.510.5 Triaging Scanner Findings
  6. 10.610.6 Fixing and Rerunning
  7. 10.710.7 Red Teaming as a Release Gate
  8. 10.8Check My Knowledge
Module 11Building an AI Threat Intelligence Pipeline

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.

Show 8 lessonsHide lessons
  1. 11.111.1 The Corpus and Its Ground Truth
  2. 11.211.2 Extracting Indicators
  3. 11.311.3 Indicators That Are Not in the Source
  4. 11.411.4 Mapping to ATT&CK
  5. 11.511.5 Enrichment and Confidence
  6. 11.611.6 Output as STIX 2.1
  7. 11.711.7 The Pipeline Scorecard
  8. 11.8Check My Knowledge
Module 12Capstone: Find, Fix, Disclose

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
  1. 12.112.1 The Codebase and the Brief
  2. 12.212.2 AI-Assisted Code Review
  3. 12.312.3 Confirming a Finding
  4. 12.412.4 Choosing What to Fix
  5. 12.512.5 Fixing With Tests
  6. 12.612.6 Writing the Disclosure
  7. 12.712.7 The Repository as Portfolio
  8. 12.812.8 The Release Recommendation, Graded
  9. 12.9Check My Knowledge

Phase 0: Course Resources

ResourcesAI Security Engineering Cheatsheets

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.

Show 13 lessonsHide lessons
  1. 1The Hunting Agent
  2. 2AI-Assisted Fuzzing
  3. 3The Alert Assistant
  4. 4MCP Servers
  5. 5The IR Agent
  6. 6Adversarial ML
  7. 7Non-Human Identity
  8. 8The AI Supply Chain
  9. 9Privacy
  10. 10Automated Red Teaming
  11. 11Threat Intelligence
  12. 12The Capstone
  13. 13Lookup Values
ResourcesLab Setup

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
  1. 1Installing the Lab
  2. 2Module Packages
  3. 3An Optional Local Model
  4. 4Verify the Lab
ResourcesWalkthroughs

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.

Show 3 lessonsHide lessons
  1. 1The Hunting Agent Before It Runs Unattended
  2. 2An Approved Isolation of the Wrong Host
  3. 3An Assistant-Drafted Repository Before It Merges
ResourcesPlayground

The lab in free mode: every command that runs a course component on its own, outside a check, by module.

Show 1 lessonHide lessons
  1. 1The Lab in Free Mode
ResourcesReferences

The standards, protocols and tools the course uses, with the version the lab pins and where each is defined.

Show 2 lessonsHide lessons
  1. 1Standards and Protocols
  2. 2Tools and Versions

Course Completion

CompletionCourse Exam

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
  1. 1Course Completion. AI Security Engineering

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

✓ Build hunting and incident response agents that report only what the evidence shows, stay within their authority and always finish within budget
✓ Build and secure MCP servers that expose security tools, with authorization on every call and token validation
✓ Use a model to guide fuzzing, triage crashes by root cause, and measure whether the model helped
✓ Attack a model you trained with evasion, poisoning and extraction, and measure what each defense costs
✓ Give agents scoped, short-lived identities, gate AI-written code and model dependencies, and keep personal data out of what a model reads
✓ Red-team your own AI with garak and PyRIT, and build a threat intelligence pipeline that catches indicators a model invented

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.

✓ A hunting agent and an IR agent that report only what the evidence shows and act only within their authority
✓ An MCP server and host that check every token and call, and contain a server you did not write
✓ A model-guided fuzzer measured against a baseline, and a triage of its crashes by root cause
✓ An adversarial assessment of a classifier of your own, with each defense priced
✓ Agent identities that expire and stop when revoked, a supply-chain gate, and a privacy layer before and after the model
✓ A red-team release gate, a threat intelligence pipeline that publishes nothing its sources do not say, and a capstone disclosure set

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.

Module 1, the hunting agent. Before: as shipped it found 1 of the 6 planted entities and invented 1. After: yours finds all 6, invents none and takes no action.
Module 4, the MCP server. Before: with descriptions only, 2 of 15 cases hold: no token reads evidence, a forged token isolates a server. After: yours holds all 15: tokens, scopes, the deputy check and a hostile server in the host.
Module 5, the IR agent. Before: with approvals alone, 7 cases fail, among them an approved isolation of a host the attacker named. After: yours holds all 35 cases, refusing that target before anyone is asked.
Module 8, model files. Before: the shipped loader ran the payload in two of four sample files. After: yours loads the two data files, refuses seven and runs nothing.

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.

COURSE ASSESSMENT

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.

40questions
90minutes
100points
Take End of Course Exam

Answers are checked on the server. Certificate issued on pass.