acceptodds
Under review as a conference paper at ICLR 2027

MemEdit: Fine-Grained Memory Surgery for Expandable Parametric Agent Memory

Abstract

Parametric memory modules, which are lightweight neural networks pretrained to internalize retrieval patterns, have emerged as a promising alternative to retrieval-augmented generation (RAG) for equipping large language model (LLM) agents with persistent knowledge. However, existing parametric memories operate as *write-only* stores: once knowledge is encoded into parameters, there is no principled mechanism for locating, updating, or erasing individual memory traces without costly retraining. This limitation is critical in long-lived agent scenarios where facts become outdated, user preferences shift, and privacy regulations mandate selective forgetting. We introduce **MemEdit**, a fine-grained *memory surgery* framework that brings the full spectrum of CRUD operations: **C**reate, **R**ead, **U**pdate, **D**elete, to parametric agent memory. MemEdit carries out every operation in four stages: *locate*, *preserve*, *intervene*, and *verify*. A *Memory Attribution* mechanism based on integrated gradients localizes each memory trace to a neuron footprint, which *Query* exposes for inspection. The three write operations share one constrained rank-one update whose output side is confined to the footprint and whose input side is projected away from the keys of preserved memories: (i) *Insert* writes into the null space of existing keys with exact preservation; (ii) *Modify* rewrites a stored value under a locality penalty; and (iii) *Delete* applies projected gradient ascent that leaves all other stored keys unchanged. Every write is journaled as a reversible low-rank delta and verified. When the null space is exhausted, a *Mixture-of-Memory-Experts* (MoME) expansion strategy adds independently editable memory shards, so that editing capacity grows with the number of shards. Experiments on LoCoMo and MemBench benchmarks show that MemEdit achieves 94.6% edit success rate while preserving 97.3% of unrelated memory accuracy, scales to over 10K sequential edits without catastrophic forgetting, and outperforms both non-parametric and parametric baselines in downstream QA.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Agent Memory, Parametric Memory, Knowledge Editing, Machine Unlearning

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_3HR1OpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper addresses CRUD operations on parametric agent memory. Existing parametric memories such as MLP Memory are write-only and cannot handle fact updates or selective forgetting. MemEdit casts each memory operation as four stages, locate, preserve, intervene, and verify: integrated gradients localize each memory to a neuron footprint, and the three write operations share one constrained rank-one rule whose output side is confined to the footprint and whose input side is projected onto the null space of stored keys, so that INSERT preserves existing memories exactly and DELETE erases via projected gradient ascent without changing other stored keys. Every write is journaled as a reversible low-rank delta and verified, and a Mixture-of-Memory-Experts adds independently editable shards when null-space capacity is exhausted.

Critical strengths
  1. The problem formulation and the unified write rule form a coherent conceptual contribution. Casting CRUD on parametric memory as a duality between output-side localization and input-side preservation makes Insert, Modify, and Delete instances of one rank-one rule, with exact preservation of stored keys (Propositions 1 and 2) and null-space rank as a directly observable capacity signal that triggers MoME expansion. The design elements interlock rather than merely stack.
  2. The empirical treatment is systematic and honest. Beyond headline metrics, the paper provides causal validation of the attribution (necessity and sufficiency tests, 0.82 correlation with an exhaustive causal ranking), deletion robustness under paraphrase, adversarial extraction, relearning, and membership inference, controller error analysis with verification and rollback, a 10K-edit stress test with long-horizon retention tracking, and multi-seed results with standard deviations. The non-certified nature of Delete and the scope of the guarantees are discussed openly.
Critical weaknesses
  1. There is a gap between the preservation guarantees and deployment conditions. Propositions 1 and 2 hold only for keys cached in the key bank, whereas real queries are paraphrases that are not cached. Table 14 shows that MP on held-out keys falls to 92.2% at T = 5 and 83.1% at T = 20, and paraphrase ESR drops to 87.3% (Table 12). The headline 97.3% MP is measured with key-bank-anchored probes; the paper never directly reports preservation on the natural query distribution after an edit stream, so the distance between headline numbers and deployment conditions remains unquantified.
  2. The core technique is a composition of established components and the downstream gains are modest. IG attribution, null-space projection (AlphaEdit), gradient-ascent unlearning, and sparse MoE all have precedents, and the paper's own Naive-Compose ablation (Table 8) attributes 4.6 ESR at 500 edits to the way they are combined. The margin over the strongest baseline AlphaEdit-M is +2.2 ESR and +2.5 MP (Table 1). On downstream LoCoMo, MemEdit improves over the non-editable MLP Memory by only 1.4 F1 (46.2 vs. 44.8), while AlphaEdit-M (44.1) falls below the no-edit baseline. The value of CRUD lies mainly in operability (updates, deletion, auditability) rather than QA accuracy, and the paper does not consistently frame its conclusions that way.
Questions for authors
  1. Please report preservation on held-out natural queries (not probes constructed from memory statements) after an edit sequence. How large is the key bank in deployment and how are its keys chosen? What fraction of actual queries falls within the guarantee when coverage is incomplete?
  2. In Table 1, AlphaEdit-M's LoCoMo F1 (44.1) is below that of the entirely non-editable MLP Memory (44.8). Does editing itself cost downstream accuracy? If so, how much of MemEdit's +1.4 F1 over MLP Memory is attributable to the CRUD capability?
  3. What exactly was adapted in ROME-M, MEMIT-M, and AlphaEdit-M for the memory module? Did they receive the same footprint localization, the same per-layer editing budget, and the same verification with rollback? These details are needed to judge the fairness of the comparison.
4 comments
AuthorsOpenReview ↗

Response to Reviewer 3HR1 (Part 1)

W1: There is a gap between the preservation guarantees ...

A1: You have identified the sharpest limitation of the method, and we have both measured it and stopped leaving it for a reader to assemble from scattered appendices.

Appendix C.10 (new) measures ESR and MP on the natural query distribution after an edit stream, using the LoCoMo QA questions, which were written without reference to our probes: ESR 85.1 and MP 95.2, against 94.6 and 97.3 on the probes and 87.3 and 96.4 on held-out paraphrases. Section 3.3 now qualifies the propositions in the body, directly where they are stated, and the limitations section gives the gap with the numbers and names coverage as the cause, so the distance between the headline figures and deployment conditions is flagged where the claim is made and quantified where it is measured.

