acceptodds
Under review as a conference paper at ICLR 2027

Resolving Hard Paraphrase-Unrelated Query Regimes in Lifelong Model Editing

Abstract

Lifelong model editing requires Reliability on edited knowledge, Generality over semantically equivalent paraphrases, and Locality on unrelated queries. In memory-based editors, these objectives depend on routing each query to either the edit-specific path or the base-model path correctly. We identify **hard paraphrase-unrelated query regimes**, where paraphrases are lexically distant from the edit query, unrelated queries are lexically near it, or both. Although defined by surface distance, these regimes exhibit the same distance trend in hidden-state representation space across evaluated backbones, increasing routing-score overlap between paraphrase and unrelated queries and thereby making simultaneous Generality and Locality difficult for memory-based routers. We propose **SEAL** (**S**yn**E**rgistic intr**A**- and extra-mode**L** framework), which combines an intra-model Hopfield-based router with a lightweight extra-model Sentinel Prompt used at test-time inference. The Sentinel Prompt induces an Asymmetric Pulling Effect, suppressing unrelated-query routing scores while maintaining or increasing paraphrase scores, thereby separating the overlapping routing-score distributions. Decoupled Two-Stage Inference removes the Sentinel Prompt on the base-model path to preserve the original output distribution. Experiments on four backbones across four benchmarks show that SEAL improves Generality and Locality in hard regimes.

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
lifelong model editing, knowledge editing, memory-based routing, prompt tuning, representation learning, large language models

Reviews

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

This paper addresses two challenges in memory-based model editing: synonymous reformulations that are lexically distant from the original query, and unrelated queries that are lexically similar to the original query. Building upon the memory and routing architecture of HoReN, we introduce SEAL, which employs an offline-trained four-token soft prompt to better decouple routing representations from scoring. During inference, queries are first processed via the prompted router; if a query is classified as unrelated, the model reverts to the original input—processed by the frozen base model—to ensure that the prompt does not inadvertently alter the base model's output. Our experiments span four backbone models and four benchmarks, with further scaling to 10,000 edits on the Llama architecture.

Critical strengths
  1. **The problem has practical significance, and the diagnosis and method are clearly connected. **The paper examines surface distance, representation distance, routing score, and final results simultaneously, rather than just reporting overall performance (Figures 3–6; Appendices E, F.2).
  2. **The generated branch design is targeted and verified. ** After fixing the route, removing prompt from the base path improves WikiBigEdit Locality from 0.552 to 0.852 (Table 8). For inputs that correctly return to the base path, there is also a direct structural basis for restoring the original output distribution.
Critical weaknesses

The primary issue with this paper is that its diagnosis and proposed solutions are derived from combinations of existing, well-known methods.

First, the paper’s diagnosis regarding model editing—specifically that a single edit can introduce perturbations to related knowledge—has already been addressed in a dedicated study presented at ACL 2026. That work demonstrates that such edits cause a distinct increase in uncertainty, which current benchmarks fail to capture (e.g., when tested using prompt sets generated via techniques like rephrasing).

Diagnosing Hidden Instabilities in Model Editing via Uncertainty Quantification. ACL 2026.

Second, the proposed method is essentially a modification of established model editing techniques; it incorporates an external component at the input stage, drawing inspiration from SERAC:

Semi-Parametric Editing with a Retrieval-Augmented Counterfactual Model. ICML 2022.

Consequently, I have reservations regarding the paper's innovation. Furthermore, given the inherent limitations of existing model editing benchmarks—a topic the paper itself touches upon—the following issues arise:

  1. The metrics used do not equate to the "complete success rate" claimed in the main text. Equation 12 in Appendix D.2 calculates the average token-wise match after truncating or padding sequences to a reference length. This approach allows for partial credit for "partially correct" answers and may overlook subsequent generated content. While the absence of teacher forcing is a positive aspect, the paper should also report the "complete answer accuracy" and the "full-output retention rate." Moreover, the loss in reliability is not always negligible; for instance, on the Mistral/CounterFact dataset, the reliability score drops from 0.997 to 0.911.
  2. The strongest alternative configuration is not sufficiently explored. In Table 10, the "BGE Router + prompt" configuration achieves an OP (Output Performance) of 0.962 on CounterFact—outperforming the primary SEAL configuration (0.911)—while avoiding the need to inject prompts into the LLM or recompute the base branch. This highlights the framework's versatility, yet the authors fail to provide a compelling justification for why the primary configuration is preferable. The analysis lacks cross-benchmark comparisons, evaluations on 10k-scale datasets, latency assessments, and a comparison against a simple, trainable router that utilizes the same triplet-based supervision.
  3. Distance-based correlation is insufficient to establish the primary cause of difficulty. In Figures 4 and 11, the data is pooled across four different datasets; the observed relationship between "distance" and routing failure may, in fact, be confounded by factors such as the specific benchmark, sequence length, prompt templates, or the presence of distractor sentences. While continuous binning and cross-model analysis are helpful, they do not replace control analysis performed within the same dataset; furthermore, ZsRE-hard involves modifications to both surface-level rewrites and distractors.
Questions for authors

See Weakness

7 comments

Part 1/5

We thank Reviewer QeDC for the careful review. We address each concern below. Unless noted otherwise, results use Llama-3.1-8B with T=1T=1k.

W1. Relation to Gu et al. (ACL 2026)

We thank the reviewer for the pointer. We respectfully note that Gu et al. (2026) address a different problem in a different class of editors, and their findings do not overlap with ours.

