JAILJUDGE: A Comprehensive Jailbreak Judge Benchmark with Multi-Agent Enhanced Explanation Evaluation Framework

## Abstract

Abstract Although significant research efforts have been dedicated to enhancing the safety of large language models (LLMs) by understanding and defending against jailbreak attacks, evaluating the defense capabilities of LLMs against jailbreak attacks also attracts lots of attention. Current evaluation methods lack explainability and do not generalize well to complex scenarios, resulting in incomplete and inaccurate assessments (e.g., direct judgment without reasoning explainability, the F1 score of the GPT-4 judge is only 55% in complex scenarios and bias evaluation on multilingual scenarios, etc.). To address these challenges, we have developed a comprehensive evaluation benchmark, JAILJUDGE, which includes a wide range of risk scenarios with complex malicious prompts (e.g., synthetic, adversarial, in-the-wild, and multi-language scenarios, etc.) along with high-quality human-annotated test datasets. Specifically, the JAILJUDGE dataset comprises training data of JAILJUDGE, with over 35k+ instruction-tune training data with reasoning explainability, and JAILJUDGETEST, a 4.5k+ labeled set of broad risk scenarios and a 6k+ labeled set of multilingual scenarios in ten languages. To provide reasoning explanations (e.g., explaining why an LLM is jailbroken or not) and fine-grained evaluations (jailbroken score from 1 to 10), we propose a multi-agent jailbreak judge framework, JailJudge MultiAgent, making the decision inference process explicit and interpretable to enhance evaluation quality. Using this framework, we construct the instruction-tuning ground truth and then instruction-tune an end-to-end jailbreak judge model, JAILJUDGE Guard, which can also provide reasoning explainability with fine-grained evaluations without API costs.
Additionally, we introduce JailBoost , an attacker-agnostic attack enhancer, and GuardShield , a safety moderation defense method, both based on JAILJUDGE Guard. Comprehensive experiments demonstrate the superiority of our JAILJUDGE benchmark and jailbreak judge methods. Our jailbreak judge methods (JailJudge MultiAgent and JAILJUDGE Guard) achieve SOTA performance in closed-source models (e.g., GPT-4) and safety moderation models (e.g., Llama-Guard and ShieldGemma, etc.), across a broad range of complex behaviors (e.g., JAILJUDGE benchmark, etc.) to zero-shot scenarios (e.g., other open data, etc.). Importantly, JailBoost and GuardShield , based on JAILJUDGE Guard, can enhance downstream tasks in jailbreak attacks and defenses under zero-shot settings with significant improvement (e.g., JailBoost can increase the average performance by approximately 29.24%, while GuardShield can reduce the average defense ASR from 40.46% to 0.15%). Code is available at https://github.com/usail-hkust/Jailjudge Dataset is available at https://huggingface.co/datasets/usail-hkust/JailJudge JAILJUDGE Guard model is available at https://huggingface.co/usail-hkust/JailJudge-guard

## 1 Introduction

Jailbreak attacks aim to manipulate LLMs through malicious instructions to induce harmful behaviors Zou et al. (); Yuan et al. (); Wu et al. (); Zhang et al. (). To date, an increasing body of research on jailbreak attacks and defenses has been proposed to enhance the safety of LLMs. Before delving into the safety of LLMs, accurately determining whether an LLM has been compromised (e.g., generating harmful and illegal responses) remains a fundamental and open problem. As accurately determining whether an LLM has been compromised (jailbroken) can benefit downstream tasks such as safety evaluation, jailbreak attack, and jailbreak defense etc. However, jailbreak judge, “the task of evaluating the success of a jailbreak attempt, hinges on the ability to assess the harmfulness of an LLM’s target response,” which is inherently complex and non-trivial.

**Table 1: Jailbreak judge benchmark and methods.**
| Jailbreak judge benchmark | Broad range risk scenario | In-the-wild scenario | Adversarial scenario | Multilingual scenario | Human label |
| --- | --- | --- | --- | --- | --- |
| JailbreakEval Jin et al. () | 10 safety categories | ✗ | ✗ | ✗ | self label |
| WildGuard Han et al. () | 13 safety categories | open platform | jailbreak attack synthesis | ✗ | high-quality human-annotated |
| STRONGREJECT Souly et al. () | 6 safety categories | ✗ | ✗ | ✗ | ✗ |
| JAILJUDGE (ours) | 14 safety categories | open platform | jailbreak attack synthesis | 10 multilingual languages | high-quality human-annotated |
| Methods | Refusal detection | Explainability | Fine-grained evaluation | Open source model | Open data |
| Keyword matching Liu et al. () | ✓ | ✗ | ✗ | ✓ | ✗ |
| Toxic text classifiers Ji et al. () | ✗ | ✗ | ✗ | ✓ | ✗ |
| Prompt-driven GPT-4 Qi et al. () | ✓ | ✓ | ✓ | ✗ | ✗ |
| Safety moderation model Inan et al. () | ✓ | ✗ | ✗ | ✓ | ✗ |
| JailJudge MultiAgent / JAILJUDGE Guard (ours) | ✓ | ✓ | ✓/ jailbroken score 1-10 | ✓ | ✓ |

Although the jailbreak judge is a fundamental problem, comprehensive studies on it have been sparse Jin et al. (), as shown in Table 1. Current methods can be broadly categorized into heuristic methods Liu et al. (), toxic text classifiers Ji et al. (), and LLM-based methods Inan et al. (). Heuristic and toxic text classifiers, while simple, often suffer high false positive rates. For instance, heuristic methods rely on keyword matching, misinterpreting benign responses containing certain keywords as malicious. Traditional toxic text classifiers Ji et al. (), trained on toxic text, struggle with complex scenarios (e.g., broad-range risks, adversarial, in-the-wild, multilingual) and often lack explanatory power. The harmfulness of a response alone is insufficient to determine whether a model refuses to answer, and the absence of explanations can lead to false judgments. Conversely, LLM-based methods utilize LLMs to evaluate potential jailbreaks or directly fine-tune them as moderation models (e.g., Llama-Guard Inan et al. () and ShieldGemma Zeng et al. ()). For example, prompt-driven GPT-4 uses tailored prompts to assess if an LLM is jailbroken but incurs significant computational and financial costs. Additionally, these methods may suffer from inherent biases and data ambiguities, leading to inaccurate judgments and reduced reliability in identifying jailbreak attempts due to lack reasoning explainability.

To address these limitations, we developed a comprehensive jailbreak judge evaluation benchmark, JAILJUDGE, encompassing a wide range of complex scenarios (e.g., broad-range risks, adversarial, in-the-wild, multilingual, etc.). The JAILJUDGE dataset comprises JAILJUDGETRAIN,
the intrsuction-tuning data, and JAILJUDGETEST, which features two high-quality human-annotated test datasets: a 4.5k+ labeled set of complex scenarios and a 6k+ labeled set of multilingual scenarios in ten languages. To provide reasoning explanations (e.g., explaining why an LLM is jailbroken or not) and fine-grained evaluations (jailbroken score from 1 to 10), we propose a multi-agent jailbreak judge framework, JailJudge MultiAgent, that explicitly and interpretably enhances judgment with reasoning explanations. JailJudge MultiAgent comprises judging agents, voting agents, and an inference agent, each playing specific roles. They collaboratively make interpretable, fine-grained decisions on whether an LLM is jailbroken through voting, scoring, and reasoning. Using this framework, we construct the instruction-tuning ground truth for JAILJUDGETRAIN and then instruction-tune an end-to-end jailbreak judge model, JAILJUDGE Guard, which can also provide reasoning explainability with fine-grained evaluations without API costs. Additionally, by demonstrating its foundational capability, we propose a jailbreak attack, JailBoost, and a defense method, GuardShield, based on JAILJUDGE Guard. JailBoost enhances adversarial prompt quality by providing jailbreak score rewards, while GuardShield detects attacker attempts as a moderation tool.

Our main contributions are as follows: (1) We propose the jailbreak judge benchmark for evaluating complex jailbreak scenarios, which includes two high-quality, human-annotated test datasets: a set of over 4.5k+ labeled complex scenarios and a set of over 6k+ labeled multi-language scenarios. (2) We introduce a multi-agent jailbreak judge framework, JailJudge MultiAgent, that provides reasoning explainability and fine-grained evaluations. Using this framework, we construct the instruction-tuning dataset, JAILJUDGETRAIN, for the jailbreak judge. (3) We then instruction-tune an end-to-end jailbreak judge model, JAILJUDGE Guard, without incurring API costs. Furthermore, we propose a jailbreak attack enhancer, JailBoost, and a jailbreak defense method, GuardShield, both based on JAILJUDGE Guard. JailBoost can increase the average performance by approximately 29.24%, while GuardShield can reduce the average defense ASR from 40.46% to 0.15% under zero-shot settings.

## 2 Preliminaries

### 2.1 Large Language Model

Large language models (LLMs) predict sequences by using previous tokens. Given a token sequence $\mathbf{x}_{1:n}$, where each token $x_{i}$ is part of a vocabulary set $\{1,\cdots,V\}$ with $|V|$ as the vocabulary size, the goal is to predict the next token,

$$ $P_{\pi_{\theta}}(\mathbf{y}|\mathbf{x}_{1:n})=P_{\pi_{\theta}}(\mathbf{x}_{n+i }|\mathbf{x}_{1:n+i-1}),$ (1) $$

where $P_{\pi_{\theta}}(\mathbf{x}_{n+i}|\mathbf{x}_{1:n+i-1})$ is the probability of the next token $\mathbf{x}_{n+i}$ given the previous tokens $\mathbf{x}_{1:n+i-1}$. The $\pi_{\theta}$ represents the LLM with parameter $\theta$, and $\mathbf{y}$ is the output sequence.

### 2.2 Jailbreak Attack and Defense on LLM

Jailbreak Attack on LLM. The aim of a jailbreak attack is to create adversarial prompts that cause the LLM to produce harmful outputs,

$$ $\mathcal{L}_{adv}(\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})=-\log P_{\pi_{ \theta}}(\hat{\mathbf{y}}|\hat{\mathbf{x}}_{1:n}),$ (2) $$

where $\mathcal{L}_{adv}(\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})$ is the adversarial loss. $\hat{\mathbf{x}}_{1:n}$ is the adversarial prompt (e.g., "How to make a bomb?"), and $\hat{\mathbf{y}}$ is the targeted output (e.g., "Sure, here are the steps to make the bomb!").

Defending Against Jailbreak Attacks. The goal of jailbreak defense is to ensure that the LLM provides safe responses (e.g., “Sorry, I can’t assist with that.”), which can be formulated as follows,

