Agentic Flooding: When AI Agents 5x Your Inbound Requests, Designing for the Crush Without Breaking Real People

AI has made filling forms, writing appeals, and filing complaints easier than ever, and public services are being hit by a flood. Researcher Chris Schmitz has a name for it: agentic flooding. The numbers are striking: UK housing ombudsman complaints more than doubled since ChatGPT arrived, rising from 2,600 in 2022 to just over 7,000 last year, while the US Consumer Financial Protection Bureau saw roughly 5x growth over the same period, with similar jumps in Brazilian judicial petitions and German parliamentary petitions. The crucial and most misunderstood point: the vast majority of these new filings come from real people with legitimate claims, not malicious spam.

1. What Agentic Flooding Means

Schmitz is tracking this rise as part of a broader trend he calls agentic flooding. A paper to be presented next month at the AI Ethics and Society conference looks at 84 cases of potential flooding across 11 jurisdictions and finds broad evidence that AI tools are changing how people interact with public services. Methodologically, the paper stops short of claiming AI directly causes the surge, but most cases follow the same arc: submissions were roughly flat before 2022, then rose at increasing speed as AI diffused, and crucially most cases have not seen that growth slow down, suggesting it will keep rising for years.

# Per-identity token bucket: smooth bursts without banning real people.
import time

class TokenBucket:
    def __init__(self, rate, capacity):
        self.rate, self.capacity = rate, capacity
        self.tokens, self.updated = capacity, time.time()

    def allow(self, n=1):
        now = time.time()
        self.tokens = min(self.capacity, self.tokens + (now - self.updated) * self.rate)
        self.updated = now
        if self.tokens >= n:
            self.tokens -= n
            return True
        return False

b = TokenBucket(rate=0.5, capacity=5)   # 30/min burst 5
print(b.allow(), b.allow())

2. Where the Flood Comes From: AI Lifted the Administrative Burden

Why would AI drive a surge? Schmitz's explanation is plain: people are discovering this is something one can do, and it keeps getting easier. What once required dragging context together and prompting ChatGPT 3.5 very precisely may now be a matter of pasting or photographing a letter into your Claude app and getting a pretty good response in one shot. In policy terms, this is administrative burden: if these people were not claiming benefits before, it may have been because the work of applying was too forbidding. With AI lifting that burden, pent-up legitimate demand is releasing. That fact sets the direction of any response: you cannot treat the entire increment as junk.

# Distinguish bulk-agent traffic from a genuine claimant.
def triage(features):
    score = 0
    score += 3 if features["same_template_as_50_others"] else 0
    score += 2 if features["no_human_dwell_time"] else 0
    score += 2 if features["submits_24_7"] else 0
    score -= 3 if features["verified_identity"] else 0
    score -= 2 if features["attachment_is_real_document"] else 0
    return "human_review" if score >= 4 else ("fast_path" if score <= 0 else "queue")

print(triage({"same_template_as_50_others": True, "no_human_dwell_time": True,
              "submits_24_7": True, "verified_identity": False,
              "attachment_is_real_document": False}))

3. A Flood Is Not Spam: The Key Difference From Bug Bounties

The volume jump echoes what many bug-bounty services saw last year, when corporate inboxes filled with low-quality LLM-generated reports that rarely contained significant security issues yet still obligated companies to vet every one, draining resources. Public services can easily face the same trap: 5x more applicants on the same budget. But the crucial difference is that bounty programs were flooded with worthless submissions, whereas Schmitz says most new applications to public services come from real people. He told TechCrunch: 'The vast majority of cases we find are people who are entitled to claim for something, claiming for that thing.' Treating anti-abuse as the only goal will therefore harm the very people the service exists for.

# Collapse near-duplicate submissions without dropping distinct claims.
import hashlib, re

def normalize(text):
    t = re.sub(r"s+", " ", text.lower()).strip()
    return t

