
Reclassify the Target
We take a live AI application and stop looking at it as an AI application. We map where the model's output goes and which of those destinations is privileged.




Twenty-five years of offensive security don't stop counting because the target has a model in it. What makes these systems exploitable isn't the model — it's that its output reaches privileged actions without ever being treated as input. Same sinks you've tested your whole career, one source nobody sanitizes. In two hours, on a live agent, I point the methodology you already have at it, and you watch it work.


You didn't fall behind. You were handed a new target class that nobody gave you a method for, so you did the reasonable thing: prompt injection threads, an open-source LLM scanner, a saved list of jailbreaks, the OWASP LLM Top 10.
None of it made the next engagement easier, because all of it is the same thing — The Jailbreak Collection, the belief that AI security is a growing pile of clever prompts you accumulate. The prompt that works this week dies with the next model update, and no client pays for a trick with an expiration date.
What actually breaks these systems is duller. Everyone files the model as a component — something that computes, like a library or a service. It isn't. A model is a stranger typing into your application, and everything it emits is user input that nobody labeled as user input. Call it Model as Input. Output reaches a shell command: command injection. A database call: SQL injection. A rendered page: XSS. A file write, an internal API, an MCP tool call — the same sinks you've been testing your whole career, reached through the one source nobody sanitizes.
That's why two hours is enough. You're not learning a new discipline, you're deleting an exclusion. And you'll know it works before the evening is over, when the agent on screen executes something it was never supposed to execute.




You see every one of them used on a live target during the session, and you use them yourself in the 48 hours after it. Nothing here waits for a course to finish.

One page each. The Sink Map, the Agent Recon Card, the Finding Write-Up Template and the 48-Hour Script — each one shown in use against a real target, not just described.

One page. Every place a model's output lands — shell, database, browser, filesystem, internal API, another agent — and the test you already know for each.

The questions for the first twenty minutes of an AI engagement: what the agent can call, what runs without a human, where the trust boundary was supposed to be.

One finding, one page. Turns “I got it to do something weird” into impact, reproduction and business risk — the version a client pays for.

What to do Monday morning on the AI target sitting in your queue. Order of operations, in one page, so the method leaves the session with you.
Nobody gave you a method for this target class, so the evening is built as one: reclassify the target, reach the sink, break the agent, write the finding. You see all four done, not described.

We take a live AI application and stop looking at it as an AI application. We map where the model's output goes and which of those destinations is privileged.

The model isn't the vulnerability; it's the delivery mechanism. We drive output into the places that act on it, working through the sinks in order of what pays.

An agent with tool access — function calling, an MCP server, an autonomous loop. We find the tool it shouldn't have been allowed to call, and make it call it.

Impact in language a client acts on, reproduction steps that survive a model update, and where this sits in a report. Then the 48-hour script.
A jailbreak is a trick with an expiration date: it works this week and dies with the next model update, and no client pays for it. Model as Input is a rule that doesn't expire — everything the model emits is unsanitized user input reaching sinks you already know how to test. Same methodology, one exclusion deleted.
A saved list of clever prompts that dies with the next model update.
A method that runs again on a system you've never seen.
Each block ends with something finished. Nothing is left as homework.
We take a live AI application and stop looking at it as an AI application. We map where the model's output goes and which of those destinations is privileged — the moment “chatbot” turns back into a system you already know how to test.

The model isn't the vulnerability; it's the delivery mechanism. We drive output into the places that act on it and watch what happens when nobody sanitized it, working through the sinks in order of what pays.

This is where the event earns its name. An agent with tool access — function calling, an MCP server, an autonomous loop — not a chat window. We find the tool it shouldn't have been allowed to call, and make it call it.

The part nobody teaches. Impact in language a client acts on, reproduction steps that survive a model update, and where this sits in a report. Then the 48-hour script: exactly what you do on Monday.

