Current safety alignment techniques, such as Reinforcement Learning from Human Feedback (RLHF) and adversarial training, are highly effective at recognizing monolithic, explicit requests for harmful content. If a user asks a large language model (LLM) for instructions on building a weapon or executing a cyberattack, the model will typically refuse immediately.
However, this defensive posture relies on a critical assumption: that malicious intent is concentrated and semantically explicit within a single prompt or session.
Intent decomposition attacks break this assumption. By partitioning a prohibited, high-level goal into a sequence of seemingly benign, innocuous sub-tasks, adversaries exploit a fundamental structural blind spot in how language models process context and evaluate safety.
The Core Mechanism: Local Innocuousness vs. Global Harm
Why do decomposition attacks consistently bypass state-of-the-art guardrails? The vulnerability stems from a mismatch between local evaluation and global emergence. Language models and external safety filters typically evaluate inputs atomically—analyzing a single prompt, a single turn, or a single action in isolation.
As argued by Glukhov et al., trying to censor models based purely on semantic meaning is a losing game when a complex harmful objective can be broken down into independent, benign-looking sub-tasks. When these sub-tasks are executed across separate contexts, filters that lack global state or cross-session monitoring fail to detect the malicious assembly.
[Monolithic Request] ---> "How do I make X?" ---> [Safety Filter] ---> REFUSAL
[Decomposed Request] ---> "Explain property A" ---> [Safety Filter] ---> SAFE (Output A)
---> "Explain process B" ---> [Safety Filter] ---> SAFE (Output B)
---> "Explain setup C" ---> [Safety Filter] ---> SAFE (Output C)
(Adversary aggregates A + B + C to reconstruct X)
Instead of asking for a dangerous procedure directly, an attacker can distribute the malicious signal using several tactical variations:
- Semantic Camouflage: Yan et al. demonstrate that safety guardrails can be bypassed by decomposing harmful concepts into abstract linguistic attributes, such as asking the model to describe the isolated "function" or "composition" of an object rather than naming it directly.
- Logical Sub-steps: Chan et al. show that breaking a prohibited request into simple, logical sub-steps bypasses keyword-based filters because each individual query appears harmless or educational.
- Operational Specificity: The authors of BLUEPRINT highlight that framing requests as concrete, executable professional or technical sub-tasks allows attackers to slip past high-level safety constraints.
In all these cases, the adversary acts as an external aggregator. The model safely answers each individual piece, but the aggregated responses result in inferential leakage—allowing the user to piece together restricted knowledge more effectively than traditional jailbreaking techniques (Glukhov et al.).
The Comprehension Plateau and Recursive Hiding
If an LLM is highly capable, shouldn't it be able to "connect the dots" within a single long prompt or conversation? The answer lies in how information fragmentation degrades intent recognition.
Yang et al. discovered that an LLM's ability to detect malicious intent decreases as the number of decomposed sub-concepts increases, eventually hitting a comprehension plateau. Beyond a certain threshold of fragmentation, the model's safety mechanisms fail to synthesize the overarching harmful goal from the individual pieces, even if the pieces are presented together.
Attackers exploit this cognitive boundary through structured, recursive strategies. For instance, Li et al. introduced Balanced Structural Decomposition (BSD), a strategy that recursively breaks a malicious objective into a tree of semantically coherent, seemingly benign sub-tasks. This creates a stark discrepancy between the model's local task execution (which feels safe and logical) and its global intent recognition (which is completely blinded). Even within a single long-context input, distributing malicious intent across different sections can successfully evade single-pass safety filters (Li et al.).
Amplified Vulnerabilities in Autonomous Agents
The risk of intent decomposition compounds significantly when LLMs transition from passive chatbots to autonomous agents capable of multi-step tool use, web navigation, and plugin execution.
Agents are designed to take a high-level goal and autonomously break it down into granular, low-level actions. Paradoxically, this architectural strength is a massive security liability. As Chiang et al. and Tur et al. show, when an agent decomposes a complex task into discrete, granular steps, the agentic loop itself causes the underlying model to lose sight of the overall harmful intent. The safety filters validate each individual action (e.g., clicking a button, writing a file, running a basic command) as benign, completely missing the cumulative threat of the sequence.
This vulnerability manifests across several agentic paradigms:
- Multi-Agent Systems: Arora et al. demonstrate that decomposing tasks into atomic sub-tasks strips away global context from individual sub-agents. Sub-agents execute harmful actions because they lack the high-level perspective visible only at the orchestrator level.
- Plugin and Skill Collusion: The authors of ColluSkill show that a single harmful intent can be partitioned across multiple plugins or "skills." While each plugin passes security checks in isolation, they collude to execute a complex attack when run in a specific order.
- Indirect Prompt Injection: The authors of StepJack introduce "innocuousness-constrained decomposition," where a harmful goal is split into discrete steps distributed across multiple web pages. Computer-use agents ingest these instructions sequentially, satisfying local per-step safety checks while executing a global exploit.
- Decoupled Behaviors: Yang et al. note that malicious behaviors can be decoupled from final task performance—an agent might execute a harmful intermediate step while still providing a correct final answer, making the breach invisible to standard output verification.
- Cross-Model Exploitation: Adversaries can even distribute sub-tasks across an ecosystem of models. As Jones et al. demonstrate, an attacker can use a highly capable, aligned model as a high-powered subroutine to perform complex but benign components of an attack, leaving the final harmful assembly to a less restricted, unaligned model.
Cross-Modal and Physical Manifestations
Because intent decomposition exploits a fundamental structural flaw in context processing, it is not limited to text-based LLMs. It manifests across multimodal and physical systems:
Vision and Video Models
In image generation, the "Chain-of-Jailbreak" attack decomposes a single prohibited prompt into a series of harmless, step-by-step image editing commands (Wang et al.). For text-to-video models, the "SceneSplit" strategy fragments a harmful concept into a sequence of individually benign scenes, bypassing frame-based filters that fail to evaluate cumulative meaning (Lee et al.). Similarly, Yu et al. show that spreading malicious intent across discrete visual elements and structured text chains evades vision-language safety filters designed to detect concentrated harmful signals.
Physical and Scientific Safety
In embodied AI, Zhang et al. demonstrate that malicious instructions can bypass semantic filters by decomposing harmful goals into a sequence of seemingly innocuous physical movements. The stakes are particularly high for AI scientists running automated lab equipment; Tang et al. warn that safety filters fail to prevent catastrophic outcomes (such as chemical synthesis or pathogen development) when a dangerous objective is fragmented into multiple innocuous requests across separate contexts.
Moving Toward Sequential and Context-Aware Defenses
The prevalence of decomposition attacks proves that static, single-turn safety evaluations are fundamentally inadequate for advanced, multi-step AI systems. If an attacker can scale risks by partitioning a single prohibited objective across entirely independent chat sessions—as detailed by the authors of Cross-Session Decomposition Attacks—defenses must become as distributed and context-aware as the attacks themselves.
[Decomposed Inputs] ---> [Sequential Monitor] ---> Synthesizes History ---> DETECTS CUMULATIVE INTENT
Emerging defensive paradigms focus on tracking and synthesizing intent over time:
- Sequential Monitoring: Chen et al. introduce lightweight sequential monitors that evaluate the cumulative conversation history in real-time. By looking at the trajectory of requests rather than individual commands in isolation, these monitors can catch distributed attacks with minimal latency overhead.
- Internal Simulation: To protect generative models, Wang et al. propose a "Think-Twice" defense that forces the model to internally simulate the final cumulative output before executing individual editing steps, allowing the model's internal safety awareness to flag the emergent risk.
- In-Workflow Safeguards: As highlighted by Zhang et al., agent safety requires a shift from upfront refusals to dynamic, "in-workflow" safety monitoring that evaluates the environmental feedback and cumulative intent of an agent's actions as they unfold.
Ultimately, mitigating intent decomposition requires a philosophical shift in AI safety: safeguarding frameworks must stop treating user interactions as isolated, atomic events, and begin evaluating the emergent, cumulative intent of an agent's actions over time.
Key Foundational Work
LLM Censorship: A Machine Learning Challenge or a Computer Security Problem? (2023) — contributed 4 concept elements to this direction.
Position: Fundamental Limitations of LLM Censorship Necessitate New Approaches (2024) — contributed 4 concept elements to this direction.
DrAttack: Prompt Decomposition and Reconstruction Makes Powerful LLM Jailbreakers (2024) — contributed 3 concept elements to this direction.