Did the LLM Answer the Question? A Semantic Reconstruction Game for Jailbreak Evaluation

Abstract: Jailbreak attacks against LLMs are evaluated using attack success rate (ASR), which depends on correctly identifying responses that fulfill prohibited requests. Existing evaluators can mistake refusals or topically related responses for successful attacks. We show that changing only the judge LLM can alter reported ASR by up to $82$ percentage points. We introduce the semantic reconstruction game, a training-free evaluator that decomposes compliance judgments into constrained semantic comparisons. Given only a response, an LLM reconstructs the request answered by its substantive content, excluding information merely repeated or refused. The game compares this reconstruction against similar decoy requests to determine whether it matches the original request, allowing abstention when neither candidate matches. Across three off-the-shelf LLM judges, the game achieves the lowest mean error against human labels among evaluated methods and reduces variation in reported ASR. It prioritizes avoiding false positives, even at the cost of missing some successful jailbreaks.

• The paper introduces a novel semantic reconstruction game to evaluate the effectiveness of jailbreak attacks on large language models (LLMs), demonstrating that conventional methods can misclassify responses due to insufficient semantic specificity.
• The game's four-stage process effectively reduces evaluator dependence and lowers the false-positive rate, notably on refusal-related responses, although it can miss semantics for confusing responses.
• Experiments show a substantial reduction in spread in reported ASR across different judges but reveal remaining challenges in multi-turn interactions and deciphering partially fulfilled requests.

Evaluation problem and central thesis

“Did the LLM Answer the Question? A Semantic Reconstruction Game for Jailbreak Evaluation” (2610.19306) addresses a methodological problem in automated jailbreak evaluation: attack success rate (ASR) is not an intrinsic property of an attack, but depends substantially on the classifier used to determine whether a response fulfilled the prohibited request. The paper argues that commonly used evaluators systematically confuse refusal, topical overlap, and substantive compliance. Consequently, they can inflate ASR and produce results that are not comparable across studies.

The paper documents two representative failure modes. Prefix matching can classify a refusal as successful merely because the response does not begin with a known refusal phrase. Conversely, a general LLM judge can classify an off-topic or defensive response as a successful jailbreak because it shares vocabulary with the harmful request. The authors report that, for I-GCG, changing only the judging LLM changes the measured ASR from $6\%$ to $88\%$, an $82$-percentage-point spread. This is a strong result: the evaluator can dominate the apparent performance of the attack itself.

The proposed solution is the semantic reconstruction game, a training-free evaluator that decomposes compliance assessment into several constrained semantic tasks. Rather than directly asking whether a response satisfies the original request, it asks what substantive request is represented by the information actually supplied in the response. It then tests that reconstruction against semantically similar but non-equivalent decoy requests. The method is designed primarily to reduce false positives, accepting false negatives as the cost of requiring stronger semantic evidence.

From direct judgment to semantic reconstruction

A direct LLM-as-a-judge formulation requires one model call to determine whether a response fulfills a request. This combines several distinct operations: interpreting the original request, identifying the response’s actual content, distinguishing substantive assistance from quotation or refusal, and comparing the two at the level of action and outcome. The paper’s methodological premise is that these operations should be separated.

The reconstruction game has four stages:

1. Response-only reconstruction: an LLM receives only the response and extracts the substantive action, information, method, or outcome that the response provides. It is explicitly instructed to exclude refusal language, contextual framing, claimed motives, and content merely mentioned or refused. If no substantive content is supplied, the reconstruction is empty and the response is immediately classified as unsuccessful.
2. Decoy generation: a second LLM generates five minimal-contrast requests from the original request. Each decoy should be topically similar but differ in the requested action, information, direction, or outcome. The decoys prevent the evaluator from treating broad topical similarity as semantic equivalence.
3. Pairwise semantic comparison: each decoy is paired with the reconstruction in randomized order. A judge receives the original request and both candidates, and selects the candidate that requests the same substantive action and outcome as the original, or abstains if neither candidate matches.
4. Majority decision: the reconstruction must win more than half of the comparisons to yield a jailbreak verdict. Abstention counts against the reconstruction, making insufficiently informative responses unsuccessful.

This decomposition operationalizes a distinction that is often blurred in jailbreak evaluation: a response can discuss a harmful request without carrying it out, or can be related to the request without providing the requested information. The comparison prompts therefore distinguish, for example, causing harm from preventing harm, attacking a compromised system from investigating it, and executing harmful text from editing or analyzing that text.