Gu et al. study parameter-update editors, such as least-squares methods like ROME and MEMIT, which write each edit directly into the shared model weights. They show that such updates perturb pretrained knowledge, which surfaces as increased post-edit uncertainty under semantic perturbations.

Memory-based editors, the class we study, work differently (Sec. 2, App. A.1). Each edit is stored in an external memory, or a lightweight edit-specific module, attached to the frozen backbone. A router then sends each incoming query along one of two paths:

  • the edit-specific path, which applies the selected edit memory, or
  • the base-model path, which bypasses all edit memories and preserves the frozen model's pre-edit behavior.

Because the backbone weights are never overwritten, the weight-level interference measured by Gu et al. does not arise. Whether pretrained knowledge is preserved depends entirely on whether the router makes the correct decision.

This is where our diagnosis applies. We identify routing failures driven by the surface distance between the edit query and its paraphrase and unrelated queries. When the paraphrase query is lexically distant from the edit query (larger ds(xi,x~i)d_s(x_i,\tilde x_i)), or the unrelated query is lexically near it (smaller ds(xi,x^i)d_s(x_i,\hat x_i)), the hidden-state representation distance drd_r used by the router follows the same trend. Paraphrase queries therefore receive lower routing scores and unrelated queries receive higher ones, so the two routing-score distributions overlap. This makes it difficult for the router to send paraphrase queries to the edit-specific path while rejecting unrelated queries to the base-model path, and hence to achieve Generality and Locality simultaneously (Sec. 2.2, Sec. 4.3, App. E).

This chain explains why WISE, GRACE, MELO and HoReN all reach their best OP on ZsRE and degrade on the three hard-regime benchmarks (Table 1). It holds across 4 backbones, 3 layers and 4 editors, and within each individual benchmark (W5).

The two works also differ in what they deliver. Gu et al. propose an evaluation protocol. Our diagnosis directly yields a remedy, which lifts CounterFact OP from 0.364 to 0.911 and ZsRE-hard OP from 0.751 to 0.968, with gains that persist at 10k edits (Table 2).

W2. Relation to SERAC

SERAC (Mitchell et al., 2022b) is a well-known early memory-based editor. It is already included in all our experiments through its SERAC-style DEFER instantiation (Sec. 4.1, App. A.1). We respectfully disagree, however, that SEAL is a modification of SERAC. The two methods differ in their components, in what the added component does, and in how it is trained.

Components. SERAC attaches two separately trained models: a scope classifier that decides whether a query is in scope, and a counterfactual model that generates answers for in-scope queries. SEAL uses neither. Beyond the edit memory and router common to memory-based editors, it adds only a 4-token Sentinel Prompt to the single backbone model. With 16.4K parameters, the Sentinel Prompt is several orders of magnitude smaller than a dedicated scope-classifier network.

Role of the added component. The Sentinel Prompt makes no routing decision and generates nothing. It only reshapes the hidden-state representations used by the router, so that paraphrase and unrelated queries become easier for the router to distinguish. Edited answers still come from the edit values, and all other answers come from the frozen backbone. Using prompt tuning to reshape routing representations has no counterpart in SERAC.

Training. Both methods use hard negatives, but they obtain them differently. SERAC takes them passively, as out-of-scope examples that are semantically similar to the edit. SEALSYN\mathrm{SEAL_{SYN}} uses only edit-side data, which matches the deployment setting, and constructs its hard negatives actively to target the failure mode we identify. Its unrelated queries keep the edit query's template and replace only the subject with a confusable entity, i.e., they have small ds(xi,x^i)d_s(x_i,\hat x_i). SEALSYN\mathrm{SEAL_{SYN}} additionally constructs hard positives, paraphrase queries with large ds(xi,x~i)d_s(x_i,\tilde x_i), which SERAC does not use (App. H).

Results. Empirically, SERAC-style DEFER performs poorly on all four benchmarks:

WikiBigEditCounterFactZsRE-hardZsRE
DEFER (OP)0.1840.0700.0330.091
SEAL (OP)0.8690.9110.9680.991

SEAL's OP is higher by 0.69–0.94 on every benchmark (Table 1).

Part 2/5

W3. Stricter metrics and the Reliability change

The token-level score of Eq. 12 follows the standard EasyEdit protocol (Wang et al., 2024b) used by the compared methods, which keeps our results comparable with prior work. We agree, though, that it can give partial credit. To examine whether this inflates our results, we re-scored all Llama-3.1-8B evaluation outputs of Table 1 with two stricter metrics:

  • Complete-answer EM (Reliability and Generality). A query counts as correct only if the generated answer exactly matches the complete target answer yi∗y_i^*, i.e., the dataset label of the corresponding edit.
  • Complete-output retention (Locality). An unrelated query counts as preserved only if the edited model's output string is identical to that of the unedited base model. We newly generated these reference outputs for this purpose.

Following the main evaluation protocol, the generation length is set by the reference label length.

BenchmarkRel. (complete-answer EM)Gen. (complete-answer EM)Loc. (complete-output retention)OP (strict)SEAL OP (token-level, Table 1)HoReN OP (token-level, Table 1)
ZsRE0.9940.9690.9990.9870.9910.979
ZsRE-hard0.9620.9180.9990.9590.9680.751
WikiBigEdit0.9490.7850.8500.8560.8690.776
CounterFact0.9680.8500.9190.9100.9110.364

Under the strict metrics, every score stays within about two points of its token-level counterpart, and OP changes by at most 0.013. The token-level metric therefore does not inflate SEAL's results.

