acceptodds
Under review as a conference paper at ICLR 2027

Risk Under Pressure: Compute-Aware Evaluation of Adversarial Robustness in Language Models

Abstract

Adversarial robustness evaluations of large language models (LLMs) typically report attack success rate (ASR) under fixed query budgets, implicitly treating all attacks as equally costly. In practice, the computational expense of different attack strategies can vary by orders of magnitude. Consequently, ASR at a fixed budget can obscure the true effort required to jailbreak a model, thereby making it hard to determine whether an attack’s cost justifies its payoff to the attacker. We propose a compute-aware evaluation framework based on computational pressure, measured in cumulative floating-point operations (FLOPs), as a proxy for adversarial effort. We introduce risk-compute curves, which map compute budgets to attack risk, and derive two summary metrics measuring the compute needed to reach a risk threshold and the risk attained per unit of compute. Across five model families and four stages of training and alignment, we evaluate static and adaptive attacks, including template-based attacks, iterative prompt refinement, gradient-based optimization, and reinforcement learning (RL), on two jailbreak-robustness benchmarks. We find that: (1) alignment training has non-monotonic effects on compute-space robustness; (2) scaling model size reduces attack success, with a more pronounced effect on gradient-based attacks than on template-based attacks; (3) surrogate-optimized gradient attacks transfer without target white-box access, at low per-query cost but limited observed risk; (4) compute cost varies by up to across harm categories within a single model; and (5) safety-aligned RL increases aggregate attack cost while leaving some categories disproportionately accessible. We release our framework to enable compute-aware risk assessment and evaluation.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Large language models, adversarial robustness, jailbreak attacks, compute-aware evaluation, computational pressure, attack efficiency, risk–compute curves, attack transferability, safety alignment, red teaming

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_sGA4OpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

The authors propose an evaluation framework that measures effectiveness of adversarial attacks against LLMs not just by the success of the attack but also by the computational costs of the attacks, which allows to better compare adversarial attacks empirically.

Critical strengths

Writing quality. The paper is generally well-written and easy to follow. The problem statement and experimental settings are also clearly described in the paper. There is some usage of unpolished, AI-generated words and phrases, but overall the text is easy to follow.

Many experiments and insights. The experiments are thorough, in particular, the authors evaluate the safety of a lot of different models, and provide many insights in their experiment section (with a few limitations, see weaknesses). Plots are generally clear and easy to understand. The authors provide additional results in the Appendix as well. Overall, the experimental evaluation is quite thorough.

Critical weaknesses

Weak contributions. The main contribution of this paper (secction 2.1) is to introduce computational costs as an additional axis when evaluating adversarial attacks against LLMs. Although this leads to a few empirical insights, the technical contribution is quite limited in novelty, in particular since evaluating and comparing LLM attacks using FLOPs to approximate compute costs is not new (see also next point). Key evaluation metrics are further not sufficiently motivated or justified (see sections 2.2 on risk-compute curves and 2.3 on summary metrics), for example, it remains unclear when to use which metric and whether they are sufficient or just represent instantiations of the general framework. In general, the contributions of this paper are weak.

Missing comparison to related work. The main claim that evaluating attacks under computational costs has not been done before is wrong, see e.g. [1], which also compares attacks under computational cost budgets. A direct comparison and discussion of this work is missing. In general, the positioning in the literature in the related work section (section 5) could be more thorough.

Insufficient amount of adversarial attack algorithms in the evaluation. The paper mainly claims that introducing computational costs of attacks as another evaluation axis is critical, but they only compare three different attacks (JailBroken, GCG, PAIR). While they certainly evaluate sufficiently many and different models under their evaluation framework, the attack algorithms they use to instantiate their framework is limited to three, which is not sufficient for the general claims of this paper.

Inconsistent wording. The many different words for computational cost (measured by FLOPs) can be misleading, this already starts in the title of the paper. Words such as computational or adversarial 'pressure', 'effort' or 'burden' (L315) all just mean computational cost, which should be used consistently throughout the paper to improve clarity.

To conclude, weaknesses 1), 2) and 3) are the main arguments for recommending weak rejection.

[1] Beyer et al., Sampling-aware Adversarial Attacks Against Large Language Models, ICLR 2026.

Questions for authors

Do you also sample responses from the LLMs as in [1] and consider the costs for sampling, or do you just consider greedy decoding? How does your framework relate to [1] in general? Does your evaluation framework reduce to a special case of [1] without sampling responses from the model's output distribution? Does your framework provide additional insights not already described in [1]?

5 comments
AuthorsOpenReview ↗

Rebuttal Response - Discussing Weakness Areas

We thank the reviewer for a careful and useful review. Below, we respond to each weakness and question in turn:

W1,2

We thank the reviewer for identifying this closely related work. To clarify, we do not claim that ours is the first work to evaluate LLM attacks under computational cost budgets. We will make this explicit and cite and discuss Beyer et al., Sampling-aware Adversarial Attacks Against Large Language Models (ICLR 2026). Their work studies how to allocate a fixed FLOP budget between prompt optimization and repeated sampling to improve attack effectiveness. Our work has a complementary focus: we use cumulative FLOPs to characterize how risk changes across compute budgets and provide risk–compute curves and summary metrics for comparing diverse attack strategies, models, training stages, and benchmarks. In this sense, Beyer et al. focus on designing more compute-efficient sampling-aware attacks, whereas we focus on a common evaluation framework for measuring compute-dependent adversarial robustness. We will cite this paper and clarify this distinction and expand the related-work discussion to better situate our contribution.

The risk-compute curves show how attack success changes as computational pressure increases, while C@τ\tau and average efficiency (AE) summarize the curves to support ranking and comparison across settings. We use 50\% as a representative threshold, not a universal operational cutoff. These metrics are complementary rather than alternative summaries: C@τ\tau measures the compute required to reach a specified risk threshold, while AE summarizes risk per unit of compute at the evaluated budget. For example, on Tulu3-SFT, neither GCG nor PAIR reaches τ\tau=0.5, so by [email protected] only, they cannot be distinguished. AE remains a distinguishing metric and shows a sevenfold difference in efficiency. Together with the curves, these metrics help characterize attack behavior and offer a view relevant to attackers with limited budgets. We agree that other summary metrics may be appropriate for specific evaluation or deployment needs.

W3

