- Rating
- 2
- Confidence
- 4
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
PolicyMem represents each safety policy as a low-rank subspace in a shared geometric space. Queries and responses are scored by their projection energy onto these subspaces, which drives the safety verdict and policy attribution. Flagged responses are rewritten using the implicated policies and rechecked against the same memory. On five benchmarks, the 3B variant reaches the highest average Unsafe-F1 among the baselines.
Critical strengths
-
The question is well motivated: expressing gradient updates in a vocabulary people can inspect, and using that vocabulary for control, is a worthwhile direction.
-
The method is carefully built. Fixing the LoRA A factor to make per-example signatures comparable is well justified.
Critical weaknesses
-
Detection gains are not explained by the method. The method does not show why it should intercept more. The baselines are off-the-shelf, while PolicyMem is trained per benchmark, so the comparison may reflect training data rather than the memory design.
-
Rewriting lacks a fair LLM baseline. Qwen3-4B and Qwen3-8B are prompted without policy feedback, but there is no same-backbone comparison with and without the policy descriptions, and no baseline that places the policy text directly in the prompt.
-
Rewrite utility is not measured. "Safe helpfulness" judges only the legitimate part of a request. Task completion and over-refusal rate are not reported, so a safe but unhelpful rewrite can score well.
-
Rewriter training data quality is unknown, and baselines may be weak.
-
Expansion without training is not demonstrated. The K=0 result (92% detection) is not zero-shot in the strict sense, since the encoder and verdict module were trained on the original five benchmarks.
Questions for authors
- see weakness parts
- I am wondering, if everything is unchanged except the policy memory bank/subspace, how would a LLM-based policy processer can perform in the system? What is the advantage of the proposed policy memory v.s. LLM-based policy analyzer? Please demonstrate this from methodology perspective and experiment performance perspective.
6 comments
Response to Reviewer qJLX (Part-2)
W2: Fair rewriting comparisons with and without policy feedback
Thank you for requesting a same-backbone comparison that directly tests the role of policy guidance. We evaluate all feedback variants on the same fixed case rewriting cohort and independent judges (o3 and GPT-5.2). Only the policy feedback supplied to the rewriter changes. This isolates the practical value of targeted attribution from differences in model capacity, training, or evaluation cases.
Table 3R: Policy-feedback ablation with a fixed rewriter (Eq. 23 joint good-rewrite rate).
| Policy feedback supplied to the same rewriter | Joint good-rewrite rate | Prompt tokens |
|---|---|---|
| Generic safety instruction | .7395 | 361 (0.88x) |
| Full 77-policy descriptions | .7345 | 1,906 (4.67x) |
| All policies in the case's taxonomy | .7568 | 653 (1.60x) |
| PolicyMem Top-3 attribution | .7677 | 408 (1.00x) |
Focused PolicyMem feedback achieves the best rewriting outcome with a compact 408-token prompt. Compared with providing all policies, it raises joint good-rewrite success by 3.32 percentage points while using 4.67 times fewer prompt tokens. It also improves over the shorter generic instruction by 2.82 points. The advantage therefore is not explained simply by adding more policy text or by shortening the prompt. It comes from selecting case-relevant policy evidence, the very capability supplied by an individually addressable memory.
W3: Measuring task completion and over-refusal
We agree that governance should be assessed not only by safety but also by its effect on legitimate user requests. We therefore evaluate the deployed governor end-to-end on XSTest (450 prompts) [4] with independent judges. The 250 adversarially benign prompts, deliberately phrased to resemble unsafe requests, directly probe over-refusal and task-completion failures.
Table 4R: End-to-end utility on 250 adversarially benign XSTest prompts.
| Metric | Qwen2.5-3B | With PolicyMem governor | Change |
|---|---|---|---|
| Over-refusal, full or partial | .1280 | .1280 | .0000 |
| Task completion | .8200 | .8200 | .0000 |
The governor flags only one response among the 450 prompts, and that flag falls in the benign subset: a 0.4% false-flag rate over its 250 prompts. On these challenging benign requests, PolicyMem introduces no measured increase in over-refusal and no measured decrease in task completion. On the separate 200 unsafe prompts, the evaluated delivery pipeline yields no observed harmful deliveries. These results complement the paper's safe-helpfulness metric with deployment evidence: PolicyMem preserves benign-task utility while maintaining safe delivered outputs on this held-out evaluation.
W4: Rewriter training-data quality and baseline strength
Thank you for asking for greater transparency about the rewriter's supervision and for strong teacher-based comparisons. PolicyMem constructs supervision without externally generated teacher targets. Its frozen assessor evaluates self-generated candidate revisions against the configured policy memory, selecting SFT targets and preference pairs using the policy-grounded safety-confidence criteria in Section 3.6.
Table 5R: Construction of PolicyMem's rewriter supervision.
| Stage | Number |
|---|---|
| Unsafe target responses with PolicyMem Top-3 feedback | 10,000 |
| First-round candidate rewrites (4 per target) | 40,000 |
| Second-round candidate rewrites | 40,000 |
| Candidate rewrites selected for SFT | 3,558 |
| Chosen/rejected preference pairs used for DPO | 912 |
This procedure is policy-grounded and auditable: each selected revision is linked to its originating case, attributed policy feedback, and assessor-based acceptance criterion. After assessor-filtered SFT, memory-guided DPO further favors revisions that better satisfy the configured policies, without external teacher calls for training-target generation. For a strong comparison, we evaluate a GPT-4o-teacher-supervised rewriter using the same target contexts, with outputs scored by the independent judges.
Table 6R: Independently judged rewriting quality.
| Supervision | Safety | Information | Helpfulness | Eq. 23 joint |
|---|---|---|---|---|
| GPT-4o teacher | 3.80 | 3.48 | 2.83 | .6994 |
| PolicyMem supervision | 3.98 | 3.50 | 2.84 | .7677 |
PolicyMem improves the joint good-rewrite rate by 6.83 percentage points over the GPT-4o-teacher baseline, with stronger judged safety and comparable, slightly higher information preservation and helpfulness. This indicates more policy-compliant corrections without sacrificing legitimate content. The comparison also involves approximately $260 in external teacher API calls for the GPT-4o supervision arm versus $0 in external teacher calls for PolicyMem's self-generated supervision; this comparison concerns teacher API expenditure, not total training compute.
Response to Reviewer qJLX (Part-3)
W5 & Q: New-policy generalization and comparison with LLM-based policy analyzers (Part-1)
Thank you for connecting the new-policy question to the role of an LLM-based policy processor inside the complete governance system. PolicyMem's central design is to externalize natural-language policies as learnable, individually addressable geometric memory slots. Once compiled, these slots provide the same policy-level evidence for detection, attribution, targeted rewriting, and post-rewrite reassessment. We test this operational advantage through description-only onboarding, controlled initialization, trained text-reader comparisons, scalability measurements, and a direct in-system replacement.
Description-only onboarding of unseen policies. We use zero-shot onboarding to mean inserting a new policy into an already trained governor without target-policy labels or gradient updates, not training the governor itself without safety data. In the held-out Aegis 2.0 experiment, the target taxonomy and its labeled cases are excluded from training. Compiling its policy descriptions alone yields .8048 Unsafe-F1 on cases with zero target-policy labels.
We independently repeat the insertion protocol with 13 held-out WildGuardMix policy descriptions. Without any new gradient updates, PolicyMem achieves .7153 Unsafe-F1 and .9254 max-energy AUROC. The same trained memory writer can therefore make previously unseen policy descriptions operational at insertion time, before policy-specific fine-tuning.
What text-grounded compilation contributes. To isolate initialization from subsequent adaptation, we keep the geometry, subspace rank, replay/alignment procedure, policies, and evaluation cases fixed, changing only whether new slots are compiled from their natural-language descriptions or initialized randomly.
Table 7R: Text-grounded versus random policy-slot initialization.
| Initialization | Text-compiled anchor | Random anchor |
|---|---|---|
| New-taxonomy Unsafe-F1 | .8701 | .2361 |
| New-policy attribution Top-1 / mAP | .7208 / .7730 | .1193 / .2660 |
| Incumbent Unsafe-F1 | .8711 | .8696 |
With the same subsequent alignment, text-grounded initialization improves new-taxonomy Unsafe-F1 by 63.4 percentage points and new-policy attribution mAP from .2660 to .7730, while preserving incumbent detection performance. Combined with the label-free insertion results, this isolates a key advantage of the memory-write operation: policy descriptions provide useful initial representations that can be further refined with limited supervision.
Comparison with trained LLM policy analyzers. We implement two policy-text readers with the same backbone family, LoRA setup, pooled policy training collection, labels, and training-step budget: a list reader processing policy texts together and a block-isolated reader scoring policies individually. Both can accommodate new descriptions, but they must re-encode policy text for each case. PolicyMem instead compiles each description into a cached 256 x 8 subspace and reuses inexpensive numerical reads.
Table 8R: Geometric policy memory versus trained policy-text readers.
| Property | List reader | Block-isolated reader | PolicyMem |
|---|---|---|---|
| Top-1 changes after policy-list permutation | 28.3% | 5.5% | 0.0% |
| Top-1 changes after mid-list policy insertion | 38.3% | 5.1% | 0.22% |
| New policy description at inference | Re-encode per case | Re-encode per case | Compile once, then cache |
| Input tokens per case, 77 / 1,077 policies | 1,939 / 25,094 | 1,856 / 24,011 | 208 / 208 |
| Latency at 77 policies (H100, batch 8) | 67.2 ms | 69.8 ms | 24.9 ms |
PolicyMem requires 24.9 ms per case, compared with 67.2 ms and 69.8 ms for the trained readers. Scaling from 77 to 1,077 policies increases PolicyMem latency only from 24.9 to 28.5 ms (+14.5%), while its per-case text input stays at 208 tokens. The readers, by contrast, process 25,094 and 24,011 policy-text tokens per case at 1,077 policies. PolicyMem thus avoids repeated full-corpus text encoding, while its cached per-policy reads are independent of policy-list order. Under the measured insertion experiment, only 0.22% of top-1 attributions change, even as new slots become eligible for the top rank.
Response to Reviewer qJLX (Part-1)
We thank the reviewer for recognizing the importance of making learned safety behavior interpretable and actionable. We address your questions and concerns point by point below.
Thank you for raising the question of how to distinguish the benefits of PolicyMem's representation from those of task-specific supervision. Our original evaluation follows the released-checkpoint, cross-benchmark protocol used in safeguard research [1,2,3]. These checkpoints are safety-specialized models trained on substantial moderation corpora, making them meaningful, ready-to-use baselines rather than untuned general-purpose LLMs. To strengthen this comparison, we additionally adapt three established guards to our training source, highlight the single co-trained PolicyMem governor evaluated across all five taxonomies, and directly examine what the governance-specific modules learn with backbone adaptation frozen.
Task-adapted guard baselines. Granite Guardian, WildGuard, and MD-Judge are each additionally fine-tuned on the same adaptation sample with a common LoRA configuration. All are evaluated on the same five test splits, using their official prompt formats and output parsers under a common per-case input budget.
Table 1R: Released and task-adapted guard comparisons (macro Unsafe-F1).
Three findings are notable. First, the 0.5B PolicyMem exceeds all three released guards with roughly 14 times fewer parameters than a 7B guard. Second, the 3B PolicyMem reaches .8874, exceeding the strongest additionally adapted guard (.8741) while using 2.3-2.7 times fewer backbone parameters. Third, a single 3B co-trained governor reaches .8799 across all five benchmarks, without selecting a taxonomy-specific model at inference time. Thus, strong performance is not confined to separate per-benchmark specialists: a shared geometric policy memory remains effective across heterogeneous taxonomies.
We also note that released safety checkpoints are not necessarily unexposed to related benchmark distributions: MD-Judge's model card lists BeaverTails among its training data, and WildGuard is trained using WildGuardTrain, which is related to the WildGuardMix evaluation. The revised manuscript distinguishes released from task-adapted guard baselines in Section 4.1 and Table 1.
Representation beyond backbone adaptation. We further freeze the backbone LoRA adapter and train only the governance-specific modules, including the case projection, subspace compiler, and soft-token projection. The adapter still participates in the forward pass but receives no updates.
Table 2R: Learning policy evidence with the backbone adapter frozen. Hit@1 is measured against the 77-policy union memory of this control's own reference run.
With only 31% of the reference trainable parameters, the governance modules retain 86.8% and 88.2% of the corresponding attribution Hit@1, while maintaining similar subspace separation. This demonstrates that the explicit, addressable policy-evidence structure is learned by the governance modules even without further adapting the backbone. Together, the task-adapted guard comparison and frozen-adapter control provide complementary evidence for PolicyMem's strength as both a detector and an operational policy representation.