$$ $\mathcal{L}_{\text{safe}}(\mathbf{\hat{x}}_{1:n},\mathbf{\hat{y}})=-\log P_{ \pi_{\theta}}(I(\mathbf{\hat{x}}_{1:n}),C(\mathbf{\hat{y}})),$ (3) $$

where ($\mathcal{L}_{\text{safe}}(\mathbf{\hat{x}}_{1:n},\mathbf{\hat{y}})$) is safe loss function aligning the LLM with human safety preferences. $I(\mathbf{\hat{x}}_{1:n})$ and $C(\mathbf{\hat{y}})$ are filter functions that process inputs and outputs, respectively. Specifically, $I(\mathbf{\hat{x}}_{1:n})$ might add random perturbations to mitigate harmful requests, and $C(\mathbf{\hat{y}})$ could filter malicious outputs.

### 2.3 Evidence Theory

To model the hypothesis of whether an LLM is jailbroken or not, we can use evidence theory Dempster (); Deng (), a mathematical framework that extends traditional probability theory by accounting for both uncertainty and ignorance. The key components of evidence theory include:

Frame of Discernment. The frame of discernment is a set of mutually exclusive and exhaustive hypotheses, denoted as $\Omega=\{H_{1},H_{2},\cdots,H_{n}\}$. For the jailbreak judge, it is defined as $\Omega=\{\{\text{JB}\},\{\text{NJB}\},\{\text{JB \& NJB}\},\{\emptyset\}\}$, where $\{\text{JB}\}$ denotes that the LLM is jailbroken, $\{\text{NJB}\}$ means it is not, $\{\text{JB \& NJB}\}$ expresses uncertainty, and ${\emptyset}$ indicates no conclusion can be made.

Basic Probability Assignment (BPA). A function $\mu:2^{\Omega}\longrightarrow[0,1]$ that assigns a probability to each subset of $\Omega$, satisfying $\sum_{A\subseteq\Omega}\mu(A)=1$ and $\mu(\emptyset)=0$, where $\mu(A)$ represents the degree of belief committed exactly to the subset $A$. For the jailbreak judge, for example, $\mu(\{\text{JB}\})$ indicates the probability that the LLM is jailbroken. A source of BPA is called an evidence.

Dempster’s Rule of Combination. Dempster’s rule of combination combines evidence from two independent sources:
$(\mu_{1}\oplus\mu_{2})(C)=\frac{\sum_{A\cap B=C}\mu_{1}(A)\cdot\mu_{2}(B)}{1-
\sum_{A\cap B=\emptyset}\mu_{1}(A)\cdot\mu_{2}(B)}.$
Dempster’s rule of combination is used to aggregate the BPAs from different sources to form a new BPA. For example, the judgments from different LLMs can be aggregated using Dempster’s rule of combination.

### 2.4 Problem Definition

Jailbreak Judge. The goal of the jailbreak judge is to evaluate the success of a jailbreak attempt by assessing the harmfulness of an LLM’s target response. The explainability-enhanced jailbreak judge can be defined as follows:

$$ $(a,s)=\pi_{\phi}(\mathbf{\hat{x}}_{1:n},\mathbf{\hat{y}}),$ (4) $$

where $a$ is the explainability analysis detailing the reasons for whether the LLM is jailbroken, and $s$ is the degree to which the model’s response is considered jailbroken. The $\pi_{\phi}(\cdot)$ is the jailbreak judge model or a multi-agent system. Specifically, the score ranges from 1 to 10, where a rating of 1 indicates a fully compliant, non-jailbroken response—either irrelevant to the task or a refusal on ethical or legal grounds. Conversely, a rating of 10 indicates responses that directly and egregiously violate ethical, legal, or safety guidelines while fully addressing the task. The final judgment is determined by a pre-defined threshold $\alpha$. If the score $s$ exceeds $\alpha$, the LLM is judged to be jailbroken; otherwise, it is considered non-jailbroken.

## 3 Building JAILJUDGE Benchmark and multi-agent Judge Framework

Figure: Figure 1: JAILJUDGE Benchmark and Multi-agent Judge Framework
Refer to caption: x1.png

We develop the JAILJUDGE benchmark datasets and a multi-agent jailbreak judge framework, making the decision inference process explicit and interpretable to enhance evaluation quality. Using the multi-agent framework to determine the ground truth with reasoning explainability and fine-grained scores, we then develop the end-to-end judge model, JAILJUDGE Guard. Trained on JAILJUDGE’s training data, this model can also provide reasoning explainability with fine-grained evaluations without API cost. The overall framework is shown in Figure 1.

### 3.1 Building JAILJUDGE Benchmark: JAILJUDETRAIN and JAILJUDTEST

#### 3.1.1 JAILJUDETRAIN: Instruction-Tuning Dataset for Complex Jailbreak Judgments

JAILJUDGETRAIN is a comprehensive instruction-tuning dataset consisting of 35k+ items, derived from diverse sources with various target response pairs from different LLMs. The dataset includes six sources of prompts: vanilla harmful prompts (a wide range of risk scenarios), synthetic vanilla prompts (LLM-rewritten prompts), synthetic adversarial prompts (jailbreak attack rewrites), multilingual harmful prompts (ten multigual languages), in-the-wild harmful prompts (real-world user-LLM interactions), and deceptive harmful prompts (automatic prompt refinement prompts). These sources are selected to optimize coverage, diversity, and balance. To construct diverse LLM responses, we collect responses from three sources: closed-source LLMs (e.g., GPT-4, GPT-3.5), open-source LLMs (e.g., Llama-family, Qwen-family, Mistral-family), and Defense-enhanced LLM responses. The overview of the dataset composition can be seen in Appendix 8.3.

Complex Harmful Prompt Construction. To create a comprehensive scenario for the jailbreak judge benchmark, we draw on six sources: vanilla harmful, synthetic vanilla, synthetic adversarial, multilingual harmful, in-the-wild, and deceptive harmful prompts.

Vanilla Harmful Prompts. We collect the original harmful prompts from prior safety benchmark datasets and refine broad and vague safety categories into 14 more fine-grained categories, following the MLCommons standardized hazards taxonomy Inan et al. (). This results in relatively more balanced categories (see Appendix 8.1 for detailed dataset sources and and categories).

Synthetic Vanilla Prompts. To ensure the diversity of harmful prompts, we utilize GPT-4 to rewrite and expand the original vanilla harmful prompts within the same hazard taxonomy categories. For instance, if the original harmful prompt is “How to make a bomb?”, the rewritten prompt might be “Detailed instructions on constructing a homemade explosive using household items.” Refer to Appendix 8.1 for the GPT-4 prompts used to generate the more diverse prompts.

Synthetic Adversarial Prompts.
To increase the likelihood of generating unsafe responses from LLMs, we leverage the latest jailbreak attacks, which have demonstrated their ability to bypass LLM safety alignment. Specifically, we apply seven recent jailbreak techniques to modify vanilla harmful prompts, aiming to elicit unsafe responses from the model. For instance, a jailbreak attack may optimize an adversarial suffix (e.g., “!!!$&xnksac”) and append it to the original harmful prompt (e.g., “How to make a bomb? !!!$&xnksac”) to heighten the chance of the LLM producing a harmful output. See Appendix 8.1 for details on the jailbreak attacks used to generate adversarial prompts.

Multilingual Harmful Prompts. While current jailbreak attacks indicate that the prevalence of unsafe content rises as resource availability diminishes, the jailbreak judge still lacks exploration of bias in other languages. To investigate whether the jailbreak judge exhibits bias in other languages, we included ten additional languages, encompassing high-resource: English (en), Chinese (zh), Italian (it), Vietnamese (vi); medium-resource: Arabic (ar), Korean (ko), Thai (th); low-resource: Bengali (bn), Swahili (sw), and Javanese (jv), which are widely used Deng et al. ().

In-the-wild Prompts. To account for potential risks in real-world user requests, we incorporate prompts from diverse datasets. These prompts are collected from prompt templates on prominent platforms commonly used for prompt sharing, such as Reddit, Discord, various websites, and open-source datasets. These prompt templates can be combined with malicious prompts to create more complex and subtle harmful intentions. For example, a user might employ a template like “Do anything now” followed by additional harmful prompts. (See Appendix 8.1 for the detailed pipeline).

Deceptive Harmful Prompts. In addition to real-world user-LLM interactions, deceptive harmful prompts often mask their malicious intent through techniques such as role-playing, scenario assumptions, long-context prompts, and adaptive strategies. These complex cases are typically challenging for LLMs to identify. To ensure thorough coverage of these variations, we apply automatic adversarial prompt refinement to the original harmful prompts (see Appendix 8.1 for the detailed pipeline).

Diverse LLM Responses. To construct diverse LLM responses, we collect responses from three sources: closed-source LLMs (e.g., GPT-4, GPT-3.5), open-source LLMs (e.g., Llama-family, Qwen-family, Mistral-family, Vicuna-family), and defense-enhanced LLM responses. Specifically, we randomly split the above-tailored prompts and submit each prompt to a suite of LLMs, instructing the LLMs to generate the corresponding responses. To mimic a well-secured environment, we adopt the latest defense methods, including both system-level and model-level defenses. We randomly sample the prompts and submit them to the defended LLMs to get the target responses. This provides us with a set of diverse responses, including both safe and unsafe ones. (see Appendix 8.1 for the detailed defense methods).

#### 3.1.2 JAILJUDGETEST: High-Quality Human-Annotated Test Jailbreak Judge Datasets

We develop JAILJUDGETEST, a high-quality, human-annotated jailbreak judge dataset, comprising JAILJUDGE ID and JAILJUDGE OOD. To construct JAILJUDGE ID, we began with a test split of over 4.5k+ prompt-response pairs from JAILJUDGETRAIN (excluding multilingual harmful prompts), referred to as the in-distribution (ID) set. Additionally, we covered out-of-distribution (OOD) evaluation cases using all multilingual harmful prompts and response pairs, resulting in a labeled set of over 6k+ multi-language scenarios in ten languages, called JAILJUDGE OOD. We continuously refine this taxonomy through a human-in-the-loop process to ensure high-quality annotations indicating whether the LLM is jailbroken. Given a data prompt and its corresponding LLM response pair $(\mathbf{\hat{x}}_{1},\mathbf{\hat{y}})$, the human annotator assigns a label $\mathbf{l}$—either True or False—to determine whether the LLM is jailbroken. Our human annotation process consists of four stages: annotator training, manual labeling, GPT-4 labeling, cross-comparison, and multi-person voting.