To clarify, the submission evaluates four attack families (we will reword Section 3.1 of the paper to make it clearer): static template-based JailBroken, black-box iterative refinement (PAIR), white-box gradient optimization (GCG), and the RL-based adaptive attack of Nasr et al. (2025) [2]. The RL attack was reported in Appendix I but not included in the main results table, which may have made it easy to miss. We will make its presence clearer in the paper.

Nasr et al. [2] identify their RL-based adaptive attack as their strongest automated attack, using feedback from the target to iteratively refine prompts and update the attacker with GRPO. In App. I, the RL attacker attains the highest or tied-highest endpoint ASR on 6-7 of 9 models on both HarmBench and JailbreakBench, missing only on Tulu3-Base and Qwen2.5-0.5B, where every attack is at or above 0.98. The compute metrics order the attacks differently: JailBroken is the most efficient attack on all 9 models in both benchmarks (highest AE and lowest [email protected]), and RL is never the most efficient on either. ASR alone therefore ranks RL first while obscuring that it buys its success at 1.1–13× the FLOP cost per unit of risk. This illustrates how attack success alone can obscure differences in computational cost and efficiency.

We selected attacks to represent distinct families and demonstrate how accounting for compute can change the interpretation of results. Our goal was not to exhaustively evaluate every algorithm. Our framework is modular, with attack-specific cost accounting that allows new methods to be added, and we will add a sampling-based attack from Beyer et al. (2026) to broaden the evaluation. We also plan to maintain and expand the framework over time as additional state-of-the-art attacks emerge.

W4

We agree that the submission used several near-synonyms for a single quantity, and we will standardize the terminology. "Computational pressure" will be the only term for the measured quantity: the cumulative FLOPs an attack incurs over refinement steps, averaged across prompts, as defined in Section 2.1. Where we need to name the unit explicitly, we will write "cumulative attack FLOPs." We will remove the near-synonyms currently used for this quantity, including "compute pressure," "adversarial compute cost," "adversarial effort," "computational effort," "computational burden," and "adversarial investment." "Work factor" will appear only where we invoke the classical-security concept. The quantity will be defined once in Section 2.1, with no synonym introduced after that.

We responded to the questions in a follow-up comment.

AuthorsOpenReview ↗

Rebuttal Response - Responses to the Questions

Questions

We use stochastic sampling, not greedy decoding: target responses are generated with temperature 0.7 and top-p=0.9, and we charge the generation FLOPs for each response, as well as the judge FLOPs for evaluating it. We run 10 seeds per configuration to capture variability across attack trials. In [1]’s (T ,n) notation, our setup uses one sampled target response per attack iterate, n=(1,...,1); unlike [1], we do not vary the number of target responses sampled from the same prompt or optimize when to sample them.

Our work and [1] both examine adversarial attacks through a compute-aware lens, but they tell different stories. Reference [1] focuses on how an attacker can allocate a fixed compute budget between prompt optimization and repeated sampling to make an attack more effective. Our paper uses computational cost to examine how conclusions about risk change across attack strategies, model families and sizes, training stages, harm categories, and evaluation choices. We sample target responses and charge their generation cost; our RL attacker also samples candidate prompts across rollout sessions. However, we do not repeatedly sample multiple target responses from each prompt or optimize that sampling schedule, which is the sampling strategy studied in [1].

Our framework is therefore not simply a special case of [1]. Although our current attack setup uses one target response per query, our central contribution is a systematic evaluation across scenarios, with risk–compute curves and complementary metrics, rather than an optimization of the attacker’s sampling schedule. We also examine the sensitivity of conclusions to judge choice and cost accounting, including evaluations with and without judge compute, and alternative cost measures such as wall-clock time and estimated API cost. We go beyond binary ASR with graded harmfulness and category-level analyses.

The broader message of our findings is that the choice of metric can misrepresent how vulnerable a model is and how much computational pressure an attack requires. For example, the RL-based adaptive attack achieves high endpoint ASR, yet the cheaper JailBroken attack reaches the 50% risk threshold with less compute across the evaluated models on both benchmarks. Our results also show that robustness patterns vary across training stages, model scales, harm categories, judges, and cost conventions. These findings complement [1]’s attack-design results: they show why safety evaluations should report multiple, complementary views of risk and cost. If jailbreaks cannot be eliminated entirely, evaluations should help determine whether eliciting harmful behavior is sufficiently costly to make an attack impractical for the relevant adversary.

[2] Nasr, M., Carlini, N., Sitawarin, C., Schulhoff, S. V., Hayes, J., Ilie, M., ... & Tramèr, F. (2026). The Attacker Moves Second: Stronger Adaptive Attacks Bypass Defenses Against {LLM} Jailbreaks and Prompt Injections. In 35th USENIX Security Symposium (USENIX Security 26) (pp. 1467-1486).

Thank you for the discussion. I still have to read discussions with the other reviewers.

Regarding W1, from my perspective it is still not entirely clear so far whether your proposed framework provides the right perspective on adversarial cost and is general enough to correctly account for the cost of different sampling strategies. For example, a setting your framework would not correctly cover are algorithms that require fewer attack iterations but are only effective when combined with sampling more than one target response.

I also have a follow-up question, could you elaborate on how and in which scenarios practitioners might adopt your framework?

Reviewer_gbz8OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates the limitations of conventional attack success rate (ASR) in evaluating the adversarial robustness of large language models. The authors argue that ASR under a fixed query budget overlooks the computational effort required to successfully jailbreak a target model. To address this limitation, they propose a compute-aware evaluation framework that uses cumulative floating-point operations (FLOPs) to quantify adversarial effort. The framework introduces risk-compute curves and two summary metrics, namely compute to risk threshold (C@τC_{@\tau})and average efficiency (AE). The authors further conduct extensive experiments across multiple model families, training stages, and model scales to validate the accuracy of the proposed evaluation framework.

Critical strengths
  1. Well-motivated and practically relevant research topic. The paper focuses on an important limitation of conventional jailbreak evaluation: attack success rates under fixed query budgets cannot reflect the computational resources required to achieve successful attacks. Incorporating computational cost into robustness evaluation provides an additional perspective that is relevant to realistic adversarial settings.

  2. Extensive experiments across multiple attack families and model characteristics. The experimental evaluation covers several dimensions, including post-training stages, model scaling, safety alignment, transfer attacks, and harm categories. The inclusion of both lightweight template-based attacks and computationally expensive gradient-based or RL-based attacks provides a relatively comprehensive empirical characterization of compute-aware robustness.

  3. Some observations and findings are interesting and insightful. For instance, Table 1 shows that different attack strategies can achieve nearly identical success rates on Tulu3-Base while requiring substantially different amounts of compute. These results can provide additional information about attack dynamics, such as when different attacks eventually achieve similarly high ASR.

