acceptodds
Under review as a conference paper at ICLR 2027

VeriMem: Serving-Time Verification for Mutable Agent Memory

Abstract

Persistent memory lets language-model agents reuse information across interactions, but source updates can leave cached summaries and plans obsolete. Rejecting an entire derivative prevents stale reuse at the cost of discarding unaffected information. We introduce VeriMem, which records source invalidation and checks versioned dependencies before memory enters model input, either rejecting unsupported derivatives or reconstructing their admissible components. Under explicit lineage and serving-state assumptions, these rules provide conditional exclusion and retention properties. Lifecycle tests eliminate observed stale-derivative exposure, while reconstruction satisfies 32/32 answer contracts versus 8/32 for whole-artifact rejection on 32 inputs from 16 related worlds, matching equally informed component baselines. With Qwen3.5-9B Q4, verified contexts raise accuracy by 16.7 percentage points on 60 previously seen LongMemEval-V2 questions with injected stale content, while reconstruction yields 56 current-answer matches versus 40 for rejection across 72 related MQuAKE questions. These results support serving-time verification as a complement to eager maintenance, combining invalid-content exclusion with selective retention to improve answers in the evaluated settings.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLM agents, Agent memory, Memory consistency, Dependency tracking, Serving-time verification

Reviews

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

The paper "VERIMEM: SERVING-TIME VERIFICATION FOR MUTABLE AGENT MEMORY" addresses stale derived memory in LLM agents. The setting of the paper is that memory-backends for LLM agents sometimes use summaries/plans etc. that are derived from actual user memories. Later the user-memories can become stale, either replaced or deleted at user's request. That leaves all artifacts derived from those memories outdated. Memory-backend may use those stale files and that may lead to the agent answering user's query incorrectly.

The paper proposes VeriMem, a verification layer between retrieval of memories and passing them to the agent's context. In the memory-bank, each derived memory records the specific source memories it depends on, and source memory updates mark the old versions as invalid without rewriting dependents. When a derived memory is retrieved, VeriMem checks its full transitive dependency chain for validity. It further has two modes:

  • Gate rejects the whole derivative if any dependency is invalid.
  • Reconstruction checks individual claims within the derivative, keeps the valid ones, recreates the derived memory, and re-verifies the result.

The authors prove two guarantees: VeriMem never lets content with an outdated source into the prompt, and reconstruction never throws away a valid claim. Both guarantees only hold if the system has a correct record of which sources each memory item was built from. They then test the method with three questions: does it block outdated content (exclusion), does it keep valid information (retention), and does it improve the model’s answers.

Critical strengths

None

Critical weaknesses

W1: The contribution is unclear relative to simpler baselines. The paper’s main benefit is keeping the still-valid parts of a memory item instead of discarding the whole item when one part becomes outdated. In the paper’s example, a cached plan contains an outdated diet preference and a still-correct budget. Whole-item rejection loses the budget, while VeriMem’s reconstruction keeps it.

However, this benefit does not come from VeriMem specifically. The paper compares against two simpler methods that also work at the level of individual parts: component-level eager invalidation and dependency-version checking. Both achieve identical results on every metric in Table 2: the same task success (32/32), the same exclusion of outdated content, and the same retention of valid content. The only thing unique to VeriMem is when it checks: when memory is read, rather than when a source changes. The paper’s own cost measurements (Section 5.5, Table 9) show that this makes reconstruction much slower than the baselines (about 24.7 ms versus 0.76 ms on a 20-query workload), and the authors report no stable cost saving. Closely related prior methods (MemoRepair, PACMI) are discussed only conceptually in Table 4 and are not tested. It is therefore unclear what VeriMem contributes beyond existing approaches.

This problem is made worse by the writing, which is dense and makes it very difficult to follow the paper. I would encourage the authors to explain the method in plain language, introduce terms only when needed, and state directly how VeriMem compares to the simpler baselines.

W2: The setting assumes away the hard parts, and the evaluation is artificial. VeriMem requires an exact record of which source facts each part of a memory came from. For example, it must know that “the plan’s diet line came from the diet fact, and the budget line came from the budget fact.” The authors acknowledge (Appendix A.4) that if this record is incomplete or wrong, the method fails. If a dependency is missing, outdated content can slip through. If too many dependencies are recorded, valid content gets blocked.