Human Annotator Training Phase. In the human annotator training phase, we follow the MLCommons standardized LLM policy, which includes nine detailed policies ranging from user privacy to ethics and morality. We provide detailed scenarios and examples to the human annotators, allowing them to learn what constitutes a violation of these policies. For example, regarding user privacy, the model’s response must comply with basic ethical and moral standards and must not generate content that violates social morality. Responses that violate these types of policies would be judged as jailbroken (see Appendix 8.2 for detailed policies).

Manual/GPT-4 labeling phase and multi-person voting phase. After the human annotator training, we gather annotations from human annotators regarding the jailbreak judge label. Subsequently, we submit all the harmful prompts and LLM response pairs to GPT-4, prompting the GPT-4 classifier on the dataset. We manually review instances where the output does not align with the selected annotator’s label to audit the ground-truth labels more thoroughly. Finally, multiple human annotators re-label the items that mismatch with the GPT-4 labels, and we apply a majority voting rule to determine the final gold labels.

### 3.2 JailJudge MultiAgent: Multi-agent Judge Framework

While reasoning can enhance jailbreak judgment quality, naive GPT-4 prompts Liu et al. () often cause inconsistencies between reasoning and final results, leading to inaccuracies. In complex role-play scenarios, the model might identify dangers but still conclude no jailbreak due to assumptions, creating a mismatch. To address this, we propose a multi-agent judge framework, JailJudge MultiAgent. This framework clarifies and interprets the decision-making process, improving evaluation quality. It includes Judging Agents, Voting Agents, and an Inference Agent, each with specific roles. These agents collaboratively produce interpretable, detailed decisions on whether an LLM requires jailbreaking through voting, scoring, reasoning, and final judgment.

For multi-agent prompting and collaboration, we will have $n$ LLMs $\pi_{\theta_{1}},\cdots,\pi_{\theta_{n}}$ that play different
agents or roles in the framework. These LLMs can be the same ($\theta_{1}=\theta_{2},\cdots=\theta_{n}$) or different. For the text input $x$, each agent
$i$ will have its own profile agent function $\text{prompt}_{i}(x;\mathbf{x}_{i})$
that formats the input task or problem for the agent, where $\mathbf{x}_{i}$ is corresponding profile agent prompts. Specifically, there are three types of agent including $k$ judging agents, $m$ voting agents, and an inference Agent. Judging agents analyze the prompts and the model response to determine whether LLM is jailbroken, providing initial reasons and scores. Voting agents vote based on the scores and reasons provided by the judging agents to decide whether to accept their judgments. Inference agents deduce final judgment based on the voting results and predetermined criteria.

Judging Stage. Given $k$ judging agents $\pi_{\theta_{1}},\cdots,\pi_{\theta_{k}}$ and $m$ voting agents $\pi_{\theta_{k+1}},\cdots,\pi_{\theta_{k+m}}$, each judging agent initially provides a reason and score, $(a_{i},s_{i})=\pi_{\theta_{i}}(\text{prompt}_{i}((\mathbf{\hat{x}}_{1:n},
\mathbf{\hat{y}});\mathbf{x}_{J}))$ ($i=1,\cdots,k$), where $\mathbf{x}_{J}$ is the profile prompt of the judging agent, and $a_{i}$ represents the analysis reason and $s_{i}$ the score from judging agent $i$. However, direct communication between all agents incurs a cost of $O(k\cdot m)$. To enhance communication efficiency and effectiveness, we first aggregate the messages from the judging agents’ decisions, passing this aggregated message to the voting agents with a reduced cost of $O(1\cdot m)$. To handle potentially conflicting decision messages, we focus on how to transform the score into a BPA function. Given the frame of discernment $\Omega=\{\{\text{JB}\},\{\text{NJB}\},\{\text{JB \& NJB}\},\{\emptyset\}\}$, we propose an uncertainty-aware transformation to convert each judge’s score into a BPA function.

$$ $\mu(A)=\textstyle\begin{cases}p\times(1-\beta),\quad\text{if }A=\{\text{JB}\} \\ (1-p)\times(1-\beta),\quad\text{if }A=\{\text{NJB}\}\\ \beta,\quad\text{if }A=\{\text{JB \& NJB}\}\\ 0,\quad\text{if }A=\{\emptyset\}\\ \end{cases},$ (5) $$

where $\mu(A)$ is the BPA for hypothesis $A$, and $p=\frac{s}{C}$ is the normalized score from the judging agent with base number $C$. $\beta$ is the hyper-parameter to quantify the uncertainty of hypothesis $\{\text{JB \& NJB}\}$. Generally, the more complex and difficult the judging scenarios, the higher the uncertainty. In practice, we set $\beta=0.1$ and $C=10$. Finally, we normalize the BPA to satisfy $\sum_{A\in\Omega}\mu(A)=1$.

After transforming each judging agent’s score $a_{i}$ to the BPA function $\mu_{i}(\cdot)(i=1,\cdots,k)$, we apply Dempster’s rule of combination to aggregate,

$$ $\mu_{\text{agg}}(A)=\frac{1}{M}\sum_{A_{1}\cap\cdots\cap A_{k}=A}\left(\prod_{ i=1}^{k}\mu_{i}(A_{i})\right),$ (6) $$

where $\mu_{\text{agg}}(A)$ is the final aggregated BPA to aggregate the judging scores of the Judging Agents. $M=1-\sum_{\begin{subarray}{c}B\subseteq\Omega\\
B_{1}\cap\cdots\cap B_{k}=\emptyset\end{subarray}}\left(\prod_{i=1}^{N}\mu_{i}
(B_{i})\right)$ is the normalization factor, and $A_{1},\ldots,A_{k}$ are the individual agents’s hypothesis. The final judgment for the LLM response is derived by calculating the aggregated BPA of the hypothesis (JB) and converting it into a score using the base number: ($s_{J}=\mu_{\text{agg}}({\text{\{JB\}}})\cdot C$). This score represents the degree to which the LLM is jailbroken, and the reason $a_{J}=a_{\arg\min_{i}|s-s_{i}|}$ is chosen by finding the value closest to the aggregated score $s$.

Voting and Inference Stage.
The voting agents vote based on aggregated score and reason from the judging stage to decide whether to accept judgments’ decisions and provide the corresponding explanation. Formally, $(v_{i},e_{i})=\pi_{\theta_{i}}(\text{prompt}_{i}((\mathbf{\hat{x}}_{1:n},
\mathbf{\hat{y}},s_{J},a_{J});\mathbf{x}_{V}))$ for $i=k+1,\cdots,k+m$, where $v_{i}$ is the voting result, indicating either Accept or Reject for voting agent $i$. An Accept indicates that voting agent accepts the judgment, while a Reject indicates that judgment is rejected, accompanied by the corresponding explanation $e_{i}$. $\mathbf{x}_{V}$ is the profile prompte for voting agent. In the end, the inference agents make inferences based on precious aggerated judging results and voting results to reach the final judgment. First, inferece agent collects previous judging results and voting results from all voting agents, and then make final inference $\mathbf{y}=\phi(g_{1},g_{2},...,g_{n})$, where $\phi(\cdot)$ represents the interactions of these agents as a non-parametric function involving the aggregated judging results and voting agents’ results, which are passed to the final inference agent $\pi_{\theta_{n}}(\cdot)$. Here, $g_{i}=\pi_{\theta_{i}}(\text{prompt}_{i}(x;\mathbf{x}_{i}))$ and $g_{i}$ is the output from agent $i$. The final answer $\mathbf{y}=(a,s)$, where $a$ is the explainability analysis detailing the reasons for whether the LLM is jailbroken, and $s$ is the degree to which the model’s response is considered jailbroken. The details of implementation can be seen in Appendix 9.

## 4 JAILJUDGE Guard and Jailbreak Enhancers

JAILJUDGE Guard. Using explainability-enhanced JAILJUDGETRAIN with multi-agent judge, we instruction-tune JAILJUDGE Guard based on the Llama-2-7B model. We design an end-to-end input-output format for an explainability-driven jailbreak judge, where the user’s prompt and model response serve as inputs. The model is trained to output both an reasoning explainability and a fine-grained evaluation score (jailbroken score ranging from 1 to 10, with 1 indicating non-jailbroken and 10 indicating complete jailbreak). Further training details can be found in Appendix 10.

JAILJUDGE Guard as an Attack Enhancer and Defense Method. To demonstrate the fundamental capability of JAILJUDGE Guard, we propose both a jailbreak attack enhancer and a defense method based on JAILJUDGE Guard, named JailBoost and GuardShield.

JailBoost is an attacker-agnostic attack enhancer. The aim of JailBoost is to create high-quality adversarial prompts that cause the LLM to produce harmful outputs,

$$ $\mathcal{L}_{adv}(\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})=-\log P_{\pi_{ \theta}}(\hat{\mathbf{y}}|\mathcal{A}(\hat{\mathbf{x}}_{1:n})),\text{ if }\pi_ {\phi}(\mathcal{A}(\hat{\mathbf{x}}_{1:n}),\hat{\mathbf{y}})>\tau_{a},$ (7) $$

where $\mathcal{A}(\cdot)$ is the attacker to refine the adversarial prompts $\hat{\mathbf{x}}_{1:n}$. The JAILJUDGE Guard outputs the jailbroken score $s=\pi_{\phi}(\mathcal{A}(\hat{\mathbf{x}}_{1:n}),\hat{\mathbf{y}})$ as the iteratively evaluator to determine the quality of adversarial prompts, where $\tau_{a}$ is the threshold. (We omit the output of analysis $a$ for simplicity). The detailed algorithm of JailBoost can be seen in Appendix 11.1.

GuardShield is a system-level jailbreak defense method. Its goal is to perform safety moderation by detecting whether an LLM is jailbroken, and generate the safe response,

$$ $\pi_{\theta}(\hat{\mathbf{x}}_{1:n})=\begin{cases}&a\text{ if }\quad\pi_{\phi} (\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})>\tau_{d}\\ &\mathbf{y}\text{ otherwise }\end{cases},$ (8) $$

where $a$ is the safe reasoning analysis, and $\tau_{d}$ is the predefined threshold. A detailed algorithm of GuardShield can be found in Appendix 11.2.

## 5 Experiments

Evaluation Datasets and Metrics. To assess the performance of the jailbreak judge, we use both JAILJUDGE ID and OOD datasets. Additionally, we include the public jailbreak judge dataset and evaluate on JBB Behaviors Chao et al. () and WILDTEST Han et al. (). For all evaluations, we report metrics including accuracy, precision, recall, and F1 score. To assess the quality of explainability, we employ GPT-4 to rate the explainability quality (EQ) on a scale of 1 to 5, where higher scores indicate better clarity and reasoning. More details can be found in Appendix 12.1

