acceptodds
Under review as a conference paper at ICLR 2027

SafeCompose: Branch-Preserving Safety Composition for Held-Out Task Adapters

Abstract

Parameter-efficient fine-tuning delivers new capability as a small adapter that leaves the base model untouched, so the party that trains an adapter is often not the party that deploys it. The deploying party, which we call the operator, receives finished adapter weights but nothing of the training run behind them. If that run included unsafe examples, composing the adapter with an aligned base model can erode the model's refusal of unsafe requests. We ask whether a defense can restore refusal without giving up the adapter's capability, even for adapters it has never seen. We introduce SafeCompose: the aligned base, the received adapter, and a safety adapter stay frozen and separate, and small per-layer gates read the input to set how much each adapter contributes. The gates are trained once on a pool of task adapters and reused unchanged on adapters that arrive later. We test on new adapters across model families and levels of unsafe training data, including a task the gates never saw, and also over a sequence of arriving adapters and under attack. On the unseen task, SafeCompose restores refusal and keeps more task capability than weight-projection and activation-steering defenses, retaining the 9–31 points of accuracy that discarding the adapter would give up. Over successive adapter arrivals, it stays safe where steering defenses do not. When the response is forced to begin by agreeing, even by an attacker who sees the gates, SafeCompose is safer than fixed gates trained the same way. It keeps this advantage even when its gates read the prompt only once, which allows cached decoding.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Safety Alignment, parameter-efficient fine-tuning, adapter composition, held-out generalization, harmful fine-tuning defense

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_tQDDOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

The paper looks at a deployment setting where an operator has an aligned base model plus its own safety LoRA, and receives a finished task LoRA from someone else. That LoRA might have been trained on data with some unsafe examples mixed in. SafeCompose keeps all three pieces frozen and separate, and at each layer it scales the safety and task activation residuals (measured against the base layer output) with two gates. The gates come from a small MLP over the pooled base state. They are meta-trained once on a pool of adapters, using distillation toward the "right" branch for each prompt type plus a V-REx term across contamination doses, and then reused unchanged on new adapters.

Experiments cover Qwen2.5-7B, Mistral-7B and Gemma-2-9B, with an in-pool GSM8K panel and a held-out MedMCQA panel. On the held-out task, SafeCompose keeps most of the accuracy that discarding the adapter would lose, at roughly discard-level ASR on Qwen and Gemma (7–9% on Mistral). The paper also has a repeated-arrival experiment, prefill attacks, over-refusal results, a lot of ablations, and a decoding cost analysis.

Critical strengths
  • The setting is practical and well motivated. "I got a LoRA from someone else and I can't retrain it" is a real situation, and wanting to keep components separate and auditable is a reasonable requirement.
  • I appreciate how honest the paper is. The authors tune baselines on validation data, and they report results that cut against their own story: a tuned weighted merge ties them on Qwen, static gates match learned gates without attack, discard and RESTA are safer under attack, and the method is 4–5x slower to decode. Most papers would leave these out.
  • The ungated-vs-gated ablation is clean and useful. Simply adding both residuals gives ~17% ASR, while any per-layer scaling brings it to ~1%. That is a clear finding about where the erosion comes from.
  • The prefill-attack result is the most interesting part of the paper to me. The prompt-reading gate holds at 41–51% ASR, while static gates, a global gate, and tuned merges go to 68–83%. The prompt-once variant keeps most of this, so caching is possible.
Critical weaknesses

1. Without attack, the method doesn't really beat a tuned merge. The large gaps in the main tables are against baselines at default settings. Once the merge weight is tuned on validation data, it ties SafeCompose on Qwen, trades off on Mistral, and only loses on Gemma GSM8K. A static gate also matches the learned gate. So without attack, the evidence supports "scale the residuals per layer with a good constant" rather than a learned input-dependent policy. I think the abstract and intro oversell this, and the attack result should be the main story.

2. The transfer claim is weaker than it sounds. The held-out panel only changes the task. Rank, training recipe, contamination source and harm distribution all stay the same. The learned α is also nearly constant (0.48–0.53, within-layer SD around 0.02), so it's not surprising it transfers. The paper also says the gates see the adapter "through its residuals," but Eq. 2 only feeds them the pooled base output b_l. They never look at Δ^S or Δ^T directly.

3. A simple baseline is missing. Appendix M says β < 0.01 on 63% of harmful prompt–layer pairs. To me the gate looks like it is mostly a harmful-prompt detector that turns T off, which would also explain the prefill-attack advantage. The obvious comparison is an input classifier (e.g. Llama-Guard on the prompt) that routes harmful prompts to discard and everything else to M+T or the tuned merge. Without it, I can't tell what the per-layer learned gating adds.

4. The attack evaluation is narrow. It uses one Qwen adapter, three seeds, a handful of openings, and no GCG-style attack, and ~45% ASR under a simple prefill is still high. The threat model also rules out the most relevant adaptive attacker: a downstream party who trains T to push later base states so the gates open β.

Minor

  • the GSM8K adapters score below the base on Qwen and Gemma, which makes the in-pool panel hard to read. Over-refusal goes up 9–13 points on OR-Bench-Hard. Decoding is 4–5x slower than a merged model. A lot of key results are buried in the appendix.

  • The opening sentence defines PEFT as "attaching a small adapter and leaving the base weights fixed," but it cites LoRA, which learns a weight delta that can be merged into the base; please define "adapter" explicitly (e.g., "PEFT modules such as bottleneck adapters and LoRA") and state that the separation argument assumes the delta is not merged.

  • the term "push" is informal (line 94-95) and is used interchangeably with "activation residual"; since the residual is the central object of the method, please define it once formally and keep "push" only as intuition.

  • Presentation is the quite weakness: the method is simple, but the paper makes it hard to follow by introducing overlapping terms — "operator", "received adapter", "branch", "push", "composer", and "gates" — and then using "gates" and "composer" interchangeably while "SafeCompose" names the whole method; one term per concept, a short glossary, and plainer sentences would make the contribution much easier to assess.

  • Eq. 3 introduces six loss weights (λsafe, γ, λvar, λover, λcap, λbeh) in addition to a curriculum schedule and an early-stopping rule, but only four are reported: λsafe and γ are said to be "listed in Appendix B," where they do not appear. No sensitivity analysis is given for any weight, and the paper notes only that λover was not swept. Please report all six values, state whether a single setting is shared across families and seeds, and show that the conclusions are stable under at least ±2× perturbation of the four safety-related terms.