A complete-answer match can never score higher than the token-level score of the same output, so HoReN's token-level scores in Table 1 are upper bounds on its strict scores. SEAL's strict Generality and Locality exceed even these upper bounds on every hard-regime benchmark. On CounterFact, for instance, SEAL reaches 0.850/0.919, against HoReN's upper bounds of 0.478/0.194. SEAL's strict OP also exceeds HoReN's token-level OP on all four benchmarks.

Regarding Reliability, the change on Mistral-7B/CounterFact (0.997 → 0.911) is the largest in our tables. In the same setting, however, Generality and Locality more than double (0.368 → 0.755 and 0.335 → 0.819), and OP rises from 0.447 to 0.823. On Llama-3.1-8B at T=1T=1k, SEAL's largest Reliability drop is 0.030.

Part 3/5

W4. The BGE configuration and a trainable-router baseline

We agree that the BGE configuration (BGE Router+ps\mathbf{p}_s, App. F.5.2) is attractive. Because BGE is used only for routing, the Sentinel Prompt never enters the LLM, and Decoupled Two-Stage Inference is unnecessary. We nevertheless regard the hidden-state configuration as the primary instantiation, for two reasons.

It requires no additional model. Routing reuses the LLM's own hidden states before the edit layer, as in GRACE, WISE, MELO and HoReN. The BGE configuration instead adds a separate 335M-parameter encoder (BGE-large-en-v1.5), which must run on every query and maintain its own embedding store.

SEAL is a framework, and the BGE result is evidence for it rather than a competitor to it. The same Sentinel Prompt objective improves the Hopfield router (Table 1), a GRACE-style router (Table 9) and the BGE Router (Table 10). The choice of router is orthogonal, and SEAL improves each router it is paired with. Without ps\mathbf{p}_s, even a strong contrastively trained retriever still fails on CounterFact (Gen./Loc. 0.678/0.689); with ps\mathbf{p}_s it reaches 0.949/0.941.

As requested, we now report the large-scale, efficiency and cross-benchmark analyses for the BGE configuration as well.

Large scale. For the BGE Router on CounterFact at T=10T=10k, we reuse the CounterFact Sentinel Prompt of Table 10 without retraining:

MethodRel.Gen.Loc.OP
BGE Router0.9910.6620.4190.611
BGE Router+ps\mathbf{p}_s (SEAL)0.9890.9150.7870.889

At 10k edits, the SEAL framework still yields a consistent gain on the BGE Router.

Inference efficiency (Table 11 extended, WikiBigEdit, T=1T=1k; average ms per query):

MethodEditPara.Unrel.MeanExtra params
Base model74.50974.54268.36772.4730
HoReN81.91581.76675.13579.60618.43M
SEAL82.31585.24192.68486.74718.45M
BGE Router89.08888.46583.42286.992≈353M (incl. 335M frozen BGE)
BGE Router+ps\mathbf{p}_s89.18888.54583.47387.069≈353M (incl. 335M frozen BGE)

Relative to HoReN, SEAL adds 9.0% mean latency and only 16,384 parameters (0.089%); its extra cost falls mainly on queries routed to the base-model path, which are recomputed without ps\mathbf{p}_s. The BGE configuration avoids this recomputation, and ps\mathbf{p}_s adds only 0.08 ms to the BGE Router. Its mean latency is nevertheless slightly higher than both HoReN's (+9.4%) and SEAL's (+0.4%), because the BGE encoder runs on every query, and it adds a 335M-parameter frozen encoder, over 18× SEAL's extra parameters.

Cross-benchmark transfer. In the primary configuration, a Sentinel Prompt trained on ZsRE-hard and applied without retraining improves OP over HoReN on CounterFact (0.364 → 0.581) and on WikiBigEdit (0.776 → 0.814), as reported in our response to Reviewer S8xy (W4 / Q3). For the BGE Router, we evaluate how a Sentinel Prompt trained on WikiBigEdit (T=1T=1k) transfers to CounterFact and ZsRE-hard without retraining:

TargetBGE Router (OP)BGE Router + WikiBigEdit ps\mathbf{p}_s (OP)
CounterFact0.7630.749
ZsRE-hard0.9380.969

Transfer is not consistent for the BGE Router: the transferred ps\mathbf{p}_s improves ZsRE-hard by 0.031 but lowers CounterFact by 0.014.

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

This paper studies routing failures in memory-based lifelong model editors. The authors argue that an editing instance is hard to route when its paraphrase is lexically far from the edit query, or when its unrelated query is lexically close to it. They show that this surface pattern carries over to the hidden states used by the router, which makes paraphrase and unrelated routing scores overlap. Built on HoReN, the proposed SEAL keeps the memory and the Hopfield router unchanged. It adds a Sentinel Prompt, four soft tokens prepended to test queries and trained with hinge losses so that edit and paraphrase scores stay high and unrelated scores stay low. A two-stage inference reruns the frozen model without the prompt whenever a query is routed to the base path. Experiments on four backbones and four benchmarks, up to 10K edits, show large gains over HoReN on the hard benchmarks, especially CounterFact.

Critical strengths
  • The diagnosis is clear and well supported. The link from surface distance to representation distance to routing score overlap is measured across backbones and layers. The routing accuracy analysis also shows exactly where existing editors fail.
  • The method is light and practical. It adds about 16K parameters, needs no per-edit training, and also works with a GRACE-style router [2] and a BGE router [3]. The two-stage inference keeps the base model output unchanged for queries routed to the base path.
  • The experiments are thorough. All baselines are run in the same setup. The threshold sweep, edit-only calibration, synthetic data variant, latency study and ablations on prompt length and training size answer most natural follow-up questions.