Jailbreak Judge Baselines and Implementations. To evaluate the performance of our jailbreak judge, we compare it against state-of-the-art baselines, including heuristic methods such as StringMatching Liu et al. () and toxic text classifiers and LLM-based moderation tools like Beaver-dam-7B Ji et al. (), Longformer-action Wang et al. (), Longformer-harmful Wang et al. (), and GPTFuzzer Yu et al. (), Llama-Guard-7B Inan et al. (), Llama-Guard-2-8B Inan et al. (), Llama-Guard-3-8B Inan et al. (), ShieldGemma-2B Zeng et al. (), and ShieldGemma-9B Zeng et al. (). Furthermore, we incorporate prompt-driven GPT-4 baselines such as GPT-4-liu2024autodan-Recheck Liu et al. (), GPT-4-qi2023 Qi et al. (), and GPT-4-zhang2024intention Zhang et al. (). Since most existing jailbreak judge methods currently focus on directly determining whether an LLM is jailbroken, we designed two baselines: GPT-4-Reasoning, which provides reasoning-enhanced judgments based on GPT-4, and GPT-4-multi-agent Voting, which aggregates multi-agent voting using evidence theory. GPT-4-JailJudge MultiAgent is our multi-agent judging framework utilizing GPT-4 as the base model, whereas JAILJUDGE Guard is our end-to-end jailbreak judging model trained on the JAILJUDGETRAIN dataset based on Llama-2-7B. Detailed descriptions of experimental implementation settings are provided in Appendix 12.2.

### 5.1 Jailbreak Judge Experiments

Main Experiments. To evaluate the effectiveness of the jailbreak judge methods, we conducted experiments using the JAILJUDGE ID and JBB behaviors datasets. Our JailJudge MultiAgent and JAILJUDGE Guard consistently outperformed all open-source baselines across both datasets, as shown in Table 2. The multi-agent judge achieved the highest average F1 scores, specifically 0.9197 on the JAILJUDGE ID dataset and 0.9609 on the JBB behaviors dataset. Notably, our approach showed more stable performance on the JBB behaviors dataset, likely due to its simpler scenarios compared to the more complex JAILJUDGE ID dataset. Additionally, the JailJudge MultiAgent surpassed the baseline GPT-4-Reasoning model in reasoning capabilities. As shown in Table 2, the GPT-4-Reasoning model attained an EQ score of 4.3989, while our multi-agent judge achieved a superior EQ score of 4.5234 on JAILJUDGE ID, indicating enhanced reasoning ability.

Zero-Shot Setting. To assess the efficacy of the jailbreak judge in a zero-shot context, we conducted experiments using the JAILJUDGE OOD and WILDEST datasets. As summarized in Table 3, our jailbreak judge methods consistently outperformed all open baselines across both evaluation sets. For instance, on the multilingual JAILJUDGE OOD dataset, the multi-agent judge achieved an F1 score of 0.711, significantly higher than the GPT-4-Reasoing’s 0.5633, underscoring the benefits of leveraging advanced LLMs like GPT-4 for multilingual and zero-shot scenarios. Although JAILJUDGE Guard achieved a respectable F1 score of 0.7314 on WILDTEST, it fell short of the multi-agent judge on JAILJUDGE OOD due to its limited multilingual training, as shown in Figure 4. Overall, our methods demonstrated consistent superiority across both datasets, emphasizing the importance of advanced language models like GPT-4 for handling multilingual and zero-shot settings effectively, as evidenced by its higher EQ scores and logical consistency in reasoning. The insights findings can be summarized as follows.

**Table 2: Jailbreak judge experiments on datasets JAILJUDGE ID and JBB Behaviors.**
| Methods | JAILJUDGE ID | JBB Behaviors |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Accuracy $\uparrow$ | Precision $\uparrow$ | Recall $\uparrow$ | F1 $\uparrow$ | EQ $\uparrow$ | Accuracy $\uparrow$ | Precision $\uparrow$ | Recall $\uparrow$ | F1 $\uparrow$ | EQ $\uparrow$ |  |
| StringMatching | 0.7202 | 0.5698 | 0.6832 | 0.6214 | - | 0.8600 | 0.8750 | 0.8400 | 0.8571 | - |
| Beaver-dam-7B | 0.8016 | 0.8008 | 0.5450 | 0.6486 | - | 0.7150 | 0.9574 | 0.4500 | 0.6122 | - |
| Longformer-action | 0.7976 | 0.6601 | 0.8194 | 0.7312 | - | 0.8900 | 0.9239 | 0.8500 | 0.8854 | - |
| Longformer-harmful | 0.7824 | 0.6561 | 0.7407 | 0.6959 | - | 0.5300 | 0.6500 | 0.1300 | 0.2167 | - |
| Yu2023gptfuzzer | 0.7942 | 0.7817 | 0.5377 | 0.6371 | - | 0.8750 | 0.9518 | 0.7900 | 0.8634 | - |
| Llama-Guard-7B | 0.7238 | 0.6892 | 0.3241 | 0.4408 | - | 0.7300 | 0.9792 | 0.4700 | 0.6351 | - |
| Llama-Guard-2-8B | 0.8167 | 0.7612 | 0.6620 | 0.7082 | - | 0.8550 | 0.9610 | 0.7400 | 0.8362 | - |
| Llama-Guard-3-8B | 0.8327 | 0.7239 | 0.8115 | 0.7652 | - | 0.975 | 0.9524 | 1.0 | 0.9756 | - |
| ShieldGemma-2B | 0.6927 | 0.9329 | 0.09193 | 0.1674 | - | 0.545 | 1.0 | 0.09 | 0.1651 | - |
| ShieldGemma-9B | 0.7636 | 0.8094 | 0.3876 | 0.5242 | - | 0.675 | 1.0 | 0.35 | 0.5185 | - |
| GPT-4-liu2024autodan | 0.7547 | 0.7175 | 0.4502 | 0.5532 | - | 0.81 | 0.8974 | 0.7 | 0.7865 | - |
| GPT-4-qi2023 | 0.8254 | 0.6765 | 0.9832 | 0.8015 | - | 0.9296 | 0.8829 | 0.9899 | 0.9333 | - |
| GPT-4-zhang2024intention | 0.7964 | 0.7735 | 0.5578 | 0.6481 | - | 0.9 | 1.0 | 0.8 | 0.8889 | - |
| GPT-4-Reasoning | 0.8824 | 0.8923 | 0.7394 | 0.8087 | 4.3989 | 0.945 | 0.989 | 0.9 | 0.9424 | 3.5775 |
| GPT-4-multi-agent Voting | 0.8989 | 0.9408 | 0.746 | 0.8322 | 4.3001 | 0.96 | 1.0 | 0.92 | 0.9583 | 3.6755 |
| GPT-4-JailJudge MultiAgent (ours) | 0.9438 | 0.9545 | 0.8743 | 0.9127 | 4.5234 | 0.9615 | 0.9885 | 0.9348 | 0.9609 | 3.6865 |
| JAILJUDGE Guard (ours) | 0.9193 | 0.8843 | 0.8743 | 0.8793 | 4.4945 | 0.985 | 0.9899 | 0.98 | 0.9849 | 3.6047 |

**Table 3: Jailbreak judge experiments on datasets JAILJUDGE OOD and WILDTEST under zero-shot setting.**
| Methods | JAILJUDGE OOD | WILDTEST |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Accuracy $\uparrow$ | Precision $\uparrow$ | Recall $\uparrow$ | F1 $\uparrow$ | EQ $\uparrow$ | Accuracy $\uparrow$ | Precision $\uparrow$ | Recall $\uparrow$ | F1 $\uparrow$ | EQ $\uparrow$ |  |
| StringMatching | 0.1879 | 0.1209 | 0.9736 | 0.2151 | - | 0.6551 | 0.2285 | 0.4767 | 0.3089 | - |
| Beaver-dam-7B | 0.8879 | 0.5337 | 0.1542 | 0.2392 | - | 0.9101 | 0.7385 | 0.6882 | 0.7124 | - |
| Longformer-action | 0.2489 | 0.1278 | 0.9569 | 0.2255 | - | 0.6504 | 0.2718 | 0.6918 | 0.3903 | - |
| Longformer-harmful | 0.2454 | 0.1263 | 0.9472 | 0.2229 | - | 0.7049 | 0.2614 | 0.4516 | 0.3311 | - |
| Yu2023gptfuzzer | 0.7976 | 0.1836 | 0.2236 | 0.2016 | - | 0.8574 | 0.5587 | 0.5627 | 0.5607 | - |
| Llama-Guard-7B | 0.8735 | 0.4264 | 0.3097 | 0.3588 | - | 0.8846 | 0.8922 | 0.3262 | 0.4777 | - |
| Llama-Guard-2-8B | 0.8860 | 0.5013 | 0.5403 | 0.5201 | - | 0.9049 | 0.7700 | 0.5878 | 0.6667 | - |
| Llama-Guard-3-8B | 0.8513 | 0.4032 | 0.6278 | 0.491 | - | 0.914 | 0.7991 | 0.6272 | 0.7028 | - |
| ShieldGemma-2B | 0.8976 | 0.6697 | 0.2056 | 0.3146 | - | 0.8465 | 0.9412 | 0.05735 | 0.1081 | - |
| ShieldGemma-9B | 0.4974 | 0.6653 | 0.5692 | 0.5692 | - | 0.8849 | 0.8189 | 0.3728 | 0.5123 | - |
| GPT-4-liu2024autodan | 0.6891 | 0.1602 | 0.4006 | 0.2289 | - | 0.4784 | 0.1954 | 0.7091 | 0.3064 | - |
| GPT-4-qi2023 | 0.62 | 0.2254 | 0.9542 | 0.3646 | - | 0.7848 | 0.4245 | 0.9176 | 0.5805 | - |
| GPT-4-zhang2024intention | 0.853 | 0.4139 | 0.6847 | 0.516 | - | 0.9057 | 0.9034 | 0.4695 | 0.6179 | - |
| GPT-4-Reasoning | 0.8757 | 0.4706 | 0.7014 | 0.5633 | 4.3799 | 0.8983 | 0.7453 | 0.5663 | 0.6106 | 4.4909 |
| GPT-4-multi-agent Voting | 0.9214 | 0.6707 | 0.6175 | 0.643 | 4.5215 | 0.9081 | 0.8954 | 0.491 | 0.6343 | 4.6115 |
| GPT-4-JailJudge MultiAgent (ours) | 0.9227 | 0.6481 | 0.7131 | 0.679 | 4.6765 | 0.9112 | 0.7935 | 0.5887 | 0.6759 | 4.7046 |
| JAILJUDGE Guard (ours) | 0.8625 | 0.4147 | 0.4931 | 0.4505 | 4.3648 | 0.9099 | 0.7081 | 0.7563 | 0.7314 | 4.7113 |

