- Rating
- 2
- Confidence
- 3
- Informativeness
- 1
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
Paper Summary
This paper proposes GUARD-IT, a training- and gradient-free method that performs LLM unlearning entirely at inference time via input-dependent activation steering, without modifying model weights.
- Offline phase. The forget corpus is embedded with a sentence encoder (all-MiniLM-L6-v2) and partitioned by k-means, with the number of clusters selected by silhouette score. For each cluster, a Prototype Steering Vector (PSV) is computed as the mean residual-stream activation at an early layer (first quartile of the stack), and a reference direction is computed from the retain corpus.
- Online phase. A similarity gate embeds each query with the same encoder and activates the clusters whose centroids exceed a cosine threshold. The active PSVs are averaged, projected orthogonally to the retain reference, rescaled to the activation norm, and subtracted from the hidden state as a norm-preserving rotation with strength . Queries that do not activate any cluster pass through the unmodified model.
Claimed contributions:
- a formulation of unlearning as norm-preserving, input-gated steering whose strength reduces to a single scalar calibrated per model;
- a similarity gate over clustered PSVs that enables input-dependent, compositional unlearning;
- support for continual unlearning and robustness to quantization and jailbreak attacks;
- a large-scale evaluation, together with newly released TOFU checkpoints for Gemma 4 and Qwen 3.5.
Validation. The main evaluation is on TOFU (forget01 and forget05) with Llama-3.2-1B, Llama-3.2-3B, and Llama-3.1-8B. It compares against 12 weight-editing baselines and 4 inference-time baselines, plus GRUN and a gated-refusal control that shares the same gate, using five seeds. Results are reported in terms of memorization, model utility, a gibberish score, and Forget Quality. The authors report that GUARD-IT is the only method that suppresses memorization without collapse in every Llama configuration, and that it achieves the highest Forget Quality on forget01. Additional experiments cover:
- Gemma 4 and Qwen 3.5;
- membership inference and seven jailbreak templates;
- ten rounds of continual unlearning;
- 4- and 8-bit quantization;
- MUSE and WMDP-Cyber, compared against published baseline numbers;
- ablations on the gate, clustering, pooling, steering-vector construction, layer, and coefficient.
Critical strengths
- Practical and appealing design for deployed models. GUARD-IT requires no training, gradients, or weight changes. The offline cost is small (minutes on a single GPU), and new forget requests are absorbed with forward passes only. Because forget requests are stored as external vectors, each request can be inspected, updated, or rolled back, which is attractive for closed-weight serving.
- Rigorous and large-scale evaluation. The TOFU comparison covers 16 baselines run under a single OpenUnlearning protocol, with five seeds and reported standard errors. It spans three Llama scales and two additional model families, and the authors release new TOFU checkpoints for Gemma 4 and Qwen 3.5, which is a useful contribution to the community.
- Informative controls and ablations. The gated-refusal control, which keeps the same gate but replaces the intervention, directly addresses whether the gains come from the gate alone. The ablations cover removing the gate and clustering, diff-means versus orthogonal projection, token pooling, a BM25 gate, paraphrase robustness, and layer and coefficient sweeps. Together they clarify the role of each component.
- Consistent results across settings. GUARD-IT avoids collapse in every reported configuration and maintains utility at the level of the original model. It achieves strong Forget Quality on forget01, and its behavior is stable across continual-unlearning rounds and quantization levels.
- Candid discussion of scope. The paper acknowledges that the forgotten content remains in the parameters, that the method targets closed-weight serving, and that the vector store must itself be protected. It also reports that an informed attacker can partially recover the membership-inference signal by inverting the decision rule.
Critical weaknesses
-
The method performs gated inference-time suppression rather than unlearning, and the evaluation does not clearly separate the two.
- The knowledge is never removed. The forgotten content remains fully intact in the parameters, and any query that does not fire the gate receives the original model's answer. The paper acknowledges this in its limitations. Nevertheless, the title, abstract, and comparisons frame GUARD-IT as machine unlearning on par with weight-editing methods.
- The metrics measure the gated system. Mem and FQ are computed only on forget queries, with the gate active. They therefore measure the behavior of the gated system, not the knowledge in the model.
- The gated-refusal control is weak. It only prepends an instruction to the prompt, which is not expected to shift the likelihood of the ground-truth answer. Its low Mem (0.13 / 0.14) therefore says little about whether the specific PSV directions matter.
- Stronger controls are needed. Under the same gate, two controls would be more informative: (i) a norm-preserving rotation along a random direction of matched magnitude, and (ii) direct logit suppression of the answer tokens. These would show whether GUARD-IT's gains in Mem and FQ come from the learned forget directions or simply from any likelihood-altering intervention applied when the gate fires.
-
The robustness of the gate is not adequately tested, and some robustness claims hold by construction.
- Template jailbreaks already evade the gate. Wrapping queries in the seven jailbreak templates lowers the fire rate from 0.86 to 0.74. About a quarter of the wrapped forget queries therefore bypass the gate entirely and receive the original model's answer.
- Natural evasion strategies are untested. These include cross-lingual queries (the gate uses an English sentence encoder), indirect references to the target (e.g., referring to an author through one of their books), splitting a question across conversation turns, obfuscated encodings, and adaptive attacks that optimize inputs to fall below the gate threshold.
- Membership leakage is inverted, not removed. The MIA results show that the leakage signal is inverted rather than eliminated: an informed attacker recovers an AUC of about 0.75. This makes the claim that the method "holds under jailbreak attacks" too strong.
- Quantization robustness is not a fair comparison. Robustness to quantization follows directly from not modifying the weights. Comparing it against weight-editing baselines whose edits can be undone by quantization does not demonstrate an advantage of the method itself.
-
The evaluation design favors the gate.
- Utility preservation is structural rather than measured. Model utility is computed on retain, real-author, and world-fact queries on which the gate almost never fires (false-positive rate 0.01). Utility therefore remains at the original level by construction, as the paper itself notes. What is not evaluated is the collateral damage when the gate does fire, for example on queries that combine a forget entity with general knowledge, or on retain authors closely related to forget authors.
- Continual unlearning may suppress content that was never requested. Each round is evaluated on the full forget05 split, and Avg and Gibb are identical at rounds 6, 8, and 10 (0.62 / 0.81 at 1B, 0.61 / 0.83 at 3B). This implies that, by round 6, authors whose removal had not yet been requested were already suppressed. This sits uneasily with the reported 0.01 false-positive rate on retain authors from the same domain. Mem should be reported separately on requested and not-yet-requested subsets at each round.
- Tuning effort is uneven. The layer and are selected by sweeping on the forget01 evaluation metrics, and they are recalibrated for Gemma, Qwen, MUSE ( = 1.0 / 0.8), and WMDP. The baselines use OpenUnlearning's released configurations.
-
Several results are less favorable than presented.
- Fluency is a relative weakness. GUARD-IT's gibberish score (0.80–0.84) is below that of the Finetuned and Retain models (0.86–0.92) and below several non-collapsed baselines on forget01 at 1B (e.g., NPO 0.91, RMU 0.89, DPO 0.92). The claim of fluent generation relies on the paper's own collapse threshold (Gibb < 0.50).
- Steered outputs contain fabricated facts. Many steered outputs in Table 9 contain fabricated specifics, such as an invented book title or a wrong parental occupation. This raises honesty concerns that the metrics do not capture.
- MUSE results indicate over-unlearning. KnowMem is 0.7 (News) and 0.5 (Books), compared with the retrained reference of 33.1 and 28.9. Under MUSE's retrain-referenced criterion, this is over-unlearning, which the paper instead presents as suppressing knowledge "past" the reference. The main text reports News PrivLeak (−1.0) but not Books PrivLeak (−25.5, comparable to the baselines).
- The WMDP evaluation is limited. It covers only WMDP-Cyber, where GUARD-IT's 26.47% accuracy is close to chance, and uses published baseline numbers. MMLU is reported only in aggregate. Overall MMLU is expected to be unaffected because the gate rarely fires; the relevant subsets (e.g., computer security, college computer science) are not reported.
- Forget Quality does not pass on forget05. On forget05, Forget Quality remains below TOFU's threshold (1.4e-3 at 1B, 4.3e-3 at 3B), ranking fourth and third among the sixteen configurations.
-
Limited novelty and missing related work.
- The components are established. Input-conditioned steering (CAST, SADI), classifier-gated intervention (ECO), gated representation editing (GRUN), and norm-preserving rotation (Angular and Spherical steering) are all prior work. The contribution lies mainly in their combination and in the evaluation.
- The most direct baselines are missing. Dynamic SAE Guardrails [1] combines a dynamic classifier with conditional activation-level intervention and reports robustness in sequential unlearning. This is essentially the same paradigm and is the most direct missing baseline. DRAGON [2] leaves the base model untouched, uses a lightweight detector to identify forget-relevant prompts, and explicitly targets continual unlearning. MLLMEraser [3] performs input-aware, training-free test-time unlearning via activation steering.
- Positioning on suppression versus erasure. Since the paper explicitly leaves the forgotten content in the parameters, it should position itself within the discussion of suppression versus erasure [4, 5].
- Other relevant work. The paper should also engage with work on honesty in unlearning [6], which bears on the fabricated outputs above, and on extracting unlearned information via activation steering [7].
[1] Aashiq Muhamed, Jacopo Bonato, Mona Diab, Virginia Smith. SAEs Can Improve Unlearning: Dynamic Sparse Autoencoder Guardrails for Precision Unlearning in LLMs. COLM 2025.
[2] Yaxuan Wang, Chris Yuhao Liu, Quan Liu, Jinglong Pang, Wei Wei, Yujia Bao, Yang Liu. DRAGON: Guard LLM Unlearning in Context via Negative Detection and Reasoning. ICLR 2026.
[3] Chenlu Ding, Jiancan Wu, Leheng Sheng, Fan Zhang, Yancheng Yuan, Xiang Wang, Xiangnan He. MLLMEraser: Achieving Test-Time Unlearning in Multimodal Large Language Models through Activation Steering. arXiv:2510.04217, 2025.
[4] Yihuai Hong, Lei Yu, Haiqin Yang, Shauli Ravfogel, Mor Geva. Intrinsic Test of Unlearning Using Parametric Knowledge Traces. EMNLP 2025.
[5] Puning Yang, Junchi Yu, Qizhou Wang, Philip Torr, Bo Han, Xiuying Chen. Distinguishable Deletion: Unifying Knowledge Erasure and Refusal for Large Language Model Unlearning. ICML 2026.
[6] Renjie Gu, Jiazhen Du, Yihua Zhang, Sijia Liu. Unlearners Can Lie: Evaluating and Improving Honesty in LLM Unlearning. ACL 2026.
[7] Atakan Seyitoğlu, Aleksei Kuvshinov, Leo Schwinn, Stephan Günnemann. Extracting Unlearned Information from LLMs with Activation Steering. arXiv:2411.02631, 2024.
Questions for authors
-
Controls for the source of the gains. Under the same gate and threshold, how do the following compare with GUARD-IT on Mem, FQ, and Gibb: (i) a norm-preserving rotation along a random direction of matched magnitude, and (ii) direct logit suppression of the ground-truth answer tokens? This would clarify whether the learned PSV directions are necessary, or whether any likelihood-altering intervention applied when the gate fires yields similar results.
-
Gate evasion. How does the gate fire rate, and the resulting leakage, change under:
- cross-lingual queries;
- indirect references to the target (e.g., asking about "the author of [book title]" without naming the author);
- questions split across multiple conversation turns;
- obfuscated or encoded inputs;
- adaptive attacks that optimize the input to fall below the similarity threshold?
For the roughly 26% of jailbroken forget queries that bypass the gate, what is the leakage (e.g., ROUGE-L against the forgotten answer)?
-
Collateral effects when the gate fires. Could you evaluate queries on which the gate fires but which also require retained knowledge? Examples include questions that combine a forget author with general facts, comparisons between a forget author and a retain author, and retain authors that are semantically close to forget authors. Could you also report the gate's false-positive rate separately for retain authors with high embedding similarity to the forget set?
-
Continual unlearning. At each round, what is Mem on the requested subsets versus the not-yet-requested subsets of forget05? Given that Avg is identical at rounds 6, 8, and 10, does the gate already fire on authors whose removal had not yet been requested, and how is this reconciled with the 0.01 false-positive rate on retain authors?
-
Hyperparameter selection and additional results.
- Were the layer and selected on the same forget set and metrics used for evaluation? How would results change with selection on a held-out split?
- Were the baselines' hyperparameters tuned with comparable effort?
- Could you report Books PrivLeak in the main text?
- Could you report WMDP-Bio, as well as MMLU subsets closely related to the forget domain (e.g., computer security and college computer science)?
- Could you compare against Dynamic SAE Guardrails [1] and DRAGON [2]?
Minor comments
- Outdated references. Several cited works have since been published and should be cited by their venues, for example TOFU (COLM 2024), WMDP (ICML 2024), SimNPO (NeurIPS 2025; currently cited as a 2024 workshop paper), LUNAR (NeurIPS 2025), and ECO (NeurIPS 2024).
- Honesty of steered outputs. It would help to quantify how often steered outputs contain fabricated specifics rather than non-committal answers (Table 9), and to discuss whether such fabrication is a desirable post-unlearning behavior [6].
- Wording of distributional claims. The phrase "statistically closest to a model that never saw them" holds on forget01 but not on forget05, where FQ remains below the threshold. The main text should state this qualification explicitly.
5 comments
2. Robustness of the gate
We agree that the gate is the component an attacker has to evade, since a query that does not fire it reaches the unmodified model. Under the seven jailbreak templates, the gate still fires on 74% of the wrapped forget questions, and leakage, measured as ROUGE-L against the forgotten answer, falls from 0.63 with the gate off to 0.37 with it (Table 7). The 26% that bypass the gate are answered as by the original model (ROUGE-L 0.62 vs. 0.63), as you anticipated. We also ran the natural evasion strategies you listed and report leakage in free generation as ROUGE-L recall of the gold answer (lower is better; 1B forget05; App. D.3–D.4):
| Query | Finetuned | Retain | GUARD-IT |
|---|---|---|---|
| Translated (mean of ES/DE/IT) | .25 | .22 | .15 |
| Indirect reference | .31 | .26 | .29 |
| Split over two turns | .57 | .36 | .33 |
| One conversation per author (turns 2–20) | .51 | .39 | .17 |
| Obfuscated (leetspeak, homoglyphs, typos, spacing) | .27 | .24 | .21 |
| Encoded (base64) | .10 | .09 | .07 |
| Adaptive paraphrases | .41 | .32 | .41 |
GUARD-IT leaks less than the Retain model, which never saw the forget set, on five of the seven strategies. Three of these rows required adapting the gate, and none required retraining. For the translated queries, we translated the 200 forget05 questions and their answers into Spanish, German, and Italian; the default English encoder does not fire on them, so we rebuilt the library from the translated forget set with a multilingual encoder. With it, leakage falls below Retain in all three languages, Util stays at 0.60, and Avg rises from 0.55 to 0.59 (App. D.4). For the obfuscated and encoded queries, your question led us to add input normalization: the gate also checks a normalized copy of the query, and Table 7 and the 1B forget05 results of Table 1 are unchanged. The two remaining strategies show the limits of the gate. On indirect references, leakage stays between Retain and Finetuned (0.29 vs. 0.26 and 0.31). Natural paraphrases keep the gate firing (85% of TOFU's paraphrased questions vs. 86% of the original ones), but paraphrases optimized to fall below the threshold evade it and leak as much as the Finetuned model. Like translations, the paraphrases found this way can be added to the library, and Sec. 5 states this limitation.
We also agree that membership leakage is inverted rather than removed. The rotation raises the loss of forget queries above the holdout level, so an attacker who knows the defense and reverses the decision rule recovers an AUC of about 0.75, against 1.00 before unlearning. Sec. 3.5 now states this, and the abstract now says that GUARD-IT reduces jailbreak leakage instead of saying that it "holds" under jailbreak attacks.
Finally, we respectfully disagree that the quantization comparison is unfair. Quantization is common practice when serving LLMs, so evaluating unlearning on quantized models is a realistic test, and it is what a provider would face in deployment. That GUARD-IT's robustness comes from keeping the weights untouched does not make it less of an advantage: it follows from the method's design, and weight-editing methods lack it, since rounding partly undoes their edits (point 1). GUARD-IT keeps its effect at 4 and 8 bits, and at 8B it has the highest Avg at both precisions and on both splits (App. N). One full-precision extraction also serves the 4- and 8-bit models, with Avg within 0.01 of re-extraction at 1B and 3B (App. N.1). The fact that GUARD-IT is inherently robust to quantization is a non-trivial feature of our method: practitioners need explicit evidence that unlearning will work in realistic quantized scenarios, as we show in App. N (Tables 25–27).
3. Evaluation design
GUARD-IT's utility is measured the way unlearning benchmarks define it. TOFU and MUSE, two of the most widely used unlearning benchmarks, compute utility on queries kept apart from the forget set, and we evaluated GUARD-IT on both, on the same sets as every baseline. The weight-editing baselines lose utility on these sets, for example, NPO on 1B forget05 (Util 0.45 vs. 0.60; Table 1) and every gradient-based baseline on MUSE Books (at most 52.7, against 74.5 for the retrained model and 69.6 for GUARD-IT; Table 29). GUARD-IT keeps utility because its gate rarely fires on these queries, which is the mechanism we propose.
Neither benchmark covers the case you raise: a query on which the gate fires but which also needs retained knowledge. TOFU and MUSE contain no such queries, so none of the methods in Tables 1, 3, and 29 are evaluated on them. This is a limitation of how the benchmarks are built, so we added the two tests you suggest (App. D.2).
On the 10% of retain authors most similar to the forget centroids, the gate fires on 12.5% of their questions and on none of the other retain questions, and the probability of their gold answer drops by 4.4 points, against 0.6 for the other retain authors. On 150 compound questions that pair a forget author with a world fact, a retain fact, or a comparison, GUARD-IT answers the retained part correctly in 37% of cases, against 43% for the original model and 19% for ECO, the other gated method.
You were right to question the identical values in Table 5: they were an error, as GUARD-IT's row repeated the same values at rounds 6, 8, and 10. Re-run with five seeds, its Avg grows as requests accumulate (rounds 6, 8, 10: 0.56, 0.60, 0.62 at 1B; 0.54, 0.59, 0.61 at 3B) and stays the highest among non-collapsed methods. As you suggested, we report Mem after each round separately for requested and not-yet-requested authors (seed 0; App. Q):
| Mem / round | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|---|---|
| 1B, requested | .61 | .58 | .63 | .55 | .63 | .68 | .66 | .66 | .67 |
| 1B, not yet requested | .09 | .11 | .10 | .11 | .11 | .09 | .10 | .12 | .26 |
| 3B, requested | .55 | .54 | .59 | .49 | .58 | .62 | .61 | .60 | .63 |
| 3B, not yet requested | .03 | .04 | .04 | .05 | .04 | .04 | .05 | .06 | .15 |
Without steering (α = 0 in the same runs), Mem is 0.09 at 1B and 0.03 at 3B. Authors not yet requested stay close to that level through round 8, so the gate does not suppress them, consistent with its 0.01 false-positive rate. At round 9, when a single author remains, their Mem rises to 0.26 and 0.15, still far below that of the requested authors, and at round 10 every author has been requested (Table 1).
We agree that the tuning effort should be comparable, and the two procedures are closer than they may appear. Layer and α were chosen on forget01; on the eight forget05 authors never used for that choice, the α ranking is the same and Mem is 0.05 lower than on the forget01 authors, so the selection carries over to held-out authors. The baselines use OpenUnlearning's configurations, which their authors tuned on TOFU, and for each one we kept the better of 5 and 10 epochs per model and split (Table 13). On a new model or benchmark, GUARD-IT recalibrates α (and, on WMDP, the layer) with forward passes only, one evaluation per candidate, and on Gemma and Qwen the layer follows the first-quartile rule without a new sweep (App. M, O). The MUSE and WMDP baselines are the published numbers on the same checkpoints, with the configurations chosen by their authors.
Thank you for the detailed review. It asked for many new controls, attacks, and comparisons, and we ran all of them, so this reply is longer than we would like. Each point is answered below, in the order of your review; each question is answered under the matching weakness. The revised PDF has the complete tables (your requests in purple, new tables numbered R1, R2, …).
1. Suppression rather than unlearning
We agree that GUARD-IT leaves the forgotten content in the weights, as the paper states in its limitations, but this does not place it outside machine unlearning. The standard benchmarks define unlearning through the model's behavior (TOFU's goal is "a model that is indistinguishable from one trained exclusively on the retain set"; Maini et al., 2024, Sec. 2.2.3), and Mem and FQ are computed from the model's outputs on forget queries for every method. For a weight-editing baseline, they measure the edited model; for GUARD-IT, they measure the model with its gate, which is what a provider serves. The same metrics evaluate all 16 baselines and the weight-preserving methods published as unlearning, including DRAGON and Dynamic SAE Guardrails, which you suggest as baselines. Whether unlearning should also be verified inside the parameters is a fair question; however, answering this question is akin to reframing the unlearning research area, which is outside the scope of this study.
Editing the weights does not guarantee removing the knowledge either. Your reference [4] finds that existing unlearning methods "minimally impact concept vectors and mostly suppress them during inference"; [7] extracts unlearned information through activation steering, and quantization restores suppressed content (Zhang et al., 2024b). In our experiments (App. N), 4-bit quantization lowers the Mem of UNDIAL from 0.60 to 0.40 and that of RMU from 0.15 to 0.03 on 8B forget05, while GUARD-IT reaches 0.60 at 4-bit (0.53 at full precision). Removal from the parameters would matter only against someone who holds the weights, and for an open-weight model the original checkpoint is already public: releasing an edited one does not withdraw the copies already downloaded, so the content stays retrievable; however, the new weights are modified. Removal can only be enforced where the provider holds the weights and serves the model; there, the served behavior, which Mem and FQ measure, is all users can reach. This is the setting GUARD-IT targets, as the introduction and Sec. 5 state, and Sec. 2 now positions it as suppression rather than erasure [4, 5].
We agree that the gated-refusal control only shows that the gate alone does not lower Mem, and that it cannot tell whether the PSV directions matter. We therefore ran both controls you proposed, with the same gate, centroids, and threshold as GUARD-IT (App. F.1). Util is the same for all edits in every cell, so the tables below report Mem, Gibb, and FQ.
Same strength (random direction with the PSV's norm):
Logit suppression (its strength raised until it reaches GUARD-IT's Mem, within 0.01):
GUARD-IT (Table 1) and random direction: means over five seeds, standard errors ≤ 0.02 (Table R4). Logit suppression: one run per strength, with Gibb and FQ interpolated at GUARD-IT's Mem.
The gate decides when to intervene, and the direction decides how much is forgotten and how cleanly. At the same strength, the PSV forgets more than a random direction in all four settings (Mem +0.11 to +0.23), produces more fluent answers (Gibb +0.04 to +0.14), and reaches a higher FQ in three of the four. The exception is 1B forget05, where the higher FQ of the random direction comes with lower Mem (0.52 vs. 0.63) and lower fluency (Gibb 0.67 vs. 0.81). The gains therefore come from the learned forget direction, and not merely from applying a likelihood-altering intervention whenever the gate fires. Logit suppression is a stronger reference than any deployable method, since it needs the gold answer at inference time, which a deployed system does not have. GUARD-IT reaches the same Mem without that information, with the same fluency at 1B, higher fluency at 3B, and a higher FQ in three of the four settings.