Critical weaknesses
  • The contribution over HoReN [1] is incremental. Memory construction and the router are identical, and the new parts are a soft prompt and a rerun rule. Prompt tuning [4, 5] is a standard technique. The paper would be clearer if it presented the Sentinel Prompt as a learned query adapter and discussed it in those terms.
  • The training losses closely follow existing routing objectives. WISE [6] already trains its routing with hinge losses that push edit activations above one margin and irrelevant activations below another, with an explicit gap term between them. Using paraphrases as positives and same-template entity swaps as hard negatives is also standard practice in dense retrieval [7]. The paper uses WISE only as a baseline and does not discuss this connection.
  • The comparison with HoReN is not on equal footing. HoReN uses no paraphrase or locality supervision, while SEAL uses about 1K annotated triplets from the same benchmark, plus LLM augmentation on WikiBigEdit. A fair control would give HoReN the same data, for example by training a small projection on the routing representation with the same losses. Without this control it is hard to tell how much of the gain comes from the prompt and how much comes from the extra supervision. The BGE router result, which goes from 0.763 to 0.962 OP once a prompt is added, suggests that almost any supervised query adaptation may help a lot.
  • A separate Sentinel Prompt and threshold are trained for every benchmark and backbone, and there is no cross-benchmark transfer experiment. In deployment the query distribution is unknown and may shift over time.
  • Part of the hard regime seems to come from how the benchmarks are built. Paraphrases in ZsRE-hard, which the authors construct with Qwen3-MAX, and in CounterFact begin with an unrelated distractor sentence. The synthesis pipeline for SEAL_SYN uses the same trick. SEAL_SYN even beats SEAL on ZsRE-hard (0.984 vs 0.968), but drops to 0.814 on CounterFact. This suggests that the prompt may mainly learn to ignore a leading distractor and to separate entity swaps, rather than becoming robust to natural paraphrases.
  • The definition of the hard regime is coarse. Hardness is based on token-level Levenshtein distance, with a median split pooled over the evaluated benchmarks, so it is relative to the benchmarks that were chosen. The claim that it is a property of the data is therefore weaker than stated.
  • Reliability drops in several settings, for example from 0.997 to 0.911 on CounterFact with Mistral-7B and from 0.999 to 0.969 with Llama-3.1-8B. Latency for unrelated queries increases by 23.4%, and in practice most incoming queries are unrelated to the stored edits.
  • The Asymmetric Pulling Effect is not consistent across benchmarks. On WikiBigEdit the mean paraphrase score even drops slightly, by 0.003, and the gain comes almost entirely from lowering unrelated scores.
  • The writing is hard to follow in places. The phrase "hard paraphrase-unrelated query regimes" is easily read as "queries unrelated to paraphrases". Calling the hard negatives "unrelated" also hides the main point, which is that they look very similar to the edit query. Standard terms such as hard positives and hard negatives, or locality queries, would be clearer. The paper also introduces many capitalized names for fairly simple ideas, and "Resolving" in the title overstates the results.

[1] HoReN: Normalized Hopfield Retrieval for Large-Scale Sequential Model Editing, arXiv 2026

[2] Aging with GRACE: Lifelong Model Editing with Discrete Key-Value Adaptors, NeurIPS 2023

[3] C-Pack: Packed Resources For General Chinese Embeddings, SIGIR 2024

[4] The Power of Scale for Parameter-Efficient Prompt Tuning, EMNLP 2021

[5] Prefix-Tuning: Optimizing Continuous Prompts for Generation, ACL 2021

[6] WISE: Rethinking the Knowledge Memory for Lifelong Model Editing of Large Language Models, NeurIPS 2024

[7] Dense Passage Retrieval for Open-Domain Question Answering, EMNLP 2020

Questions for authors
  1. Can you compare SEAL with HoReN plus a simple learned query adapter, such as a linear projection or LoRA on the layers before the edit layer, trained on the same triplets with the same losses?
  2. How does the Sentinel Prompt objective relate to the routing activation loss in WISE [6]? Have you tried training the HoReN router with a WISE-style loss?
  3. How well does a Sentinel Prompt trained on one benchmark transfer to another, for example from ZsRE-hard to CounterFact or WikiBigEdit?
  4. Can you evaluate on paraphrases without distractor prefixes, such as human-written paraphrases, to check whether the prompt mainly learns to ignore the leading sentence?
  5. How were the margins δe, δp and δl chosen, and how sensitive are the results to them?
  6. Does the prompt affect generation quality on the edit path, for example fluency or long answers, beyond token-level exact match?
  7. Is the hard regime split robust to the choice of distance, for example semantic similarity from a sentence encoder instead of Levenshtein distance, or medians computed per benchmark instead of pooled?
  8. Can you report results on a mixed query stream in which most queries are unrelated to the stored edits, including end-to-end latency?
8 comments

Part 1/5

We thank Reviewer S8xy for the detailed and constructive review. We address each point below. Unless noted otherwise, new experiments use Llama-3.1-8B with T=1T=1k.

W1. Contribution over HoReN