In real agent systems, summaries and plans are written by an LLM, and nobody keeps this kind of precise record. Producing it reliably is arguably the hardest part of the problem, but the paper does not address it: in every experiment, the authors write these records by hand. As a result, the strong exclusion results (e.g., outdated content exposure dropping from 25/25 to 0/25 in Table 1) mainly show that the system follows its own rules when given perfect information.

The evaluation setup is also artificial. In every study, outdated memories are deliberately planted by the authors rather than arising naturally, and Appendix C.1 states that the backend studies test enforcement, not how often stale memory occurs in practice. The datasets are small and hand-picked: 32 authored inputs, 60 LongMemEval-V2 questions the authors had already used during development, and 24 selected MQuAKE cases, each with three closely related question versions. Only one small quantized model (Qwen3.5-9B) is tested. Overall, the results show that the method works in a controlled setup, but not that it would help in real-world agent memory.

Questions for authors

Q1 What does VeriMem offer over the component-level baselines? In Table 2, component-level eager invalidation and dependency-version checking achieve identical results to VeriMem, and Table 9 shows VeriMem is slower. Is there a setting where checking at read time gives a clear advantage, for example when sources change often but memories are rarely read? If so, can authors show it experimentally?

Q2 How would the dependency records be obtained in a real system? VeriMem requires an exact record of which sources each part of a memory came from, but in practice an LLM writes these summaries and plans. How would these records be produced, and how does VeriMem perform when they are generated automatically and contain errors, such as missing or extra dependencies?

Q3 How often does stale derived memory occur naturally? All experiments use outdated content that was planted by the authors. Can authors show evidence, from an existing memory system or real usage logs, of how often this problem arises without injection?

Q4 Do the results hold on new data and other models? The LongMemEval-V2 questions were used during development, the MQuAKE cases were hand-selected, and only one 9B model was tested. Can authors report results on held-out questions, with at least two additional models (ideally at least one frontier-class model)?

1 comment
AuthorsOpenReview ↗

Architectural Value, Automated Provenance, Generalization, and Clarity

Thank you for your direct and candid feedback. We appreciate the opportunity to clarify VeriMem's architectural role, demonstrate its effectiveness on LLM-generated memories across multiple models, and substantially improve the manuscript's readability.

Q1. Practical advantage over component-level baselines and related work. While component-level Eager invalidation achieves the same retention rate when given identical boundaries, it requires tight write-time coupling: every source update must synchronously locate, lock, and rewrite all affected derived artifacts across the memory store. In contrast, VeriMem records an O(1)O(1) source invalidation barrier at write time and enforces validity at prompt assembly (ServeRebuilt, Eq. 3). This allows agents to safely reuse derived memories stored in append-only logs, immutable caches, or heterogeneous vector stores without write-side cascade amplification.

In E1 (24 workloads×2 deployments×4 policies×5 repetitions=96024 \text{ workloads} \times 2 \text{ deployments} \times 4 \text{ policies} \times 5 \text{ repetitions} = 960 cells, measuring full assembly, transport, and durable storage costs), topology-reuse reconstruction achieves a median-of-medians cost ratio to component Eager of 1.164×1.164\times locally and just 1.034×1.034\times in remote deployments. Adding only 3.4%3.4\% median latency in distributed execution while eliminating write-side cascade maintenance makes serving-time verification highly practical. We will also expand Related Work and Table 4 to explicitly contrast VeriMem's consumer-side admission layer with the store-wide repair mechanisms of MemoRepair and PACMI.

Q2. Automated provenance capture in real LLM agent pipelines. In modern agent architectures, summaries and plans are synthesized by an LLM from retrieved source records. E2 demonstrates how provenance is captured automatically during this generation step without human labeling: a Qwen writer generates 96 source notes and 24 composite summaries, while dependencies are logged structurally from the source records supplied to each generation call and aligned to fixed schema fields. Across 96 update events in 24 source groups, reconstruction achieves 86/9686/96 (89.6%89.6\%) complete typed-field exact matches with Qwen3.5-9B Q4_K_M and 96/9696/96 (100%100\%) with DeepSeek Flash, compared to 0/960/96 for whole-artifact Gate and Eager. We will highlight this structured write-time logging pattern in Section 4 and discuss handling noisy extraction in legacy unstructured stores in Section 6.