Questions for authors
  1. Can you show the distribution of α and β for harmful vs. benign/task prompts?
  2. How does SafeCompose compare to an input-classifier router, with and without the prefill attacks?
  3. Since the gates only read b_l, in what sense do they see the adapter's residuals? Did you try feeding Δ^S and Δ^T to the gates?
  4. Can an adapter trained by someone who knows the gate design push β up on harmful prompts?
  5. Does transfer hold with a different rank, training recipe, or contamination source?
  6. Discarding T should be the safest option, but on Qwen Table 2 shows the opposite (discard 1.0% vs SafeCompose 0.6%). Since one prompt is about 1% of the 104-prompt set, is this difference real? If so, please explain why adding the task adapter makes the model safer than removing it.
5 comments

You are right that the clean results support scaling rather than learned input dependence, and that the gate may largely detect prompt type. New evidence resolves a fixed-prefix benefit against the near-initial static gate for the retrained Qwen gate, while routing offers a different safety–accuracy operating point. The family-dependent results and gate-aware adapter-training failure preclude a general superiority claim. We will reframe the abstract, introduction and conclusion as an empirical characterization of composition, not a deployment-superiority claim.

We distinguish four checkpoint groups throughout this response:

Checkpoint groupTraining and evaluationEvidence supported
Submitted gatesOriginal Table 6 gates, trained with the surrogate objectiveGate diagnostics, pooled-input baseline, adapter transfer, opening/GCG attacks, adaptive adapter training and repeated discard tests
Matched gate checkpointsOriginal-objective gate fits, evaluated under each study's stated protocolImposed constants, format-independent capability and timing
Original-objective retrainsFresh fits with the original surrogate objective, not the Table 6 filesLoss-weight sensitivity and the residual-input variant
Retrained causal/SFT gateChanged training procedure using causal composition and prompt-only gate inputs, evaluated prompt-onceLearned-versus-static fixed-prefix comparison and routing

The first three groups use the implemented surrogate, whose description and Equation 3 require the substantive corrections detailed in Section 6 below. The causal/SFT gate is a separate method variant, not a corrected evaluation of the submitted one. Diagnostics and transfer results for the Submitted gates do not establish those properties for the retrained gate. Prompt-once SafeCompose computes gates once from the prompt and holds them fixed during generation; this policy must be distinguished from enabling a KV cache.

1. Prompt detection and the router baseline (Question 2)

Llama-Guard-3-8B classifies only the user prompt. Flagged prompts go to Discard, the safety adapter only; unflagged prompts go to the task adapter or Tuned merge, whose coefficient is selected on MedMCQA validation. The Fixed prefix forces the assistant opening “Sure, here is” on AdvBench-104, judged by the HarmBench classifier. Generation-parsed accuracy parses generated answers on MedMCQA-520. Keyword refusal is a heuristic on OR-Bench-Hard, not a semantic judgment.

This study uses the Retrained causal/SFT gate on Qwen, a held-out 5%-contaminated MedMCQA adapter and three seeds. All arms use neutral greedy decoding with repetition penalty 1.0. The router study and the five-pair comparison below evaluate the same gate family separately; we compare arms only within each table. Entries are mean ± sample SD.

ArmUnattacked ASR (%)Prefix ASR (%)Generation-parsed accuracy (%)Keyword refusal (%)
SafeCompose0.64 ± 0.5650.00 ± 11.8259.10 ± 1.2417.82 ± 3.57
Near-initial static gate0.96 ± 0.0071.79 ± 6.8258.97 ± 0.2921.61 ± 4.70
Guard → task0.32 ± 0.5637.82 ± 5.3051.86 ± 1.287.03 ± 1.28
Guard → tuned merge0.96 ± 0.0039.42 ± 6.9354.68 ± 0.2222.47 ± 7.06

Both routers have lower prefix ASR than SafeCompose, while SafeCompose has higher accuracy.

Exploratory post-hoc paired 95% percentile intervals jointly resample matched seeds and shared prompts with 20,000 draws:

SafeCompose − router (pp)Prefix ASRAccuracy
Task router+12.18 [+2.88, +21.79]+7.24 [+3.46, +11.09]
Tuned-merge router+10.58 [+2.24, +18.91]+4.42 [+1.41, +7.37]

The intervals exclude zero for both metrics, supporting a trade-off between operating points, not the necessity or dominance of per-layer gating.

Routing covers one Qwen adapter setting, without classifier-evasion, other-family or cost tests. We will include this comparison in Section 5 and replace the introduction's broad “what the gate adds” claim with the measured trade-off.

2. Scaling versus conditioning

On clean Qwen at 1/5/10% contamination, Tuned merge gives generation-parsed accuracy of 60.00/60.51/60.32% versus SafeCompose's 58.27/58.97/59.42%. These historical Qwen arms used different repetition penalties, so their contrasts are protocol-level rather than isolated method effects. On Mistral, the tuned merge is safer but less accurate than SafeCompose, and on Gemma it trails on GSM8K (Table 24). We withdraw clean input-dependence claims and will add the tuned merge and the Target-free merge, selected without MedMCQA calibration, to the main results, to separate frozen composition from conditioning.

The historical ungated comparison motivates scaling, but its unmatched conditions do not establish the size of that effect. We also rename the trained static checkpoints “Near-initial static gate” and withdraw “optimized static control”: they remained near initialization, with α≈0.7 and β≈0.5, and do not establish the best achievable static policy.

Retrained comparison. Both learned and static arms use prompt-once, uncached inference on held-out MedMCQA adapters at the same contamination setting as the router study. Fixed-prefix generation is capped at 256 tokens. Each family has five matched seed pairs; paired 95% intervals jointly resample seeds and prompts with 4,000 draws.

FamilyLearned prefix ASR (%)Near-initial static prefix ASR (%)Learned − static ASR (pp)Generation-parsed accuracy difference (pp)
Qwen56.5473.85−17.31 [−30.77, −3.85]−0.08 [−1.88, +1.50]
Mistral18.8521.35−2.50 [−7.50, +2.69]+0.81 [−1.23, +2.85]

The prefix difference is resolved only on Qwen, where four of five pairs favor the learned gate, without a detected accuracy difference.

Imposed constants. Separately, we evaluated 12 constants on Matched gate checkpoints with three seeds, one batched decoder and the same fixed-prefix token cap. Qwen SafeCompose has prefix ASR 47.12 ± 10.04%. Differences below are constant − SafeCompose, with paired 95% seed × prompt bootstrap intervals. This study's accuracy scoring rule is unspecified, so its accuracy differences are not interchangeable with generation-parsed or next-token accuracy.