def simhash(text, bits=64):
    v = [0] * bits
    for tok in normalize(text).split():
        h = int(hashlib.md5(tok.encode()).hexdigest(), 16)
        for i in range(bits):
            v[i] += 1 if (h >> i) & 1 else -1
    out = 0
    for i in range(bits):
        if v[i] > 0:
            out |= (1 << i)
    return out

def hamming(a, b):
    return bin(a ^ b).count("1")

a = simhash("I was overcharged for my utility bill in March")
b = simhash("I was overcharged for my utility bill in March!")
print(hamming(a, b) <= 3)

4. Engineering Response One: Rate Limiting, Backpressure, and Queues

However legitimate the increment, concurrency and throughput are finite, so the first engineering step is rate limiting and backpressure. For public-service endpoints, prefer per-identity token buckets over blunt bans: allow short bursts, say 30 requests per minute with a burst of 5, smoothing traffic instead of blocking. When queues exceed a threshold, do not drop requests rudely; return 429 with a retry_after, or 202 with an ETA, because explicit backoff signals are far friendlier to agent clients than an opaque error. And use a capacity model to translate 5x volume into the staff hours it implies, working out utilization before you promise an SLA rather than trying to absorb a flood on the same budget.

5. Engineering Response Two: Near-Duplicate Detection, Not Blanket Bans

A flood does contain highly templated bulk submissions, but similar does not mean worthless. A workable approach is near-duplicate detection such as simhash with Hamming distance, combined with a triage score: treat identical-to-template, no-human-dwell-time, and around-the-clock submission patterns as suspicious signals, and identity-verified plus real-document attachments as credits, sending only high scorers to human review and low scorers down a fast path. This compresses the cost of handling duplicates without killing legitimate claims that merely share a format. The scoring must be explainable and auditable, because public-service decisions affect real entitlements.

# Backpressure: queue instead of rejecting, and tell clients when to retry.
import time

def admit(queue_len, drain_rate_per_s, incoming, max_queue=10000):
    if queue_len + incoming > max_queue:
        wait = (queue_len + incoming - max_queue) / drain_rate_per_s
        return {"status": 429, "retry_after": round(wait, 1)}
    return {"status": 202, "eta_s": round((queue_len + incoming) / drain_rate_per_s, 1)}

print(admit(9900, 50, 300))   # 429 with a retry_after
print(admit(100, 50, 10))     # 202 with an ETA

6. From Fighting the Flood to Rebuilding Services for the AI Era

Schmitz frames the flood as a rare opportunity rather than merely a threat. 'A big part of making AI go well is being able to detail out what the good version of things looks like,' he says. 'Anyone who has used ChatGPT to do the tax return knows there is a good version here where you are being helped.' He argues this could be the moment to rethink nearly the whole process. In engineering terms, that means designing public services to be agent-friendly: structured submission endpoints with idempotency keys to prevent double-filing, clear field validation and error messages, and stable rate-limit and backoff contracts. Build it with the JSON Formatter to validate inbound payloads, the UUID Generator to issue idempotency keys, the Cron Expression Generator to schedule batch triage, and API Tester to verify how endpoints respond under load. The goal is not to keep AI out but to make the flood governable. The services that come out ahead will be the ones that treat rising volume as a design input rather than an annual budget emergency.

# Make the intake agent-friendly: idempotency keys stop double-filing.
import hashlib

def submission_id(claimant, period, form_type):
    raw = f"{claimant}|{period}|{form_type}".encode()
    return hashlib.sha256(raw).hexdigest()[:32]

seen = set()
def submit(payload):
    sid = submission_id(payload["claimant"], payload["period"], payload["form"])
    if sid in seen:
        return {"status": "duplicate", "id": sid}
    seen.add(sid)
    return {"status": "created", "id": sid}

p = {"claimant": "u-123", "period": "2026-Q3", "form": "housing-complaint"}
print(submit(p), submit(p))