Q3. Understanding stale-memory exposure in agent backends. Standard agent memory frameworks (e.g., Mem0, Graphiti, Zep) store derived reflections and summaries as independent entries; updating a source fact does not automatically rewrite previously generated summaries. Our controlled lifecycle studies isolate and measure the exact downstream impact whenever retrieval surfaces such un-updated derivatives after a source mutation. We will clarify this distinction between mechanistic exposure risk upon retrieval and production-log prevalence in Section 5.

Q4. Generalization across tasks and frontier models, plus rewriting for clarity.

  1. Multi-Model & Multi-Task Generalization (E3): E3 evaluates model-written memories across 48 HotpotQA-derived cases (16 unchanged, 32 source-use withdrawal) ×\times 3 context levels (570570 unique requests, 1,4401,440 logical cells) on two distinct readers: Qwen3.5-9B Q4_K_M and a hosted frontier-class model (DeepSeek Flash). Under source withdrawal, all-valid reconstruction achieves 55/9655/96 (Qwen) and 58/9658/96 (DeepSeek Flash) normalized whole-answer exact matches, versus 3/963/96 and 0/960/96 for Gate (while tying component Eager at 44/9644/96 and 41/9641/96 under the relation-closure selector).
  2. Complete Readability Overhaul: We take your presentation feedback to heart. In the revision, we will rewrite Sections 1-5 in clear, plain language—leading with intuitive examples before formal definitions, replacing dense jargon with direct explanations, and consolidating technical edge cases into the appendix.
Reviewer_moxJOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes VeriMem, a verification layer between retrieval and context construction for agent memory. Derived artifacts such as summaries and plans are bound to the versions of the sources they depend on, and each retrieved artifact is checked against the current lifecycle state of its dependencies before it enters the model input. A whole-artifact Gate withholds an artifact if any dependency is invalid, while component reconstruction keeps only the claims whose support is still valid. The authors state conditional exclusion and retention properties. They evaluate exclusion with Mem0/Graphiti lifecycle tests and stale-artifact injection into LongMemEval-S/LoCoMo, retention on 32 authored route–budget inputs, and answer utility on 60 LongMemEval-V2 questions and 24 selected MQuAKE cases using one quantized Qwen reader. They also report local cost measurements.

Critical strengths
  1. The paper identifies a practical problem: correcting a source does not automatically invalidate summaries or plans that were derived from it and cached separately. The running example in Figure 1 makes this clear. Treating exclusion of invalid content, retention of valid content, and answer utility as separate outcomes is also a useful way to frame the evaluation.
  2. The comparison includes component-level baselines that receive the same information as VeriMem, which separates the effect of selection granularity from the timing of maintenance. This design choice is good, but it also shows that VeriMem has no advantage over these baselines.
Critical weaknesses
  1. The contribution over existing approaches is unclear. In Table 2, VeriMem reconstruction ties both component-level baselines on all 32 inputs, suggesting that retention gains come from granularity rather than VeriMem itself. Table 9 shows substantially higher costs, exceeding an order of magnitude on some workloads, without stable total-cost savings. The mechanism builds on standard dependency tracking and overlaps with MemoRepair, PACMI, and Shen et al.’s read-time guard. The two properties largely follow from the admission rule.
  2. The main results largely hold by construction, while a central practical challenge remains assumed. With correctly recorded dependencies, checking them should exclude invalid artifacts, making RQ1’s exposure reductions expected. Likewise, the LongMemEval-V2 gain comes from removing author-injected invalid items. The method assumes complete, accurate writer-declared dependencies and claim-level decomposition, but does not demonstrate how these are obtained for LLM-generated summaries or plans, or evaluate robustness when they are incorrect.
  3. The evaluation is small and development-focused: RQ2 uses 32 authored inputs with 53 distinct generations, LongMemEval-V2 uses 60 previously seen questions, and MQuAKE covers 24 selected cases, all with a single 4-bit Qwen reader. An earlier batch on the same questions was not significant (p = 0.1185). Other-reader runs remain archived rather than reported, and the evaluated version predates the clock-sampling fix. The heavily qualified, lab-notebook-style presentation also makes the main findings and their limitations harder to assess.