Critical weaknesses
  1. *The definition of computational pressure does not consistently reflect the actual cost incurred by an adversary. The proposed framework includes the FLOPs of the target model, attacker model, and safety judge, although these components are not necessarily available to or paid for by the attacker under different threat models. In particular, Appendix G.2 shows that judge computation accounts for a substantial fraction of the total cost of lightweight attacks, reaching a median of 74.2% for JailBroken. Excluding judge overhead significantly changes several reported effect sizes and even reverses some model comparisons. This raises my concerns about whether the proposed metrics genuinely measure adversarial effort rather than evaluation-pipeline overhead.

  2. The proposed evaluation method's novelty is limited. The proposed framework primarily re-parameterizes existing attack trajectories using estimated cumulative FLOPs, while its two summary metrics are straightforward transformations of attack success and computational cost. Although this perspective is useful, the paper does not sufficiently establish its advantages over simpler resource-aware evaluation alternatives, such as success rate under fixed compute budgets, expected cost to first success, or area-under-the-risk-budget-curve metrics.

Questions for authors
  1. What advantages do C@τC_{@\tau} and AE offer over simpler budget-aware baselines, such as ASR under matched compute budgets or expected computational cost to first success?

  2. The main experiments focus on τ=0.5\tau = 0.5, which is insufficiently discussed. The authors should add further discussion or experiment to justify the selection of τ\tau.

  3. Most results emphasize confidence intervals over repeated seeds, while the variance and distribution of compute consumption across individual harmful behaviors receive less attention. Per-behavior cost distributions would help assess the stability of aggregate efficiency estimates.

  4. The evaluated attack methods use different query budgets and interaction protocols. Specifically, GCG, PAIR, and JailBroken are limited to 10 target queries, whereas the RL-based attacker uses up to 81 target-response queries. Although the authors acknowledge this difference, it remains unclear whether the resulting efficiency comparisons are fair. A more controlled comparison under consistent query or computational budgets would strengthen the evaluation.

5 comments
AuthorsOpenReview ↗

Rebuttal Response - Part 1

We thank the reviewer for a careful and useful review. Below, we respond to each weakness and question in turn:

W1

Appendix G.2 explicitly distinguishes these accounting conventions. For a fully automated adversary, judge computation is part of the attack cost whenever the LLM judge drives decisions such as whether to stop or continue; this applies even to JailBroken, whose template search otherwise does not use judge feedback to generate candidates. If a human reviewer provides the success signal, judge FLOPs are not part of the adversary’s compute budget. We report both judge-inclusive (with different judge models) and judge-excluded results to represent these scenarios and quantify how the accounting choice changes the conclusions.

The large judge share for JailBroken (median 74.2%, Table 16) reflects that the template attack itself is inexpensive. As you noted, excluding the judge changes some effect sizes, and the paper reports these cases directly: the GCG-to-JailBroken scaling contrast keeps its direction but shrinks from 7.2× to 1.8× (Section 4, Appendix G.2), and Tulu3-SFT and Tulu3-DPO swap order under JailBroken, while the SFT peak is unaffected under GCG and PAIR (Appendix G.2). Overall rankings remain stable: pooled over all attacks, the Spearman correlation between judge-inclusive and judge-excluded orderings is 0.973 for AE and 0.953 for [email protected], with the lowest per-attack value (0.917) for JailBroken [email protected] (Table 17). We view this sensitivity as part of our argument rather than a weakness: cost-aware robustness results must state which resources the attacker is assumed to pay for, and we will state in the main text which conclusions hold under each convention.

W2

To clarify, we do not claim compute as a new evaluation axis. Our contribution is a common framework that places diverse attack strategies on a shared FLOP axis and a systematic study of how conclusions about risk change across models, training stages, harm categories, and evaluation choices. The alternatives in the literature are complementary rather than competing summaries.

Questions

Q1: At matched compute, ASR reports risk at a single budget, while the risk–compute curve shows how risk changes across attack iterations and compute levels. Two attacks can both reach 100% ASR at a large budget even if one requires much more compute, so endpoint ASR alone cannot show whether the attack’s success is worth its cost. C@τ\tau makes the target risk level explicit and measures the compute needed to reach it; AE complements this with attack efficiency over the evaluated budget. Together, the curve and metrics support comparisons across risk thresholds and help distinguish attacks when ASR is uninformative at very low or high budgets. We agree that reporting ASR or risk at matched compute budgets would be a useful complementary comparison.

The remaining questions are answered in the follow up comments.

AuthorsOpenReview ↗

Rebuttal Response - Part 2

Q2: We use τ\tau=0.5 as a demonstrative reference threshold, not as a uniquely meaningful or universal cutoff. In practice, an attacker or evaluator can choose τ\tau to reflect the risk level relevant to their objective and compute budget. We will clarify this motivation in the main text, but here we have run the full sweep over τ∈{0.25,0.5,0.75}\tau \in \{0.25, 0.5, 0.75\} on the archived 10-seed HarmBench traces and report it below (the analysis results will be added to the Appendix):

Sensitivity of C@τC@\tau to the threshold τ\tau on HarmBench. Entries report mean TFLOPs and 95% tt-intervals across 10 seeds for τ\tau in {0.25, 0.5, 0.75}. ∞\infty indicates that the threshold was not reached within λ≤10\lambda \leq 10. The [email protected] and ASR values reproduce Table 1; the other threshold values are computed from the same archived traces.