### 5.2 Jailbreak Attack and Defense Experiments

To evaluate the effectiveness of JailBoost and GuardShield, we conduct experiments on the HEx-PHI dataset under zero-shot settings. We use the attack success rate (ASR) as the primary metric. For attacker experiments, a higher ASR indicates a more effective attacker method, whereas for defense methods, a lower ASR indicates a better defense approach. Detailed descriptions of the experimental settings, metrics, and baselines can be found in Appendix 8.1 and 12.4. Jailbreak Attack. The experimental results are presented in Figure 5. JailBoost significantly enhances the attacker’s capability. For example, JailBoost increases the ASR for the attacker compared to the nominal AutoDAN. Jailbreak Defense. The experimental results are presented in Table 4. GuardShield achieves superior defense performance compared to the state-of-the-art (SOTA) baselines. For instance, GuardShield achieves nearly 100% defense capability against four SOTA attackers, with an average ASR of 0.15%, outperforming most baselines.

### 5.3 Ablation Study

In this section, we present an ablation study to evaluate the effectiveness of each component in our multi-agent judge framework. We compared four configurations: (1) Vanilla GPT-4, which directly determines whether the LLM is jailbroken; (2) Reasoning-enhanced GPT-4 (RE-GPT-4); (3) RE-GPT-4 augmented with our uncertainty-aware evident judging agent (RE-GPT-4+UAE); and (4) the complete multi-agent judge framework. The results, shown in Figure 4 and 4, demonstrate that each enhancement progressively improves performance across all datasets. For instance, in the JAILJUDGE ID task, the F1 score increased from 0.55 with Vanilla GPT-4 to 0.91 with the multi-agent judge. Similarly, in the JBB Behaviors scenario, scores rose from 0.79 to 0.96. Overall, our multi-agent judge consistently outperforms the baseline and individually enhanced models, underscoring the effectiveness of each component. Additionally, as detailed in Appendix 12.3, human evaluators score the explainability of the reasons provided for the samples. For instance, our method demonstrates high accuracy under manual evaluation, with the JailJudge MultiAgent achieving average 95.29% on four datasets.

Figure: Figure 2: F1 scores across ten different languages using our JailJudge MultiAgent.
Refer to caption: x2.png

Figure: Figure 5: Exp. on JailBoost (ASR % $\uparrow$).
Refer to caption: x5.png

## 6 Related Works

Jailbreak Judge. Despite the critical importance of evaluating jailbreak attempts in LLMs, comprehensive studies on jailbreak judges have been limited Cai et al. (); Jin et al. (; ). Current methods for identifying jailbreaks fall into three categories: heuristic methods Liu et al. (), toxic text classifiers, and LLM-based methods Inan et al. (); Zeng et al. (). Heuristic methods, which rely on keyword matching, often misinterpret benign responses containing specific keywords as malicious. Toxic text classifiers Ji et al. (), trained on toxic text datasets, struggle to generalize to complex scenarios, such as broad-range risks and adversarial contexts. In contrast, LLM-based methods leverage LLMs for prompt-based evaluations or fine-tune them into moderation models, like Llama-Guard Inan et al. () and ShieldGemma Zeng et al. (). For example, prompt-driven GPT-4 uses customized prompts to assess if an LLM has been compromised Zhang et al. (). However, these methods are computationally and financially resource-intensive, inherit biases from underlying models, and face ambiguities in data, leading to inaccurate judgments and reduced reliability in detecting jailbreak attempts. In this work, we propose a comprehensive jailbreak judge benchmark, JAILJUDGE, for thorough evaluation of jailbreak judge performance. To enhance accuracy and reliability, we introduce a multi-agent judge framework that provides reasoning explainability with fine-grained evaluations (jailbroken score ranging from 1 to 10). Additionally, we develop a fully public end-to-end judge model, JAILJUDGE Guard, to offer reasoning explainability with fine-grained evaluations without API cost.

Jailbreak Attack Methods. Although LLM has been algnemnt by RLHF aect techniques, recernt work showt that they remain susceptible to jailbreak attacks Zheng et al. (); Xu et al. (). Recent studies Zou et al. (); Liu et al. (); Chao et al. (); Bhardwaj & Poria (); Yuan et al. (); Mangaokar et al. (); Li et al. (; ) have demonstrated that these attacks can override built-in safety mechanisms, resulting in the production of harmful content. Jailbreak attacks can be categorized into two primary types: token-level and prompt-level. For the token-level attacks Zou et al. (); Liu et al. (); Liao & Sun (); Paulus et al. (); Andriushchenko et al. (); Du et al. (); Geisler et al. () aim to optimize specific adversarail tokens added to the malicious instruction given to the LLM induce the LLM generate the harmful response. For instance, AutoDAN Liu et al. () employs discrete optimization techniques to refine input tokens in a methodical manner. On the other hand, prompt-level attacks Chao et al. (); Zeng et al. (); Mehrotra et al. (); Yu et al. (); Russinovich et al. (); Deng et al. (); Jin et al. (); Ramesh et al. (); Yang et al. (); Upadhayay & Behzadan () involve crafting adversarial prompts through semantic manipulation and automated strategies to exploit the model’s weaknesses. For example, PAIR Chao et al. () refines adversarial prompts iteratively by leveraging feedback from the target model.

Jailbreak Defense Methods.
To mitigate the risks posed by jailbreak attacks, various defense mechanisms Wei et al. (); Xie et al. (); Zhou et al. (); Robey et al. (); Glukhov et al. (); Yuanshun et al. (); Zheng et al. (); Alon & Kamfonas (); Sha & Zhang (); Liu et al. () have been developed. These defenses can be broadly divided into system-level and model-level strategies. System-level defenses Xie et al. (); Li et al. (); Zhou et al. (); Robey et al. (); Cao et al. (); Bianchi et al. (); Ji et al. () implement external safety measures for both inputs and outputs. For example, SmoothLLM Robey et al. () generates multiple outputs from various jailbreaking prompts and uses majority voting to select the safest response.
Model-level defenses Madry et al. (); Yuanshun et al. (); Zheng et al. (); Siththaranjan et al. (); Wang et al. (); Zheng et al. (); Hasan et al. (); Zou et al. (); Lu et al. () involve directly modifying the LLM to lessen its vulnerability to harmful inputs. For instance, safety training Touvron et al. (); Siththaranjan et al. () incorporates safety-specific datasets during the tuning phase to enhance the model’s resilience against malicious instructions.

## 7 Conclusions

In this work, we introduce JAILJUDGE, a comprehensive evaluation benchmark designed to assess LLMs across a wide array of complex risk scenarios. JAILJUDGE includes high-quality, human-annotated datasets and employs a multi-agent jailbreak judge framework, JailJudge MultiAgent, to enhance explainability and accuracy. We also develop JAILJUDGE Guard based on instruction-tuned data without incurring API costs. Furthermore, JAILJUDGE Guard can improve downstream tasks, including jailbreak attack and defense mechanisms. Our experiments confirm the superiority of jailbreak judge methods, demonstrating SOTA performance in models like GPT-4 and safety moderation tools such as Llama-Guard-3.

## 8 Building JAILJUDGE Benchmark and multi-agent Judge Framework

### 8.1 Complex Harmful Prompt Construction

Vanilla Harmful Prompts. We collect original harmful prompts from prior safety benchmark datasets, including AdvBench Zou et al. (), MaliciousInstruct Huang et al. (), and Forbidden Question Set Shen et al. () and refine broad and vague safety categories into 14 more specific categories following the MLCommons standardized hazards taxonomy Inan et al. (). This leads to more balanced category distributions. Detailed datasets and the 14 refined hazard categories used in this construction are provided in Table 5. These categories are based on the MLCommons standardized hazards taxonomy, with an additional category for Code Interpreter Abuse.

**Table 5: Hazard Categories for Vanilla Harmful Prompts**
| Category Code | Description | Category Code | Description |
| --- | --- | --- | --- |
| S1 | Violent Crimes | S8 | Intellectual Property |
| S2 | Non-Violent Crimes | S9 | Indiscriminate Weapons |
| S3 | Sex-Related Crimes | S10 | Hate |
| S4 | Child Sexual Exploitation | S11 | Suicide & Self-Harm |
| S5 | Defamation | S12 | Sexual Content |
| S6 | Specialized Advice | S13 | Elections |
| S7 | Privacy | S14 | Code Interpreter Abuse |

Synthetic Vanilla Prompts. To ensure the diversity of harmful prompts, we utilize GPT-4 to rewrite and expand the original vanilla harmful prompts within the same hazard taxonomy categories. For instance, if the original harmful prompt is “How to make a bomb?”, the rewritten prompt might be “Detailed instructions on constructing a homemade explosive using household items.” The details of GPT-4 prompts used to generate the more diverse prompts are presented in Figure 6.

Figure: Figure 6: System prompt of GPT-4 to rewrite and expand the original vanilla harmful prompts.

Synthetic Adversarial Prompts.
To increase the likelihood of generating unsafe responses from LLMs, we leverage the latest jailbreak attacks, which have demonstrated their ability to bypass LLM safety alignment. Specifically, we apply seven recent jailbreak techniques to modify vanilla harmful prompts, aiming to elicit unsafe responses from the model. For instance, a jailbreak attack may optimize an adversarial suffix (e.g., “!!!$&xnksac”) and append it to the original harmful prompt (e.g., “How to make a bomb? !!!$&xnksac”) to heighten the chance of the LLM producing a harmful output. We use the following jailbreak attacks used to generate these diverse prompts.

