Is Traditional DAST Dead? AI Pentesting Is Changing the Security Testing Model

I recently listened to a discussion between James Berthoty and Chris Romeo about AI pentesting and whether traditional DAST is basically dead.

The title sounds provocative, but the interesting part for me wasn't really whether DAST is "dead."

It was the distinction between traditional automated testing and testing that can actually understand application context.

That's where things are changing.

Traditional DAST has always had a context problem

Traditional DAST is pretty straightforward.

You give it an application, it crawls the endpoints, sends different payloads and looks at the response.

SQL injection.

XSS.

Bad headers.

Known patterns.

This is useful, but the scanner doesn't really understand what the application is supposed to do.

Imagine an application with three roles:

Normal user

Vendor

Administrator

A traditional scanner can test the endpoints exposed to those users, but understanding that:

"A normal user should never be able to perform this vendor action"

is a different problem.

You need some understanding of the application's state, permissions and business logic.

This is where AI pentesting starts becoming interesting.

James's definition of AI pentesting was actually simple: the important part is whether the tool can generate tests and payloads that are contextual to the application, instead of running the same generic checks against every target.

For me, that's the biggest difference.

It's not that the AI suddenly invented completely new security testing techniques.

It can still use tools we already know: browsers, ZAP, Nuclei, CLI tools, static analysis, etc.

The difference is the reasoning layer sitting on top of them.

Instead of:

Run payload A against endpoint B

you start getting something closer to:

I am logged in as User A. This endpoint appears to belong to User B. Let me see if changing this object ID gives me access.

That's much closer to how a pentester thinks.

And that's also why vulnerabilities such as BOLA, IDOR, broken authorization and business-logic issues are particularly interesting use cases for this type of testing.

The real shift is from pattern matching to reasoning

I think security vendors sometimes make this sound more magical than it actually is.

An AI pentesting agent isn't some autonomous hacker that suddenly knows everything.

A lot of the underlying tools are still the same.

What changes is how they are orchestrated.

The agent can browse the application, collect information, form a hypothesis, execute a test, look at the result and decide what to try next.

That feedback loop matters.

Traditional scanners are largely deterministic.

That's actually useful because if I run the same scan twice, I generally want similar results.

AI introduces a trade-off.

The more freedom you give the agent, the more interesting things it might discover.

But you also introduce:

less predictable results

more false positives

harder reproducibility

more compute/token usage

more potential for the agent to do something you didn't expect

The podcast described this as a sliding scale between deterministic testing and more autonomous agent-driven testing.

And I don't think every company should automatically move all the way toward autonomy.

Especially not in production. A CI pipeline running the same deterministic scan on every PR is doing its job precisely because it's boring and repeatable, that's not a weakness to engineer away, it's the point of that stage. Where I'd actually want the reasoning layer is earlier and looser: exploratory testing against a staging environment, or augmenting a human pentester's coverage, not sitting in a blocking gate where non-determinism is the last thing you want.

So, is DAST dead?

No. But its job is narrowing.

Deterministic scanning still earns its place anywhere you need cheap, repeatable, "did we regress" coverage, which is most of CI. What's actually changing is that context-aware reasoning, the part that used to require a human pentester sitting down and thinking about roles, state, and business logic, is no longer exclusively human. That's the real shift, not "DAST bad, AI good."

What's next

That's also exactly what I want to test next, but on a different kind of target.

Everything above is about web application logic, roles, endpoints, business rules. In the next post in this series, I'm going to switch domains and test how far the same "reasoning over pattern-matching" idea holds when the target isn't a web app at all.

I'll be running an AI pentesting agent against ExploitGym — a benchmark built from real-world memory-corruption vulnerabilities in userspace programs, the V8 engine, and the Linux kernel. Each task hands the agent a known vulnerability plus a proof-of-concept crash, and the job isn't to find the bug, it's to turn that PoV into a working exploit.

It's a genuinely different kind of "context" than a BOLA check. Worth seeing whether the same reasoning loop actually holds up once the target stops being an API endpoint.