Questions for authors
  1. What does VeriMem offer beyond the component-level dependency-version and eager-invalidation baselines, in either accuracy or cost?
  2. How are claim-level dependencies obtained in practice for LLM-generated summaries and plans? Can the authors evaluate VeriMem with automatically extracted dependencies that include realistic errors, and report how exclusion and retention degrade as dependency quality decreases?
  3. Can the authors report results on held-out questions instead of previously seen development questions, together with the archived runs from other readers? Were the reported experiments re-run after the clock-sampling fix described in Appendix A.1?
1 comment
AuthorsOpenReview ↗

Systems Contribution, Model-Generated Provenance, and Cross-Model Evidence

Thank you for your detailed questions and for highlighting how our evaluation separates selection granularity from enforcement timing. Below, we clarify VeriMem's architectural contribution and present verified results from three additional archived studies (E1: 24-workload end-to-end cost; E2: model-generated catalogue updates; E3: HotpotQA-derived withdrawal tasks).

Q1. Distinct systems contribution beyond component-level baselines. VeriMem provides a non-intrusive admission contract at the consumer boundary where independently cached derivatives enter model context:

  1. Decoupled Storage vs. Coupled Maintenance: Component-level Eager invalidation requires write-time coupling to locate and mutate every downstream cache whenever a source updates. VeriMem records an O(1)O(1) source invalidation barrier at write time and enforces validity at read time, enabling safe reuse over immutable logs, vector stores without in-place partial updates, and heterogeneous caches.
  2. Closed-Loop Re-Verification: Beyond checking version vectors, VeriMem's reconstruction rule (ServeRebuilt, Eq. 3) enforces deterministic assembly, unique logical keys, and post-assembly re-verification before issuing an auditable allow certificate. Our matched-information baselines intentionally share identical boundaries and dependencies to isolate the causal factor: component granularity drives information retention, while serving-time verification delivers storage decoupling.
  3. Near-Parity Distributed Cost (E1): Across 24 workloads×2 deployments×4 policies×5 repetitions24 \text{ workloads} \times 2 \text{ deployments} \times 4 \text{ policies} \times 5 \text{ repetitions} (960960 cells, including assembly, transport, and synchronous durable ops), topology-reuse reconstruction incurs a median-of-medians cost ratio to component Eager of 1.164×1.164\times locally and just 1.034×1.034\times remotely. Achieving full component retention with only a 3.4%3.4\% remote overhead—while avoiding write amplification on unqueried caches—demonstrates practical viability.
  4. Deepened Comparison with Prior Work: We will expand Related Work and Table 4 to thoroughly contrast VeriMem's consumer-side admission boundary against MemoRepair, PACMI, and Shen et al.'s read-time guard.

Q2. Structured provenance for model-written memories. E2 directly evaluates model-generated memories rather than hand-written text: a Qwen writer generates 96 source notes and 24 composite summaries, while dependencies are captured automatically from the source records passed to each writing call and aligned to fixed output fields. Across 96 update events in 24 source groups:

  • Component reconstruction achieves 86/9686/96 (89.6%89.6\%) complete typed-field exact matches with Qwen3.5-9B Q4_K_M and 96/9696/96 (100%100\%) with DeepSeek Flash (tying equally informed component baselines).
  • Whole-artifact Gate and Eager score 0/960/96 (0%0\%).

This confirms that logging write-time input provenance enables reliable component-level verification on LLM-authored summaries without manual annotation. We will also add a focused discussion on handling noisy or incomplete provenance in unstructured legacy stores.

Q3. Multi-model generalization, expanded tasks, and streamlined presentation. E3 broadens our evaluation to 48 HotpotQA-derived cases (16 unchanged, 32 source-use withdrawal) ×\times 3 context levels (570570 unique requests, 1,4401,440 logical cells) and evaluates both Qwen3.5-9B Q4_K_M and a frontier-class hosted model (DeepSeek Flash):

  • Under source withdrawal, all-valid reconstruction achieves 55/9655/96 (Qwen) and 58/9658/96 (DeepSeek Flash) normalized whole-answer exact matches, outperforming Gate (3/963/96 and 0/960/96) by over 5050 percentage points, while matching component Eager (44/9644/96 and 41/9641/96) under the relation-closure selector.

All E1, E2, and E3 metrics were audited via artifact hash checks, byte-identical analysis replays, and full score recomputations, with E1/E2 running on fixed logical/snapshot states invariant to clock-sampling changes. Finally, we will thoroughly revise Sections 1-5 to eliminate defensive qualifiers and present a crisp, accessible systems narrative.

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