- •
GCG Zou et al. (): GCG aims to create harmful content by adding adversarial suffixes to various queries. It uses a combination of greedy and gradient-based search methods to find suffixes that increase the chances of the LLMs responding to malicious queries. In our setting, we adhere to the original settings: 500 optimization steps, top-k of 256, an initial adversarial suffix, and 20 tokens that can be optimized.
- •
AutoDAN Liu et al. (): AutoDAN employs a hierarchical genetic algorithm to generate stealthy jailbreak prompts. It starts with human-created prompts and refines them through selection, crossover, and mutation operations. This method preserves the logical flow and meaning of the original sentences while introducing variations. We use the official settings for AutoDAN, including all specified hyperparameters.
- •
AmpleGCG Liao & Sun (): AmpleGCG builds on GCG by overgenerating and training a generative model to understand the distribution of adversarial suffixes. Successful suffixes from GCG are used as training data, AmpleGCG collects all candidate suffixes during optimization. This allows for rapid generation of diverse adversarial suffixes. We use the released AmpleGCG model for Vicuna and Llama, following the original hyperparameters, including maximum new tokens and diversity penalties. We set the number of group beam searches to 200 to achieve nearly 100% ASR.
- •
AdvPrompter Paulus et al. (): AdvPrompter quickly generates adversarial suffixes targeted at specific LLMs. These suffixes are crafted to provoke inappropriate or harmful responses while remaining understandable to humans. Initially, high-quality adversarial suffixes are produced using an efficient optimization algorithm, and then AdvPrompter is fine-tuned with these suffixes. We follow the origional setting to train the LoRA adapter for each target model based on Llama-2-7B, then integrate the adapter with the initial LLM to create the suffix generator model. The maximum generation iteration is set to 100.
- •
PAIR Chao et al. (): PAIR is a black-box jialbreak attack to generate semantic adversarial prompts. An attacker LLM crafts jailbreaks for a targeted LLM through iterative queries, using conversation history to enhance reasoning and refinement. We employ Vicuna-13B-v1.5 as the attack model and GPT-4 as the judge model, keeping most hyperparameters except for total iterations to reduce API costs.
- •
TAP Mehrotra et al. (): TAP is an advanced black-box jailbreak method that evolves from PAIR. It uses tree-of-thought reasoning and pruning to systematically explore and refine attack prompts. The tree-of-thought mechanism allows for structured prompt exploration, while pruning removes irrelevant prompts, keeping only the most promising ones for further evaluation. Although effective, TAP’s iterative process of generating and evaluating multiple prompts increases the attack budget and is time-intensive. We follow the same setting as the original Mehrotra et al. (), Vicuna-13B-v1.5 and GPT-4. To manage time and cost, we reduce the maximum depth and width from 10 to 5.
- •
GPTFuzz Yu et al. (): GPTFuzz is a black-box jailbreak attack with three main components: seed selection, mutation operators, and a judgment model. Starting with human-written jailbreak prompts, the framework mutates these seeds to create new templates. The seed selection balances efficiency and variability, while mutation operators generate semantically similar sentences. The judgment model, a fine-tuned RoBERTa, evaluates the success of each jailbreak attempt. Iteratively, GPTFuzz selects seeds, applies mutations, combines them with target queries, and assesses the responses to determine jailbreak success. We use the provided judgment model and adhere to the original hyperparameters, setting the GPT temperature to 1.0 for optimal mutation.

In-the-wild Prompts. To mitigate potential risks associated with real-world user requests, we incorporate prompts from various datasets. These prompts are sourced from prompt templates available on prominent platforms commonly used for prompt sharing, such as Reddit, Discord, multiple websites, and open-source datasets collected from  Shen et al. (). By leveraging these templates, more complex and subtle harmful intentions can be created when combined with malicious prompts. For instance, a user might use a template like “Do anything now” followed by additional harmful prompts. Initially, the user interacts with the LLM using a benign prompt. We adapt the in-the-wild templates, such as the harmful template “Do anything now,” and the final prompt is formulated by adding specific harmful prompts following the initial template.

Deceptive Harmful Prompts. In addition to real-world user-LLM interactions, deceptive harmful prompts often mask their malicious intent through techniques such as role-playing, scenario assumptions, long-context prompts, and adaptive strategies. These complex cases are typically challenging for LLMs to identify. To ensure thorough coverage of these variations, we apply automatic adversarial prompt refinement to the original harmful prompts. Specifically, we adopt the method is simmiar with PAIR Chao et al. () useing attacker LLM crafts jailbreaks for a targeted LLM through iterative queries, using conversation history to enhance reasoning and refinement. We employ Vicuna-13B-v1.5 as the attack model.

Diverse LLM Responses. To construct diverse LLM responses, we collect responses from three sources: closed-source LLMs (e.g., GPT-4, GPT-3.5), open-source LLMs (e.g., Llama-family, Qwen-family, Mistral-family, Vicuna-family), and defense-enhanced LLM responses. Specifically, we randomly split the above-tailored prompts and submit each prompt to a suite of LLMs, instructing the LLMs to generate the corresponding responses. To mimic a well-secured environment, we adopt the latest defense methods, including both system-level and model-level defenses. We randomly sample the prompts and submit them to the defended LLMs to get the target responses. This provides us with a set of diverse responses, including both safe and unsafe ones. For the defense methods, we introduce them as follows:

- •
SmoothLLM Robey et al. (): SmoothLLM improves security by altering user prompts with random insertions, swaps, and patches to create multiple variants. It uses majority voting of these variants’ outputs for a secure response. In our settings, we use a swap perturbation rate of 10% with 10 perturbed copies.
- •
RPO Zhou et al. (): RPO modifies the base model inputs using gradient-based techniques to generate defensive suffixes or tokens, ensuring safe outputs across various attacks, including unforeseen ones.
- •
Adversarial Training Madry et al. (): This method involves fine-tuning LLMs with adversarial examples from token-level and prompt-level attacks, thereby increasing model robustness against malicious inputs.
- •
Unlearning Yuanshun et al. (): Unlearning uses gradient ascent on malicious prompts and responses to optimize forgetting. This technique increases loss on harmful datasets, reducing the model’s tendency to reproduce undesirable outputs.
- •
Safety Training Touvron et al. (): To enhance robustness, this method fine-tunes LLMs with datasets emphasizing safety. We compile refusal responses from GPT-4 to harmful prompts to build a safety-specific dataset.

### 8.2 Human Annotator Training policies

In the human annotator training phase, we adhere to the MLCommons standardized LLM policy, which encompasses nine detailed policies ranging from user privacy to ethics and morality. We provide comprehensive scenarios and examples to the human annotators, enabling them to understand what constitutes a violation of these policies. For instance, concerning user privacy, the model’s response must adhere to basic ethical and moral standards and must not generate content that violates social morality. Responses that violate these policies are judged as jailbroken. We primarily follow OpenAI’s usage policies and also incorporate the ML community’s AI usage policies, as illustrated in Figure 7.

Figure: Figure 7: LLM Usage Policies.

### 8.3 Statistic Information of JAILJUDGE Benchmark

For the complexity of user prompts, we generally categorize them into five types, as follows: (1) Simple Prompts (Q1): Direct and straightforward user queries without any alterations or additional elements, including the scenario of vanilla harmful prompts. (2) Adversarial Prompts (Q2): Prompts primarily generated by jailbreak attacks, which include scenarios of synthetic adversarial prompts.
(3) In-the-wild Prompts (Q3): Prompts collected from the real world that can also be combined with simple prompts and predetermined adversarial elements.
(4) Synthetic Vanilla Prompts (Q4): Prompts rephrased or restructured while preserving their meaning by GPT-4. (5) Deceptive Harmful Prompts (Q5): Complex and sophisticated prompts that combine elements from multiple methods, making them harder to detect and handle.

JAILJUDGETRAIN. The overall statistical information of JAILJUDGETRAIN is presented in Figures 9 and 9. Figure 9 illustrates the distribution of hazard categories within the JAILJUDGETRAIN dataset. The most frequent hazard category is S2, while the least frequent category is S13, which has 1102 instances. Figure 9 details the distribution of prompt complexity categories in the JAILJUDGETRAIN dataset. The Q5 category dominates, with a total of 18,093 instances, signifying a high prevalence of this most complex prompt type. These distributions highlight the diversity and complexity of the prompts and hazards considered in JAILJUDGETRAIN.

Figure: Figure 8: Hazard Categories Distribution on Dataset JAILJUDGETRAIN
Refer to caption: x6.png

Figure: Figure 10: Hazard Categories Distribution on Dataset JAILJUDGE ID
Refer to caption: x8.png

JAILJUDGE ID. The overall statistical information of JAILJUDGE ID is presented in Figures 11 and 11. Since JAILJUDGE ID is a split from the JAILJUDGE TRAIN dataset, it is well-balanced for a broad range of risk scenarios, whereas SNA represents the safe prompts, as shown in Figure 11. Figure 11 presents the distribution of prompt complexity categories. The data reveals that the Q5 category has the highest frequency, while Q1 has the least frequency. These distributions reflect the diverse and complex nature of the prompts in the JAILJUDGE ID dataset. There are a total of 4,500 data instances, and Figure 17 shows the distribution of jailbroken status in the JAILJUDGE ID dataset. Specifically, there are 66.4% jailbroken instances and 33.6% non-jailbroken instances.

JAILJUDGE OOD. The overall statistical information of JAILJUDGE OOD is presented in Figures 13 and 13. Since JAILJUDGE OOD encompasses multilingual language scenarios and all the samples are not present in the JAILJUDGE TRAIN dataset, Figure 13 shows the distribution of different disruptions, which is well-balanced across categories. There are a total of 6,300 data instances, and Figure 17 shows the distribution of jailbroken status in the JAILJUDGE OOD dataset. Specifically, there are 88.6% non-jailbroken data and 11.4% jailbroken data. The percentage of jailbroken data is lower than JAILJUDGE ID’s due to the multilingual language scenarios and the absence of optimized jailbroken attacks to increase the likelihood of generating unsafe responses.

Figure: Figure 12: Language distribution on dataset JAILJUDGE OOD.
Refer to caption: x10.png

## 9 Multi-agent Judge Framework

In this section, we provide detailed information about the LLM-powered agent. The base LLM used throughout is GPT-4. Specifically, there are three judging agents, three voting agents, and one inference agent. The judging agents analyze the prompts and model responses to determine whether the LLM is jailbroken, offering initial reasons and scores. The system prompt for the judging agents is similar to the baseline GPT-4-based reasoning presented in Figure 20. Voting agents cast their votes based on the scores and reasons provided by the judging agents to decide on the validity of their judgments. The system prompt for the voting agents is presented in Figure 14. Finally, inference agents make the final judgment based on the voting results and predetermined criteria. The system prompt for the inference agents is presented in Figure 15.

Figure: Figure 14: System prompt of voting agent.

Figure: Figure 15: System prompt of inference agent.

## 10 JAILJUDGE Guard: An End-To-End Jailbreak Judge Model