We agree that SEAL inherits HoReN's memory construction and Hopfield router, and that soft-prompt tuning as a parameterization is established (Lester et al., 2021; App. A.2). However, SEAL's contribution lies elsewhere.

  1. A data-level diagnosis of why strong memory-based routers fail. Larger ds(xi,x~i)d_s(x_i,\tilde{x}_i) and smaller ds(xi,x^i)d_s(x_i,\hat{x}_i) propagate to drd_r, and from drd_r to overlapping routing-score distributions. This chain holds across 4 backbones, 3 layers and 4 editors (Sec. 4.3, App. E), and also within each individual benchmark (see W6). It explains why memory-based editors (WISE, GRACE, MELO, HoReN) all reach their best OP on ZsRE and degrade on the three hard-regime benchmarks (Table 1). The most striking case is HoReN, which is near-perfect on ZsRE (OP 0.979) yet collapses on CounterFact (OP 0.364).
  2. A router-agnostic framework that leaves both the backbone and the memory untouched. Prompt tuning is common, but to our knowledge SEAL is the first model-editing method to use it to reshape the hidden-state geometry on which routing decisions are made. Keys are encoded without ps\mathbf{p}_s and only queries are prompted. A single shared 4-token prefix (16.4K parameters) generalizes to edits never seen in training, without per-edit optimization, and improves Hopfield, GRACE-style and BGE routers alike (Tables 1, 9, 10).
  3. Decoupled Two-Stage Inference, which is what makes input-level steering usable for editing at all. Without it, Locality falls from 0.852 to 0.552 (Table 8).

On the suggested "learned query adapter" view, our new same-supervision comparison (W3/Q1, Part 2) shows that this framing undersells the design. Generic query adapters, with up to four orders of magnitude more parameters and trained on identical data with the identical loss, do not reproduce SEAL's effect. A linear adapter overfits the key geometry of the training memory, and a LoRA adapter shifts routing only modestly and stays far below SEAL. The substantive design choice is where ps\mathbf{p}_s acts: at the input, conditioning every layer through attention, against frozen unprompted keys.

W2 / Q2. Relation to WISE and DPR

Hinge margins and same-template hard negatives are standard tools, and we do not claim the loss form as a contribution. However, the problem each method solves differs fundamentally.

WISE optimizes side-memory parameters at edit time. Its routing activation is therefore a function of the edited weights and must be re-optimized as edits arrive. SEAL instead trains a query-side input module once, offline, on edits disjoint from evaluation. Memory keys and values stay frozen and are reused unchanged for all future edits. Empirically, WISE falls far below SEAL on all four benchmarks on Llama-3.1-8B (OP 0.177/0.274/0.133/0.334 versus 0.869/0.911/0.968/0.991). Despite its routing loss, WISE still degrades in the hard regimes relative to ZsRE (Table 1), and its routing scores still overlap on CounterFact (Fig. 13).

The idea behind our margin loss is indeed similar to DPR's contrastive training: pull positives toward their target and push hard negatives away. The difference lies in what is trained and at what cost. DPR fine-tunes full encoders (two BERT-base models) on tens of thousands of question–passage pairs. SEAL trains only a 4-token prompt (16.4K parameters) on 1,000 instances, with the backbone, the router and the memory all frozen. At this far lower training cost, it still substantially improves the routing of memory-based editors: on CounterFact, routing HM rises from 0.356 to 0.905 and OP from 0.364 to 0.911.

Direct answer to Q2. The Hopfield router has no trainable parameters, so training it with a WISE-style loss requires attaching a trainable query module. We did exactly this in W3/Q1 (Part 2). We additionally added WISE's explicit gap term ReLU(γ−(sp−sl))\mathrm{ReLU}(\gamma-(s_p-s_l)) with γ=0.1\gamma=0.1. The gap term moves the routing harmonic mean only marginally (0.443 → 0.465), far below SEAL (0.905). The bottleneck is not the form of the objective but where the adaptation is applied.

Part 2/5

W3 / Q1. Is the gain due to extra supervision?

To examine whether SEAL's gain comes from the additional supervision rather than from ps\mathbf{p}_s itself, we ran the requested control. We attached a learned query adapter to HoReN and trained it on the same 1k triplets, with the same loss (Eq. 8) and the same margins. As in SEAL, keys are left unadapted. All added modules act only on the routing query; keys, edit values and the final generation use exactly the same parameters as HoReN, so any difference between the variants arises from routing alone. The table reports routing accuracy on held-out CounterFact edits. Adapters are reported at their best threshold; HoReN and SEAL are taken from Table 6.

MethodExtra paramsEditPara.Loc.HM
HoReN01.0000.4660.1890.356
+ Linear adapter on hrh_r (14336×14336, init. II, query-only)205.5M0.8640.2410.6840.443
+ Linear adapter + WISE gap (γ\gamma=0.1, query-only)205.5M0.7830.2810.6210.465
+ LoRA (rr=8, α\alpha=16, last 2 layers before the edit layer, query-only)1.31M0.9990.4640.6380.635
SEAL (ps\mathbf{p}_s)16.4K0.9710.8360.9190.905

The linear adapter memorizes rather than generalizes. It reaches 0.996/0.998/0.977 on the training memory but only 0.864/0.241/0.684 on the held-out memory. Its weight matrix drifts far from initialization: ∣W−I∣F=3724|W-I|_F=3724 versus ∣I∣F=119.7|I|_F=119.7 (31×), already 2252 after the first epoch. Its singular values range from about 0 to 804.5, with a median of 5.9. It thus learns the key geometry of the training memory rather than a transferable query transform.

The LoRA adapter does not overfit, but its control over the hidden-representation geometry is limited. Its training-memory accuracy (1.000/0.489/0.577) is close to its held-out result. On held-out edits it still trails SEAL on both sides (paraphrase routing 0.464 vs. 0.836; unrelated routing 0.638 vs. 0.919), despite having 80× more parameters.

Only SEAL lifts both sides on unseen edits, with 80× fewer parameters than LoRA and over 12,000× fewer than the linear adapter. Identical supervision alone therefore does not account for the gain; what matters is where and how the adaptation is applied.