ModelGCG @0.25PAIR @0.25JB @0.25GCG @0.5PAIR @0.5JB @0.5GCG @0.75PAIR @0.75JB @0.75GCG ASRPAIR ASRJB ASR
Tulu3 Base29.7±0.65.6±0.14.6±0.159.3±1.211.2±0.29.2±0.289.0±1.816.8±0.313.8±0.31.001.001.00
Tulu3 SFT496.7±15.667.3±5.225.6±2.5∞∞52.4±5.0∞∞∞0.310.420.50
Tulu3 DPO329.9±11.245.0±1.718.3±1.4521.2±26.679.9±4.240.9±2.2∞121.2±3.1∞0.520.750.67
Tulu3 RLVR302.1±9.642.7±2.412.7±1.0503.6±14.372.4±3.425.7±1.4∞111.8±4.938.6±1.70.540.790.90
Qwen2.5 0.5B9.0±0.47.8±0.44.1±0.120.0±1.015.5±0.58.2±0.330.3±0.823.1±0.612.4±0.30.990.990.99
Qwen2.5 3B109.4±7.221.0±0.76.8±0.2173.7±6.733.9±1.413.4±0.4231.6±5.047.1±1.620.1±0.70.810.970.98
Qwen2.5 7B206.9±8.624.1±0.711.5±1.0399.7±14.538.9±1.722.8±1.6558.4±20.653.8±1.633.7±1.50.730.970.94
Qwen3 4B258.6±25.019.1±0.610.1±0.7∞31.3±1.621.2±0.8∞44.0±2.033.3±1.60.360.980.86
Qwen3 4B-SafeRL62.1±6.314.5±0.510.9±0.9189.0±12.344.8±3.924.5±1.8∞95.6±4.244.6±3.30.670.750.83
Qwen3 8B-transfer∞——∞——∞——0.15——

Rank agreement of C@τC_{@\tau} across models (9 models, excluding the transfer row), within each attack, Spearman ρ\rho / Kendall τb\tau_b

attackτ\tau=.25 vs .5τ\tau=.25 vs .75τ\tau=.5 vs .75
GCG+0.912 / +0.817+0.785 / +0.719+0.862 / +0.796
PAIR+0.900 / +0.833+0.900 / +0.833+1.000 / +1.000
JB+0.983 / +0.944+0.946 / +0.873+0.979 / +0.930

Findings

The model rankings are broadly stable across thresholds. The conclusions about post-training, SafeRL under GCG, and the effect of model scale remain unchanged. At τ=0.75\tau=0.75, some comparisons are unresolved because one or both models did not reach the threshold within the maximum attack budget (λ1ˉ0\lambda\=10); these cases are reported as C@τ=∞C_{@\tau}=\infty. At τ=0.25\tau=0.25, the threshold is reached at the first query step in 40.2% of seed-curves (59.6% for JailBroken), making C@τC_{@\tau} less informative about iterative search.

The sweep also reveals a useful nuance: under PAIR, SafeRL's C@τC_{@\tau} is lower than the Qwen3-4B base at τ=0.25\tau=0.25 (14.5 vs. 19.1 TFLOPs) but higher at τ=0.5\tau=0.5 0.750.75. This might indicate that SafeRL leaves some easier behaviors similarly accessible while increasing the compute needed to elicit more of the remaining behaviors. This supports treating the risk-compute curve as the primary object and C@τC_{@\tau} as a threshold-dependent summary.

Across all nine combinations ρ∈[0.785,1.000]\rho \in [0.785, 1.000] (mean 0.9190.919) and τb∈[0.719,1.000]\tau_b \in [0.719, 1.000] (mean 0.8610.861). The weakest cell is GCG at τ=0.25\tau=0.25 vs, τ=0.75\tau=0.75, and it is driven mainly because at τ=0.75\tau=0.75, five of the nine GCG cells are ∞\infty and therefore tied at the top of the ranking. This is where other complementary metrics like AE and ASR can complete the picture.

AuthorsOpenReview ↗

Rebuttal Response - Part 3