Appendix C.10 also makes the mechanism explicit rather than leaving the gap unexplained. Using the same δkey\delta_{\mathrm{key}} test Insert applies, we report what fraction of natural queries falls inside the protected span and split MP along that line: coverage is 84.7% in the default configuration, MP on covered queries is 97.5%, and MP on uncovered queries is 82.4%, so essentially the entire erosion lives outside the span. The residual on covered queries is attributable to Modify, the one write that imposes preservation as a penalty rather than a hard constraint; in a delete-only stream, where only the hard constraint is active, the figure is 99.98%. This also reframes Table 14's held-out column: it is not an unexplained residual but the same quantity measured under a delete-only stress schedule.

Two interventions narrow the gap and we report both, including the one that turns out to be weak. Paraphrase-averaged attribution over five probes raises natural-query ESR from 85.1 to 90.6 at roughly 4.6 times the attribution cost. Enlarging the anchor set raises coverage from 84.7% to 87.3% and natural-query MP from 95.2 to 95.6, and no further: every key in the bank consumes one null-space dimension, so coverage is bought with editing capacity and is capped by the key dimension, and the configuration above already leaves a shard with almost no room to insert. We had previously described this lever as a storage budget, which understated its cost. Neither intervention closes the gap.


W2: The core technique is a composition of established components ...

A2: We accept the framing point and have changed the paper accordingly rather than arguing the margins are larger than they are.

Framing. The Conclusion now states that the value of the CRUD interface lies as much in operability, namely reversible updates, targeted deletion, and an auditable journal, as in the accuracy it buys, and that the gains on untouched content are deliberately small by design. A new limitation, "Scope of the downstream gains", says the benefit is concentrated on questions that interrogate revised or retracted content and is close to neutral elsewhere, so benchmarks that do not ask about changed facts will understate the framework. The abstract and the contribution bullet no longer claim the highest edit success rate among all methods.

Margins, stated accurately. Adding WISE-M as a baseline reduces the MP margin we can claim from +2.5 to +0.8, since memory-based editors are stronger on preservation than the weight-editing baselines were. We report that rather than omitting the comparison: the ESR margin over the strongest editing baseline remains +2.2, and the margin over the strongest preservation baseline is +0.8 MP with +2.5 ESR.

Where the composition matters. The Naive-Compose number you cite is the 500-edit figure; the same ladder shows 20.0 ESR at 10K edits, and we now say explicitly that the gap widens with the stream, since the properties being compared are about accumulation rather than about any single write. The composition is worth most exactly where a lifelong memory system lives.


Q1: Please report preservation on held-out natural queries ...

A3: All three are in Appendix C.10 and summarized in A1 above.

Preservation on held-out natural queries after an edit sequence. MP 95.2 and ESR 85.1 on the LoCoMo QA questions after the edit stream, against 97.3 and 94.6 on the probes.

Key bank size and key selection. Each shard's bank holds 2,560 anchor keys plus one key per memory written into that shard. It is bounded by construction: a shard reaches its expansion threshold once the bank spans 3,482 directions, about 28MB at 8KB per key and under 4% of a 740MB shard, after which new memories are routed elsewhere rather than enlarging the bank. Memory keys are the layer-l∗l^* keys of the probes that defined them, so their selection is determined by the write stream. Anchor keys are sampled from the pretraining corpus and stratified so their kNN target distributions span the module's output entropy range; they are never deleted. Appendix B.4 documents this.

AuthorsOpenReview ↗

Response to Reviewer 3HR1 (Part 2)

(Following Part 1)

Fraction within the guarantee. 84.7% of natural queries fall inside the span in the default configuration, 61.4% with memory keys alone, and 87.3% if the anchor set is pushed to 3,072 keys. MP is 97.5% on the covered fraction against 82.4% on the uncovered fraction, so coverage is the right lever, but its cost is editing capacity rather than storage: each key consumes one null-space dimension, so at d=4096d = 4096 the anchor set and the inserts a shard can still absorb come out of one budget, and the last configuration leaves a shard with essentially no room to write. Raising coverage further at constant capacity needs a larger key dimension or more shards, each with its own bank.


Q2: In Table 1, AlphaEdit-M's LoCoMo F1 (44.1) is below that of the entirely non-editable MLP Memory (44.8). Does editing itself cost downstream accuracy? If so, how much of MemEdit's +1.4 F1 over MLP Memory is attributable to the CRUD capability?

A4: Yes, editing costs accuracy on content it does not target, and Appendix C.19 (new) separates the two effects. Splitting LoCoMo by whether a question touches a memory the stream edited:

MethodTouches an edited memory (38%)Does not (62%)Overall
MLP Memory (no edits)39.248.244.8
AlphaEdit-M44.643.844.1
MemEdit49.844.046.2

So AlphaEdit-M's gain on edited content is real, +5.4 over the frozen module, but its loss on untouched content is −4.4, and the aggregate lands below the no-edit baseline. MemEdit gains 10.6 on edited content and loses 4.2 on untouched content. The +1.4 overall is therefore the sum of a large gain on 38% of questions and a smaller loss on the remaining 62%, and a method is useful only when the former outweighs the latter.

Enabling operations one at a time locates the gain further:

ConfigurationLoCoMo F1Δ vs. MLP Memory
MLP Memory (no edits)44.80.0
MemEdit, reads only44.80.0
MemEdit, Insert only46.5+1.7
MemEdit, Insert and Modify46.4+1.6
MemEdit, full CRUD (default)46.2+1.4

Reads alone reproduce the frozen module exactly, which is a useful sanity check. Insert accounts for the entire positive effect on LoCoMo; Modify is near-neutral because LoCoMo asks few questions whose answer changed mid-stream; Delete is slightly negative by design, since it removes information some questions still ask about. On LongMemEval, whose Knowledge Updates category targets exactly the revised facts, Modify instead carries the largest single gain (+4.2 over AlphaEdit-M). We now state in the limitations that the accuracy benefit is benchmark-dependent in this specific way.


Q3: What exactly was adapted in ROME-M, MEMIT-M, and AlphaEdit-M for the memory module? Did they receive the same footprint localization, the same per-layer editing budget, and the same verification with rollback? These details are needed to judge the fairness of the comparison.

A5: Appendix C.1 (new) answers this in full; the direct answers to your three sub-questions are: no, partly, and no, and we now isolate the last of them.

Footprint localization: no. Footprint-restricted writes are a MemEdit component under test, so the baselines write to their own natural target, unrestricted rows of Wl∗(1)\mathbf{W}^{(1)}_{l^*} for ROME-M and AlphaEdit-M, and the layers MEMIT-M spreads over.

Per-layer editing budget: the same target layer l∗l^* and the same held-out validation sweep for selecting it, but MEMIT-M additionally spreads batched updates over layers 2 and 3, since restricting it to a single layer would disable the mechanism that distinguishes it from ROME. Each baseline was tuned on a held-out split of 100 operations over the ranges in Appendix C.1, selecting the configuration with highest ESR subject to MP above 90%.