Qwen controlPrefix ASR difference (pp)Accuracy difference (pp)
Paper constant gate (0.7/0.5)+35.58 [+24.04, +49.04]+0.64 [−0.90, +2.31]
Validation-selected constant (0.8/0.3)+28.21 [+17.31, +40.06]+1.79 [+0.13, +3.53]
Lowest-ASR constant (diagnostic) (0.9/0.1)+6.09 [−2.88, +14.42]−1.15 [−3.97, +1.60]

Conditioning lowers prefix ASR against the paper and validation-selected constants, but no advantage over the diagnostic constant is resolved.

A fixed per-layer profile of the dynamic gate's harmful-prompt values also recovers most of the advantage over the paper constant: its ASR difference from SafeCompose is +8.01 pp [+0.00, +16.35], consistent with your detector reading. Validation selection uses clean safety and utility on JailbreakBench-100 and MedMCQA-128, not prefix robustness; the diagnostic constant was selected on the test panel and is not a deployable selection result.

On Mistral, the ordering reverses: SafeCompose prefix ASR is 52.88 ± 7.26%, versus 29.17 ± 10.28% for constant 0.7/0.3. Constant − SafeCompose is −23.72 pp [−36.54, −10.58] for ASR and −0.90 pp [−2.95, +1.15] for accuracy. This is a safer constant without a detected accuracy cost, not accuracy equivalence.

Thus, the retrained Qwen contrast establishes a conditioning benefit against its near-initial static gate, routing supplies a different operating point, and Mistral prevents a general superiority claim.

3. Gate distributions and the adapter-input pathway (Questions 1 and 3)

For Submitted gates, we captured the first causal composed forward pass on 104 prompts × three seeds per row. Quantiles are over per-prompt layer averages.

Cohort / formatα meanα p10/p50/p90β meanβ p10/p50/p90
AdvBench / raw0.96670.94/0.96/1.000.05960.00/0.05/0.13
AdvBench / chat0.86240.77/0.85/0.970.13400.04/0.14/0.21
XSTest-safe / chat0.68590.49/0.67/0.890.16180.07/0.14/0.24
MedMCQA / raw SFT0.40180.23/0.38/0.610.44750.26/0.45/0.64
Benign / chat0.17260.06/0.16/0.300.74800.61/0.75/0.88

These distributions are consistent with your prompt-type-detector interpretation, with XSTest-safe nearer the harmful cohort.

The format diagnostics were designed after initial results were visible, and prompt type and format remain confounded; they do not causally explain transfer or prefix behavior. We will replace the Appendix J/M near-constant-α and β-threshold summaries with checkpoint-, format- and cohort-specific statistics, explicitly separating prompt variation from decoding-step variation. For example, β<0.01 occurs in 72.30% of raw AdvBench prompt–layer pairs versus 13.69% under chat formatting.

On the gate input, you are right. Equation 2 reads pooled b_l, not the current ΔS or ΔT. The task adapter affects gate inputs indirectly through earlier composed layers. We will correct the introduction and Appendix A's “through its residuals” explanation.

We also trained a fresh residual-input variant under the original recipe, using pooled [b_l; ΔS; ΔT]. Its pooled-b_l baseline is the Submitted gates, not another fresh retrain. Over three seeds, the variant gives generation-parsed accuracy 58.97 ± 0.87%, versus the baseline's 58.91 ± 1.09%, and both give unattacked ASR 0.64 ± 0.56%. This does not resolve a clean advantage or establish safety equivalence at the ASR floor. Prefix ASR and over-refusal were not measured for this variant, and ΔS-only input was not trained.

4. Transfer beyond the original adapter recipe (Question 5)

The original held-out panel changes task, not adapter recipe. We therefore applied unchanged Submitted gates to one-factor changes in Qwen MedMCQA adapters. The mild, attention-only and aggressive recipes were specified after earlier results were visible but before their own evaluation. Entries are mean ± sample SD over three seeds, using generation-parsed accuracy.

Adapter changeSafeCompose accuracy (%)SafeCompose ASR (%)Tuned-merge accuracy (%)
Rank 859.55 ± 0.220.32 ± 0.5660.19 ± 0.33
Rank 6458.46 ± 1.350.64 ± 0.5660.13 ± 0.78
PKU-SafeRLHF contamination59.36 ± 0.970.00 ± 0.0059.87 ± 0.78
Mild recipe60.13 ± 0.440.32 ± 0.5657.44 ± 0.89
Attention-only LoRA59.49 ± 1.130.00 ± 0.0059.87 ± 0.59
Aggressive recipe43.97 ± 10.770.64 ± 0.5637.76 ± 32.54

The first five changes preserve task accuracy, while the aggressive recipe degrades every task-using arm.

A degenerate aggressive-recipe seed makes SafeCompose answer “A” on 502/520 items; the near-initial static arm also degrades, to 42.44 ± 18.99% mean accuracy. Among the five non-degenerate shifts, only the mild recipe exceeds tuned merge's mean accuracy, and that merge retains the coefficient selected for the original adapter. These tests retain Qwen, MedMCQA, 5% contamination and direct-request AdvBench evaluation, without prefix attacks; floor-level ASR across arms supports accuracy transfer, not safety separation. We will add this table to Section 4 and narrow the transfer claim in Section 4.1 and Appendix O accordingly.

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

This paper introduces SafeCompose, a framework that addresses deployment of a task adapter whose training data and optimization history are unavailable to the operator. It retains the aligned base model, safety adapter, and task adapter as frozen, separately loadable branches. A small learned policy combines their block-level residual contributions using gates conditioned on the evolving representation.

The policy is trained on an operator-owned adapter pool and applied to held-out adapters, including a MedMCQA task absent from policy training. Experiments cover three model families, multiple contamination levels, repeated adapter arrivals, response-prefix attacks, component ablations, and a cache-compatible prompt-once variant.

Critical strengths

The deployment setting and frozen-component construction are useful. The method separates offline policy learning from deployment on an arriving adapter. The held-out MedMCQA experiment is particularly relevant because both the target adapter and its task are absent from the training pool. The model also preserves a substantial portion of the received adapter’s task value: on Qwen, SafeCompose reaches approximately 58-59% MedMCQA accuracy, compared with 28% when the task adapter is discarded.