On BGE. SEAL(BGE-router) is itself an instance of SEAL: the same Sentinel Prompt objective applied at a different router's input. Its improvement (OP 0.763 → 0.962, Table 10) therefore supports the framework, rather than the view that any supervised query adaptation suffices. The adapters above point the other way.

W4 / Q3. Per-benchmark prompts and transfer

A Sentinel Prompt is trained once and then reused for any number of future edits, at no per-edit cost. To assess transfer, we applied the prompt trained on ZsRE-hard, without retraining, to the two benchmarks the reviewer named:

TargetHoReN OPSEAL, ps\mathbf{p}_s trained on ZsRE-hardSEAL, in-distribution ps\mathbf{p}_s
CounterFact0.3640.5810.911
WikiBigEdit0.7760.8140.869

The transferred prompt improves over HoReN on both targets without retraining. This shows a meaningful degree of cross-benchmark generalization, although, as expected, it does not reach an in-distribution prompt.

The WikiBigEdit result is particularly telling. ZsRE-hard paraphrases are surface-distant and carry leading distractors, whereas WikiBigEdit paraphrases are surface-close and carry no distractors. The prompt nevertheless improves WikiBigEdit. This indicates that ps\mathbf{p}_s has not memorized the paraphrase template or distractor pattern of its training distribution.

Part 3/5

W5 / Q4. Does ps\mathbf{p}_s merely learn to skip a leading distractor?

To test whether ps\mathbf{p}_s relies on skipping a leading distractor, we took the prompt trained on the original ZsRE-hard (with distractors). We then evaluated it on ZsRE-hard paraphrases with the distractor sentence removed, keeping memory, prompt and τ\tau fixed.

Paraphrase inputRel.Gen.Loc.
Original (with distractor)0.9740.9331.000
Distractor removed0.9740.9051.000

If ps\mathbf{p}_s had learned a "skip the leading sentence" shortcut, removing the distractor would make it skip the actual query, and Generality would collapse. Instead, Generality changes by only 0.028 on purely rewritten paraphrases, while Reliability and Locality are unchanged. This indicates that ps\mathbf{p}_s does not depend on such a shortcut.

The other benchmarks point the same way, since SEAL's gains are not confined to data that contains distractors. WikiBigEdit has no distractor prefixes, yet SEAL raises its Locality from 0.655 to 0.852 and its Generality from 0.753 to 0.805. The original ZsRE has no distractors either, and SEAL raises its Generality from 0.942 to 0.974 (Table 1).

On SEALSYN\mathrm{SEAL_{SYN}}. The distractors in CounterFact belong to the original benchmark (Meng et al., 2022), not to our construction. They take noisy, document-derived forms such as narrative fragments, citation strings and URLs (Tables 3, 16). SEALSYN\mathrm{SEAL_{SYN}}'s synthetic distractors, in contrast, are clean factual sentences (App. H.2). Despite this large mismatch in form, SEALSYN\mathrm{SEAL_{SYN}} still lifts CounterFact substantially over HoReN (Gen. 0.478 → 0.726, Loc. 0.194 → 0.825, OP 0.364 → 0.814; Table 15). A prompt that had merely memorized how to skip one particular form of distractor could not carry over between such different forms.

W6 / Q7. Robustness of the regime definition

The quadrant split is a descriptive tool for relative routing difficulty. Its boundary is relative by design, and none of our conclusions depend on where it is placed. What we claim is a trend: drd_r rises with dsd_s, and routing scores fall as drd_r rises. Figs. 4 and 11 establish this with equal-frequency binning and Pearson tests, without using any median.

To rule out that the pooled trend is driven by between-benchmark differences (dataset, templates, distractor style), we recomputed both correlations within each benchmark. Each benchmark contributes 1k instances, and all correlations are significant at p<0.001p<0.001. More detailed analyses and experiments are provided in our response to Reviewer jYwc (W2 & Q1).

Benchmarkdsd_s–drd_r (Para.)dsd_s–drd_r (Unrel.)drd_r–score (Para.)drd_r–score (Unrel.)
ZsRE0.7790.515−0.857−0.722
ZsRE-hard0.6340.515−0.835−0.722
WikiBigEdit0.7810.609−0.938−0.775
CounterFact0.6280.537−0.890−0.724
Pooled (Fig. 4)0.7400.681−0.936−0.793

Both links hold inside every benchmark, with the same sign and comparable strength as the pooled analysis. Within benchmarks, dsd_s–drd_r ranges from 0.63 to 0.78 for paraphrases and from 0.52 to 0.61 for unrelated queries. drd_r–score ranges from −0.84 to −0.94 and from −0.72 to −0.78, respectively. Since no split is involved, the trend is an artifact neither of pooling nor of per-benchmark medians. ZsRE and ZsRE-hard share identical edit and unrelated queries, which is why their unrelated-side values coincide.

On semantic distance. drd_r is itself a model-internal representation distance: it is the quantity the router actually uses, and it follows dsd_s within every benchmark. Moreover, a router operating purely on sentence-embedding similarity (BGE-large-en-v1.5) still struggles on CounterFact, with Generality 0.678 and Locality 0.689 (Table 10). The difficulty is therefore not an artifact of a lexical metric. We use Levenshtein distance precisely because it is model-free and reproducible, so the regime is determined from the text alone, before any model is involved. This is what "data-level" refers to, and that regime then predicts routing failure across 4 backbones, 3 layers and 4 editors.

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