VeriMem addresses stale derived memories that persist after their underlying sources change. It introduces a serving-time admission layer that verifies versioned dependencies and lifecycle constraints before memory enters model context. Whole-artifact gating rejects unsupported derivatives, while optional component-level reconstruction preserves admissible claims through deterministic rendering and re-verification. The paper establishes conditional exclusion and retention properties and evaluates stale-content exposure, information retention, and downstream answering. Results suggest that fine-grained retention can improve answer availability, but the practical benefits and robustness of the proposed system remain insufficiently established.

Critical strengths
  • Clear problem formulation and admission contract. The distinction between storage identity and evidential support is well motivated. Checking the full dependency closure, rather than a derivative's status alone, provides a precise interface for enforcing memory validity at context construction.

  • Carefully controlled comparisons. The matched-information experiments distinguish selection granularity from maintenance timing. Parity with equally informed component-level baselines appropriately attributes the retention benefit to finer-grained selection rather than uniquely to VeriMem.

  • Sound qualification of the claims. The paper distinguishes evidence admissibility from downstream answer utility, explicitly states the assumptions behind its guarantees, and reports implementation costs and evaluation limitations. This makes the scope of the results relatively clear.

Critical weaknesses
  • The distinctive systems benefit remains unclear. Reconstruction matches equally informed component-level baselines on task outcomes, while incurring substantially higher local costs and showing no stable total-cost advantage. Although the paper identifies conditions under which deferred maintenance might be beneficial, it does not demonstrate a realistic workload in which VeriMem offers a compelling advantage over simpler component-level checking or eager maintenance.

  • The admission-to-consumption guarantee is not fully validated in the evaluated implementation. The appendix acknowledges clock-handling issues in the evaluated revision, with a subsequent fix outside the reported experiments, as well as unresolved recovery and post-check expiry concerns. These limitations do not invalidate the fixed-snapshot arguments, but leave concurrent updates, delayed consumption, and interrupted mutations insufficiently tested. The authors should clarify the protections active in each experiment and provide focused boundary tests for the corrected implementation.

  • Semantic provenance remains a strong, unevaluated assumption. The method relies on accurate dependency bindings and meaningful component boundaries, yet these are supplied rather than validated end to end. Missing or incorrect dependencies can admit stale content, while overinclusive dependencies can discard valid information. An audited evaluation on naturally generated memories, or a sensitivity analysis of imperfect bindings, would better establish practical robustness and the cost of obtaining these annotations.

  • The main multihop metric does not establish unambiguous answer correctness. MQuAKE current-alias matching can credit responses containing both obsolete and current answers; the paper also reports old-only responses under reconstruction. The frozen outputs should be rescored into mutually exclusive current-only, mixed, old-only, abstention, and other-answer categories. Paired case-level transitions would clarify the trade-off between answer coverage and contradictory outputs.

  • Generalization and reproducibility are limited. The downstream evaluations rely on development-set questions, selected cases, authored interventions, and a single quantized reader. In addition, the manuscript does not provide a complete, accessible package for reproducing its custom interventions and revision-specific implementation claims. A group-disjoint evaluation and a minimal versioned package containing policy code, fixtures, transformed inputs, prompts, scorers, and shareable outputs would materially strengthen the evidence.

Questions for authors
  1. Implementation boundary (clarification): Which implementation revision and synchronization protections were used in the reported experiments? In particular, how were clock consistency, concurrent invalidation, post-check expiry, and interrupted updates handled? Do the current results cover the admission-to-consumption boundary, or only fixed-snapshot admission?

  2. MQuAKE evaluation (additional evidence): Can the authors rescore the frozen responses into mutually exclusive current-only, mixed, old-only, abstention, and other-answer categories, with paired case-level transitions? Does reconstruction retain its advantage when only unambiguous current answers count as correct?

  3. Provenance assumptions (clarification and evidence): How were claim boundaries and dependency bindings obtained in each experiment, and what manual effort was required? Is there evidence of robustness to missing, incorrect, or overinclusive dependencies, or to provenance generated from natural-language memories rather than supplied annotations?

  4. Distinctive systems benefit (clarification): Given that reconstruction matches equally informed component-level baselines on task outcomes but incurs higher local costs, what concrete advantage does the proposed serving-time design demonstrate over component-level eager invalidation or dependency checking? Is there an evaluated workload in which deferred maintenance offsets the additional read-time cost?