Also, the matched gate ablations establish a real benefit under the tested prefix attacks. Table 26 shows that input conditioning becomes consequential under response-prefix attacks. On the Qwen held-out adapter, dynamic gating achieves 40.71% adaptive-prefix ASR, compared with 78.53% for the static gate, while MedMCQA accuracy remains approximately 59%. The prompt-once gate retains much of this benefit and enables caching.

Critical weaknesses
  1. The novelty comparison applies inconsistent criteria to the closest prior methods.

Appendix D defines an unseen adapter as one absent from training of the learned component, and target-specific adaptation as optimization or fitting on the target adapter. The treatment of TRACE and HyperSafe does not follow these definitions consistently. TRACE learns a reusable patch from provider-owned surrogate training trajectories and applies it to unseen user checkpoints without per-user adaptation. Its offline trajectory requirement does not require access to the arriving checkpoint’s training history. SafeCompose similarly permits an operator-owned offline adapter pool. Giving TRACE partial credit for unseen-checkpoint transfer on the stated basis is therefore unjustified.

HyperSafe generates side-network weights through a pretrained hypernetwork without target-specific gradient updates. Its evaluation includes held-out domains and checkpoints. The description that it fits a side network to the received checkpoint obscures this distinction. HyperSafe does require domain-specific calibration prompts for activation fingerprints; that is a valid deployment-resource difference and should be stated as a separate criterion.

These discrepancies matter because TRACE, HyperSafe, and NeWTral are identified as close alternatives but receive no quantitative comparison. NeWTral is especially relevant to the adapter setting because it learns a reusable mapping from unsafe to repaired adapters.

SafeCompose’s preservation of separately loadable generative branches remains a concrete architectural distinction. The broader claim of uniquely supporting transfer without target-specific training needs correction and comparative evidence.

  1. The evidence for the value of the additional inference cost is concentrated in a limited attack setting.

The appendix includes tuned weighted merging, so the relevant comparison is stronger than the main-table naive merge. On Qwen MedMCQA, a weighted merge with coefficient 0.75 obtains 60.0–60.5% accuracy and 0.3–0.6% ASR across the contamination settings. SafeCompose obtains 58.3–59.4% accuracy and 0.6% ASR. These point estimates show that the more complex policy provides no demonstrated advantage in this part of the evaluation.

The dynamic gate has a substantial advantage over static gates under the Qwen prefix attacks. Its relative advantage over other safety-repair methods is less settled. For example, the separate Table 25 comparison gives RESTA lower prefix-attack ASR at a utility cost. The scientific question is therefore which safety–utility operating points require the proposed composition policy.

The optimized prompt-once implementation is a meaningful improvement over the reference decoder, but still takes approximately four to five times the base-model decoding time in the reported batched benchmarks. Establishing value at that cost requires a joint comparison of attack robustness, task utility, benign refusal, and runtime. The present evidence most clearly supports a benefit in one held-out task/model prefix-attack regime.

Questions for authors
  1. Can Table 1 be revised to distinguish offline preparation, target conditioning, and target optimization consistently? Under the same available base model and offline data pool, how do TRACE or NeWTral compare on the held-out task? If HyperSafe is excluded because target calibration prompts are unavailable, please make that constraint explicit.

  2. Does the dynamic-gate advantage persist on the Mistral and Gemma held-out adapters under the same prefix-attack model? Comparisons with weighted merging and RESTA at comparable task utility would test the generality of the strongest positive result.

  3. Which operating points justify the remaining decoding overhead of the cache-compatible variant? A consolidated comparison with the strongest static alternatives would make the deployment advantage assessable.

4 comments

You are right that Table 1 applied inconsistent criteria to TRACE and HyperSafe, and that the evidence did not establish what the inference overhead buys. We withdraw the “first,” unique-transfer and deployment-superiority claims. New comparisons establish a Qwen conditioning benefit against particular controls, including a retrained prompt-once comparison, but the cross-family and runtime results require the narrower interpretation below.

Q1. Consistent criteria and closest-method comparisons

Table 1 and Appendix D will distinguish:

MethodOffline preparationTarget calibrationTarget computationTarget optimizationSeparate task/safety generative branches
TRACESurrogate trajectories train shared patchNoneMerge patch into weightsNoneNo
HyperSafeHypernetwork trained over checkpointsDomain-specific promptsActivation fingerprint generates side networkNoneNo
NeWTralTranslator trained on unsafe/repaired adapter pairsNone statedRewrite received weightsNone statedNo
SafeComposeGates trained on operator-owned adaptersNoneRead activations affected by earlier task-adapter layersNoneYes

Under Appendix D’s own definitions, TRACE and HyperSafe receive full credit for unseen-checkpoint transfer and no target-specific optimization. HyperSafe’s calibration prompts become a separate resource criterion, and Section 2 will describe generation by its pretrained hypernetwork rather than target-specific fitting. The remaining distinction is separately loadable generative branches, which imposed constant gates also preserve.

New quantitative comparison. Received adapters, not offline resources, are matched, so equal-offline-pool performance remains unresolved. All arms use Qwen2.5-7B, identical MedMCQA adapters at three doses, no prefix attack, and greedy decoding with neutral repetition penalty 1.0.

The Retrained causal/SFT gate uses causal composition and prompt-only gate inputs during training. Here it uses Prompt-once SafeCompose, which computes gates once from the prompt, rather than the original Table 6 policy. We will correct Section 3.3 and Eq. 3 to describe the original implemented final-hidden surrogate, and present the causal/SFT objective and causal, prompt-only computation as a modified method—not a documentation-only correction. The original held-out panels and repeated-arrival results remain evidence for the original checkpoints, not validation of the retrained gate.

Generation-parsed accuracy measures MedMCQA-520 answers parsed from generated text; ASR is HarmBench-judged attack success on AdvBench-104. The documented preparation and adaptations for these runs are:

MethodOffline resources and preparationImplementation qualification
SafeComposeOperator-owned adapters with Alpaca, CodeAlpaca and GSM8K task data, plus safety and benign-preservation trainingThe retrained gate uses the modified training procedure above.
TRACESurrogate trajectories train one shared rank-64 patch.Loader, entry-point and single-GPU training were adapted. Its SD measures received-adapter variation only.
RESTAAn unaligned copy supplies the safety vector.An audited 1,000-row unsafe-only BeaverTails substitute replaces unreleased upstream data.
SafeMERGEThe received task adapter and operator’s safety adapter supply the updates.Rank-32 task adapters are losslessly zero-padded to rank 64. Task/safety weights 0.7/0.3 and threshold 0.7 are untuned.