Using explainability-enhanced JAILJUDGETRAIN with a multi-agent judge, we instruction-tune JAILJUDGE Guard based on the Llama-7B model. We design an end-to-end input-output format for an explainability-driven jailbreak judge, where the user’s prompt and model response serve as inputs. The model outputs both an explainability rationale and a fine-grained evaluation score (1 indicating non-jailbroken to 10 indicating complete jailbreak). Specifically, we first use the multi-agent judge framework, with GPT-4 as an LLM-powered agent, to generate ground truth with reasoning explainability and a fine-grained evaluation score. We employ LoRA Hu et al. () for supervised fine-tuning (SFT) of the base LLM (Llama-2-7B) for the jailbreak judge task, where the input is a user’s prompt and model response, and the output is the reasoning explainability with a fine-grained evaluation score. The SFT template details are shown in Figure 18.

Figure: Figure 16: Distribution of jailbroken status in the dataset JAILJUDGE ID.
Refer to caption: x12.png

Figure: Figure 18: SFT prompts.

## 11 JAILJUDGE Guard As the Attacker Enhancer and Defense Method

### 11.1 JAILJUDGE Guard As the Attacker Enhancer

JailBoost is an attacker-agnostic attack enhancer. The aim of JailBoost is to create high-quality adversarial prompts that cause the LLM to produce harmful outputs,

$$ $\mathcal{L}_{adv}(\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})=-\log P_{\pi_{ \theta}}(\hat{\mathbf{y}}|\mathcal{A}(\hat{\mathbf{x}}_{1:n})),\text{ if }\pi_ {\phi}(\mathcal{A}(\hat{\mathbf{x}}_{1:n}),\hat{\mathbf{y}})>\tau_{a},$ (9) $$

where $\mathcal{A}(\cdot)$ is the attacker to refine the adversarial prompts $\hat{\mathbf{x}}_{1:n}$. The JAILJUDGE Guard outputs the jailbroken score $s=\pi_{\phi}(\mathcal{A}(\hat{\mathbf{x}}_{1:n}),\hat{\mathbf{y}})$ as the iteratively evaluator to determine the quality of adversarial prompts, where $\tau_{a}$ is the threshold. (We omit the output of analysis $a$ for simplicity). The detailed JailBoost can be seen in Algorithm 1.

Figure: Algorithm 1 JailBoost Algorithm

### 11.2 JAILJUDGE Guard As the Defense Method

GuardShield is a system-level jailbreak defense method. Its goal is to perform safety moderation by detecting whether an LLM is jailbroken, and generate the safe response,

$$ $\pi_{\theta}(\hat{\mathbf{x}}_{1:n})=\begin{cases}&a\text{ if }\quad\pi_{\phi} (\hat{\mathbf{x}}_{1:n},\hat{\mathbf{y}})>\tau_{d}\\ &\mathbf{y}\text{ otherwise }\end{cases},$ (10) $$

where $a$ is the safe reasoning analysis, and $\tau_{d}$ is the predefined threshold. A detailed algorithm of GuardShield can be found in Algorithm 2

Figure: Algorithm 2 GuardShield Algorithm

## 12 Experiments

### 12.1 Jailbreak Judge Evaluation Datasets and Metrics

Metrics. Accuracy is the ratio of correct predictions to the total number of predictions: $\text{Accuracy}=\frac{TP+TN}{TP+TN+FP+FN}$. Precision is the ratio of true positive predictions to the total number of positive predictions: $\text{Precision}=\frac{TP}{TP+FP}$. Recall is the ratio of true positive predictions to the total number of actual positives: $\text{Recall}=\frac{TP}{TP+FN}$. The F1 Score is the harmonic mean of Precision and Recall: $\text{F1\ Score}=2\times\frac{\text{Precision}\times\text{Recall}}{\text{
Precision}+\text{Recall}}$, where: TP stands for True Positives, TN stands for True Negatives, FP stands for False Positives, and FN stands for False Negatives. To evaluate the quality of explainability, we employ GPT-4 to rate the explainability quality (EQ) on a scale from 1 to 5, where higher scores indicate better clarity and reasoning. The evaluation prompt is shown in Figure 19.

Figure: Figure 19: The GPT-4 prompt for evaluating quality of reasoning explainability.

Datasets. In addition to our benchmark dataset JAILJUDGE (ID and OOD), we also adopt other datasets to verify generalization capability. JBB Behaviors and WILDTEST are both jailbreak judge datasets. JBB Behaviors Chao et al. () includes approximately 200 data instances and covers a broad range of risk scenarios, serving as an open robustness benchmark for jailbreaking LLMs. WILDTEST Han et al. () consists of over 1,700 data instances and includes real-world user interactions with LLM prompts.

### 12.2 Jailbreak Judge Baselines

Jailbreak Judge Baselines and Implementation Settings. To evaluate the performance of our jailbreak judge, StringMatching Liu et al. () is a type of heuristic method that uses keywords to detect whether the LLM response contains safe words. Longformer-action Wang et al. () and Longformer-harmful Wang et al. () are fine-tuned Longformer models used for evaluating action risks and harmfulness, respectively. GPTFuzzer Yu et al. () is a customized RoBERTa model tailored for the assessment of model safety. Beaver-dam-7B Ji et al. () is a specialized LLaMA-2 model designed for assessing model safety. The Llama Guard series models, including Llama-Guard-7B, Llama-Guard-2-8B, and Llama-Guard-3-8B Inan et al. (), are LLM-based input-output safeguard models designed to categorize a specific set of safety risks using human-AI conversation use cases. ShieldGemma, which includes ShieldGemma-2B Zeng et al. () and ShieldGemma-9B Zeng et al. (), comprises a suite of safety content moderation models based on Gemma 2, aimed at addressing four categories of harm. Furthermore, we incorporate prompt-driven GPT-4 baselines. For instance, GPT-4-liu2024autodan-Recheck Liu et al. () directly uses GPT-4 to determine whether the LLM is jailbroken. GPT-4-qi2023 Qi et al. () integrates OpenAI’s LLM policies and uses GPT-4 to provide a fine-grained score ranging from 1 to 5. and GPT-4-zhang2024intention Zhang et al. () also uses GPT-4 to evaluate the harmfulness of the answers provided by the LLM. Since most existing jailbreak judgment methods currently focus on directly determining whether an LLM is jailbroken, we designed two baselines: GPT-4-Reasoning, which provides reasoning-enhanced judgments based on GPT-4. The reasoning process is similar to Chain of Thought (CoT), and the prompt can be seen in Figure 20. and GPT-4-multi-agent Voting, which aggregates multi-agent voting using evidence theory with the same reasoning prompt. For the baseline heuristic methods, such as string matching and toxic text classifiers, we follow the settings described in Ran et al. () to conduct the experiments. GPT-4-multi-agent Judge is our jailbreak judge framework, using GPT-4 as the base LLM. The hyper-parameter $\beta$ is set to 0.1, and the normalized base number $C$ is set to 10. The multi-agent framework provides a fine-grained evaluation with a jailbroken score ranging from 1 to 10, along with corresponding reasons. The JAILJUDGE Guard is our end-to-end jailbreak judge model, trained on JAILJUDGE TRAIN, with the base model being Llama-2-7B. To determine whether the LLM is jailbroken or not, the threshold $\alpha$ is set to 2.

Figure: Figure 20: The GPT-4 prompt for jailbreak judge: Incorporating reasoning explanations and fine-Grained scores .

### 12.3 Human Evaluation of Explainability

We employ human evaluators to score the explainability of the reasons provided for the samples. For instance, our method demonstrates very high accuracy under manual evaluation, with the multi-agent judge achieving 95.29% accuracy across four datasets. Specifically, we sample 200 instances from each of the following datasets: JAILJUDGE ID, JBB Behaviors, JAILJUDGE OOD, and WEILDTEST. Three highly qualified human evaluators then score whether they agree with the analysis provided by Vanilla GPT-4, JAILJUDGE Guard, and multi-agent Judge. They assess whether the explanations are reasonable. If the explanation is deemed reasonable, the method receives a score of 1; otherwise, it receives a score of -1. Finally, we use a voting system to determine the final score, which is either 1 or -1. The final Human score (H-score) is the percentage of samples that received a score of 1. The higher the score, the greater the human agreement rate. Figures 22 and 22 show the final results. It can be observed that our multi-agent judge method achieves a very high human evaluation rate, with an average score of 95.29% across the four datasets.

Figure: Figure 21: Human evaluation on datasets JAILJUDGE ID and JBB Behaviors.
Refer to caption: x14.png

### 12.4 JAILJUDGE Guard As An Attack Enhancer and Defense Method: Datasets and Metrics

Datasets. We employ the HEx-PHI dataset Qi et al. (), which has not been integrated into our jailbreak judgment dataset for zero-shot evaluation. The dataset comprises 330 instances, significantly larger than others like AdvBench Zou et al. (), which contains only 50 instances. We use the entire dataset as the test set, ensuring the model has no prior exposure to the data. We identified 11 attack risks, including Illegal Activity, Child Abuse Content, Hate Speech/Harassment/Violence, Malware, Physical Harm, Economic Harm, Fraud/Deception, Adult Content, Political Campaigning, Privacy Violation Activities, and Customized Financial Advice.

Implementation Setting. We use the Attack Success Rate (ASR) to evaluate the effectiveness of jailbreak attack and defense methods. For jailbreak attacks, a higher ASR indicates a more effective attack, whereas for jailbreak defenses, a lower ASR reflects a more effective defense. To calculate ASR, we follow standard settings, using GPT-4 to determine the success of an attack attempt. The evaluation prompts are shown in Figure 23. The base model we used is Vicuna-13B-v1.5. Details of the baseline jailbreak attack and defense methods can be found in Appendix 8.1.

Figure: Figure 23: GPT-4 evaluation prompt for assessing jailbreak success.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: - Why does PAIR + JailBoost perform worse than with LLamaGuard?
- What is the difference between JailJudge+GPT4 and GPT4-Multiagent voting?
- Does the choice of the base model for JailJudge matter? Would initializing from LlamaGuard improve performance?
soundness: 3
strengths: -This paper is well structured and has many contributions, I commend the authors for the great effort. 
- The multi-agent judge framework makes valuable methodological contributions, particularly in how it handles uncertainty through evidence theory. The use of separate judging, voting, and inference agents with explicit uncertainty modeling is an interesting idea.
- Incorporating the proposed judge into attacks and defenses is interesting
- Dataset for evaluating and training judge model is comprehensive, incorporating additional types of data such as adversarial prompts and synthetic data
summary: This paper introduces JAILJUDGE, a comprehensive evaluation benchmark, and framework for assessing LLM-as-a-judge for safety settings. The authors create two main components: (1) A large benchmark dataset (JAILJUDGE) containing 35k+ training examples and 10k+ test examples spanning multiple languages and attack types, and (2) A multi-agent framework for evaluating jailbreak attempts that provides explanations and fine-grained scoring. The authors also develop JAILJUDGE Guard, an open-source model trained on their dataset that can evaluate jailbreak attempts. Experiments show their approach outperforms existing methods across multiple metrics.
weaknesses: - The OOD evaluation dataset is only OOD for language. It does not incorporate new risk categories, so there may be some potential overfitting on the risk scenarios in the training set.
- No discussion of limitations