The paper studies a routing bottleneck in lifelong memory-based model editing: lexically distant paraphrases may miss the intended edit, while similar-looking unrelated queries may trigger it. SEAL learns a shared soft prompt to reshape query representations against unchanged edit memories, and removes the prompt when returning to base-model generation. It organizes routing difficulty using two surface-distance axes and reports improvements across four backbones, four benchmarks and up to 10k edits, with direct routing measurements and additional controls.

Critical strengths
  1. The paper addresses an important failure mode and demonstrates a lightweight remedy. A shared four-token prompt improves access to unseen edits without changing their stored memories or retraining the prompt for each edit. The CounterFact OP gain from 0.364 to 0.911, and from 0.184 to 0.836 at 10k edits, makes this more than a marginal optimization (Tables 1–2). The separation of routing from base-model generation is also well motivated.

  2. The experiments support a coherent empirical claim rather than just a higher aggregate score. Direct routing accuracy and threshold sweeps support improved separation; the generation ablation explains why the base-model path needs an unprompted rerun. GRACE-style and BGE experiments extend the idea beyond Hopfield routing, and edit-only synthetic supervision partly addresses the need for annotated triplets (Tables 6, 8–10, 12 and 15).

Critical weaknesses
  1. The conceptual advance is limited. SEAL builds on HoReN’s memory and routing framework, mainly adding a learned soft prompt and branch-specific inference (§§3.3–3.4). The Asymmetric Pulling Effect demonstrates useful generalization to unseen edits, but offers limited insight beyond the intended score separation. The empirical gains are substantial; the paper should more clearly distinguish this effective adaptation from a broadly new editing framework.

  2. The distance-based diagnosis remains largely descriptive (§4.3). The regimes largely track benchmark construction, and pooled analyses do not clearly separate distance effects from dataset or template effects. Paired ZsRE/ZsRE-hard and cross-backbone results strengthen the association, but wording and distractors change together. A controlled within-benchmark analysis, or a narrower interpretation, would clarify the diagnosis’s added value without calling the routing gains into question.

If these issues can all be addressed, I would consider raising the score.

Questions for authors
  1. Does the relationship between surface distance and routing failure remain within each benchmark after accounting for query length, templates and distractor prefixes? The existing pooled plots establish an association, but a stratified analysis would clarify the independent value of the proposed diagnosis.

  2. What does the Asymmetric Pulling analysis establish beyond successful optimization of the separation objective in Eq.8? Can the existing results identify conditions where the four-token adaptation succeeds or remains limited, so that the paper provides a reusable lesson beyond the benchmark gains?

4 comments

Part 1/2

We thank Reviewer jYwc for the thoughtful and constructive review. We appreciate the recognition that SEAL addresses an important failure mode with a lightweight remedy, and that our experiments support a coherent empirical claim rather than just a higher aggregate score. We address each point below.

W1 & Q2: Contribution beyond HoReN and the Asymmetric Pulling Effect

We agree with the reviewer that prompt tuning is an existing technique and that SEAL reuses the memory and router of existing memory-based editors (HoReN).

However, we believe the contribution goes beyond applying an existing technique. Conventional prompt tuning serves as a PEFT method that improves a specific capability of the model. To our knowledge we are the first to use it to reshape the representation geometry of queries for routing in memory based editing. The Sentinel Prompt psp_s acts only on test queries, while the edit memory and its keys stay unchanged.

Moreover, SEAL is not tied to HoReN or to any particular memory-based editor. It is a router-agnostic framework that can improve the routing of different memory-based editors. Beyond the Hopfield router, the same Sentinel Prompt training improves a GRACE-style router (Table 9) and a frozen BGE router (Table 10).

We agree that the Asymmetric Pulling Effect arises from successful optimization of the separation objective. This does not make its emergence inevitable. Our objective couples conflicting goals: it pulls edit and paraphrase queries toward their keys while pushing unrelated queries away from all keys. In hard regimes this conflict is concrete. On CounterFact without psp_s, unrelated queries have a higher mean routing score than paraphrases (0.807 vs. 0.794, Table 7), so the prompt must reverse this order (0.697 vs. 0.867 with psp_s). Whether a single shared 4-token prefix trained under such an objective could satisfy both sides was not predictable a priori; we demonstrate it empirically.

Beyond what the separation objective directly induces, the Asymmetric Pulling Effect generalizes to cases unseen during training. psp_s is trained on only N=1N = 1k instances, and the edits used for evaluation are disjoint from them. Even with 10k unseen edits, the same psp_s substantially improves over HoReN (Table 2). This matters for real-world deployment: within the same benchmark distribution, SEAL does not need to keep retraining psp_s as the number of edits grows.

Regarding when the four-token adaptation succeeds, our experiments show that it improves the overall routing of memory-based editors in many settings. SEALSYN\mathrm{SEAL_{SYN}} simulates the realistic case where paraphrase and unrelated queries are unavailable and trains psp_s only on triplets synthesized from edit-side data. It still improves over HoReN on all three hard-regime benchmarks (Table 15). This indicates that SEAL has potential for production use.

SEAL also has limitations. First, on the three hard-regime benchmarks, edit-query routing accuracy decreases slightly (97.9 / 97.1 / 98.9% vs. 100%, Table 6). Without psp_s, an edit query is identical to the query used at editing time, so its hidden-state representation matches its key and the routing score is close to 1. Prepending psp_s reduces this score slightly, which lowers Reliability. SEAL is therefore less suitable for applications that require exact recall on the original edit query, such as correcting a safety-critical fact (e.g., an updated drug contraindication), where the original edit query must always return the updated answer. Second, to avoid contaminating inference on unrelated queries, psp_s and Decoupled Two-Stage Inference introduce some additional inference latency (mean +9.0% over HoReN, Table 11), mainly on queries routed to the base-model path. Future work could reduce this cost by moving the router to a shallower layer, which reduces the prompted computation that is discarded before the prompt-free rerun.