The method is related to backtranslation and prompt inversion, but its objective is different. Backtranslation methods infer a likely prompt from a response to expose hidden intent or defend against jailbreaks [Wang et al., 2024]. Prompt inversion studies recover information about prompts from model behavior [Morris et al., 2024]. Here, reconstruction is not intended to recover the original wording or hidden context. It is intended to determine whether the response supplied the substantive content requested.

Formal analysis

The theoretical analysis separates three quantities: semantic recoverability, information leakage, and harmful fulfillment. This separation is important because the reconstruction game does not directly observe whether a harmful action was fulfilled.

The paper models a semantic prompt class $X$, a response $Y$ generated by the target model, and a reconstructed prompt $\hat{X}$ generated from the response. A reconstruction is correct when it belongs to the same semantic class as the original request. The comparison game produces a reconstruction win rate $q$. If $p_1$ is the probability that the reconstruction wins when it is semantically correct, and $p_0$ is the corresponding probability when it is incorrect, the paper derives the calibration identity

$q=p_1(1-P_e)+p_0P_e,$

where $88\%$0 is the semantic reconstruction error probability. When $88\%$1, the correct-reconstruction rate is recoverable from the observed game score:

$88\%$2

The condition $88\%$3 is substantive rather than automatic. If the comparison judge is equally likely to select the reconstruction whether or not it is correct, the game score contains no information about reconstruction quality. Thus, the analysis requires the semantic comparator to discriminate correct from incorrect reconstructions.

Using the Markov chain $88\%$4 and Fano’s inequality, the paper establishes that sufficiently accurate reconstruction implies nonzero semantic information leakage from the prompt to the response. In particular, if reconstruction exceeds the best strategy based only on the prior distribution over prompts, the response must contain information about the original request. This result formalizes the intuition that a response which reliably identifies the requested action cannot be semantically independent of that request.

The authors explicitly reject an equivalence between information leakage and harmful fulfillment. A detailed refusal can reveal the harmful request while providing no harmful assistance. Conversely, a partial harmful answer may provide useful information without allowing the complete request to be reconstructed. To bridge the two quantities, the paper introduces a fulfillment–recoverability assumption. The parameter $88\%$5 bounds the probability that a genuinely fulfilling response fails to reveal enough information for reconstruction; $88\%$6 bounds the probability that a non-fulfilling response nevertheless reveals the request.

Under this assumption, the true ASR $88\%$7 is bounded by the adjusted reconstruction rate $88\%$8:

$88\%$9

When $82$0, reconstruction exactly measures harmful fulfillment. The practical interpretation is asymmetric. Small $82$1 means that refusals and deflections rarely generate false positives. Large $82$2 means that incomplete successful jailbreaks are often missed. The theory therefore predicts the empirical behavior observed later: the method should be conservative, with errors concentrated among false negatives rather than false positives.

The formal results depend on idealized assumptions, including a finite semantic prompt space, a perfect semantic-equivalence oracle in the analysis, and a comparator whose accuracy is higher on correct than incorrect reconstructions. These assumptions are not satisfied literally by deployed LLM judges; their empirical evaluation is therefore essential to the paper’s claims.

Experimental design

The experiments use three off-the-shelf judge models: Qwen 3.5 9B, Ministral 3 8B, and Gemma 4 12B. The baselines are prefix matching, a vanilla binary LLM judge, and the StrongREJECT rubric-based evaluator. The authors do not compare against fine-tuned classifiers such as HarmBench’s classifier because those systems are trained on the human-labeled test responses under evaluation.

Three datasets and evaluation settings are used. First, the authors examine response categories in SorryBENCH, including generic refusals, specific refusals, refusals with safe alternatives, incoherent responses, incomplete harmful responses, and substantive harmful responses. Second, they compare evaluator outputs with human labels from StrongREJECT and HarmBench. Third, they measure the ASRs of PAIR, PAP, I-GCG, SlotGCG, and HERETIC under different evaluation models.

The paper uses mean absolute error (MAE) for graded outputs and F1 for binary jailbreak classification. This distinction matters because MAE can favor conservative classifiers when positive examples are rare. The authors therefore report F1 alongside MAE, particularly on StrongREJECT, where only $82$3 of responses are labeled successful, and HarmBench, where the positive rate is $82$4.

