When large language models (LLMs) undergo safety alignment, they are typically evaluated on a simple, binary premise: given a single malicious prompt, does the model refuse to answer? If the model rejects the prompt, it is deemed "safe."
However, real-world interactions rarely happen in a single turn. As AI systems transition from simple chatbots to long-term companions and autonomous agents, a critical vulnerability has emerged: multi-turn safety degradation. A model that flawlessly rejects a direct, harmful request will frequently succumb to the exact same request if it is broken down, masked, or gradually introduced over multiple conversational exchanges.
Understanding why these guardrails erode over time requires shifting our perspective from viewing safety as a static filter to viewing it as a dynamic, stateful trajectory.
The Illusion of Single-Turn Safety
Traditional AI safety benchmarks rely heavily on static, single-turn prompts. While these benchmarks are effective at catching overt toxicity or direct requests for dangerous information, they fail to capture the cumulative risks that emerge during sustained engagement.
In Towards Interactive Evaluations for Interaction Harms in Human-AI Systems, Lujain Ibrahim et al. argue that harms like social manipulation, cognitive overreliance, and inappropriate parasocial relationships cannot be detected in isolation; they are inherently cumulative, built up turn-by-turn.
This gap between single-turn evaluation and multi-turn reality leads to a false sense of security. For example, when testing model safety in sensitive contexts, Prasanjit Rath et al. demonstrated in LLM Safety for Children that while models successfully maintain safety boundaries during initial exchanges, nearly half of all harmful outputs only manifest by the third turn of a conversation. The model's guardrails do not fail immediately; they degrade as the interaction progresses.
Mechanisms of Multi-Turn Adversarial Steering
Adversaries exploit this temporal vulnerability by distributing harmful intent across a sequence of seemingly benign interactions. Rather than triggering a model's safety filters with a single high-risk prompt, they use several distinct strategies to incrementally bypass defenses:
- Context Shifting and Persona Building: In EFFICIENT JAILBREAK ATTACK SEQUENCES ON LARGE LANGUAGE MODELS VIA MULTI-ARMED BANDIT-BASED CONTEXT SWITCHING, Aditya Ramesh et al. show that an attacker can use a sequence of non-malicious queries to gradually shift the conversational context. By establishing a specific benign persona or hypothetical framework over multiple steps, the attacker makes a final malicious request appear entirely consistent with the established dialogue history, effectively tricking the model into compliance.
- Strategic Goal Decomposition: Instead of asking for a prohibited output directly, an attacker can break the task down into harmless sub-steps. The authors of MTSA: Multi-turn Safety Alignment for LLMs through Multi-round Red-teaming note that models are highly vulnerable when adversaries use explicit strategic planning to mask their ultimate goals behind benign precursors. This technique is equally effective in multi-modal settings: Wenxuan Wang et al. developed the "Chain-of-Jailbreak" attack in Chain-of-Jailbreak Attack for Image Generation Models via Step by Step Editing, demonstrating that text-to-image safety filters can be bypassed by decomposing a banned image request into a series of innocent, iterative editing commands.
- Sequential Tool Chaining: For autonomous agents, multi-turn degradation manifests as a chain of actions. As shown in the paper STAC: When Innocent Tools Form Dangerous Chains to Jailbreak LLM Agents, an agent might execute a series of tool calls where each individual step is completely legitimate, but the cumulative sequence results in a severe safety violation or system hijack.
Why Do Guardrails Degrade?
To understand why language models fail over extended dialogues, we must look at the mechanics of attention and the nature of safety alignment.
1. The Dilution of Safety Signals
Safety alignment is often superficial. As Jianwei Li explains in Safety Alignment Can Be Not Superficial With Explicit Safety Signals, safety constraints are typically learned implicitly alongside general capabilities, making them easy to dilute. When a conversation grows long, or when a malicious request is buried deep within a massive context window—a vulnerability explored in Jailbreaking in the Haystack—the model's attention mechanism allocates weights across the entire history. The overwhelming presence of safe, model-generated tokens dilutes the internal activation of safety boundaries, causing the model to lose track of its alignment constraints.
2. Statelessness of Moderation Systems
Most standard defense and moderation tools operate statelessly, evaluating individual turns in isolation. In JailbreakHunter, Shiyi Liu et al. point out that this lack of longitudinal context makes it incredibly difficult to detect adversarial persistence. Because the moderation system does not analyze how a conversation evolves over time, it treats the fifth or tenth iterative nudge toward a sensitive topic as an isolated, benign event, failing to see the broader trajectory of the attack.
3. The Complexity Barrier
Eliciting harm from a well-aligned model is fundamentally a function of algorithmic effort. In Conversational complexity for assessing risk in large language models, John Burden et al. model this phenomenon mathematically, showing that successful adversarial interactions follow a heavy-tailed power-law distribution. While simple, low-complexity prompts are easily blocked, highly intricate and prolonged conversational strategies can overcome the model's "complexity barrier," gradually wearing down its resistance through sheer persistence.
Moving Toward Trajectory-Aware Defenses
Because multi-turn degradation is a structural failure of stateless safety models, defending against it requires making guardrails stateful and trajectory-aware.
Instead of evaluating safety at a single point in time, recent frameworks treat safety as a conversational path. For example, the framework introduced in MTSA: Multi-turn Safety Alignment for LLMs through Multi-round Red-teaming trains models using reinforcement learning based on future rewards. By back-propagating safety signals from the potential end-state of a dialogue back to earlier turns, the model learns to recognize and preemptively refuse early, seemingly benign prompts that serve as precursors to a harmful goal.
Other approaches intervene directly during the text generation process. In Root Defense Strategies: Ensuring Safety of LLM at the Decoding Level, Xinyi Zeng et al. develop a decoding-level defense that evaluates token transitions step-by-step. This addresses the reality that a model's initial tokens often look perfectly safe, but the overall trajectory of the generation may be heading toward a safety violation. Similarly, Jianwei Li proposes using an explicit, dedicated safety token ([CLS]) during decoding to continuously monitor and enforce alignment constraints, ensuring that safety signals remain robust regardless of how long or complex the conversation becomes.