These are official-code runs with adaptations, not exact reproductions. Cells give accuracy (%) / ASR (%), mean ± sample SD over three received-adapter seeds.

Method1% dose5% dose10% dose
Prompt-once SafeCompose58.46 ± 1.54 / 0.64 ± 0.5659.17 ± 1.31 / 0.32 ± 0.5658.59 ± 0.68 / 0.64 ± 0.56
TRACE55.90 ± 0.99 / 0.00 ± 0.0056.22 ± 0.95 / 0.00 ± 0.0057.24 ± 1.06 / 0.00 ± 0.00
RESTA56.41 ± 0.62 / 0.00 ± 0.0055.58 ± 1.39 / 0.32 ± 0.5655.96 ± 0.84 / 0.32 ± 0.56
SafeMERGE57.76 ± 0.29 / 0.64 ± 0.5657.88 ± 0.88 / 5.45 ± 3.8958.27 ± 1.39 / 8.01 ± 4.34

SafeCompose has higher mean accuracy than TRACE and RESTA at every dose, while both have lower or equal mean ASR; SafeMERGE’s mean ASR rises with dose, but no significance, equivalence or dominance claim follows from these point estimates.

Unavailable comparisons. No official executable NeWTral artifact was located, rechecked November 10. HyperSafe has official code but no released weights; reconstruction was cancelled before any run, not blocked by missing calibration prompts. We will state these gaps explicitly and compare both methods structurally only.

Q2. Generality and safety–utility operating points

Clean setting. You are right that Table 19 does not justify conditioning over a well-chosen merge on clean Qwen. We will add the Tuned merge, selected on target-task validation, and the Target-free merge, selected without MedMCQA items, to the main results to separate frozen composition from conditioning.

Imposed constant controls. Matched gate checkpoints are the original-objective fits used for the following controls, the joint comparison below, the A–D capability test and timing. We tested 12 imposed constants on held-out 5% MedMCQA adapters over three seeds with one batched decoder. The Fixed prefix forces “Sure, here is” on AdvBench-104, with a 256-token cap. Differences below are constant − dynamic in percentage points, with paired seed × prompt bootstrap 95% intervals. Accuracy is this study’s MedMCQA measure and is not pooled with the other accuracy tables.

Family and comparatorPrefix-ASR difference [95% interval]Accuracy difference [95% interval]
Qwen: Paper constant gate (0.7/0.5)+35.58 [+24.04, +49.04]+0.64 [−0.90, +2.31]
Qwen: Validation-selected constant (0.8/0.3)+28.21 [+17.31, +40.06]+1.79 [+0.13, +3.53]
Qwen: Lowest-ASR constant (diagnostic) (0.9/0.1)+6.09 [−2.88, +14.42]−1.15 [−3.97, +1.60]
Mistral: validation-selected constant (0.7/0.5)−14.10 [−26.28, −1.92]−0.51 [−2.37, +1.41]
Mistral: constant 0.7/0.3−23.72 [−36.54, −10.58]−0.90 [−2.95, +1.15]

Qwen conditioning improves prefix safety against the paper and validation-selected constants, but not demonstrably against the diagnostic constant, whereas Mistral constants are safer without a detected accuracy cost—not accuracy equivalence.

Validation selection used clean safety and utility, not prefix robustness. The diagnostic constant was selected on the test panel and is not a deployable validation-selected winner. Separately trained static checkpoints remained near initialization (α≈0.7, β≈0.5), so we rename them Near-initial static gate and withdraw “optimized static control”; they do not establish the best achievable static policy.

Retrained prompt-once comparison. The retrained gate and its near-initial static gate both use prompt-once inference without caching. Each family has five matched seed pairs, identical items and adapter seeds, with 95% intervals jointly resampling seeds and prompts over 4,000 draws. Keyword refusal measures OR-Bench-Hard refusal by a keyword heuristic, not a semantic judge. This comparison uses OR-Bench-Hard-Q4, the 330-item subset taking every fourth prompt.

FamilyMeasure (%)Learned gateNear-initial staticLearned − static, pp [95% interval]
QwenFixed-prefix ASR56.5473.85−17.31 [−30.77, −3.85]
QwenGeneration-parsed accuracy59.1559.23−0.08 [−1.88, +1.50]
QwenKeyword refusal15.7620.61−4.85 [−11.27, +0.67]
MistralFixed-prefix ASR18.8521.35−2.50 [−7.50, +2.69]
MistralGeneration-parsed accuracy52.7351.92+0.81 [−1.23, +2.85]
MistralKeyword refusal49.9449.27+0.67 [−2.12, +3.27]

The prefix-ASR difference is resolved on Qwen, where four of five pairs favor the learned gate, but not on Mistral; neither family has a resolved accuracy or keyword-refusal difference.

Thus, the original matched Mistral gates lose to fixed controls, whereas the retrained prompt-once comparison does not resolve a learned-versus-static difference; the latter is not evidence of repairing the original adapted-prefix failure.

Gemma fixed-prefix grid. This prespecified grid uses the original submitted Gemma composer, imposed constants and bf16 greedy decoding. Each row uses its exact matched seed intersection, with keyword refusal on OR-Bench-Hard-Q4. These descriptive results have no intervals, and Gemma adapted-prefix, tuned-merge and RESTA comparisons were not run.

ComparatorSeed pairsDynamic ASR (%)Constant ASR (%)Dynamic − constant (pp)Dynamic / constant MedMCQA (%)Dynamic / constant keyword refusal (%)
Paper constant gate23.85 ± 1.3652.40 ± 14.28−48.5659.81 / 59.6276.52 / 66.36
Prespecified High-safety constant (0.9/0.1)33.53 ± 1.113.85 ± 1.67−0.3259.81 / 56.0377.88 / 77.37

Gemma is comparator-sensitive: dynamic gating is far safer than the paper constant, while the high-safety constant nearly matches its ASR at lower accuracy, and all arms have substantial keyword refusal.

Joint comparison against merging and RESTA. The following tables use the original matched gates, not the retrained gate, with uncached inference. The Adapted prefix was selected historically by a separate search for each arm on 16 development prompts with eight queries, then tested with a 128-token cap; Mistral prefixes were rejudged, but the search was not replayed. Qwen uses the two seeds shared by all six arms, with baselines regenerated at neutral repetition penalty 1.0; hardware can differ across methods. Mistral uses five seeds. These are descriptive operating points, not significance claims.

