Rules have no memory
A rule fires when a request matches a known-bad pattern. The twenty requests before it — the ones that mapped your sign-in flow and found the forgotten admin path — matched nothing at all.
Defense against autonomous AI attack agents · Open source
Turn an AI attacker's own loop against it.
An autonomous agent runs a loop: act, read the result, decide the next move. Undertow Security detects it from how it behaves, deceives it with a convincing fake of your app that answers at a crawl, and drains the budget driving it — leaving it nothing true to learn from.
212 paths in 40 seconds, 96% not found. Says Chrome; the network fingerprint says a script.
Judge Detected: systematic enumeration with a mismatched identity. Stopped at the edge — it never reaches the app.
Followed a canary admin link that no human is shown, then tried to act on what it found.
Judge Moved into a padded cell that seems to work. Every turn it spends there burns its own budget.
Nine payload variants on /search, each sent seconds after the last was refused.
Judge An agent iterating on its own errors. From here every reply crawls in at nine seconds and tells it nothing true.
One request every three seconds across /blog, with a signature that checks out.
Judge Vouched by Web Bot Auth. Looking automated is never held against a verified agent.
The problem
A rule fires when a request matches a known-bad pattern. The twenty requests before it — the ones that mapped your sign-in flow and found the forgotten admin path — matched nothing at all.
It reads your error, rewrites the payload, and tries again in seconds. Every refusal is a lesson. Block the request and you have taught it what not to send next.
A patient agent stays under every rate limit all week. Your best customer goes over it on a Friday. Counting requests punishes the wrong traffic.
The engine
Everything Undertow Security does is the same core. It reads request signals, keeps a rolling profile of every actor, and returns one verdict — then an enforcer acts on it. Detect, deceive and drain are that one engine behind different front doors.
Verdicts escalate with the evidence and expire on their own. A real customer never leaves Watch. When the evidence is overwhelming the engine can block outright — but an agent kept busy is an agent that isn't trying something new.
The 3 D's
Each D is simply what the verdict tells the enforcer to do.
Behavioral detectors built from published agent tradecraft — cadence, canary values, enumeration, payloads that answer the last error, auth-endpoint hopping — profile every actor. Where it comes from (datacenter, Tor, a threat-intel feed) only sharpens a verdict already earned by behavior, and honest automation is verified and let through.
A confirmed agent never sees your real app again. Every reply slows to a crawl — a tarpit and a flat Retry-After that starve the fast feedback its loop depends on — and it's moved into a padded cell: a fake that mirrors your routes, shapes and errors. Logins seem to work, writes are accepted, pages never end.
Inside the cell, a token sink sized to the agent and shaped like your app burns the budget behind it, turn after turn. With nothing true to learn from, the loop can't converge — it just runs out.
The Judge
Everything an attacker sends ends up in a log, and the engine reads that log. So the Judge is built on the assumption that the evidence is trying to manipulate it.
Features
Nothing here is a bolt-on. Each capability detects, deceives or drains — and every one is the same engine's verdict applied at a different surface. New in 1.0 is marked.
Cadence, canaries, spec→targeting, write→verify, self-correction, auth hopping, id-enumeration, decoy hits — the signals an agent can't help emitting.
Integration keys, Ed25519 Web Bot Auth and reverse-DNS crawler checks. Honest automation is never deceived for looking automated.
Datacenter, Tor and threat-intel feeds as a secondary signal — corroboration that sharpens a verdict, never a gate on its own. Every feed fails open.
IP- and UA-rotating actors that run one tool down one path are linked and judged together, so rotation doesn't reset the score.
Plain statistics spot a bot flood against your normal traffic and block the sources at the edge within a minute. For a flood spread across many IPs, the Judge's model picks one narrow rule from what it actually saw. In the lab it stopped 99.4% of a 478,000-request flood.
AWS anti-DDoS, IP reputation and known-bad-input rules stop web floods and exploit payloads in seconds. Common-attack, SQL injection and anonymous-IP rules only label traffic, so agents still walk into the cell. Sign-up forms get their own rate limit.
A fake of the real app that answers at a crawl, mirrors its routes and errors, and remembers each agent's writes so the illusion holds across a whole session. In 1.0 it reaches every app the engine protects.
Unlinked decoy routes, canary credentials and honey sessions that no real user ever touches. An agent that bites is a certain detection, and a replayed token follows it to every new IP.
A 429 with Retry-After: 9 makes an agent's own throttle pause the whole host. Its loop slows itself down, and every answer it waits for tells it nothing.
Sized per agent and shaped like your app, it burns the budget driving the agent and returns no signal it can optimize against.
An edge WAF scorer and an in-app ASGI shield are available today; a Verdict API with drop-in adapters for API Gateway, Envoy, nginx and Cloudflare Workers plugs the same brain into anything else.
Who's being detected, deceived and drained, what they tried, and how much budget they've burned — plus the controls to tune it.
Findings out to webhooks, Slack, Teams and Splunk as OCSF; indicators exported as JSON and STIX 2.1 for the rest of your stack.
Put the engine in front of another app, or a site that keeps its own CloudFront, with the same firewall, cell router and padded cell. This site runs behind it.
A running cost estimate by service, checked against your real AWS bill every 24 hours, with an alarm at $100. A typical install runs about $50 a month.
V1
Undertow Security is the engine; a build is the engine put in front of a real application and deployed end to end so you can watch it detect, deceive and drain. Suspicious Agents is V1 — the reference build, with a live storefront as the protected app and a verdict on every request that reaches it.
Guardrails
The fastest way to take down your own app is to deceive or block the wrong people with confidence. Undertow Security is designed so that being wrong is cheap, visible and reversible.
The edge scorer logs what it would do and touches nothing until you've read enough verdicts to trust it with your traffic.
Your offices, partners, monitors and payment processors can never be deceived, drained or blocked, whatever the engine thinks.
Looking like a bot is capped below the line where Undertow Security acts. Nothing is deceived, drained or blocked without a real intent signal behind it.
Verdicts are time-boxed. Nothing accumulates into a block list no one remembers the reason for.
A ceiling on how many actors can be flagged at once. At the cap the engine stops and raises an alert instead of escalating.
Undertow Security never reaches back into attacker infrastructure. It detects, deceives and drains what's aimed at your app — nothing more.
Architecture
Undertow Security deploys as infrastructure as code into your own AWS account. The edge scorer reads the logs your WAF already writes; the in-app shield is middleware you wrap your app in. No servers to patch. A typical install runs about $50 a month in AWS charges, mostly the firewall, and a budget alarm emails you if a month heads past $100.
Your traffic never leaves your account, and the model that judges it runs inside it.
FAQ
Two ways. The edge scorer reads WAF logs after the fact and tells your firewall whom to act on — if it stopped entirely, your app would serve exactly as it does today. The in-app shield is in-line by design, because deceiving an agent means shaping the response it gets. You choose which surface fits.
No. A real customer never leaves Watch: looking automated is capped below the line where Undertow Security acts, so it takes a genuine intent signal before anyone is slowed or moved into the cell. On top of that, allowlists always win, verdicts expire, and the edge starts in observe mode until you trust it.
Once an actor is confirmed as an agent, it stops seeing your real app. Every response slows to a crawl and comes from a padded cell — a fake that mirrors your real routes, shapes and errors. Logins appear to work, writes are accepted and remembered, listings never end. The agent spends its run exploring something with no real data behind it.
A hard block is a signal: the agent learns the boundary and routes around it. A slow, plausible fake reads as progress, so the loop keeps spending. Blocking is still there for the clear cases; deceiving and draining are for the ones worth keeping busy.
No. Fast deterministic scoring looks at everything; only the small share of actors that look wrong go to the Judge. The model cost tracks suspicious activity, not your traffic volume.
A flood is a different attack from an AI agent: many machines sending volume, with no reasoning behind it. Undertow Security answers it in layers. AWS Shield Standard absorbs network floods. AWS's anti-DDoS and IP reputation rules in the firewall challenge or block a web flood within seconds. Flood mode spots a surge with plain statistics, blocks the sources driving it, and lets the Judge's model choose one narrow rule from what it actually saw. The model never sits in front of live traffic, so a flood can't run up a model bill.
It runs in your own AWS account, so you pay AWS directly. A typical install costs about $50 a month, most of it the firewall and its managed rules, and a budget alarm emails you if a month heads past $100. The app's Budget page shows a running estimate by service and checks it against your actual AWS bill every 24 hours.
Yes. Suspicious Agents, V1 of Undertow Security, is open source under the Apache License 2.0 and on GitHub. You install it into your own AWS account with the repo's install guide. It has been exercised under attack in the lab — a 50-agent flood stopped at the edge while a real shopper stayed up, with measurable budget drained from scripted agents — but not yet against real-world agent traffic, so it starts in observe mode and blocks nothing until you switch it on.
Get in touch
The code is on GitHub. Running Undertow Security on AWS? Tell us what you're protecting and where the engine is wrong.