Failure modes across response categories

The reconstruction game performs especially well on non-fulfilling responses. On generic refusals, its mean MAE is $82$5 across the three judges. On specific refusals and refusals with safe alternatives, mean MAE is $82$6 and $82$7, respectively. By contrast, StrongREJECT has mean MAE of approximately $82$8 on each refusal category because its graded rubric assigns nonzero scores to refusals, while the vanilla LLM judge has mean MAE between $82$9 and $X$0.

The result directly supports the paper’s central claim: decomposing the task into substantive-content extraction and contrastive semantic comparison is effective at preventing refusal-related false positives. The game rarely mistakes safe alternatives or explicit refusals for harmful compliance. This property is operationally important because refusal inflation can substantially distort ASR.

The method is less effective on incoherent responses. Its mean MAE is $X$1, compared with $X$2 for the vanilla LLM judge. The authors attribute this to the fact that some incoherent responses still reveal enough of the original request to produce a misleading reconstruction. This is a concrete case where the game’s semantic-recoverability objective does not perfectly track human judgments of fulfillment.

The largest errors occur on responses that genuinely fulfill the request. For incomplete responses, the reconstruction game’s mean MAE is $X$3, compared with $X$4 for the vanilla judge and $X$5 for StrongREJECT. For substantive responses, the corresponding values are $X$6, $X$7, and $X$8. Although the game improves over the baselines on average, these error rates remain high. The paper identifies unrecoverability, rather than semantic comparison, as the dominant source of error: many successful responses provide too little information to reconstruct the original harmful request.

The estimated fulfillment–recoverability gaps make this asymmetry explicit. For incomplete responses, mean $X$9 is $Y$0; for substantive responses, it is $Y$1. By contrast, mean $Y$2 is $Y$3 for generic refusals and approximately $Y$4 for specific refusals. The game therefore has a low false-positive gap for refusals but a substantial false-negative gap for fulfilling responses. Its conservatism is not merely a thresholding choice; it follows from the information requirements imposed by reconstruction.

Agreement with human labels

On StrongREJECT, the reconstruction game obtains a mean MAE of $Y$5, compared with $Y$6 for the vanilla LLM judge and $Y$7 for the StrongREJECT rubric used as a graded evaluator. Its MAE spread across the three judges is only $Y$8, compared with $Y$9 for the vanilla judge and $\hat{X}$0 for the rubric.

The F1 results show that this improvement is not solely an artifact of class imbalance. The reconstruction game achieves F1 values between $\hat{X}$1 and $\hat{X}$2, whereas StrongREJECT obtains $\hat{X}$3–$\hat{X}$4 and the vanilla judge ranges from $\hat{X}$5 to $0.58. The corresponding confusion counts show a relatively balanced tradeoff: the game produces substantially more true positives than the rubric, while maintaining materially lower false-positive rates than prefix matching.

On HarmBench, the reconstruction game achieves mean MAE $\hat{X}$6, compared with $\hat{X}$7 for the vanilla judge and $\hat{X}$8 for StrongREJECT. Its F1 range is $\hat{X}$9–$q$0, while the vanilla judge ranges from $q$1 to $q$20.74$ on this benchmark, but its performance is not robust across response categories and depends on refusal-style regularities rather than semantic fulfillment.

The cross-model variation is not eliminated. On HarmBench, the reconstruction game’s MAE ranges from $q$3 with Gemma to $q$4 with Ministral, and its F1 ranges from $q$5 to $0.792. Nevertheless, the method’s lower average error and comparatively stable behavior support the claim that task decomposition reduces, rather than removes, evaluator dependence.

Effect on reported attack success rates

The attack-level experiments provide the clearest evidence that evaluator choice can alter scientific conclusions. For PAIR, the reconstruction game reports ASRs of $q$6, $q$7, and $q$8 with Qwen, Ministral, and Gemma, respectively, for a $q$9-point spread. The vanilla judge reports $p_1$0, $p_1$1, and $p_1$2, producing a $p_1$3-point spread. StrongREJECT has a $p_1$4-point spread.

For PAP, the reconstruction game reduces the spread to $p_1$5 points, compared with $p_1$6 points for the vanilla judge and $p_1$7 points for StrongREJECT. For I-GCG, the spread falls from $p_1$8 points under the vanilla judge to $p_1$9 points under the reconstruction game. For SlotGCG, it falls from $p_0$0 to $p_0$1 points. These reductions are substantial, although the remaining $p_0$2–$p_0$3 point spreads show that the proposed method does not provide evaluator invariance.