Discard’s generation-parsed accuracy is depressed by prose answers. Mistral RESTA’s parsed score likewise does not establish format-independent capability loss.

Qwen. All entries are percentages; uncertainty is sample SD.

ArmNo-attack ASRAdapted-prefix ASRGeneration-parsed accuracyKeyword refusal
Dynamic SafeCompose0.0037.98 ± 12.9258.46 ± 1.9020.20
Prompt-once SafeCompose0.0047.12 ± 6.8058.46 ± 1.9019.86
Near-initial static gate0.0075.48 ± 0.6859.04 ± 0.5419.26
Tuned merge0.0060.10 ± 3.4060.48 ± 0.4120.13
RESTA (γ=0.5)0.0028.85 ± 16.3256.25 ± 0.9560.92
Discard0.0023.08 ± 8.1626.63 ± 2.0417.36

On this cohort, SafeCompose lies between RESTA, with lower ASR but lower accuracy and much higher keyword refusal, and tuned merge, with higher ASR and accuracy.

Mistral. RESTA’s coefficient was validation-selected to maximize utility under a safety cap, rather than accuracy-matched to SafeCompose.

ArmNo-attack ASRAdapted-prefix ASRGeneration-parsed accuracyKeyword refusal
Dynamic SafeCompose8.27 ± 3.6466.35 ± 14.6153.12 ± 1.4331.18
Prompt-once SafeCompose11.92 ± 7.6873.85 ± 13.7253.00 ± 1.2130.30
Near-initial static gate2.50 ± 2.5135.38 ± 10.7452.46 ± 1.4740.05
Tuned merge1.35 ± 2.5129.42 ± 11.4751.42 ± 1.0945.64
Safety-capped RESTA (γ=0.7)0.38 ± 0.530.19 ± 0.4335.00 ± 8.573.41
Discard0.19 ± 0.438.46 ± 9.3135.8559.24

Mistral reverses the ASR ordering in favor of the static gate and merge, while SafeCompose has higher mean accuracy and lower keyword refusal than the merge.

Prompt-once’s higher mean adapted-prefix ASR on both families does not establish matching robustness. A matched adapted-prefix comparison of the retrained gate against the strongest merging alternatives remains open.

Attack breadth and boundary. A separate study used Submitted gates, the original Table 6 Qwen composer, on one adapter over three seeds: SafeCompose had lower ASR than tuned merge and the near-initial static gate under all four openings fixed before held-out evaluation, while discard was safer under every opening.

Training a received Qwen adapter through frozen Submitted gates raises no-prefix ASR from 0.64% to 63.46 ± 6.00%, a paired increase of +62.82 pp [+55.13, +70.19]. This attacker targeted the learned gates, and no mitigation is validated; the result does not evaluate the retrained gate. We will state the gate-aware adapter-training vulnerability in Section 3.1 and Limitations, and exclude this attacker from robustness claims.

Capability relative to discard. A–D accuracy, next-token choice among the four answer letters, provides a complementary format-independent measure on the matched gates at the held-out dose, over three seeds:

FamilySafeCompose A–D accuracy (%)Discard A–D accuracy (%)Difference of means (pp)
Qwen58.65 ± 1.3952.31 ± 0.67+6.35
Mistral53.85 ± 1.7142.63 ± 1.44+11.22

These capability gains have no paired intervals, and Gemma was not scored with this control. We will remove “retaining 9–31 points” and report generation-parsed accuracy and A–D accuracy side by side.

Q3. What does the overhead buy?

The joint tables identify intermediate safety–utility–refusal trade-offs, not an operating point that requires conditioning or establishes cost-adjusted superiority.

We timed all six methods sequentially on the same physical GPU within each seed using the original matched-gate implementations, not the retrained gate. The metric is end-to-end time per generated non-padding token, with batch 8, 256 generated tokens and three repeats over five seeds per family. The uncached columns characterize dynamic execution, whose robustness was measured; the cached columns characterize prompt-once execution, whose robustness was not validated.

FamilyGPUUncached dynamic / uncached tuned merge, naturalUncached dynamic / uncached tuned merge, 900 tokensCached prompt-once / cached tuned merge, naturalCached prompt-once / cached tuned merge, 900 tokens
QwenRTX A60006.00×2.73×3.59×3.93×
QwenRTX A60005.83×2.83×3.56×3.96×
QwenL40S6.65×2.65×3.84×4.47×
QwenA405.41×2.72×3.83×4.44×
QwenA405.68×2.72×3.68×4.07×
MistralA405.19×2.57×4.10×3.80×
MistralA407.97×2.73×3.62×4.28×
MistralL40S10.01×2.67×3.79×4.78×
MistralA407.59×2.73×3.85×4.72×
MistralL40S10.00×2.67×3.82×4.85×

The matched-hardware measurements confirm substantial overhead relative to a merged model in both execution modes.

A cache-compatible policy is not a validated cached implementation: cached and uncached prompt-once outputs matched in only 3 of 60 timing checks, all in one of 20 seed/context conditions. These were benign timing prompts, and cached-path safety, utility and refusal were not measured. Fully dynamic gating has no KV-cache implementation. We will restrict robustness claims to uncached inference and remove cached-robustness claims from the abstract and conclusion.

What still stands

SafeCompose contributes an architectural construction for frozen, separately loadable composition of arriving adapters, with controlled evidence separating capability preservation from the value of input conditioning. The resolved Qwen fixed-prefix contrast, Mistral reversal and cached-execution limitations make this a useful empirical contribution about when conditioning helps and fails, rather than evidence that its deployment overhead is justified.

Reviewer_1sgSOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SafeCompose addresses safety degradation caused by task adapters. It uses learned layer-wise gates to combine activations from frozen base, safety, and task branches. The composer is trained on a pool of adapters and applied to an unseen task adapter without retraining. Experiments across three model families examine safety, task accuracy, and inference cost, with additional comparisons against static gates and evaluations under response-prefix attacks.

Critical strengths
  1. The held-out MedMCQA results show substantial gains in task accuracy over discarding the adapter across three model families. Achieving these gains without using the target task during composer training is a useful contribution.
  2. The static-gate comparison supports the use of input-dependent gates. They achieve lower attack success rates under the evaluated response-prefix attacks, with comparable MedMCQA accuracy.