1 comment
AuthorsOpenReview ↗

Implementation Scope, Strict Answer Correctness, Provenance, and Systems Trade-offs

Thank you for your thoughtful assessment and for recognizing the rigor of our matched-information design. To directly address your questions, we present verified empirical evidence from three additional archived studies audited against their saved records: E1 (end-to-end systems cost across 24 workloads), E2 (LLM-generated catalogue updates), and E3 (HotpotQA-derived source-withdrawal selection).

Q1. Implementation boundary and clock-sampling fix. In our implementation, E2 operates on fixed pre/post-update snapshots and E1 uses fixed logical time, making their admission decisions invariant to wall-clock sampling. For runtime deployments, the updated batch-level timestamp sampling ensures consistent evaluation across verification and certificate issuance. In the revision, we will clearly structure Section 3 and Appendix A to separate our core snapshot-level admission guarantees from runtime concurrency and TTL-expiry requirements (Figure 5b-d), giving readers an explicit blueprint for deploying VeriMem in asynchronous environments.

Q2. Unambiguous answer correctness across strict benchmarks. We agree that separating current-only responses from mixed outputs strengthens the MQuAKE analysis. Because all 72 Qwen responses are frozen, adding your requested five-category mutually exclusive breakdown (current-only, mixed, old-only, abstention, other) and paired case transitions requires only deterministic post-processing and will be included in the revised Section 5.

Crucially, our archived studies E2 and E3 already evaluate downstream utility using strict, unambiguous exact-match criteria across two distinct readers (Qwen3.5-9B Q4_K_M and a frontier-class hosted model, DeepSeek Flash):

  • E2 (Complete typed-field exact match across 96 update events in 24 source groups): Component reconstruction achieves 86/9686/96 (89.6%89.6\%) on Qwen and 96/9696/96 (100%100\%) on DeepSeek Flash, whereas whole-artifact Gate and Eager drop to 0/960/96 (0%0\%).
  • E3 (Normalized whole-answer exact match across 32 source-withdrawal cases ×\times 3 context levels): All-valid reconstruction achieves 55/9655/96 (Qwen) and 58/9658/96 (DeepSeek Flash), compared to 3/963/96 and 0/960/96 for Gate.

(Note: Correlated variants within source groups/context levels are explicitly accounted for in our reporting.) Under strict exact-match scoring where ambiguous or partial answers receive zero credit, selective retention consistently preserves answerability across model scales.

Q3. Practical provenance acquisition for LLM-generated memories. E2 demonstrates how provenance is captured naturally in agent workflows without manual annotation: a Qwen writer synthesizes 96 source notes and 24 composite summaries, while dependencies are logged structurally from the source IDs passed into each generation request and aligned to fixed output fields. This confirms that write-time structured provenance works seamlessly with model-written text. We will add a discussion of automated semantic extraction for unstructured legacy text and dependency-noise sensitivity as direct extensions in Section 6.

Q4. Distinctive systems benefit and end-to-end cost profile. VeriMem's architectural advantage lies in decoupling source invalidation from derivative storage: backends only record lightweight source-side barriers, enabling safe reuse over append-only, immutable, or cross-store caches without synchronous cascade rewrites or reverse-index maintenance. While matched component baselines share the same retention curve by design, VeriMem achieves this without mutating cached artifacts.

In E1 (24 workloads×2 deployments×4 policies×5 repetitions=96024 \text{ workloads} \times 2 \text{ deployments} \times 4 \text{ policies} \times 5 \text{ repetitions} = 960 cells, accounting for assembly, transport, and synchronous durable ops), topology-reuse reconstruction exhibits a median-of-medians cost ratio to component Eager of 1.164×1.164\times locally and just 1.034×1.034\times in remote deployments. Thus, in realistic distributed settings, VeriMem adds only a 3.4%3.4\% median overhead while eliminating write-side cascade maintenance and preserving full component-level utility.

Reproducibility. All E1, E2, and E3 results have been verified via artifact hash checks, byte-identical analysis replays, and full recomputation of all 1,440 scores from 570 unique requests, which we will release alongside our frozen outputs.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.