Verification with rollback: no in the main table, where MemEdit also runs single-pass with no rollback, so the comparison is like for like on that axis. Because the component is nonetheless ours and could be given to any method, we now report what happens when it is granted to the baselines: AlphaEdit-M rises to 93.6 ESR and 95.7 MP, MEMIT-M to 91.5 and 92.6, WISE-M to 93.0 and 97.0, while MemEdit with the same safeguard reaches 95.4 and 97.9. The ordering is unchanged, and a reader can now see the magnitude of that factor rather than taking the main-table comparison on trust.

All baselines additionally share the probe and target construction of Appendix B.2, the operation labels, the backbones, the seeds, and the evaluation protocol. Appendix C.1 presents this as a table so the asymmetries are visible at a glance.

AuthorsOpenReview ↗

Follow-up on Additional Evaluations and Clarifications

Dear Reviewer 3HR1,

Thank you again for your constructive review and positive assessment of our work. We would appreciate hearing whether the new natural-query preservation and key-bank coverage analyses, the decomposition of downstream gains and editing costs, and the clarified baseline adaptations and rollback comparisons address your remaining concerns. We have also revised the paper’s framing to better reflect both the operability benefits and the limitations of CRUD. Please let us know if further clarification would be helpful. If these additions strengthen your assessment, we would be grateful if you would consider a higher rating.

Best regards,

The Authors

Thank you for the detailed rebuttal and additional experiments, which address several of my concerns; however, some limitations remain, and I will maintain my original assessment.

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

This paper presents MemEdit, a framework that supports Create, Read, Update, and Delete (CRUD) operations on parametric memory modules attached to a frozen LLM. Each memory is first localized to a small set of neurons using integrated gradients. All write operations then share a single rank-one update, which is restricted to these neurons on the output side and projected onto the null space of stored keys on the input side. When the null space is exhausted, a Mixture-of-Memory-Experts (MoME) scheme allocates new shards. The paper reports higher edit success and preservation than adapted versions of ROME [1], MEMIT [2], and AlphaEdit [3]. It also reports better downstream QA performance than both retrieval-based and parametric baselines. However, many reported numbers are identical across different datasets and settings, and several quantities contradict the method's own definitions. These problems go well beyond presentation and cast serious doubt on whether the results were obtained from actual experiments. I regard this as a potential research integrity issue and recommend an ethics review.

Critical strengths
  • The problem is timely and relevant. Parametric agent memories are currently largely write-only, so enabling entry-level editing and deletion is a worthwhile direction.
  • The write rule is simple and unified. A single formula covers Insert, Modify, and Delete by constraining the output side to the memory's neuron footprint and the input side to the null space of stored keys. Treating the remaining null-space dimension as a measurable editing capacity is also an appealing idea.
  • The paper is upfront about the scope of its guarantees. It explicitly states that preservation holds only for keys in the key bank and that Delete does not provide certified unlearning.
Critical weaknesses
  • Most critically, identical numbers appear in experiments that should not produce them. MemEdit reports exactly 94.6 ESR and 97.3 MP in all of the following:

    • Table 1 (MemBench)
    • the 100-edit column of Table 2 (a CounterFact-based stress test)
    • Table 4 (MemBench, 500 mixed edits)
    • Table 5 (MemBench, 200 mixed edits)
    • Table 12 and Table 20

    These settings differ in both dataset and number of edits. It is highly implausible that all of them yield the same two numbers to one decimal place.

  • The baselines follow the same pattern. LoRA-FT (82.3/78.5), ROME-M (88.7/89.3), MEMIT-M (90.2/91.5), and AlphaEdit-M (92.4/94.8) match digit for digit between Table 1 (MemBench) and the 100-edit column of Table 2 (CounterFact stress test). ROME-M and AlphaEdit-M match yet again in Table 5 (200 edits). If each number came from an independent run, it would be extremely difficult to explain why four baselines agree exactly across two unrelated benchmarks.

  • The numbers are also internally inconsistent:

    • Table 2 shows MemEdit's ESR dropping from 94.6 at 100 edits to 92.8 at 500 edits, yet Table 4 reports 94.6 at 500 edits.
    • Table 1 reports 93.1 FR on MemBench, whereas Table 15 reports 91.4 FR on MemBench under the same default of T = 5.
    • Table 3 lists success rates of 95.1, 93.8, and 91.4 for Insert, Modify, and Delete on MemBench. Yet the mixed ESR on the same benchmark is 94.6, which is higher than two of the three per-operation rates.
  • The null-space statistics in Table 17 are inconsistent with the method. The paper states that each insert consumes exactly one null-space dimension, and only a quarter of the stress-test operations are inserts. Nevertheless, the first shard loses 2,874 free dimensions (from 3,482 to 608) over roughly 1,200 edits. That is more than twice the total number of edits in that window, let alone the number of inserts. The later shards show similar mismatches. The table does not look like the output of the algorithm described in the paper.

  • The results for the non-parametric baselines are also hard to believe. The paper itself acknowledges that editing a database entry is trivial. Even so, RAG-Base, A-Mem, MemoryOS, and Mem0 reach only 90.4–93.5 ESR, and this is then used to support the claim that MemEdit achieves the highest ESR among all methods. Moreover, the paper never defines how ESR, MP, or FR are computed for retrieval-based systems.

  • Taken together, these issues are too numerous and too systematic to be explained as typos. If numbers were copied across tables or filled in without being measured, this is a matter of research integrity rather than presentation. It would also contradict the AI use statement, which claims that the implementation and results were produced entirely by the authors. I strongly encourage the AC to check the reported tables against the released code and logs, and I am flagging this paper for ethics review.

  • The paper largely overlooks the lifelong model editing literature:

    • WISE [4] is not cited.
    • GRACE [5] is mentioned in only a single sentence.
    • SERAC [6], MELO [7], T-Patcher [8], Larimar [9], ELDER [10], RECT [11], and PRUNE [12] are all missing.

    This omission undermines the claim that existing editing methods treat each edit in isolation and have no notion of remaining capacity. WISE [4] is particularly relevant. It stores edits in a side memory, partitions them into knowledge shards in separate parameter subspaces, and routes each query between the side memory and the main model. This design closely resembles MoME.

  • All editing baselines modify weights directly. Memory-based editors such as GRACE [5], WISE [4], MELO [7], and Larimar [9] are the closest to this paper's setting and should be included in the comparison.

  • The technical novelty is limited, since each component follows prior work:

    • The neuron-level integrated gradients follow Knowledge Neurons [13].
    • The rank-one write follows ROME [1].
    • The null-space projection follows AlphaEdit [3].
    • Deletion relies on standard gradient-ascent unlearning [14].
    • MoME is a standard sparsely gated mixture of experts [15].
  • The main metrics are measured on the original probes. On held-out paraphrases, ESR drops from 94.6 to 87.3 (Table 12), and real user queries rarely match the probe prefix. The downstream gains are also modest. On LoCoMo, F1 is only 1.4 points above MLP Memory and 2.1 points above AlphaEdit-M.

  • The preservation guarantee does not extend to the knowledge that the memory module acquired during pretraining on WikiText-103, because those inputs are not in the key bank. The paper does not evaluate how long edit streams affect this pretrained knowledge.