Part 2/2

W2 & Q1: Does the distance–routing relationship hold within each benchmark after accounting for confounds?

We thank the reviewer for raising this important point.

Fig. 4a shows that drd_r follows the same trend as dsd_s for both edit–paraphrase and edit–unrelated pairs, and Fig. 4b shows that larger drd_r is associated with lower routing scores. Together, they link dsd_s to routing failure: paraphrases with larger ds(xi,x~i)d_s(x_i,\tilde{x}_i) receive lower routing scores and are more likely to be wrongly rejected, while unrelated queries with smaller ds(xi,x^i)d_s(x_i,\hat{x}_i) receive higher routing scores and are more likely to be falsely activated.

We acknowledge that the pooled analysis may be confounded by between-benchmark differences and by other factors such as query length. We therefore recomputed both links separately within each benchmark (1k instances per benchmark; Pearson rr on raw instances; all p<0.001p<0.001):

Benchmarkdsd_s–drd_r (para.)dsd_s–drd_r (unrel.)drd_r→score (para.)drd_r→score (unrel.)
ZsRE0.7790.515−0.857−0.722
ZsRE-hard0.6340.515−0.835−0.722
WikiBigEdit0.7810.609−0.938−0.775
CounterFact0.6280.537−0.890−0.724
Pooled (Fig. 4)0.7400.681−0.936−0.793

Both links remain moderate to strong within every benchmark (∣r∣≥0.51|r| \ge 0.51) and keep the same sign as in the pooled analysis, showing that the relationship between dsd_s and routing scores holds within each benchmark rather than arising only from differences between benchmarks. That said, the pooled analysis masks substantial variation in correlation strength across benchmarks, and it is partly inflated by between-benchmark differences: for edit–unrelated pairs, the pooled correlation exceeds every within-benchmark value in both links, indicating that the relative placement of the benchmarks strengthens the pooled trend. Note that ZsRE and ZsRE-hard share identical edit and unrelated queries, so their unrelated-query correlations coincide.

To rule out query length as a confound, we split the queries of each benchmark into three equal-frequency bins by whitespace-token count and recompute both links within each bin (all p<0.001p<0.001):

BenchmarkQueryLength bins (words)dsd_s–drd_r (T1 / T2 / T3)drd_r→score (T1 / T2 / T3)
ZsREpara.3–6 / 6–8 / 8–170.68 / 0.77 / 0.85−0.87 / −0.83 / −0.85
ZsREunrel.9–10 / 10–11 / 11–200.55 / 0.47 / 0.49−0.72 / −0.74 / −0.68
ZsRE-hardpara.6–15 / 15–17 / 18–250.65 / 0.63 / 0.65−0.84 / −0.81 / −0.86
WikiBigEditpara.2–8 / 8–10 / 10–240.77 / 0.74 / 0.88−0.92 / −0.98 / −0.99
WikiBigEditunrel.3–8 / 8–10 / 10–190.55 / 0.63 / 0.73−0.76 / −0.84 / −0.74
CounterFactpara.4–11 / 11–14 / 14–220.58 / 0.65 / 0.67−0.90 / −0.87 / −0.90
CounterFactunrel.2–5 / 5–6 / 6–140.53 / 0.47 / 0.54−0.68 / −0.70 / −0.71

Bins are split by rank, so a boundary length can appear in two adjacent bins. ZsRE-hard unrelated queries are identical to those of ZsRE and are omitted. In every bin, both links keep the same sign and a magnitude comparable to the corresponding benchmark-wide values, indicating that the relationship between dsd_s and routing scores persists across query lengths and is not explained by length.

To rule out distractor prefixes as a confound, we compare ZsRE-hard with a variant in which the distractor sentence is removed from every paraphrase while the rewritten question is kept:

ZsRE-hard (para.)dsd_s–drd_rdrd_r→score
With distractor0.634 (p<0.001p<0.001)−0.835 (p<0.001p<0.001)
Without distractor0.587 (p<0.001p<0.001)−0.816 (p<0.001p<0.001)

Removing the distractor changes both correlations only slightly, and the relationship between dsd_s and routing scores is preserved, indicating that it does not arise from the distractor prefix.

Each benchmark contains many relations with different templates. To rule out template differences as a confound, we group WikiBigEdit instances by relation and recompute both links within every relation with more than 50 instances (all p<0.001p<0.001):

Relationdsd_s–drd_r (para.)drd_r→score (para.)dsd_s–drd_r (unrel.)drd_r→score (unrel.)
P17 country0.870−0.9800.755−0.908
P31 instance of0.858−0.9790.618−0.884
P407 language0.797−0.9410.741−0.767

Within each relation, both links keep the same sign as the benchmark-wide values and are of comparable or greater strength, indicating that the relationship between dsd_s and routing scores is not driven by differences between templates.

We hope these responses address your concerns, and we sincerely thank you again for your time and constructive feedback.

Dear Reviewer jYwc,

Thank you again for your time and valuable comments. We have posted a detailed response addressing your concerns. We would greatly appreciate it if you could take a look at our rebuttal when convenient and let us know whether it resolves your concerns or if any questions remain. We are happy to provide further clarification.

Best regards,

The Authors

Dear Reviewer jYwc,

As the discussion period is coming to a close, we would like to kindly follow up on our earlier response. We would be grateful if you could take a look at our rebuttal when convenient and let us know whether it addresses your concerns or if any questions remain. Thank you again for your time.

Best regards,

The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.