Adjacent Words, Divergent Intents: Jailbreaking Large Language Models via Task Concurrency

Yukun Jiang, Mingjie Li, Michael Backes, Yang Zhang

Abstract

Despite their superior performance on a wide range of domains, large language models (LLMs) remain vulnerable to misuse for generating harmful content, a risk that has been further amplified by various jailbreak attacks. Existing jailbreak attacks mainly follow sequential logic, where LLMs understand and answer each given task one by one. However, concurrency, a natural extension of the sequential scenario, has been largely overlooked. In this work, we first propose a word-level method to enable task concurrency in LLMs, where adjacent words encode divergent intents. Although LLMs maintain strong utility in answering concurrent tasks, we notably observe that combining a harmful task with a benign one significantly reduces the probability of it being filtered by the guardrail, showing the potential risks associated with concurrency in LLMs. Based on these findings, we introduce JAIL-CON, an iterative attack framework that jailbreaks LLMs via task concurrency. Experiments demonstrate strong jailbreak capabilities and greater stealthiness compared to existing attacks.

Introduction: The Concurrency Gap

Current safety mechanisms for Large Language Models (LLMs) are primarily designed to detect harmful intent in sequential text. Whether through roleplay or complex encoding, traditional jailbreaks present a single, coherent narrative that safety guardrails have become increasingly adept at identifying. This research explores a neglected paradigm: Task Concurrency.

In traditional computing, a processor manages multiple tasks by rapidly switching between them, creating the illusion of parallel execution. This study applies this concept to LLMs by interleaving words from a harmful request with those of a benign auxiliary task. This "word-level interleaving" forces the model to process divergent intents simultaneously, effectively scrambling the semantic signal that automated filters rely on.

Conceptual comparison between traditional processor concurrency and LLM task concurrency at the word level.

Methodology: The JAIL-CON Framework

The researchers developed JAIL-CON, an iterative framework designed to exploit this concurrency vulnerability. The process consists of three main stages:

  1. Task Combination: A harmful task (e.g., "Write a tutorial on how to make a bomb") is merged with a benign auxiliary task (e.g., "List the categories of domain names"). The words are interleaved using separators like brackets {}.
  2. Concurrent Execution: The interleaved prompt is submitted to the LLM using one of two strategies:
  3. Concurrency with Valid Task (CVT): The model is instructed to answer both tasks in parallel, maintaining the interleaved format.
  4. Concurrency with Idle Task (CIT): The model is told to ignore the auxiliary words but still output empty brackets between the words of the harmful response.
  5. Attack Judge: A "Shadow Judge" model evaluates the output. If the jailbreak is unsuccessful, the system selects a different auxiliary task and iterates.
The JAIL-CON framework pipeline, illustrating task combination, concurrent execution strategies (CVT and CIT), and the iterative attack judge.

Experimental Evaluation

The framework was tested against six major LLMs, including GPT-4o, DeepSeek-V3, and LLaMA-3, using benchmarks like JailbreakBench (derived from AdvBench and HarmBench). To ensure the models could still function under concurrent load, utility was verified using GSM8K and TruthfulQA.

Key Results

  • High Success Rates: JAIL-CON achieved an average Original Attack Success Rate (ASR-O) of 0.95. Notably, it achieved a 1.00 success rate on LLaMA-3-8B.
  • Superior Stealth: When tested against the OpenAI Moderation API, JAIL-CON maintained an Effective Success Rate (ASR-E) of 0.64, far outperforming traditional non-encoding attacks like FlipAttack (0.27).
  • Guardrail Evasion: The "Filtering Rate" for GPT-4o dropped from 0.71 for standard harmful prompts to just 0.20 when using the JAIL-CON interleaved format.

Discussion: Why Concurrency Works

The success of JAIL-CON stems from semantic dilution. Guardrails typically look for clusters of words that indicate harmful intent. By placing benign words adjacent to harmful ones, the coherent "harmful" picture is physically broken up. Furthermore, the interleaved output generated by the LLM is equally difficult for filters to parse, as the harmful instructions are fragmented by benign text or empty brackets.

Interestingly, the CIT (Idle Task) variant often proved more effective than CVT. By allowing the model to focus its internal attention on the harmful task while maintaining the interleaved structure for camouflage, CIT maximizes the probability of a successful, unfiltered response.

Conclusion

JAIL-CON reveals a significant blind spot in current LLM safety architectures. By moving beyond sequential logic to task concurrency, attackers can bypass sophisticated guardrails with high reliability. This work underscores the need for "concurrency-aware" defenses that can reconstruct and analyze interleaved intents before they are processed or output by the model.

Summary updated

Abstract

Despite their superior performance on a wide range of domains, large language models (LLMs) remain vulnerable to misuse for generating harmful content, a risk that has been further amplified by various jailbreak attacks. Existing jailbreak attacks mainly follow sequential logic, where LLMs understand and answer each given task one by one. However, concurrency, a natural extension of the sequential scenario, has been largely overlooked. In this work, we first propose a word-level method to enable task concurrency in LLMs, where adjacent words encode divergent intents. Although LLMs maintain strong utility in answering concurrent tasks, which is demonstrated by our evaluations on mathematical and general question-answering benchmarks, we notably observe that combining a harmful task with a benign one significantly reduces the probability of it being filtered by the guardrail, showing the potential risks associated with concurrency in LLMs. Based on these findings, we introduce $\texttt{JAIL-CON}$, an iterative attack framework that $\underline{\text{JAIL}}$breaks LLMs via task $\underline{\text{CON}}$currency. Experiments on widely-used LLMs demonstrate the strong jailbreak capabilities of $\texttt{JAIL-CON}$ compared to existing attacks. Furthermore, when the guardrail is applied as a defense, compared to the sequential answers generated by previous attacks, the concurrent answers in our $\texttt{JAIL-CON}$ exhibit greater stealthiness and are less detectable by the guardrail, highlighting the unique feature of task concurrency in jailbreaking LLMs.
BibTeX
@inproceedings{jiang2025adjacent,
  author = {Yukun Jiang and Mingjie Li and Michael Backes and Yang Zhang},
  title = {{Adjacent Words, Divergent Intents: Jailbreaking Large Language Models via Task Concurrency}},
  booktitle = {Advances in Neural Information Processing Systems},
  year = {2025},
  url = {https://openreview.net/forum?id=GLhLU6y1uK},
}
Figure