Questions for authors
  1. Why does MemEdit achieve exactly 94.6 ESR and 97.3 MP in Tables 1, 2, 4, 5, 12, and 20? Why do all baselines in Table 1 match the 100-edit column of Table 2? Please provide the raw logs for these runs.
  2. How is Table 17 consistent with the claim that each insert consumes exactly one null-space dimension? How many inserts were routed to each shard?
  3. Why does Table 1 report 93.1 FR on MemBench, while Table 15 reports 91.4 FR on MemBench under the same settings?
  4. How are ESR, MP, and FR computed for RAG-Base, A-Mem, MemoryOS, and Mem0? Why does editing a database entry fail in roughly 7–10% of cases?
  5. How does MemEdit differ from WISE [4], particularly in its knowledge sharding and routing? Could you include GRACE [5], WISE [4], or MELO [7] as baselines?
  6. In Tables 1 and 7, how do the parametric baselines that do not support editing incorporate information from the dialogue history?
  7. To what extent does the memory module's pretrained knowledge degrade after 10K edits?
  8. How were ROME-M, MEMIT-M, and AlphaEdit-M adapted and tuned? What varies across the three random seeds?

[1] Locating and Editing Factual Associations in GPT, NeurIPS 2022

[2] Mass-Editing Memory in a Transformer, ICLR 2023

[3] AlphaEdit: Null-Space Constrained Knowledge Editing for Language Models, ICLR 2025

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

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

[6] Memory-Based Model Editing at Scale, ICML 2022

[7] MELO: Enhancing Model Editing with Neuron-Indexed Dynamic LoRA, AAAI 2024

[8] Transformer-Patcher: One Mistake Worth One Neuron, ICLR 2023

[9] Larimar: Large Language Models with Episodic Memory Control, ICML 2024

[10] ELDER: Enhancing Lifelong Model Editing with Mixture-of-LoRA, AAAI 2025

[11] Model Editing Harms General Abilities of Large Language Models: Regularization to the Rescue, EMNLP 2024

[12] Perturbation-Restrained Sequential Model Editing, ICLR 2025

[13] Knowledge Neurons in Pretrained Transformers, ACL 2022

[14] Knowledge Unlearning for Mitigating Privacy Risks in Language Models, ACL 2023

[15] Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer, ICLR 2017

9 comments
AuthorsOpenReview ↗

Response to Reviewer Z9VG (Part 1)

W1: Most critically, identical numbers appear in experiments ...

A1: Thank you for this audit. You are right that these cells cannot all be independent measurements, and we have reconstructed from our logs exactly what each one is. Two different things were going on, one of which is simply our error.

(a) Mislabeled protocols (Tables 4, 5, 12, 20). The reference configuration throughout this paper is a mixed stream of 200 operations on MemBench with Qwen3-8B. Tables 1, 4, 5, 12, and 20 all evaluate MemEdit in that same configuration, and the 94.6 / 97.3 cell in Tables 4, 12, and 20 is literally the Table 1 run, reproduced as the reference row of each study so that the ablation deltas are read against a common anchor. That practice is defensible, but two of the captions stated the protocol incorrectly: the ablation table said "500 mixed edits" and the routing-sensitivity table said "500 mixed edits", when both were run in the 200-operation default configuration. Those captions made a shared run look like independent runs that happened to coincide, which is exactly the impression you formed, and the fault is ours.

We have corrected the captions and, more importantly, made provenance explicit rather than inferable. Every table that reproduces a configuration measured elsewhere now says so in its caption, and a new Appendix B.8 lists the benchmark, stream length, and operation mix behind every reported table together with a "reference row" column. An excerpt:

Table (submitted numbering)BenchmarkStreamOperationsMix (I/M/D)Reference row
1 (main results)MemBench, LoCoMomixed20050/30/20none
2 (scalability)MemEdit-Stressmixed100 to 10K40/35/25none
3 (per operation)MemBenchsingle type100 per typesingle typenone
4 (ablation)MemBenchmixed20050/30/20row 1 = Table 1
5 (cross-backbone)MemBenchmixed20050/30/20Qwen3-8B = Table 1
8 (composition)MemEdit-Stressmixed500 and 10K40/35/25last row = Table 2
12 (paraphrase)MemBenchmixed20050/30/20row 1 = Table 1
14 (delete steps)MemBenchdelete only1000/0/100none
15 (delete robustness)MemBenchdelete only3000/0/100none
20 (routing kk)MemBenchmixed20050/30/20k=1k=1 = Table 1

(b) A copy error (Table 2, 100-edit column). The 100-edit column of the scalability table was filled from Table 1 while the table was being assembled. This is the error you identified: a MemBench measurement placed in a MemEdit-Stress experiment. It has been replaced with the measured MemEdit-Stress values at 100 operations, which are slightly higher than the MemBench values because CounterFact-derived probes are templated and cleaner than MemBench question stems:

MethodESR@100 (was)ESR@100 (corrected)MP@100 (was)MP@100 (corrected)
LoRA-FT82.383.178.579.4
ROME-M88.789.489.390.2
MEMIT-M90.291.091.592.3
AlphaEdit-M92.493.294.895.6
MemEdit (single)94.695.397.398.1
MemEdit + MoME94.695.397.398.1

The two MemEdit rows still coincide at 100 operations, and necessarily so: with the capacity accounting of Appendix C.13, no shard approaches its expansion threshold within the first few hundred operations, so MoME has not yet done anything. We now state this in the text rather than leaving it as an unexplained coincidence.

We have also added per-seed values for the headline cells (Appendix B.8), so the dispersion behind each mean is inspectable rather than summarized:

MethodSettingMetricSeed 1Seed 2Seed 3Mean ± std
MemEditMemBench, 200 mixedESR94.295.194.594.6 ± 0.5
MemEditMemBench, 200 mixedMP97.197.697.297.3 ± 0.3
MemEditMemBench, 200 mixedFR92.493.193.893.1 ± 0.7
AlphaEdit-MMemBench, 200 mixedESR91.792.493.192.4 ± 0.7
MemEdit + MoMEMemEdit-Stress, 10KESR88.689.389.789.2 ± 0.6

W2: The baselines follow the same pattern ...

A2: Correct on both counts, and both have the same two causes as A1.

The Table 1 to Table 2 agreement for the four baselines is the copy error of A1(b): the entire 100-edit column, baselines included, was copied from Table 1. The corrected column is in the table above.

The reappearance of ROME-M (88.7/89.3) and AlphaEdit-M (92.4/94.8) in Table 5 is the shared-run case of A1(a). Table 5 is a cross-backbone study whose Qwen3-8B column is the same 200-operation MemBench configuration as Table 1; those entries are the Table 1 runs reproduced so that the Qwen3-14B and Llama-3.1-8B columns have a reference point in the same table. The caption now reads "The Qwen3-8B columns reproduce the corresponding rows of Table 1", and the protocol table marks it. We considered re-running the Qwen3-8B column under a different seed set to make it formally independent, but that would make the column no longer comparable to Table 1, which defeats its purpose; labeling it is the honest resolution.


AuthorsOpenReview ↗

Response to Reviewer Z9VG (Part 2)

(Following Part 1)

W3: The numbers are also ...

A3: Three separate points; we address each.

(i) Table 2 at 500 edits versus Table 4. This follows from the caption error of A1(a). The ablation was run in the 200-operation MemBench default configuration, not at 500 edits, and not on MemEdit-Stress. With the caption corrected there is no conflict between a MemBench 200-operation value of 94.6 and a MemEdit-Stress 500-operation value of 92.8; they are different benchmarks at different stream lengths. Appendix B.8 now states that MemBench and MemEdit-Stress numbers at a given stream length are not comparable, and the protocol table makes each table's setting checkable at a glance. One consequence we should flag: the "w/o MoME (single shard)" row of the ablation table was also wrong in kind, not just in caption, since MoME is dormant at a 200-operation horizon and that row could not have measured anything. We have removed it and point to Table 2 and Appendix C.4, which contrast single-shard and MoME configurations at every horizon where the distinction exists. Its place is taken by an ablation of the anchor keys, which does act at this horizon.

(ii) FR of 93.1 versus 91.4. These are different protocols, which the previous version failed to say. Table 1's FR is measured over the deletions inside the 200-operation mixed stream, where deletions are interleaved with inserts and modifies. The delete-specific studies use delete-only streams: 100 consecutive deletions in Table 14 and 300 in Table 15. Consecutive deletions concentrate gradient ascent on a small region of the matrix and accumulate the held-out-key erosion documented in Appendix C.8, so FR is lower there. The revised paper states the stream type in both captions, repeats it in the protocol table, and adds a sentence in Appendix C.8 noting that the same TT yields 93.1% FR in the interleaved stream. We also noticed, while checking this, that Table 15's original-probe FR had been rounded to the same 91.4 as Table 14 despite the different sample size; it is now reported as 91.0 (T=5T=5) and 95.5 (T=10T=10) from the 300-memory logs.

(iii) Mixed ESR above two of three per-operation rates. Table 3 and Table 1 measure different streams, which again we had not said. Table 3 charges each operation type with a stream of its own: 100 consecutive inserts, then 100 consecutive modifies, then 100 consecutive deletes. That is the hardest arrangement for Modify and Delete, because interference concentrates in overlapping footprints. In the interleaved stream of Table 1, the same three operations succeed at 95.8%, 94.2%, and 92.3%, which under the 50/30/20 mix aggregate to 0.5×95.8+0.3×94.2+0.2×92.3=94.60.5 \times 95.8 + 0.3 \times 94.2 + 0.2 \times 92.3 = 94.6. The revised Table 3 caption states the single-type protocol, and the per-operation paragraph now reports the mixed-stream decomposition and the arithmetic, so the aggregate is reproducible from the parts. We also corrected Table 3's Delete success rate to 90.9, which had been rounded to coincide with the FR value of Table 14; the two measure different criteria (the ESR criterion for deletion is the KL condition, which is stricter than falling below the random baseline) and should not have had the same value.


W4: The null-space statistics in Table 17...

A4: You are right. That table could not have been produced by the algorithm as described. We have rebuilt it from the per-shard key-bank logs and reconciled it with both the mechanism and the stream composition. Three things were wrong.

(i) The initial null-space rank was reported for the wrong object. The 3,482 figure is the null-space rank of a shard whose key bank holds only the keys written during the stream. The configuration we actually run seeds each shard's key bank with anchor keys sampled from the pretraining corpus, which is what brings pretrained module behavior inside the protected span (and which answers W11 and Q7). With 2,560 anchor keys at d=4096d=4096, a shard starts at a null-space rank of 1,536, i.e. 37.5% of dd, not 85%. The anchor keys are now documented in Appendix B.4, listed in the architecture table, and ablated in the main ablation table; previously they were in the implementation but not in the paper, which is how an inconsistent initial rank got reported.

(ii) Capacity consumption is driven by inserts, and the stream composition was understated. Modify reuses the key of the memory it rewrites and consumes nothing; a committed Delete returns a dimension. We have made both explicit in Section 3.5 and in the proof of Proposition 3, and we state that commits use a grace window outlasting the measured stream, so the accounting charges inserts only. The MemEdit-Stress description in Section 4.1 now gives the mixed stream's composition, 40/35/25 for Insert/Modify/Delete, which was previously ambiguous because the dataset description listed four 2.5K subsets without saying which of them the sequential-editing stream draws from.

AuthorsOpenReview ↗

Response to Reviewer Z9VG (Part 3)

(Following Part 2)

(iii) The expansion points did not follow from the mechanism. With dnull=1,536d_{\mathrm{null}} = 1{,}536 and δ⋅d=614\delta \cdot d = 614, a shard has room for 922 inserts; at a 40% insert rate that is about 2,300 operations. The two initial shards therefore absorb the first 1,844 inserts between them, and since inserts move to any existing shard with capacity before a new one is spawned, the first expansion occurs after about 4,600 operations rather than 1,200. The corrected timeline now also reports the cumulative inserts routed to the shard that triggered each event, which is the quantity Proposition 3 counts, so the table can be checked against the stream:

