The phrase "AI-generated DDoS attack" is used far more often than it is evidenced.
That does not make it empty. It means the useful question is narrower than the headlines: which parts of a denial-of-service attack does a model make cheaper, and which of your defences were quietly relying on those parts being expensive?
Most DDoS controls encode a guess about the attacker. That the tool repeats itself. That the flood is loud. That nobody outside knows what normal looks like. That a human on your side can write a rule faster than a human on theirs can change the traffic. Each guess was reasonable when variety cost the attacker time. Automation, and now language models, take that cost away.
What the phrase means
An AI-generated DDoS attack is a denial-of-service attack in which a machine-learning model or large language model does part of the attacker's work: mapping the target, writing or varying the requests, or choosing when to change approach. The packets still come from botnets, proxy networks and rented servers. The model changes the decisions behind the traffic, not the bandwidth under it.
That split runs through everything below. Where an attack is limited by bandwidth or packet rate, AI adds nothing. Where it is limited by the attacker's time and attention, it adds a great deal.
What the public record shows
The providers who can see misuse
The organisations best placed to watch attackers use models are the model providers themselves, and their published findings are consistent.
In February 2024, Microsoft and OpenAI reported that five state-affiliated groups had used OpenAI's models for research on targets, help with scripting and translation, and closed the accounts. In January 2025, Google's Threat Intelligence Group published its review of threat actors using Gemini and described the same pattern: reconnaissance, code troubleshooting and content, a gain in productivity rather than a new capability.
None of those reports describes a model designing a flood. They describe a model doing the tedious parts faster.
The national assessment
The UK's National Cyber Security Centre reached a similar view in January 2024, in its assessment of AI's near-term impact on the cyber threat. It judged that AI would almost certainly increase the volume and heighten the impact of attacks over the following two years, mostly by improving existing techniques, with the clearest uplift in reconnaissance.
Volume and reconnaissance are exactly the two things a DDoS campaign spends its effort on. That is the honest basis for taking the subject seriously: not a new weapon, but an old one that is cheaper to aim and cheaper to vary.
The automated traffic that already arrives
The AI era's clearest effect on availability so far did not come from attackers. In April 2025, the Wikimedia Foundation reported that bandwidth used to download multimedia from its projects had grown 50% since January 2024, driven mainly by scrapers collecting training data, and that bots generated about 65% of its most expensive traffic while accounting for roughly 35% of pageviews.
The reason it was expensive matters here. Readers cluster on popular pages that sit in cache; bulk crawlers read the long tail, which does not. That is the same property a cache-busting attack exploits on purpose, arriving with no malicious intent and from many addresses at once.
Any site that has had to separate heavy AI crawlers from customers has already met the core problem of AI-era DDoS: automated traffic that is not obviously automated, and not obviously hostile, at a volume that still hurts.
What a model cannot add
A language model does not make a reflector answer with more bytes, does not lift the uplink on a compromised camera, and does not let anyone spoof source addresses on a network that applies BCP 38. The size of a volumetric flood is still set by how much capacity the attacker controls or rents.
So the defences against the loud end of the spectrum are measured the way they always were: upstream scrubbing capacity, the diversion path, and whether the provider in front of you absorbs a volumetric attack of the size you plan for. None of that needs re-thinking because a model is involved.
What changes is everything on either side of delivery. Before it, finding the endpoint worth hitting, the origin worth bypassing to, and the request shape that blends in. After it, reading how the defences reacted and producing the next variant.
The assumptions each defence makes
Every control below is a bet on what the attacker finds expensive. The table is the short version.
| Control | What it assumes | What makes the assumption cheaper to break |
|---|---|---|
| Signatures and static WAF rules | the tool repeats itself | request variants generated on demand |
| Fixed rate thresholds | the flood is loud | low-rate requests aimed at costly paths |
| Behavioural baselines | the attacker does not know your normal | public traffic patterns mapped in advance |
| Image and puzzle challenges | a bot cannot see | vision models that solve them |
| Manual rule changes during an incident | your team changes faster than the traffic does | a variant loop measured in minutes or less |
Signatures assume the tool repeats itself
A signature-based rule works because flood tools are lazy. They send the same header order, the same user agent, the same path pattern and the same TLS client hello from every node, and one rule catches the lot.
Variation was always possible. It used to need someone to write it. A model asked for a hundred plausible request templates, each with a believable header set, query string and navigation path, produces them in seconds, and the rule written against template one says nothing about template forty.
TLS fingerprints are harder to vary than headers, because they come from the client library rather than the request. JA3/JA4 fingerprinting still separates a scripting library from a real browser. It does far less once the traffic comes from real browsers driven by automation, which is the direction the cheap tooling is moving.
Thresholds assume the flood is loud
A fixed requests-per-second limit catches what is abnormally fast. Reconnaissance turns that around: an attacker who has found the search query, the report export or the uncached product filter can exhaust an origin at a rate well inside any per-client limit.
Mapping an application used to be manual: read the JavaScript bundle, browse the site, pull the mobile app apart for its API calls. That is the kind of patient, text-heavy work models do quickly, and it is what the NCSC meant by reconnaissance uplift. Why a cheap request can carry an expensive backend cost is covered in API DDoS testing; the AI-specific point is that finding those requests no longer takes days.
Spreading the load across many addresses is older than any of this. Carpet-bombing and residential proxy networks already defeat per-IP limits. Models do not create that capacity; they make better use of it.
Baselines assume the attacker does not know your normal
Anomaly detection learns what normal traffic looks like and flags what departs from it. It is strongest against attackers who do not know the shape of normal and send something visibly different.
A great deal of normal is public. Popular pages, the order people move through a checkout, the share of mobile clients, the hours your customers wake up, the paths your app calls on launch: much of it can be inferred from outside. Traffic generated to follow those flows, at human pacing, from residential addresses, moves the attack from "abnormal" toward "busy day".
The baseline still has one advantage the attacker lacks: it sees the outcome. A flood can imitate the path real users take; it cannot easily imitate what real users then do, such as completing a purchase or returning tomorrow from the same device.
Challenges assume a bot cannot see
Interactive challenges ask the client to prove it is human by recognising something. That bet has weakened. A 2024 paper from ETH Zurich reported solving every reCAPTCHA v2 image challenge it was given using an off-the-shelf object-detection model, and human solving farms were defeating image puzzles long before that.
Challenges that price compute rather than perception hold up differently. A proof-of-work challenge or a JavaScript challenge charges each client CPU time, and a model does nothing to reduce that bill. They have their own costs, mostly to legitimate users on slow phones, but intelligence is not what they test.
Manual response assumes you change faster than the traffic does
The last assumption is about people. In most incidents, the defence that eventually works is a rule someone writes after looking at the logs: a new match on a header, a path, a country, a fingerprint.
That loop has a cycle time. An alert has to fire, someone has to be paged, read the traffic, write a rule, test it in count mode and deploy it. Fifteen minutes is fast. The attacker's loop is shorter: send, read the status codes and response times, produce the next variant. Automation shortened it years ago; models remove the last manual step, writing the variant itself.
The arithmetic of a rule that arrives late
Take an illustrative model. The attacker rotates to a new request variant on a fixed timer, and each new variant runs unfiltered until a rule for it is deployed. If a hand-written rule takes 15 minutes from alert to deployment, a 60-minute rotation leaves a quarter of the hour unfiltered. A 15-minute rotation leaves all of it: the rule always lands just as the traffic it matches is retired.
An attacker who changes on every block, rather than on a timer, does at least as well as the fastest rotation.
Automating the rule helps until the rotation gets shorter. A two-minute automated response against a 15-minute rotation leaves about 13% of the hour exposed; against a one-minute rotation, the whole hour again.
The numbers are assumptions; the shape is not. Any defence keyed to the variant loses once the attacker can vary faster than the defence can match. The defences that hold are the ones that do not care which variant arrives.
What a test now has to prove
That controls hold against variants they have not seen
A DDoS test that sends one request profile and records a block proves the rule matches that profile. Against an attacker who can produce new profiles at will, that is close to the least useful result available.
The question to ask instead is what happens to variant two, ten and forty. If each new variant gets through until someone writes a rule for it, the control is a signature in practice, whatever the product calls it.
That limits are set on cost, not count
Per-client request counts lose to low-rate traffic aimed at expensive paths. A test should show whether the stack limits what each client costs: concurrent expensive queries per session, origin CPU per route, queue depth on the slow endpoints. A flood that stays inside the request limit and still saturates the database is a finding about where the limit was set, not about the attacker's cleverness.
How long the defender's loop takes
Time-to-mitigate is usually measured once, at the start of an attack. Against traffic that changes, the figure that matters is how long it takes to respond to each change, both the automated controls and the people. Measure it per change. If the third adjustment takes as long as the first, the runbook has not shortened anything.
Who got turned away
Every assumption in the table can be restored by tightening: stricter challenges, lower thresholds, narrower baselines. Each tightening also catches customers. A test against human-like traffic is only meaningful if it counts the false positives alongside the blocks, because an attack that pushes you into turning away your own users has done its job.
What does not need to change
Authorisation, ceilings, stop conditions and vector selection are the same whoever, or whatever, wrote the attack. The complete guide to DDoS testing covers that ground.
The difference is in the attacker the test stands in for. A scripted run that keeps one plan whatever the defences do cannot show any of the four results above. A test that changes as the defences respond can, which is the case for AI-driven DDoS testing and the subject of adaptive DDoS testing, defined.
FAQ
Are AI-generated DDoS attacks real?
Attackers using AI for parts of their work is documented: Microsoft and OpenAI in 2024 and Google's Threat Intelligence Group in 2025 reported threat actors using models for reconnaissance, scripting and content. Public reports describe faster and cheaper versions of existing techniques rather than a new class of flood.
Can AI make a DDoS attack bigger?
Not in bandwidth or packet rate. Those come from the botnets, proxies, reflectors and servers an attacker controls or rents. AI makes an attack better aimed and more varied, which can make a smaller flood more damaging at the application layer.
Does a WAF still help against AI-generated traffic?
Yes, but rules keyed to a specific request pattern lose value when patterns are cheap to change. Rules and limits keyed to cost per client, request outcomes, or a compute challenge keep working regardless of what each request looks like. Testing tells you which kind you actually have.
Do CAPTCHAs stop AI-driven bots?
Image and puzzle challenges are increasingly solvable by vision models, as academic work on reCAPTCHA v2 showed in 2024. Challenges that charge each client compute time, such as proof-of-work, are unaffected by how intelligent the client is, though they carry their own cost for real users on slow devices.
Variety used to be the expensive part
For most of DDoS history, the scarce resource on the attacker's side was bandwidth, and on the defender's side it was the time it took to tell the attacker from the customer. Signatures, thresholds and challenges all worked by making the attacker pay for variety.
That payment is what models have cut. Bandwidth is no cheaper than it was; a new request shape, a new path through the site and a new answer to a puzzle all are.
So the defences worth having are the ones that never priced variety in the first place: limits on what a client costs, signals drawn from what traffic does rather than how it looks, and a response loop measured in seconds. The rest keep working until the attacker sends something new, which is now the cheapest thing it can do.