Four working tools. You see every one of them used inside the session, and use them yourself in the 48 hours after it. The Sink Map and the Agent Recon Card come with every seat. The Finding Write-Up Template and the 48-Hour Script come with the VIP seat.

One page. Every place a model's output lands in a real system — shell, database, browser, filesystem, internal API, another agent — and the test you already know for each one. I fill it in live during the first block, and you get the blank one to use on your own target.

The questions you ask in the first twenty minutes of an AI engagement to find where tool access actually lives.

One finding, one page. Impact, reproduction and business risk — the version a client reads and pays for.

What to do Monday morning on the AI target sitting in your queue right now. Order of operations, in one page.
Two hours of real work on a live agent environment, shown step by step, with your questions answered as we go.
Not slides and not a highlight reel. One real test on a live agent, from recon to written finding, with nothing skipped.
Tool access, MCP, autonomous loops. Not a chatbot in a browser tab.
When a test doesn't land, you see why and what I try next. That is the part a polished write-up never shows.
So you know what the version a client pays for looks like before you write your own.
The MCP server your client runs, the scope you were just handed, the target you're already stuck on. Q&A closes the session, and VIP seats stay for 30 more minutes.
No public replay. The recording goes to VIP seats.
Thursday, 9:05 PM

The first AI target I had to test wasn't a client's. It was ours — a customer-facing assistant at the fintech where I run security. Twenty-five years in, and I got it producing code it had no business producing, then sat there with a finding I couldn't write up properly and no idea how to test the next one. Everything I had was a pile of prompts that worked that week.
Then I built the other side: agents with tool access, MCP servers wired into live security platforms. Once I saw what a model's output could actually execute, it stopped being a chatbot problem and became application security again. That's where Model as Input came from, and it's what I teach now — labs, live sessions, and a CTF where people break agents themselves.
I'm still testing real AI systems, which is the only thing that keeps the method honest.
MIT Cyber Security · CISSP · CISM · CRISC · C|CISO · CEH · C|RAGE

The price is low on purpose. Nobody in this room is short the money — you're short a method, and I'd rather the only question you ask yourself be whether the Thursday evening is worth it. It is. You'll have a method by the end of it.
It isn't free because free events fill up with people who register and never show. This one is built for people who are in the room: the questions, the dead ends and the write-up all happen live. Thirty-seven dollars filters for people who actually turn up, and everything about the session is built for people who turn up. The price exists to protect the room, not to pay for it.
Thursday, October 22, 2026 · 8:00 PM – 10:00 PM ET (5:00 PM – 7:00 PM PT) · Live online on Zoom
No. You need to have tested web applications. The whole premise is that the sinks are the ones you already know — shell, SQL, XSS, file writes, internal APIs — reached through a source nobody sanitizes. If you've never tested a web app, this is the wrong room.
No, and that's the point. A jailbreak is a trick with an expiration date. Model as Input is the rule that everything a model emits is unsanitized user input reaching a privileged action. You'll use injection as a delivery mechanism, not as the finding.
The price is low on purpose and it isn't free on purpose. Free events fill with people who register and never show, and this session is built for people who are in the room. Thirty-seven dollars filters for people who turn up. It protects the room, it doesn't pay for it.
The audience is experienced testers who were handed a target class without a method. Nothing in the two hours re-teaches you injection. What changes is the classification of the model, the recon questions for tool access, and the write-up that turns a weird behavior into paid impact.
That's what Block 4 and the 48-Hour Script exist for: impact in language a client acts on, reproduction steps that survive a model update, and exactly what to do Monday morning on the AI target already sitting in your queue.
It is a live demonstration, not a lab. I run the whole test on screen, and you follow every step and ask questions. You leave with the tools to repeat it on your own target.
The recording comes with the VIP seat. General seats are live only.
Thursday evening you'll watch a real AI target get mapped as an ordinary attack surface, model output driven into something that executes, a live agent with tool access broken, and the whole thing written up as a finding a client would pay for.
You leave with the method, the tools, and a worked example to run again on the next system you've never seen.