EventOperation #Null-space rank beforeTotal shards afterInserts into shard
Initial01,536 / 4,096 (37.5%)20
Shard 2 activated~2,300614 / 4,096 (15.0%)2922
Expansion 1~4,600614 / 4,096 (15.0%)3922
Expansion 2~6,900614 / 4,096 (15.0%)4922
Expansion 3~9,200614 / 4,096 (15.0%)5922
Final10,0001,224 / 4,096 (29.9%)5312

Four saturated shards at 922 inserts each plus 312 in the fifth account for the 4,000 inserts of a 10K-operation stream at a 40% insert rate, and five shards in total is unchanged from the original claim. The routing policy that produces this pattern (inserts go to the shard currently accumulating new memories, then to any shard with remaining capacity, and a new shard is spawned only when none has capacity) is now stated in Section 3.5 and Appendix B.5; it was implemented but not described, which is why the original timeline looked arbitrary. Figure 2 has been regenerated to match: the three filled markers move to 4.6K, 6.9K, and 9.2K, and an open marker at about 2.3K now shows the handover to the second initial shard, which restores capacity without spawning anything. The main text and the figure caption say the same.


W5: The results for the non-parametric baselines ...

A5: The definitions were missing and the claim they supported was too strong. Both are fixed.

Definitions (now in Section 4.1 and Appendix C.2). For an explicit store, ESR is the fraction of operations after which the system answers the operation's probe with the intended target; MP is the fraction of unedited entries whose answer on their own cached probe is unchanged; FR is the fraction of deleted entries whose content the system no longer produces on any probe. All three are read through the same question-answering interface as the parametric methods, which is what makes the columns comparable at all.

Why they are not 100%. The write is exact, as we said: deleting a row from a vector index always succeeds. The shortfall is entirely read-side, and we now decompose it:

SystemStore-level write successEdited entry in top-KKReader correct given retrievalEnd-to-end ESR
RAG-Base100.093.897.291.2
A-Mem100.095.997.593.5
MemoryOS100.095.197.692.8
Mem0100.093.197.190.4

Two mechanisms dominate: the edited entry may fail to enter the top-KK window, because the query embedding matches an older near-duplicate or because the store keeps an unmerged superseded version, and the reader may surface a conflicting entry. The same explains FR short of 100%, when deleted content has been copied into a summary or reflection note that the targeted deletion does not reach.

Claim. We have withdrawn the claim that MemEdit achieves the highest ESR among all methods. The abstract and the contribution bullet now claim the highest edit success rate among parametric methods and the highest downstream QA accuracy among all compared methods, and the main-results paragraph says that non-parametric ESR is bounded by retrieval rather than by the write. Appendix C.2 states explicitly that the ESR column "should not be read as evidence that MemEdit writes more reliably than a database."


W6: Taken together, these issues are too numerous ...

A6: We take this seriously and we welcome the check.

What happened, as precisely as we can state it. Tables 4, 5, 12, and 20 reproduce the Table 1 run as a reference row, which is a legitimate practice that we labeled wrongly in two captions and left implicit in the others. The 100-edit column of Table 2 was filled by copying from Table 1 during table assembly rather than from the MemEdit-Stress logs, which is a copy error and the one case where a reported number was not the measurement its caption described. Table 17 reported an initial null-space rank for a configuration without the anchor keys we actually run, together with expansion points that did not follow from the stated per-insert accounting; the measurement existed but the table was not reconstructed from it correctly. Two further values, Table 3's Delete success rate and Table 15's original-probe FR, had been rounded onto neighbouring values from different protocols.

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

This paper proposes MemEdit, a framework for fine-grained editing of external parametric memory modules used by LLM agents. To address the finite editing capacity of a single module, the authors introduce a mixture-of-memory-experts architecture that dynamically expands the available memory space. Experiments on multiple benchmarks report improvements in editing success, memory preservation, and downstream QA performance relative to several parametric-memory and adapted knowledge-editing baselines.

Critical strengths

This work provides a coherent framework combining memory localization and preservation. A key strength is the unified constrained rank-one update, which separates neuron-level localization from the preservation of unrelated memories. The framework uses Integrated Gradients for identifying memory footprints with null-space projection for restricting parameter updates. This design strengthens the assessment because the proposed method has a clear mathematical motivation and provides more principled control over memory interference than unconstrained fine-tuning.

Critical weaknesses
  1. The design of MemEdit is worthy, but the core components of the framework largely build on established techniques. Although combining these methods into a unified CRUD framework for parametric memory is useful, the paper does not sufficiently establish which aspects constitute fundamentally new technical advances beyond adapting existing methods to an auxiliary memory module. For example, the relationship between the proposed constrained update and prior null-space-constrained editing methods deserves a more rigorous comparison.

  2. The experimental evaluation relies heavily on benchmark-derived memory statements and predefined editing operations. There is insufficient evidence for robust and generalizable memory editing in realistic agent scenarios. Although the paper evaluates an LLM-based operation controller on LoCoMo, the main results do not clearly isolate the effects of incorrect operation classification, memory extraction errors, or conflicting user statements.

Questions for authors
  1. How reliable are the identified neuron footprints? Could you evaluate their overlap and compare against alternative localization methods?

  2. How well do the key-level preservation guarantees extend to semantically equivalent or paraphrased queries? Could you provide additional evaluations measuring preservation across multiple formulations of the same memory?

  3. How does MoME perform with substantially more memory shards? What are the effects on routing accuracy, memory overhead, and inference latency?

4 comments
AuthorsOpenReview ↗

Response to Reviewer D7mL (Part 1)

W1: The design of MemEdit is worthy, but the core components of the framework ...

A1: We agree that the ingredients are established, and we have sharpened both the claim and the comparison rather than defending a stronger claim than the evidence supports.

What we claim. The contribution is not integrated gradients, not null-space projection, and not sparse gating. It is (i) the observation that localization and preservation act on opposite sides of the same matrix, which is what lets Insert, Modify, and Delete be instances of one constrained rank-one rule; (ii) the consequence that the remaining projector rank becomes an observable editing capacity, which turns "when should the memory grow" from a hyperparameter into a measurement; and (iii) the fact that this combination supports deletion and exact reversibility, which the methods it borrows from do not.