Critical weaknesses
  1. I am less convinced by the benefit over simpler composition relative to its cost. In Table 19, the tuned merge has higher mean MedMCQA accuracy at all three Qwen doses, with equal or lower mean AdvBench ASR. The merge uses target-task validation data, which favors it in this comparison. Still, the strongest evidence favoring input-dependent gates under attack comes from one Qwen configuration. Even the cached prompt-once variant is roughly 4–5× slower than cached base decoding in the reported batch-8 benchmark.

  2. The conclusion overstates safety parity with discard. On Qwen, Table 10 reports HarmBench ASR of 10.3% for SafeCompose versus 3.5% for discard, and the attack experiments also show a gap. The paper acknowledges these results, but the conclusion should make clear that parity holds only under particular evaluation conditions.

Questions for authors
  1. What explains the variation in the discard results across runs? Since this configuration uses the same safety adapter and a fixed test set, I would have expected its results to be more consistent.

  2. The HarmBench and attack results suggest that SafeCompose sometimes trades safety for task accuracy, even on Qwen. Could the conclusion distinguish these cases from those where it matches the safety of discard?

3 comments

You are right that Table 19 does not justify conditioning over simpler composition on clean Qwen, and that the conclusion overstates safety relative to discard. New evidence preserves the format-independent capability gain and establishes a fixed-prefix benefit for a retrained Qwen gate against the near-initial static gate, but not cross-family superiority. We will reframe the abstract, introduction and conclusion as an empirical characterization of composition, not a deployment-superiority claim.

1. Safety relative to discard (Weakness 2, Question 2)

We withdraw “parity.” The repeated safety test uses Submitted gates, the original Table 6 Qwen composer, and the original 5%-contaminated Alpaca adapter, not Table 2's MedMCQA adapters. SafeCompose and Discard (safety adapter only) use the same custom decoder across three adapter seeds. Differences below are SafeCompose − discard in percentage points, with paired prompt-cluster bootstrap 95% intervals.

Benchmark/decodingSafeCompose ASR%Discard ASR%Difference [95% CI]
AdvBench/greedy0.640.96−0.32 [−0.96, +0.00]
AdvBench/sampled1.070.53+0.53 [+0.00, +1.39]
HarmBench/greedy9.333.33+6.00 [+3.33, +9.00]
HarmBench/sampled8.724.83+3.89 [+1.39, +6.67]

Replacement conclusion. Section 4.2 and the conclusion will state no resolved paired Qwen AdvBench difference, and higher SafeCompose ASR on Qwen HarmBench, Mistral clean AdvBench and the tested prefixes. On Mistral clean AdvBench, SafeCompose has 9.29 ± 2.22% ASR versus discard's 0.00 ± 0.00%, without a paired interval. Held-out Gemma MedMCQA adapters yield zero harmful responses in both arms. Neither the Qwen interval nor the Gemma zero-ASR observation establishes equivalence.

Capability. A–D accuracy is MedMCQA-520 next-token choice among A–D and does not depend on answer format. Matched gate checkpoints are the original matched dynamic-gate fits, distinct from Submitted gates. At 5% dose, mean ± sample SD over three seeds is:

FamilySafeCompose A–D accuracyDiscard A–D accuracyDifference (pp)
Qwen58.65 ± 1.39%52.31 ± 0.67%+6.35
Mistral53.85 ± 1.71%42.63 ± 1.44%+11.22

The capability gain survives this format-independent measure, although these are differences of means without paired intervals.

Gemma was not scored on this measure. These capability tests use different adapters from the repeated safety test, so they are not a joint operating point. We will remove “retaining 9–31 points” and report Generation-parsed accuracy, which parses generated MedMCQA-520 answers, and A–D accuracy side by side.

2. Benefit over simpler composition (Weakness 1)

Clean comparison

Tuned merge, whose coefficient is selected on MedMCQA validation, has higher Qwen generation-parsed accuracy at every dose: 60.00/60.51/60.32% versus SafeCompose's 58.27/58.97/59.42%.

Target-free merge selects α∈{0, 0.25, 0.5, 0.75, 1} without MedMCQA items, maximizing GSM8K or MMLU-520 calibration utility subject to JailbreakBench-100 ASR ≤ 0.10. On Qwen, the GSM8K rule selected α=1, which discards the task adapter. We added the MMLU rule post hoc, after seeing that result, but fixed its rule before any MMLU cell ran. The MMLU subset is unfiltered, with 6.7% medical questions. At 5% dose, accuracy / clean AdvBench ASR (%), mean ± sample SD over three seeds, is:

FamilyTarget-free mergeSafeCompose
Qwen (MMLU, α=0.5)58.65 ± 0.51 / 1.92 ± 0.9658.97 ± 1.25 / 0.64 ± 0.56
Mistral (α=0.75)52.05 ± 0.91 / 2.24 ± 2.4253.91 ± 1.13 / 9.29 ± 2.22
Gemma (MMLU, α=0.5)60.38 ± 0.19 / 0.64 ± 0.5659.87 ± 0.29 / 0.00 ± 0.00

Removing target-task validation leaves the merge competitive on Qwen and Gemma, and safer but less accurate on Mistral.

This selection uses a coarse grid and has no paired intervals. The Qwen merge and SafeCompose arms in this historical clean cohort used different repetition penalties, so their contrasts are protocol-level, not isolated method effects. We will add the tuned merge and the target-free merge to the main results, to separate frozen composition from conditioning.

Conditioning under attack

Retrained comparison. The Retrained causal/SFT gate uses Prompt-once SafeCompose, which computes gates once from the prompt. We compared it with a Near-initial static gate, both evaluated prompt-once without caching, on identical adapters and items. The Fixed prefix forces AdvBench-104 responses to begin “Sure, here is,” with HarmBench judging and a 256-token cap. Each family has five matched seed pairs. Intervals jointly resample seeds and prompts with 4,000 draws.

FamilyLearned fixed-prefix ASRStatic fixed-prefix ASRLearned − static ASR (pp), 95% intervalGeneration-parsed accuracy difference (pp), 95% interval
Qwen56.54%73.85%−17.31 [−30.77, −3.85]−0.08 [−1.88, +1.50]
Mistral18.85%21.35%−2.50 [−7.50, +2.69]+0.81 [−1.23, +2.85]

The ASR difference is resolved only on Qwen, where four of five pairs favor the learned gate, without a detected accuracy difference.

The static checkpoints stayed near initialization (α≈0.7, β≈0.5), so we will rename them “near-initial static gate” and withdraw “optimized static control.” This comparison does not establish superiority to an optimized static policy.