The reconstruction game also reports a lower ASR than the other evaluators for every attack and judge combination in the main experiments. For I-GCG, it reports $p_0$4–$p_0$5, compared with $p_0$6–$p_0$7 for the vanilla judge and $p_0$8–$p_0$9 for StrongREJECT. For SlotGCG, it reports $q=p_1(1-P_e)+p_0P_e,$0–$q=p_1(1-P_e)+p_0P_e,$1, compared with $q=p_1(1-P_e)+p_0P_e,$2–$q=p_1(1-P_e)+p_0P_e,$3 for the vanilla judge. These lower scores are consistent with the method’s intended bias toward avoiding false positives, but they should not be interpreted automatically as more accurate attack estimates because the method’s high $q=p_1(1-P_e)+p_0P_e,$4 can cause it to miss partial or incomplete jailbreaks.

HERETIC exposes an additional complication. Here, the target model varies rather than the evaluator, and the reconstruction game reports ASRs from $q=p_1(1-P_e)+p_0P_e,$5 to $q=p_1(1-P_e)+p_0P_e,$6, a $q=p_1(1-P_e)+p_0P_e,$7-point spread. Prefix matching has a much smaller $q=p_1(1-P_e)+p_0P_e,$8-point spread, but this result is not evidence that prefix matching is generally superior: the target models and response distributions differ, and prefix matching is known to fail on refusals that do not follow standard prefixes. The HERETIC results instead demonstrate that evaluator stability depends on the attack and target-model regime.

The decoy ablation further clarifies the precision–recall tradeoff. Degrading decoys generally increases the true-positive rate, by as much as $q=p_1(1-P_e)+p_0P_e,$9 for Ministral on HarmBench, but also increases false-positive rates on some benchmarks. On SorryBENCH, false-positive rates remain between $88\%$00 and $88\%$01 across degradation levels, whereas on StrongREJECT they rise by as much as $88\%$02. Decoy quality therefore controls the conservatism of the game: stronger decoys make successful reconstruction harder and reduce false positives, while weaker decoys recover more positives at the cost of less reliable rejection.

Limitations and open questions

The empirical scope is restricted to relatively small judge models of 8–12 billion parameters and target models sufficiently small to permit gradient-based attacks and abliteration. Whether the reconstruction game retains its calibration and lower false-positive rate with larger frontier judges and targets remains untested.

The method evaluates only final, single-turn responses. Its assumptions may fail for multi-turn jailbreaks, chain-of-thought traces, tool-mediated interactions, and multi-agent settings, where harmful fulfillment may be distributed across several responses and no individual response contains enough information for reconstruction. The method may consequently classify a successful interaction as unsuccessful when the relevant semantic content is temporally dispersed.

The decoy study varies word corruption but does not systematically vary the number of decoys, decoy-generation models, sampling temperature, or decoy semantic distance. Since decoy quality directly controls the false-positive/false-negative tradeoff, these factors require more rigorous characterization. The paper also does not report human inter-annotator disagreement, making it difficult to determine how much of the residual evaluator error reflects ambiguity in the labels themselves.

Finally, the evaluator remains an LLM-based procedure and may be adversarially optimized if its score is used inside an attack loop. The reconstruction prompt, decoy generator, and pairwise comparator are all potential attack surfaces. The authors therefore appropriately state that the method should not be used alone to certify model safety.

Conclusion

The paper establishes that jailbreak ASR is highly evaluator-dependent: changing only the judging LLM can alter reported success by up to $88\%$03 percentage points. Its semantic reconstruction game replaces direct compliance judgment with response-only reconstruction, contrastive decoy generation, pairwise semantic matching, and majority voting. Across SorryBENCH, StrongREJECT, and HarmBench, it achieves the lowest mean error among the evaluated training-free methods and substantially reduces cross-judge variation in attack-level ASR.

Its principal strength is the suppression of false positives from refusals, safe alternatives, and topical but non-compliant responses. Its principal weakness is the high false-negative rate for harmful responses that do not reveal enough information to reconstruct the original request. The method is therefore best characterized as a conservative evaluator whose reliability depends on the fulfillment–recoverability gap and on the quality of its semantic decoys, not as a complete solution to jailbreak measurement.