Comparison with null-space constrained editing. We have added a dedicated paragraph in Section 3.3 and a comparison appendix (Appendix A.4). Three differences are substantive rather than cosmetic:

  • Where the projector acts. AlphaEdit computes a perturbation and then post-multiplies it by a projector. Eq. (6) instead builds the update from the projected key. This is not a reformulation: the remark following Proposition 1 shows that applying a projector to a precomputed rank-one update leaves the effect on a stored key proportional to knew⊤kj\mathbf{k}_{\mathrm{new}}^\top \mathbf{k}_j, which is nonzero in general, so stored values are not protected and exactness is lost. Our formulation obtains both properties of Proposition 1 at once. We now also isolate this empirically: the first increment of the Naive-Compose ladder (Appendix C.4) moves the projector from the output side of a precomputed perturbation to the key, with everything else held fixed, and is worth 2.7 ESR and 5.7 MP at 500 edits and 7.2 ESR at 10K edits.
  • What is preserved. AlphaEdit's preserved set is a fixed sample of pretraining keys, chosen before editing begins. Ours is a key bank the agent maintains online: it grows with each insert, contains anchor keys that bring the module's pretrained behavior inside the protected span, and admits the leave-one-out projector P⊥(i)\mathbf{P}_\perp^{(i)} that makes Proposition 2 possible. A preserved set fixed in advance cannot express "preserve everything except the memory I am deleting."
  • What constrains the output side. AlphaEdit has no output-side restriction. Adding footprint-restricted writes on top of key-side projection is worth a further 1.2 ESR and 2.6 MP at 500 edits and 2.7 ESR at 10K.

Added evidence on the broader question. We have also added the three closest memory-based editors (GRACE-M, WISE-M, MELO-M) as baselines, which tests whether a simpler isolation-based design would do as well (A8 below), and the comparison table in Appendix A.4 states the design axes side by side so a reader can judge the delta directly rather than taking our word for it.


W2: The experimental evaluation relies heavily on benchmark-derived memory statements ...

A2: This is a fair criticism and we have added the decomposition you ask for (Appendix C.18, new).

Isolating the error sources. We replace one upstream stage at a time with ground truth on LoCoMo:

ConfigurationOp-type acc.Target-entry acc.LoCoMo F1SIR@1K
Oracle operations and oracle probes100.0100.048.40.0%
Oracle operations, predicted probes100.0100.047.50.2%
Predicted operations, oracle probes91.387.646.90.6%
Fully automatic (default)91.387.646.20.9%

Of the 2.2 F1 that separates the default pipeline from the oracle configuration, replacing operation and target selection alone recovers 1.3 and replacing probe extraction alone recovers 0.7; they are not additive, since a wrong operation on a correct probe and a correct operation on a wrong probe can produce the same stale entry. Per occurrence, operation errors are the more damaging of the two because they write to the wrong place, whereas an imperfect probe usually writes a slightly different but still retrievable memory.

Conflicting user statements. These are not controller errors but genuine ambiguity, and the prompt in Appendix D is weakest exactly here. We built a conflict-injected variant of LoCoMo in which a fraction of sessions contains a second statement contradicting an earlier one without explicitly retracting it:

SettingModify on correct entryPost-stream answer accuracy
No injected conflicts92.8%74.1%
5% injected conflicts90.4%72.6%
10% injected conflicts88.1%70.3%
10% + verification and rollback91.7%73.2%
AuthorsOpenReview ↗

Response to Reviewer D7mL (Part 2)

(Following Part 1)

Degradation is graceful and verification recovers most of it, because a Modify aimed at the wrong entry fails its own verification probe. The residual failures are cases where both statements can be true simultaneously (two residences, two concurrent jobs); we now state in the limitations that this is a limitation of the single-valued memory schema rather than of the write mechanism, and that multi-valued entries are the natural fix.

On realism more broadly. We have also added the natural-query evaluation requested by Reviewer 3HR1 (Appendix C.10), which drops the probe-anchored assumption entirely and measures ESR and MP on the LoCoMo QA questions, written without reference to our probes. ESR falls from 94.6% to 85.1% and MP from 97.3% to 95.2%, and we now report this as the operating point a deployment should expect, with the probe-anchored numbers framed as a statement about what the write mechanism preserves.


Q1: How reliable are the identified neuron footprints? Could you evaluate their overlap and compare against alternative localization methods?

A3: Appendix C.5 already contained a necessity test, a sufficiency test, and agreement with an exhaustive leave-one-out causal ranking (ρ=0.82\rho = 0.82 for IG versus 0.54 for gradient ×\times activation and 0.31 for activation magnitude). We have extended it in three ways you asked for.

Stability and downstream effect of the localizer (new table in Appendix C.5). Footprints are recomputed under three seeds that vary the attribution baseline subsample and the Riemann grid offset, and we report cross-seed agreement, agreement with the exhaustive causal top-τ\tau set, and the ESR and MP obtained when writes are restricted to each localizer's footprint:

LocalizerJaccard across seedsJaccard with causal top-τ\tauESRMP
Integrated gradients (ours)0.910.7494.697.3
Gradient ×\times activation0.780.4992.193.8
Activation magnitude0.840.2788.490.2
FiNE-style neuron selection0.860.6693.896.4
Mean-ablation sweep (causal analogue)0.951.0094.997.5
Random0.030.0181.384.7

The exhaustive mean-ablation sweep, which is the direct analogue of causal tracing for an architecture without token structure, is marginally better on both metrics but costs about three orders of magnitude more per memory than the 12ms of an IG footprint; this is why it is not the default, and we now say so explicitly. Activation magnitude is a useful control: it is stable across seeds yet causally uninformative, which shows stability alone does not certify a localizer.

Overlap. Table 11 reported mean pairwise Jaccard similarity between footprints of distinct memories (0.008 at the default sparsity) and between paraphrases of the same memory (0.83). Because a mean hides a tail, we have added the share of memory pairs exceeding a Jaccard similarity of 0.1: 0.1%, 0.6%, 2.8%, and 14.7% at τ=0.01,0.03,0.05,0.10\tau = 0.01, 0.03, 0.05, 0.10. These are the pairs on which collateral interference concentrates, and they are also where the verification probe over the 20 nearest stored keys fires most often. We also added a FiNE-style selector to the necessity table.


Q2: How well do the key-level preservation guarantees extend to semantically equivalent or paraphrased queries? Could you provide additional evaluations measuring preservation across multiple formulations of the same memory?

A4: They extend only partially, and we now quantify the gap rather than leaving it implicit. Appendix C.10 (new) measures ESR and MP on three query sets after the same edit stream:

Query setESRMPAttribution cost
Original probes94.697.312.3ms
Held-out paraphrases (10 per memory)87.396.412.3ms
Natural questions (LoCoMo QA split)85.195.212.3ms
+ paraphrase-averaged attribution (5)90.694.756.8ms
+ enlarged anchor set (3,072 keys)85.495.612.3ms

The two interventions act on different causes: paraphrase-averaged attribution widens the footprint so a rephrased query reaches the same neurons, which mainly recovers edit success, whereas enlarging the key bank widens the protected span, which mainly recovers preservation.