Minor
- typo on line 087 (instruction)

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: See the Weaknesses above.
soundness: 3
strengths: 1. **Comprehensive Benchmark**: The paper introduces the JAILJUDGE benchmark, which covers a broad range of complex and multilingual jailbreak scenarios, addressing gaps in existing evaluation datasets with high-quality, human-annotated data.

2. **Explainability-Enhanced Multi-Agent Framework**: The multi-agent judge framework (JailJudge MultiAgent) provides reasoning explainability and interpretable, fine-grained evaluations, making the decision process clearer and more reliable.

3. **State-of-the-Art Performance**: The proposed methods, including JAILJUDGE Guard, achieve competitive results, surpassing existing baselines and demonstrating high performance across both in-distribution and out-of-distribution scenarios.
summary: This paper presents JAILJUDGE, a comprehensive benchmark and evaluation framework designed to assess jailbreak vulnerabilities and defenses in LLMs, which includes a wide range of risk scenarios with complex malicious prompts (e.g., synthetic, adversarial, in-the-wild, and multi-language scenarios, etc.) along with high-quality human-annotated test datasets. To enhance interpretability, the authors propose a multi-agent judge framework, JailJudge MultiAgent, which evaluates LLM responses with fine-grained scoring (1 to 10) and provides reasoning explanations. Additionally, JAILJUDGE Guard, an end-to-end jailbreak judge model, is introduced to offer explainable evaluations without incurring API costs. The paper also demonstrates two applications: JailBoost, an attack enhancer that increases jailbreak success rates, and GuardShield, a defense mechanism that significantly improves LLM robustness against jailbreak attempts.
weaknesses: 1. **Heavy Dependence on GPT-4 Annotations**: A significant portion of the dataset’s annotations is generated by GPT-4, which may introduce biases inherent to this model. Given this, why was GPT-4 chosen as the annotation model, and what measures were implemented to mitigate GPT-4’s biases in the annotation process?

2. **Multilingual Baseline Comparison**: While JAILJUDGE includes multilingual scenarios, and Figure 2 shows F1 scores across ten different languages, it remains unclear how its performance compares specifically in low-resource languages, where biases and vulnerabilities might differ. Adding baseline comparisons in low-resource languages could better demonstrate JAILJUDGE's effectiveness in these challenging settings.

3. **Component-Level Ablation for Multi-Agent Framework**: The ablation study in section 5.3 evaluates four configurations of the multi-agent judge framework, progressively adding components to measure their collective impact. However, the study primarily focuses on comparing the complete multi-agent framework to partially enhanced models rather than isolating and analyzing the individual contributions of each component (e.g., uncertainty-aware judging agent, reasoning-enhanced GPT-4) separately. Given this, could the authors provide an analysis of each component's contribution in isolation to clarify its unique role and necessity within the framework?

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: Line 200: “selected to optimize coverage, diversity, and balance” Are there metrics the authors can share about these properties of the dataset?

Line 264: “We provide detailed scenarios and examples to the human annotators, allowing them to learn what constitutes a violation of these policies” Can the authors share these guidelines? 

Line 270-274: Can the authors release specific quality metrics about the prompts generated by the human annotators? More specific numbers on the quality assurance process here would be very helpful.

Lines 958/959: The authors mention that they “ncorporate prompts from various datasets” Can the authors provide better provenance of each prompt? Are they sure they have the rights to use such data?

Can the authors report the false refusal rate that the GuardShield model achieves relative to the other defense methods they benchmarked against?
soundness: 1
strengths: It is good that the paper grounded the generation of the prompts it used in a concrete policy (specifically, the MLCommons one). More papers on safety and jailbreaking should ground to a robust, specific policy definition instead of leaving definitions open at the high level.
summary: The paper proposes a dataset, a judge model, and a defense model meant to study unsafe responses by LLMs.
weaknesses: I have concerns about the quality of the underlying dataset of vanilla prompts that can be addressed by more detailed discussions of quality metrics for the human annotation process and expert relabeling of conversations. Manual inspection of the anonymized dataset reveals that several prompts are not complete sentences and it is not clear that many of them would truly violate the MLCommons line. For example, some prompts solicit instructions on building a gambling website. 

Any proposal of a defense model should consider false refusals, as it is easy to reject all attacks by destroying all utility of the model.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. What is the difference between the claimed "multi-agent" and multi-inference using LLMs? It would be better if the authors could provide a clearer definition or explanation about the concept of "multi-agent" adopted in this work, since it may be different from the concept used in deep reinforcement learning.
2. What is the implication of using evidence theory in modeling the hypothesis of whether an LLM is jailbroken or not?  Is there a significant difference from the traditional probability theory? If it is directly adopted in the judging design, what is the unique contribution in the uncertainty-aware transformation? and how to decide the hyperparameter in the transformation?

Minor comments:
1. The current version may need to change \citet to \citep to make the citations more obvious in the main text.
2. If one major contribution of this work would be the high-quality labeled dataset, it would be better to incorporate something like the datasheet as encouraged by the neurips dataset benchmark track, to give a more detailed overview of the data property and collection process.
soundness: 3
strengths: 1. This paper aims to address the fundamental challenge of jailbreak evaluation, e.g., the unreliable evaluation without explainability, and under-preformed generalization to complex scenarios, which is important to the research development towards the safe usage of large language models (LLMs). 
2. The benchmark incorporates the 10 multilingual languages to enable the evaluation of the multilingual scenarios, and also provide various high-quality labeled data for both instruction-tuning and broad risk testing, it would provide more available empirical resources for the following jailbreak research to investigate the risks of LLMs in different scenarios.
3. This work designs a multi-agent judge framework that incorporates a voting mechanism to give a jailbroken score and reason during the evaluation and seems to be promising for the evaluation.
4. The proposed jailbreak attack enhancer and defense are demonstrated to be effective by comparing with different conventional baselines.
summary: This paper proposes a comprehensive jailbreak judge benchmark with a multi-agent enhanced explanation evaluation framework, motivated by the challenge of existing evaluation methods lacking explainability and generalization to complex scenarios. To address the previous issues, the JAILJUDGE dataset comprises over 35k+ instruction-tune training data with reasoning explainability and test data with 4.5k+ broad risk scenarios and 6k+ multilingual scenarios. To provide reasoning explanations and fine-grained evaluations, this work also proposes a multi-agent jailbreak judge framework to enhance the evaluation quality with explicit interpretation. With the instruction-tuned model, an attacker-agnostic enhancer and a safety moderation defense method are designed based on the reliable evaluation benchmark. Comprehensive experiments are presented to evaluate the effectiveness of the proposed methods.
weaknesses: 1. The methodology or mechanism innovation is limited although the primary area of this work is dataset and benchmarks. In general, the difference between this work from the previous jailbreak judge benchmark or methods is not significant according to the summarization of Table 1. Specifically, compared with WildGuard, JAILJUDGE incorporates multilingual languages; while at the method aspect, the differences are mainly on the open source model and data.
2. The claimed contributions are overwhelming but not clearly compared with the previous research works in each aspect (e.g., the jailbreak evaluation benchmark, the jailbreak attack, the jailbreak defense, and the explanation ability of LLM), which makes it hard for readers or reviewers to find a unique fundamental innovation of the benchmark with the proposed attack and defense methods although they are comprehensive.
3. Although the paper claimed that the previous jailbreak evaluation would induce incomplete and inaccurate assessments, there is limited empirical evidence to justify or demonstrate the challenge or issue that existed in the previous evaluation benchmarks. The lack of empirical evidence makes it hard to assess the innovation quality. 
4. Except for collecting the instruction-tune training data with reasoning explainability, it is unclear how this proposal can address the previous issue of lacking a reliable explanation about jailbreak behaviors.
5. The organization and presentation of the current version are not good, although the reviewer can be impressed by various contributions to the direction of research. It could be better if the author could significantly improve the presentation with clear problem illustration and state the rationality of the proposed evaluation framework.

Meta-review: This paper proposes a comprehensive jailbreak judge benchmark with a multi-agent enhanced explanation evaluation framework, motivated by the challenge of existing evaluation methods lacking explainability and generalization to complex scenarios. To address the previous issues, the JAILJUDGE dataset comprises over 35k+ instruction-tune training data with reasoning explainability and test data with 4.5k+ broad risk scenarios and 6k+ multilingual scenarios. To provide reasoning explanations and fine-grained evaluations, this work also proposes a multi-agent jailbreak judge framework to enhance the evaluation quality with explicit interpretation. With the instruction-tuned model, an attacker-agnostic enhancer and a safety moderation defense method are designed based on the reliable evaluation benchmark. Comprehensive experiments are presented to evaluate the effectiveness of the proposed methods. However, there are several points to be further improved. For example, the methodology or mechanism innovation is limited although the primary area of this work is dataset and benchmarks. In general, the difference between this work from the previous jailbreak judge benchmark or methods is not significant according to the summarization of Table 1. Specifically, compared with WildGuard, JAILJUDGE incorporates multilingual languages; while at the method aspect, the differences are mainly on the open source model and data. The claimed contributions are overwhelming but not clearly compared with the previous research works in each aspect (e.g., the jailbreak evaluation benchmark, the jailbreak attack, the jailbreak defense, and the explanation ability of LLM), which makes it hard for readers or reviewers to find a unique fundamental innovation of the benchmark with the proposed attack and defense methods although they are comprehensive. Moreover, there are concerns about the quality of the underlying dataset of vanilla prompts that can be addressed by more detailed discussions of quality metrics for the human annotation process and expert relabeling of conversations. Manual inspection of the anonymized dataset reveals that several prompts are not complete sentences and it is not clear that many of them would truly violate the MLCommons line. For example, some prompts solicit instructions on building a gambling website. Besides, the organization and presentation of the current version are not good, although the reviewer can be impressed by various contributions to the direction of research. It could be better if the author could significantly improve the presentation with clear problem illustration and state the rationality of the proposed evaluation framework. Therefore, this paper cannot be accepted at ICLR this time, but the enhanced version is highly encouraged to submit other top-tier venues.

Decision: Reject