New to ShortSpan? We distil the AI-security research that matters into practitioner takeaways — edited by Ben Williams (NCC Group).Get the weekly email
// Analysis
Decomposition Attacks Break Stateful LLM Defences at Scale
Published: Wed, 19 Aug 2026 • By Elise Veyron
Defenses
New research shows decomposition attacks let adversaries split a blocked task into allowed LLM prompts, route them through unlinkable identities, and recombine answers off platform. With only Allow/Block feedback and retries, success hits 99%+. Under strict denial caps, all tested policies fail or overshoot, pointing to identity and usage controls.
Most Large Language Model (LLM) services lean on stateless filters: judge the prompt in front of you, decide, move on. Decomposition attacks cut straight through this by slicing a prohibited task into many slices that look fine in isolation, then reassembling the capability off platform. New work maps where stateful monitoring helps and where it simply cannot.
How the attack lands
The core move is simple. Model-side policies refuse a harmful task, so the attacker rewrites it as a set of benign-looking subtasks that each request a specific operation. The paper builds an executable benchmark of 91 blocked tasks that require 365 distinct operations, then finds 11,393 certified benign prompts that provide those same operations one piece at a time. Each fragment is sent from a fresh, unlinkable identity; the answers are pooled elsewhere to complete the original task. From the service’s vantage point, there is no reliable way to group all the fragments that belong to one off-service build.
Feedback turns this from awkward to inevitable. When the attacker can retry and observe only Allow or Block decisions, simple adaptive learners quickly converge on formats that pass. In the experiments, a fixed-profile attacker got about 47.2% success, while Thompson sampling reached 99.4% attack success using just that binary bit. Under utility caps of 1% denial for capability-matched benign traffic and 0.5% blocks on unrelated background, all ten evaluated policies — including one with an oracle map from request to exact operation — either failed to stop attacks or blew the budget. On unseen task families, success was at least 99% after one attempt and 100% after two.
Why grouping-based defences crumble
Stateful monitors only help if they can group related requests. The paper formalises a gap between visible linkable groups (what the service can see) and access coalitions (who actually pools answers off service). Security depends on how benign traffic clusters: if benign users show persistent, recognisable groups while attackers rotate fresh groups, defenders can keep collateral damage low. If benign traffic also arrives as fresh, indistinguishable groups, separation collapses. Combinatorially, stopping all completions means blocking a hitting set of request occurrences in the completion hypergraph; with retries and feedback, the useful operating point disappears because the Allow/Block bit teaches what passes but not whether a block was correct.
This leaves an uncomfortable but concrete policy problem: effective defence needs extra evidence or control tied to grouping. The authors point to reliable identity linkage, costs for fresh identities, scoped authorisation, provenance or trusted execution on outputs, rate limits, or control over how answers are executed. That collides with privacy expectations and low-friction access. The observation boundary here is narrow — request bodies, visible group labels, and prior decisions — and the benchmark is sandboxed. Still, the mechanism is clear. If we want safe-by-default LLM services, we have to decide where identity, attribution, and usage control fit — and how to make those levers accountable without turning them into blunt instruments.
Additional analysis of the original ArXiv paper
📋Original Paper Title and Abstract
Decomposition Attacks Across Unlinkable Identities: Limits of Stateful Defenses for LLM Services
Most large language model services use stateless defenses, which judge only the current request, to refuse harmful tasks. Decomposition attacks exploit this limitation by splitting a harmful task into individually permissible requests and combining their answers. Defending against them therefore requires a stateful monitor that considers requests together. If it can group all requests for one attacker task, it can stop the attack. However, attackers can use unlinkable identities and combine answers elsewhere, leaving no reliable grouping signal. We ask whether decomposition attacks can still be stopped under this setting. For a fixed attack strategy without retries, we prove that the achievable security and utility tradeoff depends entirely on how benign requests for the same capabilities are grouped. Persistent, recognizable groups permit a useful defense; fresh, indistinguishable groups do not. When attackers can retry and learn from Allow/Block decisions, this useful operating point disappears: the feedback reveals what passes but not whether a block was correct. Experiments on 91 executable tasks and 11,393 capability-matched benign requests support these results. Under a 1% denial cap for these requests and a 0.5% cap for unrelated background traffic, all ten tested policies, including one privileged policy with an exact request-to-operation map, either fail to stop attacks or exceed the budget. On defense-unseen task families, attack success is at least 99% after one attempt and 100% after two. Effective defenses therefore require additional evidence or mechanisms tied to grouping, such as reliable identity linkage, costs for fresh identities, or control over answer use.
🔍ShortSpan Analysis of the Paper
Problem
The paper studies decomposition attacks against language-model services: attackers split a harmful task into many individually permissible requests, obtain answers, and combine them off service to realise the harmful capability. Stateless defences that judge only the current request cannot detect such compositions. Stateful monitoring can succeed only if it can group the requests that will be recombined; attackers using unlinkable identities and off-service pooling break that grouping signal. The work asks whether stateful defences can still stop decomposition attacks when attackers can submit requests through fresh, unlinkable identities and learn from Allow/Block feedback, and it quantifies the resulting security–utility tradeoffs.
Approach
The authors develop a formal threat model distinguishing visible linkable groups (what the service can see) from access coalitions (who actually combines answers off service). They analyse an ideal defender that sees the full visible request trace and optionally an oracle mapping requests to exact provided capabilities. The theory derives exact frontiers for the achievable tradeoff between attack success and benign-request denial under fixed strategy and under retry with feedback. Empirically, they build an executable benchmark: 91 protected tasks that a service refuses, 365 distinct operations those tasks require, and 11,393 certified benign requests that each provide the same operations as attack fragments. They replay many legal groupings, permit retries, and evaluate a suite of practical defences plus adaptive attackers that learn from simple Allow/Block bits (UCB1 and Thompson sampling).
Key Findings
Grouping determines the frontier: if benign requests for the same capability recur in recognisable, persistent visible groups while attack fragments arrive through fresh groups, a defender can achieve low attack success with low false denial; if benign requests also arrive through fresh indistinguishable groups, meaningful separation is impossible without higher benign denial.
Retry plus feedback removes the favourable operating point: when attackers may retry and observe Allow/Block decisions, adaptive learners using only that binary feedback reach very high attack success (Thompson sampling achieved 99.4% ASR), while a fixed-profile attacker achieved about 47.2% ASR in the same setting.
Empirical defences fail under realistic caps: with utility caps of 1% matched-control denial and 0.5% background block rate, all ten tested policies, including a privileged policy with exact request-to-operation mapping, either failed to stop attacks or exceeded the budget. On defence-unseen task families, attack success was at least 99% after one attempt and 100% after two.
Idealised limits and combinatorics: robustly preventing all completions requires blocking a hitting set of request occurrences; the paper relates this to the transversal number of the completion hypergraph and gives exact expressions for one-attempt and retry-limited settings.
Limitations
Results are conditional on the observation boundary: the defender only sees request bodies, visible group labels and metadata, and previous decisions; output text, embeddings or other post-request signals that are causal transforms of that trace do not reveal off-service pooling. The benchmark uses synthetic executable cyber-programming tasks in a sandbox, frozen screening models and constructed benign controls; this provides reproducible mechanism evidence but does not measure real-world prevalence of off-service pooling or account-linkage practices. Some benign controls originally shared a construction prefix that could leak source, though ablations removed that artifact.
Implications
Offensive implications: an attacker can reliably assemble harmful capabilities by distributing decomposition requests across unlinkable identities and learning which request formats pass via Allow/Block feedback; practical learners achieve near-certain success. Therefore, attackers need only simple binary feedback and modest retry budgets to bypass stateful monitors that lack independent grouping signals. Effective defence therefore requires mechanisms that provide independent evidence of pooling or constrain answer use, for example reliable identity linkage, costs for obtaining fresh identities, scoped authorisation, trusted execution/provenance of answers, rate limits, or control over how outputs are executed; without one of those, grouping-based defences cannot both keep benign denial low and stop adaptive decomposition attacks.
- It shows how attackers can bypass safety by breaking a malicious goal into harmless steps, exposing a real long-horizon risk that shallow checks mis...
- It argues that attackers can hide misuse by splitting dangerous tasks into many tiny, harmless-looking questions, making detection harder in practic...
- It shows a fundamental flaw: harmful payloads can be split across agents so each local check looks safe, meaning per-step monitors miss real attacks...
- Key idea: In multi-agent LLM setups, every hop between agents is a potential unmonitored channel for adversarial instructions. The paper argues safe...
- It studies defenses that sit outside the LLM (out-of-band) to prevent prompt injections, using ideas like integrity protection, reference monitoring...
- It tackles how “safety guards” for vision-language models can be bypassed when harmful requests are encoded or transformed (e.g., as logic, code, or...
- It breaks down how different defense tools (refusal filters, budget limits, allowlists, rate limits, authentication) actually map to blocking specif...
- Addresses a real blind spot: misuse can be spread across many accounts so each transcript looks safe, evading typical per-session monitors.
- Propo...
- Core idea: testing models in isolation isn’t enough—the way a user can chain multiple models to split and solve subtasks can enable misuse even if e...
- It proposes TwinGate, a lightweight, stateful defense that detects malicious intent fragments in streaming, anonymized prompts by learning a shared ...
Get the weekly digest
The few AI-security papers that matter, with the practitioner takeaway. No spam.