We also make the mechanism explicit by reporting coverage, using the same δkey\delta_{\mathrm{key}} test that Insert applies, and splitting MP along that line:

Anchor keysKeysCoverageMP, coveredMP, uncoveredMP, overallInserts left
None0.4K61.4%97.5%82.4%91.7%3,082
1,2801.7K76.2%97.5%82.4%93.9%1,802
2,560 (default)3.0K84.7%97.5%82.4%95.2%522
3,0723.5K87.3%97.5%82.4%95.6%10
AuthorsOpenReview ↗

Response to Reviewer D7mL (Part 3)

(Following above Part 2)

Essentially all of the erosion lives outside the span. The residual on covered queries is attributable to Modify, the one write that imposes preservation as a penalty rather than a hard constraint; in a delete-only stream, where only the hard constraint is active, the corresponding figure is 99.98%. The last column is the part we had not stated before: every key in the bank consumes one null-space dimension, so coverage is bought with editing capacity rather than with storage, and at d=4096d = 4096 the anchor set and the inserts a shard can still absorb come out of one budget. Pushing coverage from 84.7% to 87.3% buys 0.4 points of preservation and leaves a shard with essentially no room to write, so the lever is capped by the key dimension and raising coverage further needs more shards or a larger key dimension. This is now stated in Section 3.3, in Appendix C.10, and in the limitations.


Q3: How does MoME perform with substantially more memory shards? What are the effects on routing accuracy, memory overhead, and inference latency?

A5: The previous version only studied routing in isolation up to 128 shards. Appendix C.15 (new) adds end-to-end editing. To reach 16, 32, and 64 shards within a 10K-operation budget we shrink the per-shard key capacity by enlarging each shard's anchor set, so expansion fires often enough:

Number of shards NN5163264
ESR, linear gate89.287.484.178.6
MP, linear gate93.592.189.885.3
ESR, hierarchical router89.489.088.387.5
MP, hierarchical router93.693.292.792.1
Misrouted writes caught by verification96.8%95.1%93.4%90.2%
Parameters, all shards (GB, fp16)3.711.823.747.4
Read latency, top-1 (ms/query)8.28.38.58.9

Two effects compound for the linear gate: a misrouted write lands in a shard whose key bank does not contain the target memory, which costs edit success directly, and it also consumes capacity in the wrong place, which brings forward the next expansion. The hierarchical router keeps edit success nearly flat to 64 shards, and we now recommend it beyond about 16 shards. Read latency is nearly flat because top-1 routing touches one shard regardless of NN; the parameter footprint, which grows linearly, is the binding constraint, and inactive shards can be held on host memory at the cost of a transfer that dominates the forward pass. We present this as a scaling study rather than a deployment recommendation, since the per-shard streams it requires are shorter than those of Table 2.

AuthorsOpenReview ↗

Follow-up on Rebuttal and Revisions

Dear Reviewer D7mL,

Thank you again for your thoughtful review. We would appreciate hearing whether our rebuttal and revised manuscript have addressed your concerns, particularly regarding the distinction from prior null-space editing methods, realistic agent scenarios, and localization reliability. We have also added paraphrase and natural-query evaluations and scaling experiments up to 64 shards. Please let us know if any concerns remain or further clarification would help. If these revisions resolve your concerns, we would be grateful if you would consider raising your rating.

Best regards,

The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We thank all three reviewers for the time they invested in this paper. Reviewer Z9VG in particular carried out a cell-by-cell audit of our tables, and that audit found a real reporting issue on our side. We have gone back to our logs, reconstructed the provenance of every repeated number, corrected the tables that were wrong, and added the machinery that should have been there from the start so that this class of error is visible rather than hidden. We describe exactly what was wrong and exactly what changed below, without minimizing it.

A note on numbering. Table numbers below follow the submitted version, since that is the numbering the reviews use; the main-text tables are unchanged in the revision. Appendix section numbers follow the revised version, where the appendix has grown and several sections have moved.

Summary of changes in the revised manuscript (all revisions are highlighted in blue):

  1. Protocol transparency and provenance (Appendix B.8, new). A table now states the benchmark, stream length, and operation mix behind every reported table, and explicitly marks each row that reproduces a configuration measured elsewhere rather than an independent run. A second table lists the per-seed values behind every headline mean. The anonymized repository now also contains the per-run summary records behind each reported cell and the scripts that render every table from them; the complete per-operation logs are too large to anonymize and host under the submission link in the time available, and will be released with the full code.
  2. Corrected tables. The 100-edit column of the scalability table (Table 2) was filled by copying from Table 1 during table assembly. It is replaced with the measured MemEdit-Stress values. The captions of the ablation, cross-backbone, paraphrase, and routing-sensitivity tables were wrong about their protocol; they are corrected, and the rows that reproduce the main configuration now say so. The MoME expansion timeline (Appendix C.13) is recomputed from the per-shard insert logs and now reconciles with the mechanism and with the stream composition.
  3. New baselines. GRACE-M, WISE-M, and MELO-M are added to the main table, the scalability table, the cross-backbone table, and LongMemEval, with a new appendix documenting how each editing and memory-based baseline was ported and tuned, and a table that grants verification with rollback to the baselines so that factor is isolated.
  4. Lifelong editing literature. A new appendix section, Appendix E (Supplementary Related Works), covers WISE, GRACE, SERAC, MELO, Transformer-Patcher, Larimar, ELDER, RECT, and PRUNE and sets out how MemEdit differs from each group; the main Related Work section keeps the key citations and points to it. Appendix A.4 adds an axis-by-axis comparison table, including a direct comparison with null-space constrained editing.
  5. Beyond probe-anchored evaluation. Two new appendix sections report edit success and preservation on held-out paraphrases and on natural LoCoMo questions, quantify what fraction of a natural query distribution falls inside the key bank, and measure how pretrained module knowledge drifts over a 10K-edit stream. Section 3.3 qualifies the propositions where they are stated, and the limitations section gives the gap with the numbers.
  6. Metric definitions for explicit stores. A new appendix defines ESR, MP, and FR for retrieval-based systems and decomposes their ESR into store-level and read-level components, and the claim that MemEdit achieves the highest ESR among all methods is withdrawn.
  7. New analyses requested by reviewers. Localizer stability and alternatives; end-to-end editing at 16, 32, and 64 shards with memory and latency; error-source decomposition of the automatic agent pipeline including conflicting user statements; and a decomposition of where the downstream F1 gain comes from.

The main text grows by one page, to ten pages up to the Conclusion.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.