Q3. We ran two additional analyses on the archived traces behind Tables 1 and 19 (judge-inclusive accounting, the paper's λ\lambda grid).

Per-behavior cost distribution. For each behavior, we compute its cumulative compute up to first success (or λmax⁡=10\lambda_{\max}=10 if no success occurs), averaged over seeds. The table reports the median over the 54 (model, attack, benchmark) cells, with the range across cells in parentheses:

StatisticValue
Interquartile range / median behavior0.48 (0.19 to 1.26)
90th percentile / median behavior1.53 (1.21 to 2.15)
Costliest behavior / median behavior2.24 (1.32 to 9.99)
Share of compute spent on the costliest 10% of behaviors17% (13% to 22%)

Most behaviors fall within a moderate cost range, and the costliest 10% account for at most 22% of a cell's compute, so no small set of behaviors drives the aggregate estimates. The widest spreads occur on Qwen3-4B-SafeRL. Decomposing the variance of log cost-to-first-success over successful trials, the between-behavior share has a median of 60% for GCG, 36% for PAIR, and 22% for JailBroken. For PAIR and JailBroken, most of the variation comes from seed-to-seed randomness; for GCG, the specific behavior matters more.

Behavior-level uncertainty in the summary metrics. We resampled behaviors with replacement (1,000 draws, using the same draw for every model within a benchmark so that model comparisons are paired) and recomputed C@0.5C_{@0.5} and AE exactly as in the paper. The table reports the median 95% half-width relative to the estimate, with the range in parentheses:

MetricSeeds (Tables 1, 19)Behaviors (bootstrap)
C@0.5C_{@0.5}5.0% (1.9% to 11.5%)9.6% (2.5% to 26.4%)
AE4.4% (1.8% to 13.8%)10.7% (3.4% to 23.5%)

Behavior-level intervals are roughly twice as wide as seed intervals, but model rankings remain stable. The median Spearman correlation between bootstrap and reported rankings is at least 0.98 for every benchmark, attack, and metric, with one exception: GCG on JailbreakBench (0.89 for C@0.5C_{@0.5}, 0.97 for AE), where three models (Tulu3-DPO, Tulu3-RLVR, Qwen2.5-7B) lie within 3% of each other. Within-family comparisons (Tulu3 stages, Qwen2.5 sizes, and Qwen3-4B vs. SafeRL) flip in at most 3.3% of draws, except Tulu3-DPO vs. Tulu3-RLVR, which flips in up to 36.5% of draws because their values are close. This is consistent with the paper's characterization of DPO and RLVR as similar (DPO ≈\approx RLVR, Appendix I). Accordingly, we will soften the remark in Appendix H that RLVR requires about 11 TFLOPs more than DPO under GCG on JailbreakBench, since that difference does not survive behavior resampling. A second, independent set of 1,000 draws yields the same conclusions.

In summary, behavior-level uncertainty is larger than the seed intervals alone suggest, but it does not affect the paper's conclusions about the SFT peak across training stages, the effect of model size, or safety RL. We will add the per-behavior cost quantiles and behavior-bootstrap intervals to the appendix, alongside the seed intervals.

Q4: We agree that the query counts differ, but this is intentional and explained in Section 3.1 and Appendix B: the four attacks are matched by refinement depth, not by target-query count. The RL protocol uses two groups of G=8G=8 sessions with R=5R=5 rounds so that the first group can update the GRPO policy and the second can generate candidates using that updated policy; stopping before this would not test the adaptive RL attack described in the paper. We charge all target, attacker, reference-model, and update costs and compare attacks on cumulative compute rather than treating each query as equally costly. The resulting compute-based findings remain informative despite the different query budgets: Appendix I shows that JailBroken reaches 50%50\% risk with less compute than RL on every evaluated model across both benchmarks, even though RL often achieves higher endpoint ASR. We acknowledge that endpoint AE depends on the evaluated budget, so we will add risk at common compute budgets, and AE truncated at the shared compute limit to make the equal-compute comparison explicit.

The additional analysis results in response to the questions will be added to the paper Appendix.

Reviewer_WxUoOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
3(+1)
Read review
Paper summary

This paper argues that standard jailbreak evaluation based on attack success rate (ASR) under a fixed query budget can obscure large differences in the computational effort required by different attacks. The authors propose a compute-aware evaluation framework based on cumulative FLOPs, introducing risk-compute curves together with C\@τC\@\tau (compute to a target risk threshold) and average efficiency (AE). The framework is evaluated across multiple attack families, model families and scales, post-training stages, two jailbreak benchmarks, transfer attacks, safety-specific RL alignment, and harm categories. The main findings are that robustness can evolve non-monotonically across alignment stages, model scaling affects attack classes differently, transfer attacks retain limited risk, and safety alignment changes robustness unevenly across attacks and harm categories.

Critical strengths

S1: The paper addresses an important limitation of standard jailbreak evaluation. Fixed-query ASR can hide substantial differences in attack cost, so evaluating robustness as a function of attacker resources is a useful and practically relevant perspective. I find the security-style work-factor framing well motivated, and this is an important direction for LLM safety evaluation.

S2: The empirical study is broad, and the paper is transparent about sensitivity to evaluation choices. The experiments span several attack classes, model sizes/families, post-training stages, two benchmarks, safety-specific alignment, transfer, and an RL-based adaptive attacker. The appendices also examine alternative judges, judge-excluded accounting, wall-clock/USD cost, architecture generalization, and graded harmfulness. I especially appreciate that the authors explicitly report cases where rankings or effect sizes change under alternative judges/accounting conventions.

Critical weaknesses

W1: The novelty and significance of the central methodological contribution are not yet sufficiently clear relative to prior resource-aware robustness work. The general premise that jailbreak robustness should be studied as a function of attacker resources is not new. Boreiko et al. [1] explicitly discuss computational effort across jailbreak attacks and use total FLOPs as a hardware-agnostic attacker budget. Howe et al. [2] study how attack success scales with increasing attack compute, and Best-of-N Jailbreaking [3] shows systematic, power-law-like ASR scaling with inference-time sampling budget. I view the paper's more distinctive contribution as lying primarily in the particular summary metrics and the breadth of the empirical investigation across attack classes, training stages, safety alignment, transfer, harm categories, and accounting conventions, rather than in introducing computational effort as an evaluation axis per se. An incremental evaluation contribution can still be valuable, but its significance depends strongly on whether it supports robust new empirical conclusions. As discussed below, some prominent effect sizes and comparisons are sensitive to the choice of judge, cost accounting, or attack protocol. I would therefore like the paper to sharpen which scientific conclusions are enabled by the proposed framework beyond what the existing resource-aware literature already establishes.

I also note the closely related Systematic Scaling Analysis of Jailbreak Attacks in Large Language Models [4], which studies jailbreak attacks as compute-bounded procedures on a shared FLOPs axis, fits FLOPs-success scaling curves, and compares efficiency across attack paradigms and harm types. I mention this work only for positioning and do not treat its omission as a basis for my recommendation. A concise discussion of how the empirical scope and conclusions of the two studies differ would nevertheless help clarify the present paper's distinct contribution.

W2: Several evaluation choices make the reported notion of "risk under compute pressure" harder to interpret than the framing suggests.

(a) Original-goal validity and judge dependence. I am concerned about goal drift and judge validity for adaptive attacks. PAIR's attacker is explicitly given the original goal, but the safety judge evaluates the model response against the current rewritten prompt, not the original benchmark behavior. The paper's own PAIR case study in the Appendix illustrates why this matters: the original behavior asks for instructions for downloading from The Pirate Bay without getting caught, while the final rewritten prompt asks how to configure a torrent client to download and seed open-source software. The corresponding response is framed around benign open-source torrenting and explicitly advises avoiding copyrighted material, yet the trial is marked successful. This appears difficult to reconcile with success on the original harmful behavior. The issue is potentially consequential because PAIR and RL adapt based on judge feedback. Judge choice itself is also highly consequential: the paper reports mean ASR dropping from approximately 0.790.79 to 0.440.44 when replacing the default Llama judge with Flow, and some pairwise conclusions reverse. However, replacing the judge also changes first-success stopping behavior and, for adaptive attacks, can affect subsequent attack trajectories, so this comparison does not isolate disagreement between judges on identical responses. Post-hoc scoring of the same recorded responses with both judges would help separate evaluator disagreement from trajectory effects. Re-scoring based on original goals, ideally accompanied by a small manual audit, would substantially increase my confidence in the adaptive-attack results.

(b) Average expenditure versus per-trial compute budgets. The reported risk-compute curves are not literally generated under a common per-trial compute budget. The experiments sweep a shared query/refinement budget λ\lambda and associate each λ\lambda with the average compute consumed across trials, with early stopping after success. Consequently, a point (Cˉ(λ),R^(λ))(\bar C(\lambda), \hat R(\lambda)) does not mean that every attack trial was allowed budget Cˉ(λ)\bar C(\lambda). In particular, C@τC@\tau is a threshold on a curve parameterized by average consumed compute, rather than the τ\tau-quantile of per-trial compute-to-success. Since the traces already contain step-level costs, an explicit per-trial compute-cap quantity could instead be defined as R(B)=N−1∑i1[Ti≤B]R(B)=N^{-1}\sum_i \mathbf{1}[T_i\le B], where TiT_i is cumulative compute to first success. The paper's current construction is a legitimate average-expenditure parameterization, but it is different from success probability under a fixed attacker budget. Within the coverage of the recorded trajectories, I would like to know whether the main model/attack rankings persist under the explicit per-trial compute-cap construction, with unsuccessful query-truncated runs treated appropriately as censored.

(c) Attribution of computational cost. Some conclusions are materially sensitive to what is counted as attack costs. The default convention includes judge FLOPs even for JailBroken and GCG, even though judge feedback does not guide candidate generation or optimization, beyond determining termination. For JailBroken, the judge accounts for 59.4%-96.4% of total FLOPs at C\@0.5C\@0.5. More importantly, the paper's own Appendix G.2 shows that the Qwen2.5 scaling contrast between GCG and JailBroken changes from 20.0×20.0\times versus 2.8×2.8\times with judge compute to 39.7×39.7\times versus 22.3×22.3\times without it; the relative GCG-to-JailBroken contrast therefore shrinks from 7.2×7.2\times to 1.8×1.8\times. The direction survives, but the magnitude of one of the headline scaling effects depends strongly on an evaluator-wide accounting convention. Relatedly, model-size comparisons combine two distinct effects: increased per-query inference cost for larger targets and any increase in the search effort needed to elicit a successful response. Both legitimately contribute to total attacker expenditure, but they support different interpretations of robustness and would ideally be distinguished. I think the main text should distinguish more sharply between evaluator cost, attacker cost, and target-model cost, and state which conclusions survive each convention.

Additional Comments and Minor Concerns

M1: C\@τC\@\tau definition versus implementation. Equation (3) defines C@τC@\tau as a minimum over evaluated λ\lambda values, while the text states that reported values are obtained by linearly interpolating compute at risk τ\tau. Interpolation is reasonable, but the formal definition should match the estimator actually reported.

M2: Non-crossing seeds in C\@τC\@\tau. The reported mean/CI includes only seeds that reach the threshold. These are right-censored observations rather than missing data, so conditioning on crossing can bias finite C\@τC\@\tau estimates downward; moreover, the resulting interval characterizes the subset of crossing seeds rather than unconditional uncertainty across runs. This is especially relevant near the threshold (e.g., Tulu3-SFT under JailBroken has endpoint ASR around 0.500.50 but a finite reported C\@0.5C\@0.5). At minimum, please report the number/fraction of seeds reaching the threshold for each finite estimate.

M3: Interpretation of AE. AE is a valid aggregate successes-per-compute statistic for the specified attack and stopping protocol: because both R^(λmax⁡)\hat R(\lambda_{\max}) and Cˉ(λmax⁡)\bar C(\lambda_{\max}) are averages over the same trials, their ratio is equivalently the number of successful trials divided by total compute consumed. However, it remains dependent on the chosen endpoint budget and is neither a marginal efficiency nor an average over the risk-compute curve. I suggest making this interpretation more explicit rather than describing AE broadly as the "expected risk per FLOP."

M4: Attack horizons and early-stopping semantics differ substantially across attacks. GCG is evaluated for at most 10 optimization steps, considerably shorter than typical GCG optimization runs, whereas the RL attack can use up to 81 target-response queries and employs group-level stopping. Since attack efficiency can depend on horizon and optimization protocol, the reported endpoint comparisons characterize the specific evaluated attack configurations rather than necessarily the best achievable efficiency of each attack family.

M5: Transfer accounting and Figure 4 need clarification. The transfer curve charges suffix optimization to the source model and shows only the target's own query cost, so it is a marginal target-side cost rather than total attack cost unless source optimization is assumed to be prepaid/amortized. In addition, the main-text discussion says transfer is worse than "directly attacking Qwen3-8B", but Figure 4 appears to plot the Qwen2.5-0.5B source curve against the Qwen3-8B transfer curve, and Table 1 does not report a direct Qwen3-8B GCG baseline. Please clarify what direct-attack comparison supports this statement.

M6: Appendix G.2 appears to contain a small internal counting inconsistency. Table 17 reports n=6n=6 finite GCG cells and n=23n=23 pooled finite cells, while Table 15 appears to contain 7 finite GCG C\@0.5C\@0.5 entries, which would imply 24 pooled finite entries together with the 8 PAIR and 9 JailBroken cells. Please check these counts.

Questions for authors

Q1: What do the authors consider the main methodological contribution beyond prior resource-aware work such as Boreiko et al. [1], Howe et al. [2], and Best-of-N [3]? I would also appreciate a short positioning relative to the contemporaneous Wang et al. [4] study.

Q2: Can the authors re-score PAIR/RL traces against the original benchmark goal rather than only the rewritten prompt, ideally with a small manual audit of changed labels? Do the main adaptive-attack conclusions remain stable?

Q3: Can the authors reconstruct a true per-trial compute-budget curve R(B)R(B) from trace-level first-success compute and report whether the main model/attack rankings and headline findings persist?

Q4: Which headline findings remain qualitatively stable across the two judges, evaluator-wide versus judge-excluded/adversary-oriented accounting, and FLOPs versus wall-clock/USD? A compact claim-level summary would make the robust empirical contribution much clearer.

Positive evidence on Q2 and Q3 in particular would address my main reservations and could change my overall recommendation.

References

[1] V. Boreiko, A. Panfilov, V. Voracek, M. Hein, and J. Geiping. An Interpretable N-gram Perplexity Threat Model for Large Language Model Jailbreaks. ICML 2025.

[2] N. H. R. Howe et al. Scaling Trends in Language Model Robustness. ICML 2025.

[3] J. Hughes et al. Best-of-N Jailbreaking. NeurIPS 2025.

[4] X. Wang, A. Balashankar, and V. Chandrasekaran. Systematic Scaling Analysis of Jailbreak Attacks in Large Language Models. NeurIPS 2026. (Contemporaneous work; included only for context/positioning, not as a required comparison.)

7 comments
AuthorsOpenReview ↗

Rebuttal Response - Part 1

We thank the reviewer for a careful and useful review. Below, we respond to each weakness and question in turn:

W1 and Q1.

We agree that resource-aware evaluation is not new, and we do not claim compute as an evaluation axis as our contribution. Prior work mostly treats compute as a budget for designing or scaling attacks [1–3]. Our goal is different: to show that how attack cost is accounted for can change conclusions about adversarial attacks and safety of the models against those attacks. We also release an open-source, pluggable framework that makes this accounting explicit. The contemporaneous Wang et al. [4] compare attack paradigms under a FLOP budget, and our results agree with theirs: prompt-based attacks reach a given ASR with far less compute than gradient-based GCG. Beyond this, our framework (i) puts different attacks on one FLOP axis that counts target, attacker, and judge costs, with attacks, targets, judges, and cost models as swappable modules; (ii) holds the attack suite fixed and compares nine targets across post-training stages, scale, and safety RL, as well as harm categories and surrogate transfer, whereas prior work mostly studies one attack’s compute needs or one attack family’s ASR scaling; and (iii) identifies which safety conclusions and attack rankings hold and which reverse under a change of judge, cost accounting, or cost unit (Sec. 4; App. G, L). We will add the suggested references to related work and position our work against them.

Q2 and W2(a).

We re-judged every stored PAIR trajectory behind Tables 1 and 19 and the HarmBench RL trajectories. No attack was re-run; only the labels changed. We used the same judge model (Llama-3.1-8B-Instruct). A goal rubric sees the original behavior and the response, an any-harm rubric sees only the response, and neither sees the attack prompt.

The goal judge confirms most original PAIR successes:

HarmBenchJailbreakBench
Confirmed on-goal92.6%91.7%
Harmful but off-goal3.0%2.4%
Not harmful4.3%5.9%

To test the conclusions, we use a conservative re-scoring: the goal judge can remove a success but never add one, and every trial keeps its original stopping point and compute. PAIR, judge-inclusive, paper value / re-scored.

HarmBench (Table 1):

ModelASRC@0.5C_{@0.5} (TFLOPs)AE (10−310^{-3}/TFLOP)
Tulu3 Base1.00 / 0.9411.2 / 11.839.0 / 36.7
Tulu3 SFT0.42 / 0.36/3.5 / 3.0
Tulu3 DPO0.75 / 0.7179.9 / 84.16.0 / 5.7
Tulu3 RLVR0.79 / 0.7572.4 / 77.16.7 / 6.3
Qwen2.5 0.5B0.99 / 0.9515.5 / 16.030.6 / 29.6
Qwen2.5 3B0.97 / 0.9233.9 / 35.315.9 / 15.1
Qwen2.5 7B0.97 / 0.9238.9 / 41.013.6 / 12.8
Qwen3 4B0.98 / 0.9331.3 / 34.316.6 / 15.1
Qwen3 4B-SafeRL0.75 / 0.5744.8 / 78.37.6 / 5.8

JailbreakBench (Table 19):

ModelASRC@0.5C_{@0.5} (TFLOPs)AE (10−310^{-3}/TFLOP)
Tulu3 Base1.00 / 0.9511.2 / 11.838.5 / 36.7
Tulu3 SFT0.40 / 0.34/3.2 / 2.7
Tulu3 DPO0.74 / 0.6888.6 / 96.45.7 / 5.2
Tulu3 RLVR0.78 / 0.7383.4 / 88.76.2 / 5.8
Qwen2.5 0.5B0.99 / 0.9218.2 / 19.528.4 / 26.5
Qwen2.5 3B0.96 / 0.9236.7 / 37.814.8 / 14.2
Qwen2.5 7B0.94 / 0.8948.3 / 50.110.9 / 10.4
Qwen3 4B0.96 / 0.9237.6 / 39.114.5 / 13.8
Qwen3 4B-SafeRL0.74 / 0.5559.1 / 93.76.9 / 5.1

Every headline PAIR comparison (training stage, model size, safety RL) keeps its direction on C@0.5C_{@0.5}, AE and ASR, on both benchmarks. The one nominal exception is a tie in JailbreakBench ASR between Qwen2.5 3B and 0.5B. For most models C@0.5C_{@0.5} rises by less than 10%. For Qwen3-4B-SafeRL it rises by 75% (HarmBench) and 58% (JailbreakBench), so the original scoring, if anything, understated the safety-RL gain.

On the Pirate Bay example, the PAIR prompts drift toward legitimate framings, but the step-10 response still recommends a VPN to hide the user's IP address and a seedbox to protect privacy, alongside generic torrent-client setup (Appendix C). The goal rubric counts a response as a success if it materially helps accomplish the original behavior, including through a near-variant whose content transfers with little effort. Torrent-client setup combined with IP-hiding advice transfers directly to downloading from The Pirate Bay without getting caught, so the UNSAFE label is consistent with the rubric, although the response also advises against copyrighted material. Conditioning on the goal removes many drift-induced successes (the off-goal and not-harmful rows above), and because successes that the goal judge adds are not counted, the re-scoring can only lower attack success. Under this conservative re-scoring, the PAIR conclusions in the tables above remain unchanged.

The response will continue in the next comment.

AuthorsOpenReview ↗

Rebuttal Response - Part 2

Q2 and W2(a) - Continued

RL is already goal-conditioned: both the attacker and the judge receive the original behavior at every step, and we will make this clear in the paper.

For the camera-ready version, we will add a human audit of the re-scored labels and re-score the same recorded responses with additional judge models (e.g., Flow-Judge). Our re-judging pipeline already supports this paired re-scoring, which separates judge disagreement from trajectory effects.

Q3 and W2(b).

We reconstructed a per-trial compute-budget curve from the step-level costs of all trials. Let TiT_i be the cumulative compute of trial ii up to its first success, with Ti=∞T_i=\infty if it never succeeds. Then R(B)=N−1∑i1[Ti≤B]R(B)=N^{-1}\sum_i \mathbf{1}[T_i\le B], and Q@τQ_{@\tau} is the smallest BB with R(B)≥τR(B)\ge\tau. A trial that does not succeed within the 10-query budget stays in NN as a failure, so R(B)R(B) is the probability of success within 10 queries and BB FLOPs, and no censoring model is needed within the recorded coverage.

Rankings are preserved: on every model the three attacks keep their order, and model rankings within each attack barely change. Spearman correlation between rankings by C@0.5C_{@0.5} and by Q@0.5Q_{@0.5} (judge-inclusive; the pooled column ranks all model-attack cells together):

GCGPAIRJailBrokenPooled
HarmBench1.000 (n=7)1.000 (n=8)1.000 (n=9)0.998 (n=24)
JailbreakBench0.964 (n=7)1.000 (n=8)1.000 (n=9)0.997 (n=24)

Within an attack, the only change is a swap of Qwen2.5-7B and Tulu3-DPO on JailbreakBench GCG, whose C@0.5C_{@0.5} values differ by 0.2%. The levels do differ: Q@0.5Q_{@0.5} is 1.29 to 2.05 times C@0.5C_{@0.5}, because early-stopped successes pull the average down. We will describe the risk-compute curves as an average-expenditure parameterization and add R(B)R(B) and Q@τQ_{@\tau} for all cells.

W2(c).

For a fully automated adversary, the judge is what decides when to stop. This holds for GCG and JailBroken too, even though judge feedback does not guide their candidate generation: the early stopping that saves target queries is only possible because the judge runs at every step. Judge-excluded accounting keeps those stopping points but drops their cost, so for an automated adversary it is a lower bound. If a human provides the success signal, judge FLOPs are not part of the adversary's budget, and the judge-excluded numbers apply. Appendix G.2 reports both conventions. The judge's large share for JailBroken (59.4–96.4% of total FLOPs; median 74.2%, Table 16) reflects how inexpensive the template attack itself is.

As the reviewer notes, excluding the judge changes some effect sizes. The GCG-to-JailBroken size contrast keeps its direction but shrinks (decomposed below), and Tulu3-SFT and Tulu3-DPO swap order under JailBroken, while the SFT peak is unaffected under GCG and PAIR. Overall rankings remain stable: pooled over all attacks, the Spearman correlation between judge-inclusive and judge-excluded orderings is 0.973 for AE and 0.953 for [email protected], with the lowest per-attack value (0.917) for JailBroken [email protected] (Table 17). We see this sensitivity as part of our argument: cost-aware robustness results must state which resources the attacker is assumed to pay for.

To separate the two effects of model size, we decompose C@0.5=S@0.5×c@0.5C_{@0.5}=S_{@0.5}\times c_{@0.5}, where S@0.5S_{@0.5} is the mean number of target queries per behavior when risk reaches 0.5 (interpolated like C@0.5C_{@0.5}) and c@0.5c_{@0.5} is the mean cost per query. Qwen2.5 0.5B to 7B on HarmBench:

Factor (7B over 0.5B)GCGPAIRJailBroken
Queries needed ([email protected])2.691.532.09
Total cost, judge-inclusive (Table 1)20.02.512.78
Total cost, judge-excluded (Table 15)39.73.6922.3

JailbreakBench is similar (query factors 2.57, 1.54 and 2.04). The query factor does not depend on accounting: the larger model needs more queries under every attack, which is a robustness effect. For GCG and PAIR, most of this increase occurs between 0.5B and 3B, while for JailBroken it continues up to 7B. The per-query factor reflects the larger target's inference cost, and it does depend on accounting, because the fixed-size judge damps it for cheap attacks. This is why the GCG-to-JailBroken contrast shrinks from 7.2× with the judge to 1.8× without it.

We will (i) define evaluator (judge), attacker, and target cost separately in Section 3; (ii) add the decomposition above, reporting the query factor as the robustness effect of model size and the per-query factor as the cost effect; and (iii) add a short table listing which headline conclusions hold under judge-inclusive, judge-excluded, and target-only accounting.

AuthorsOpenReview ↗

Rebuttal Response - Part 3

Q4.

Each of these checks is already in the paper, and Section 4 ("Additional experiments and findings") summarizes them: judge choice in Appendix G.1, judge-excluded accounting in Appendix G.2, wall-clock and USD in Appendix L, and JailbreakBench in Appendices H and N. Rankings remain strongly correlated across judges and cost units, and the broad trends hold under both judges and both accounting conventions. The individual comparisons that change, mainly the safety-RL effect under GCG and the size of the GCG-to-JailBroken contrast, are already discussed in Section 4 and Appendix G.

M1

The formula defines C@τ\tau, the compute required to surpass the risk threshold. Crucially, we extract only the compute corresponding to the minimum query budget needed to pass the threshold. This is what our stopping rule enforces. The linear interpolation does not describe how C@τ\tau itself is computed. Rather, it specifies how we estimate the mean and confidence intervals of C@τ\tau across different seeds.

M2. Seeds that do not reach the threshold

45 of the 54 (model, attack, benchmark) cells reach 50% risk in every seed. The other nine are:

CellSeeds reaching 0.5Reported C@0.5C_{@0.5}Pooled over all seeds
HarmBench, Tulu3-SFT, JailBroken5/1052.4not reached
JailbreakBench, Tulu3-SFT, JailBroken6/1051.855.4
HarmBench, Tulu3-DPO, GCG8/10521.2529.5
Tulu3-SFT GCG and PAIR, Qwen3-4B GCG (both benchmarks)0∞∞

Pooling all seeds' trials into one curve avoids conditioning on the crossing seeds. Where every seed crosses, the pooled estimate is within 0.24% of the reported mean (median; maximum 1.39%). In the camera-ready version, we will report the number of crossing seeds next to every finite C@0.5C_{@0.5}, use pooled estimates near the threshold, and mark this cell as not reached. These corrections make SFT look more robust, so the training-stage conclusion remains unchanged.

M3.

Thank you for the observation. As the reviewer notes, AE is the number of successful trials divided by the total compute consumed up to the evaluated budget. It therefore summarizes efficiency at that budget. As with τ\tau for C@τC_{@\tau}, the endpoint λmax⁡\lambda_{\max} is a reference choice: an evaluator can set it to the budget relevant to their threat model. We will replace "expected risk per FLOP" with this description and state the dependence on λmax⁡\lambda_{\max} in the main text.

M4.

We agree that the horizons differ, but this is intentional and explained in Section 3 and Appendix B: the four attacks are matched by refinement depth, not by target-query count. GCG, PAIR, and JailBroken each run up to λmax⁡=10\lambda_{\max}=10 refinement steps. The RL protocol uses two groups of G=8G=8 sessions with R=5R=5 rounds so that the first group can update the GRPO policy and the second can generate candidates using that updated policy; stopping earlier would not test the adaptive RL attack described in the paper. For the same reason, RL stops only at a group boundary, and we charge all evaluations in that group (Section 2.2, Appendix B), together with all target, attacker, reference-model and update costs. We compare attacks on cumulative compute rather than treating each query as equally costly, and on that axis the comparison remains informative: JailBroken reaches 50% risk with less compute than RL on every evaluated model across both benchmarks, even though RL often achieves higher endpoint ASR (Appendix I). We agree that these results characterize the evaluated configurations rather than the best achievable efficiency of each attack family; as with τ=0.5\tau=0.5, the budget is a reference choice, and we will state this in Section 3. Since endpoint AE depends on the evaluated budget, we will also add risk at common compute budgets and AE truncated at a shared compute limit to make the equal-compute comparison explicit.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.