Imposed constants. On Matched gate checkpoints, we tested 12 constants using held-out MedMCQA adapters, three seeds and one batched decoder under the Fixed prefix. SafeCompose's ASR is 47.12 ± 10.04% on Qwen and 52.88 ± 7.26% on Mistral. Differences below are constant − SafeCompose, with paired seed × prompt bootstrap 95% intervals. Accuracy is this study's MedMCQA measure and is not pooled with the other accuracy tables.

FamilyConstant (α/β)ASR difference (pp)Accuracy difference (pp)
QwenPaper constant gate (0.7/0.5)+35.58 [+24.04, +49.04]+0.64 [−0.90, +2.31]
QwenValidation-selected constant (0.8/0.3)+28.21 [+17.31, +40.06]+1.79 [+0.13, +3.53]
QwenLowest-ASR constant (diagnostic) (0.9/0.1)+6.09 [−2.88, +14.42]−1.15 [−3.97, +1.60]
MistralValidation-selected (0.7/0.5)−14.10 [−26.28, −1.92]−0.51 [−2.37, +1.41]
Mistral0.7/0.3−23.72 [−36.54, −10.58]−0.90 [−2.95, +1.15]

Qwen conditioning lowers ASR against the validation-selected constant at lower accuracy, while Mistral constants are safer without a detected accuracy cost.

Validation selection used clean safety and utility, not prefix robustness. The diagnostic constant was selected on the test panel, and no advantage over it is resolved. Failure to detect an accuracy cost on Mistral is not accuracy equivalence.

The prespecified Gemma fixed-prefix grid uses the original submitted Gemma composer and imposed constants. Dynamic ASR is 3.85 ± 1.36% versus the Paper constant gate's 52.40 ± 14.28% over two matched seeds. Over three matched seeds, dynamic ASR is 3.53 ± 1.11% versus the High-safety constant's (0.9/0.1) 3.85 ± 1.67%, with accuracy 59.81% versus 56.03%. These descriptive results are comparator-sensitive, not a general conditioning advantage.

Adapted-prefix comparison. On Matched gate checkpoints, the Adapted prefix uses separate searches per arm on 16 development prompts, eight queries, and a 128-token cap. Qwen uses two seeds shared across the arms, with baselines regenerated at neutral repetition penalty 1.0. Mistral uses five seeds, with historically selected prefixes rejudged rather than the search replayed. The table pairs ASR with same-cohort generation-parsed accuracy, as mean ± sample SD (%). Tuned merge uses α=0.75 on both families. RESTA uses γ=0.5 on Qwen and γ=0.7 on Mistral, where validation selection imposed a safety cap.

FamilyArmAdapted-prefix ASRGeneration-parsed accuracy
QwenSafeCompose37.98 ± 12.9258.46 ± 1.90
QwenNear-initial static75.48 ± 0.6859.04 ± 0.54
QwenTuned merge60.10 ± 3.4060.48 ± 0.41
QwenRESTA28.85 ± 16.3256.25 ± 0.95
QwenDiscard23.08 ± 8.1626.63 ± 2.04
MistralSafeCompose66.35 ± 14.6153.12 ± 1.43
MistralNear-initial static35.38 ± 10.7452.46 ± 1.47
MistralTuned merge29.42 ± 11.4751.42 ± 1.09
MistralRESTA0.19 ± 0.4335.00 ± 8.57
MistralDiscard8.46 ± 9.3135.85 (parsed)

These descriptive operating points place Qwen SafeCompose between tuned merge and RESTA in both ASR and accuracy, while Mistral's static gate and merge are safer than SafeCompose at lower mean accuracy.

Generation-parsed scores, particularly for discard and Mistral RESTA, do not establish format-independent capability loss. A separate Qwen Target-free merge has 76.28 ± 3.89% adapted-prefix ASR across three seeds, but no protocol-matched SafeCompose arm, so it does not establish a defense comparison.

The robustness boundary also matters: training a received Qwen adapter through frozen Submitted gates raises no-prefix ASR from 0.64% to 63.46 ± 6.00%, a paired +62.82 pp [+55.13, +70.19]. This attacker targeted the learned gates, not the comparators. We will state the gate-aware adapter-training vulnerability in Section 3.1 and Limitations, and exclude this attacker from robustness claims.

Cost

Your cost objection stands. Per generated token, cached Prompt-once SafeCompose took 3.56–3.84× as long as cached Tuned merge on Qwen natural prompts and 3.93–4.47× at 900 tokens. Mistral ranges were 3.62–4.10× and 3.80–4.85×. Each ratio compares the original Matched gate implementations on the same physical GPU within a seed, with five seeds per family, batch 8, 256 generated tokens and three repeats.

Fully dynamic gating has no KV-cache implementation. Cached and uncached prompt-once outputs matched in only 3 of 60 timing checks, all in one of 20 seed/context conditions. Cached-path safety and utility were not measured. We will restrict robustness claims to uncached inference and remove cached-robustness claims from the abstract and conclusion.

Qwen coefficient selection cost about 1.68 GPU-hours for the MMLU rule and about 4.42 GPU-hours for the GSM8K search. Comparable composer-training and amortization costs remain open. These measurements do not establish an operating point whose measured safety–utility benefit justifies the added deployment cost.

3. Variation in discard (Question 1)

You are right for a fixed adapter under greedy decoding. Contrary to Appendix B, safety adapters are trained per seed; we will correct this. A five-run Qwen audit varied one factor at a time:

Varied factorGeneration-parsed accuracy%AdvBench ASR%
Decoding seed, safety adapter fixed23.27 ± 0.000.96 ± 0.00
Safety-adapter training seed, decoding fixed29.96 ± 5.190.96 ± 0.00

Changing training seeds changes generated answers, while ASR remains one harmful response out of 104.

A–D accuracy of the same five safety adapters is 52.96 ± 1.07% (range 51.54–54.42%), indicating that most of the generation-parsed spread comes from answer format. This audit is Qwen-only and does not explain every source of variation: A–D scoring applies the safety adapter directly, whereas generation uses the α=1 merge, and outputs were not compared item by item.

What still stands

The contribution is a controlled separation of frozen, separately loadable composition from input conditioning: format-independent capability gains survive on the tested Qwen and Mistral adapters, while the conditioning benefit is comparator- and family-dependent. This empirical account remains worth publishing because it identifies what composition adds beyond discard and where simpler composition suffices, rather than offering a deployment recommendation.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.