acceptodds
Under review as a conference paper at ICLR 2027

Stable Loci Addressing: A Shared-State Architecture for Referential Stability in Evolving Long-Term LLM Memory

Abstract

Long-term memory for large language models (LLMs) is usually treated as a retrieval problem: given a query, find the relevant stored information. But a memory that changes over time faces another problem. Once a computation refers to a record, later updates should not make that reference silently point elsewhere. We call this requirement referential stability and show that exact revisitation requires retained information about the earlier choice. We introduce Stable Loci Addressing (SLA), which unifies persistent indirection, rebinding, and structured locus operations within one shared-state memory interface without a separate per-record reverse-locator layer. Shared writes can therefore affect other references. We derive exact RLS and Delta one-write laws, an exact cumulative native-Delta law, and a necessary-and-sufficient Top-1 certificate. Experiments span semantic conflict, learned cue embeddings, long mutation sequences, LongMemEval content and structural evolution, cross-bank maintenance, and zero-trainable-parameter integration with a frozen DeltaNet. Raw semantic keys can initialize correctly yet fail after relocation. Verified dereference prevents wrong-record returns, and the certificate tracks failure. On 70 LongMemEval-S knowledge-update questions, stale predecessor evidence lowers answer accuracy by 68.6 percentage points, while SLA exactly matches updated-pointer semantics. Together, these results show static retrieval accuracy is insufficient for evolving shared memory and establish referential stability as a distinct, testable correctness criterion.

Primary area:
foundation or frontier models, including LLMs
Keywords:
long-term LLM memory, referential stability, associative memory, test-time memory, fast weights, Delta rule, neural memory, memory systems

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_zW2FOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies how a reference established by semantic retrieval can continue to identify the same record as its content and storage location change. It formalizes this requirement as referential stability and shows that revisiting an earlier selection requires retained information about that selection. SLA binds stable identity keys to structured location codes through a shared writable matrix, supporting relocation and relation operations without a separate per-record reverse locator. A forward registry verifies identity before returning the current payload. Because updating one binding can disturb others, the authors derive single-write interference laws for RLS and Delta updates, a cumulative law for Delta, and an exact condition for correct Top-1 decoding. A separate sufficient bound guides bank rebuilding. Experiments show that accurate initialization can mask failures after updates, evaluate maintenance under sustained churn, and verify equivalence to updated pointers on LongMemEval. A frozen DeltaNet integration demonstrates compatibility without additional trainable parameters.

Critical strengths
  1. The paper identifies a concrete failure mode that static memory evaluations can miss. Raw semantic keys can decode correctly at initialization yet lose other bindings after a record is relocated. This provides useful evidence that memory quality should be evaluated through updates, with attention to both key geometry and access stability.

  2. The analysis connects the update rule to observable access failures. It describes how a write affects other bindings, how these effects accumulate, and when they change the decoded address. The controlled overlap experiments support this explanation. Separating the exact decoding condition from the conservative rebuilding criterion also provides a useful basis for studying the trade-off between reliability and maintenance cost.

Critical weaknesses

1. The case for choosing SLA over an explicit locator remains weak. In the resident-state address-recovery benchmark, cached pointers take 0.113μs and SLA takes 30.898μs; even registry scanning is faster at 20.151μs (Table E.2). Delta-SLA also uses more memory than pointers under the reported common-control accounting (Table E.4). The natural-data experiments establish equivalence to correctly updated pointers, without demonstrating an advantage that compensates for shared-state interference and maintenance. Avoiding a separate reverse locator is a clear design difference, but the paper does not establish a concrete setting where this difference justifies the added complexity.

2. Sustained availability and maintenance cost are insufficiently characterized. The paper correctly distinguishes rejecting an incorrect lookup from successfully accessing an active record. On the high-churn trace, maintaining access requires 1,744 rebuilds for 11,000 candidate writes and increases runtime by 2.13× (Table C.10). In Appendix G’s independent CPU replay, rebuilding every 32 bank writes produces no observed misses with 340 rebuilds. Periodic rebuilding does not provide the same per-commit check, but this comparison leaves the cost-benefit of the guarded policy unresolved. The principal long-horizon maintenance comparison uses one fixed trace, so it remains unclear how failures, rebuild frequency, and latency change across workloads.

Questions for authors

1. Why choose SLA? What concrete system constraint makes an explicit pointer or dictionary unsuitable? Given the reported lookup costs, memory footprint, and equivalence to correctly updated pointers, what benefit justifies SLA’s additional interference and maintenance machinery?

2. Scope of stability. Appendix G provides a check on the correctness of published states. What operating conditions on bank load, key geometry, and update patterns support sustained successful access and continued acceptance of writes? Please clarify the supported operating range, including when rebuilding may fail to produce a certifiable state.

3. Maintenance comparison. In Appendix G’s CPU replay, periodic rebuilding every 32 bank writes has no observed misses with 340 rebuilds, while guarded maintenance uses 1,744. I recognize that these policies provide different guarantees. Can the authors quantify what additional robustness the guarded policy buys, and at what cost, across multiple update traces?

4. Full system cost. Can SLA, periodic rebuilding, and explicit locators be compared on the same mutation workloads, including verification, key generation or caching, maintenance state, and rebuild workspace? Reporting access failures, rejected writes, throughput, tail latency, and peak memory across different loads and churn patterns would help establish where SLA offers a useful trade-off.

6 comments
AuthorsOpenReview ↗

W1/Q1 - why choose SLA?

Thank you for your detailed and insightful assessment of stability and systems cost. Your distinction among safe lookup, active-reference availability, and continued write acceptance provided a valuable structure for the new evaluation. The independent-trace experiments and explicit operating conditions have made the paper substantially stronger.

SLA retains inexpensive pointer-style execution for simple requests and offers certified incremental maintenance with measured service savings. The revision adds the requested multi-trace maintenance comparison, explicit admission conditions, and full cost/resource measurements. Section 4.5 is on pp. 9-10, Figure 4 on p. 9, and Appendix H on pp. 54-66. We address the four questions through complementary evidence on practical deployment, stability conditions, maintenance robustness, and full-system resource costs.

W1 / Q1: what benefit justifies the additional machinery?

The benefit is lower-cost maintenance of changing continuous associations, without imposing matrix maintenance on exact requests. A known handle selects SLA-Direct. Its paired public-service cost ratio to Exact Pointer is 0.9989 [0.9982, 1.0011]. Ordinary SLA-Compiled access gives 0.9950 [0.9844, 1.0102]. Both meet the 2% engineering criterion, with no unused binder or numerical gate in Direct (Appendix H.3-H.4).

Your comparison of exact-access latency and memory costs in Tables E.2 and E.4 correctly highlights the importance of selecting the appropriate execution mechanism for each workload. The 0.113/30.898-microsecond lookup results, registry-scan control, and common-control memory figures remain in Tables E.2 and E.4. SLA-Direct retains exact access without the shared-matrix work, using the same permitted routing and identity information.

Shared maintenance has its own positive evidence. With fixed keys, residual-aware rebinding corrects the target and preserves other active responses in exact arithmetic, using a minimum-Frobenius correction. Geometry is reused and factors are maintained across structural changes. Every stored candidate is certified. At 256 records and dimension 512, independent calibration selects Incremental before evaluation. Across ten input seeds, its complete-service ratio to independent Compiled Readout with the same certificate is 0.8505 [0.8343, 0.8726], or 14.95% lower cost. A separate 62-history controlled study following real session order gives 0.8921 [0.8306, 0.9693], or 10.79% paired savings (Appendix H.2, H.4, H.9).

A continuous application consumes the output. We reproduced the SSP-SLAM View network of Dumont et al. (2023) and confirmed that continuous associative recall contributes directly to the localization feedback pathway. Using the spatial-semantic representations and sensory functions from Dumont et al. (2023), we constructed a controlled closed-loop service in which memory readout influences position correction and subsequent map updates. Every eligible method receives the native identities and weights. Direct-weighted execution satisfies quality in all 960 formal runs and saves 14.58% against same-certificate Compiled Readout, while meeting noninferiority against native aggregation and resolver/gather (Appendix H.5). This measures the benefit of input-appropriate deployment, separately from Incremental's maintenance advantage.

The workload coverage is broader than one trace. The extension spans 24 profiles, varying scale, dimension, update structure, and 1/8/64 reads after each write. All 1,728 validation runs satisfy quality. The four Incremental profiles selected on independent calibration data yield 8.06-16.03% savings with nominal 95% intervals below one. All 20 retained profiles match their references' output, state, and core-call sequences without a per-request proxy (Appendix H.8).

SLA therefore preserves efficient basic execution and adds a certified shared-maintenance realization with measured benefits. Your practical-cost question helped us make this execution choice explicit. The additional theoretical and experimental evidence establishes explicit stability conditions, independently measured active-reference availability, and complete resource costs (Appendices H.6-H.7).

AuthorsOpenReview ↗

W2/Q2 - stability and write admission

W2 / Q2: which conditions support sustained successful access and continued writes?

Active access is preserved when committed associations meet the numerical certificate under atomic publication and trusted control metadata. Writes are admitted when the proposed or rebuilt state satisfies the same conditions. Your scope question prompted an explicit account of representability, finite-precision separation, and admission, supported by state-transition tests (Appendices H.2 and H.6).

Representability. With active keys as rows of KK and assigned unit target codes as rows of TT, full-row-rank KK admits the exact-real interpolant

B0=TT(KKT)−1K,B0KT=TT.B_0=T^T(KK^T)^{-1}K,\qquad B_0K^T=T^T.

Thus bank load at most key dimension is necessary for full row rank, while the realized key geometry determines rank and conditioning. For ridge regularization,

BλKT−TT=−λTT(KKT+λI)−1.B_\lambda K^T-T^T=-\lambda T^T(KK^T+\lambda I)^{-1}.

The Gram spectrum, ridge bias, and target separation jointly determine the attainable margin.

Numerical separation and updates. For unit codes, let mm be the smallest ideal target-competitor gap and ee bound response error. The condition m>2em>2e preserves the decoded identity before score-rounding terms. The implemented certificate also accounts for actual stored-state reads and score arithmetic, checking all active bindings against the complete codebook. An inconclusive norm-first bound invokes the componentwise check.

Fixed-key residual correction sets the target while preserving other active responses in exact arithmetic. Structural changes update factors and invalidate affected caches. Checking the actual candidate makes publication independent of assumptions about random update order. Rebuilding restores access when it recovers a representable, sufficiently separated state.

Admission preserves the last certified state. Every accepted update is checked before publication. When incompatible duplicate keys, insufficient rank, or inadequate finite-precision separation prevents a certifiable reconstruction, the request receives a defined rejection and the preceding committed state is retained. Retirement and fresh generations prevent old handles from aliasing reused slots. These guarantees apply to atomic or externally locked publication with trusted registry, routing, and liveness metadata.

Long-horizon validation. Three independent 25,000-event streams were run with Incremental and two compiled controls. All nine runs preserve the checked contract: 75,000 distinct input events / 225,000 method events, comprising 101,685 accepted mutations, 11,379 expected rejections, 55,899 handle reads, and 56,037 soft reads. Public checks include cross-bank second-stage failure and clearing stale readouts. Expected rejection is distinguished from an active-reference miss.

High-correlation validation. At 256 active keys, dimension 4096, capacity 1024, and correlation parameters 0.999/0.9999, Read64 retains FP32 state but actually accumulates reads in FP64 before FP32 output. Three seeds per setting and method give 12 passing runs, 384 updates, and 12,288 mixed queries for SLA and Compiled, with zero refits or decoding errors. The output budget remains 0.15, and incompatible duplicate-key controls are still rejected. This is a precision-specific operating result, complementary to the longer lifecycle runs.

The supported operation is now explicit: admit certifiable updates, preserve successful access to the committed associations, and retain that state when a proposal is rejected. We appreciate your request to state these conditions clearly. The theory, actual arithmetic, and long-horizon tests now support the same operating contract.

AuthorsOpenReview ↗

W2/Q3 - guarding across update traces

W2 / Q3: what additional robustness does guarding buy, and at what cost across traces?

In both three-stream configurations, score and norm guarding preserve all 90,000 measured active-reference reads, while periodic-32 incurs misses. Table H.8 reports the complete cost of obtaining this availability. Your request to test beyond one trace motivated this paired robustness-cost evaluation.

Design. The comparison uses the same native-Delta maintenance policies and numerical settings defined in Appendix G, ensuring that the additional update traces isolate differences in maintenance policy rather than changes in implementation. Each of two configurations uses three independent 25,000-event streams: 20,000 mutations, 5,000 scheduled revisits, and an active-reference read after every event. Policies receive identical inputs within a configuration and seed. Random keys use two banks, initially 48 records per bank, dimension 256, and capacity 128. The correlated configuration uses two banks, initially 64 records, dimension 256, capacity 192, and correlation-generation parameter 0.9. These are two operating configurations, not a single-factor geometry ablation.

Results. Each miss count aggregates 90,000 reads across three streams. Each duration is the median complete cold-service time of those streams.

Random keys: Periodic-32 71 misses / 1.797 s; Periodic-256 3,235 / 1.414 s; score guard 0 / 6.138 s; norm guard 0 / 19.549 s.

Correlated keys: Periodic-32 56,827 misses / 2.258 s; Periodic-256 78,975 / 1.589 s; score guard 0 / 23.130 s; norm guard 0 / 31.705 s.

Identity verification remains enabled. These are unavailable active references, not wrong-record returns. Periodic-32 incurs 24, 21, and 26 misses on the three random streams; both guards eliminate them. Score guard uses 836 versus 1,169 rebuilds in that group, 28.5% fewer than Periodic-32, while still paying per-candidate checking. Compared with norm guard, its complete cost is 68.6% and 27.0% lower in the two configurations.

The update law explains the extra robustness. For initially exact bindings and unit keys, a target-correct Delta write to key ii gives, for another key jj (i≠ji \ne j),

B+kj=tj+(kiTkj)(ti+−ti).B^{+}k_j=t_j+(k_i^Tk_j)(t_i^{+}-t_i).

The interference term can exhaust another reference's decoding margin after one write, before the next scheduled rebuild. The executable two-record witness starts at decoded addresses [0, 1], reaches [1, 2] after the write, and returns to [0, 2] after rebuilding. The protected record's ideal margin becomes -0.002230638. Candidate verification detects that state before publication under the stated arithmetic assumptions.

Consistency with the reference maintenance experiment. Appendix G retains periodic-32's 340 rebuilds and no observed miss on the original trace. Table C.10 retains the guarded result of 1,744 rebuilds for 11,000 candidate writes at 2.13-times unmaintained runtime. The added streams test robustness across workloads, while the update law explains the protection provided by checking every candidate. The 37,488 correlated score-guard rebuilds characterize the Delta-policy experiment; the geometric Incremental writer has its own service comparisons.

Guarding provides measured active-reference availability on the added independent streams, and the interference law explains how candidate checks protect it between periodic rebuilds. Verification and recovery are included in the reported cost. Thank you for requesting this comparison, which substantially improves the evidence connecting the guarantee to observed operation.

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

This paper distinguishes semantic retrieval from stable revisitation of an already selected logical record in evolving LLM memory. Stable Loci Addressing (SLA) uses protocol-stable keys and a bank-shared associative matrix to recover mutable locations, followed by identity verification against a forward registry. The paper derives single-write and cumulative interference identities, Top-1 correctness conditions, and maintenance rules. Experiments cover controlled mutations, learned-key interference, cross-bank churn, structured relation execution, LongMemEval, and a frozen DeltaNet integration, with explicit pointer, dictionary, and scan controls.

Critical strengths

The one-write interference laws, cumulative native-Delta identity, and decoding-margin conditions are coherent and supported by controlled tests. The evaluation includes both successful operation and meaningful failures under coherent learned keys and long mutation sequences. It also distinguishes fail-closed safety from successful active-reference recovery, and repeated checkpoint coverage from independent statistical samples.

Critical weaknesses

W1. The practical motivation for replacing exact locator state with a larger, interference-prone shared binder remains unestablished.

The paper's own matched measurements show that the classical alternatives are substantially cheaper in the evaluated regime. At 1,024 slots, Table E.2 reports mean address-recovery times of 0.1131 microseconds for cached pointers, 0.1426 for a hash dictionary, 20.1514 for a forward-registry scan, and 30.8980 for exact SLA. The scan also avoids a reverse-locator table. Under the common control-state accounting in Table E.4, the concrete pointer representation occupies 285,496 bytes versus 539,448 for Delta-SLA, before optional identity-key caches and maintenance state.

SLA additionally introduces interference, possible active-reference misses, and maintenance requirements. Appendix G transparently reports these costs: the eight-bank reference initialization uses 64 MiB of resident identity keys and 1.0625 MiB of controller state, while regenerating a key on demand takes 54.87 microseconds on average. The certified policy also uses 1,744 rebuilds on the reference trace, compared with 340 for the every-32-writes policy that has no observed misses. The per-commit guarantee is stronger than that empirical periodic result, but no practical efficiency advantage is established.

These observations do not invalidate shared-state characterization. They do leave the main architecture insufficiently motivated: the system already permits exact identity, routing, liveness, and forward-registry metadata, so what concrete deployment constraint makes an additional small exact locator undesirable while this larger shared representation is useful? The 257x Delta-versus-RLS tensor reduction does not answer that comparison.

W2. The downstream and pretrained-model experiments validate fidelity, but do not establish an SLA-specific memory benefit.

The LongMemEval-S intervention is cleanly controlled, but the 68.57-point accuracy difference is between current and stale evidence. Updated SLA and updated pointers provide identical evidence, complete inputs, outputs, and correctness labels in all 70 cases. Consequently, this result establishes the importance of state freshness and the fidelity of the SLA implementation, rather than a benefit attributable to its shared-state architecture. The manuscript appropriately acknowledges this distinction; nevertheless, this headline result does not resolve the contribution question.

The other natural/model studies have a similar limitation. The LongMemEval-V2 locator substitutions preserve supplied evidence, while the periodic, integer, and adjacency relation executors operate under fixed controller decisions and produce equivalent evidence. Appendix D.4 carries a separate SLA matrix alongside the frozen DeltaNet cache and serializes the retrieved payload into the model input; the pretrained recurrent dynamics remain unchanged. The 700/700 input/logit equivalences therefore demonstrate correct external-state composition, not an improvement in learned recurrent memory.

Taken together, these are extensive and useful correctness checks, but the empirical breadth does not supply a discriminating task or operating regime in which choosing SLA produces an additional capability or a favorable resource trade-off. The retained-state counting bound, cumulative update identity, and current-score correctness condition characterize the chosen locator; their validity alone does not establish why this realization offers a substantive advance over the exact alternatives.

Questions for authors
  1. Architectural motivation: What concrete hardware, representation, or deployment constraint makes explicit reverse locators unavailable or undesirable while the required exact registry, routing, liveness, and cue metadata remain accessible? Can SLA demonstrate an advantage in that regime against the supplied exact alternatives?

  2. Discriminating application evidence: Beyond matching updated-pointer or symbolic-executor semantics, which task-level or operational benefit arises specifically from the shared associative representation? A matched evaluation isolating that benefit would materially affect the significance assessment.

  3. Correctness–cost operating point: At a matched correctness requirement, how do total query/update latency, availability, key handling, certification, and rebuild costs compare with pointer/dictionary access and simpler maintenance schedules? Please distinguish the guarded policy's per-commit guarantee from empirical no-miss behavior on a fixed trace.

4 comments
AuthorsOpenReview ↗

W1/Q1 - motivation and exact access

Thank you for the exceptionally careful distinction between referential correctness, consumer fidelity, and architectural benefit. Your assessment motivated a more discriminating evaluation of architectural compatibility, numerical maintenance, and operational benefit, with matched comparisons and clearer causal attribution that substantially strengthen the paper's significance evidence.

SLA provides a matched maintenance benefit while retaining efficient exact and compiled access. Incremental execution lowers paired complete-service cost by 14.95% against an independent compiled implementation with the same certificate and by 10.79% in a separate session-order study. Section 4.5 (pp. 9-10), Figure 4 (p. 9), and Appendix H (pp. 54-66) now connect the mechanism, deployment choice, and measured outcomes. W2/Q2 and Q3 follow.

W1 / Q1: what makes a reverse locator unsuitable while exact metadata is available?

The relevant distinction is the required continuous response under updates; exact metadata remains available and exact requests retain direct execution. A mixed association is a different output from one record lookup. Decomposed Readout, Compiled Readout, and explicit resolution/weighted gathering are eligible controls for that output, with the same information supplied to SLA. The deployment rule preserves exact locators wherever they directly satisfy the request, and evaluates continuous implementations under the same information permissions (Appendix H.1).

Known-handle requests use SLA-Direct. It retains the measured exact implementation without a binder, factors, or numerical gate. Eight paired blocks of a fixed 10,000-operation sequence give a public-service ratio to Exact Pointer of 0.9989 [0.9982, 1.0011], with matching states and checkpoints. Public transaction checks separately cover rejection, retirement/reuse, and stale-readout clearing (Appendix H.3-H.4).

Your comparison in Tables E.2 and E.4 usefully identifies the cost of selecting a shared-matrix path for exact lookup: pointer/dictionary/scan/shared-SLA address recovery is 0.1131/0.1426/20.1514/30.8980 microseconds, and pointer/Delta-SLA common-control totals are 285,496/539,448 bytes. The scan remains a valid reverse-table-free implementation. Direct specialization preserves efficient exact lookup without constructing that matrix. The original measurements remain reported, and the 257-fold tensor reduction retains its Delta-versus-RLS accounting boundary.

Continuous basic access retains Compiled Readout. Its independent 20-seed confirmation gives 0.9950 [0.9844, 1.0102]. Both basic confirmations meet the 2% criterion. Input permissions determine eligible modes; separate calibration then fixes the mode before validation. The two-profile lifecycle experiment activates incremental maintenance when the calibrated cost ratio is at most 0.95, while the broader 24-profile experiment applies a more conservative criterion requiring the calibration confidence interval's upper bound to be at most 0.95. Neither rule inspects validation outcomes (Appendix H.2, H.8).

Across all 20 reference-retaining profiles, outputs, state sequences, and core-call traces match without a per-request proxy. This verifies execution-path preservation independently of timing uncertainty. Selection is charged at construction.

The continuous interface has a concrete consumer. We reproduced the published SSP-SLAM View network (Dumont et al., 2023) and verified that continuous sensory inputs drive associative memory recall, which is subsequently used for position correction. We additionally evaluated a controlled closed-loop service using the same spatial-semantic representations and sensory functions. Native IDs and weights are available equally, so it selects Direct-weighted execution. All 960 formal runs across ten environments satisfy quality; deployment is noninferior to native aggregation and resolver/gather (Appendix H.5).

The scientific contribution is the analyzable maintenance of interacting reference state: update interference, correction of stored-state residuals, checked publication, and reusable geometry with measured service savings. Existing direct paths make that realization usable without imposing it on requests that do not need it. Observation-preserving specialization is the compatibility argument; matched dynamic experiments establish the additional operational value.

The execution choice is therefore explicit: retain efficient exact lookup, and activate incremental shared maintenance when independent calibration supports its benefit. This deployment rationale is supported by the residual-aware maintenance mechanism, its minimum-intervention property, and statistically supported complete-service improvements (Appendix H.4 and H.9). We appreciate your emphasis on this distinction, which makes the revised architectural rationale more precise and useful.

AuthorsOpenReview ↗

W2/Q2 - benefit beyond fidelity

W2 / Q2: which operational benefit goes beyond matching updated-pointer semantics?

The operational benefit is lower-cost certified incremental maintenance at matched output and certification requirements: 14.95% in the primary dynamic service and 10.79% in the separate natural-order controlled study. Your request for a discriminating evaluation shaped the mechanism, runtime, and consumer tests below.

Stored-state correction. For full-row-rank active keys KK, let vj=KT(KKT)−1ujv_j=K^T(KK^T)^{-1}u_j, with Kvj=ujKv_j=u_j. A nominal target-difference update retains the current residual rj=Bkj−tjr_j=Bk_j-t_j. SLA instead uses

B+=B+(tj′−Bkj)vjT.B^{+}=B+(t'_j-Bk_j)v_j^T.

This removes the target residual in exact arithmetic while preserving all other active responses. Proposition 5 establishes its unique minimum-Frobenius-norm property. Thirty matched pairs of certified FP32 initial states and 1,920 method updates validate the distinction: for a controlled initial residual near 10−310^{-3}, final target-error medians are 1.62×10−81.62\times10^{-8} for residual-aware correction and approximately 10−310^{-3} for target-difference updating. Both satisfy the same certificate without refitting. Maximum observed SLA collateral displacement is below 4.61×10−84.61\times10^{-8} (Appendix H.9). The deliberately introduced initial residual isolates correction of stored-state error.

Matched maintenance cost. Reusing fixed-key directions avoids repeated solves; structural changes maintain factors and invalidate affected caches. All stored candidates remain certified. At 256 records and dimension 512, separate calibration selects Incremental before the ten-seed, three-block evaluation. The complete-service ratio is 0.8505 [0.8343, 0.8726] to independent Compiled Readout with the same norm-first certificate. The ledger includes initialization/selection, keys, registry/payload operations, all offered updates, checking/recovery, query formation, and reads (Appendix H.2-H.4). The mechanism experiment isolates residual correction, while this comparison measures the combined maintenance implementation, including geometric reuse and factor updates.

Stronger matched control. Compiled Readout also uses a 32-direction cache, stored-residual correction, and the same certificate. In 256-key mixed structural updates, Incremental lowers complete-service cost by 8.34% (0.9166 [0.8710, 0.9660]; ten seeds, three blocks), despite zero cache hits for either method. Within SLA, caching saves 12.80% on hot rebinding (Appendix H.10, Tables H.12-H.13).

Independent workload extension. Twenty-four interleaved profiles vary scale, dimension, update structure, and read reuse. All 1,728 validation runs meet quality. The four profiles activated on disjoint calibration seeds yield 8.06-16.03% savings, each with a nominal 95% interval below one. For 256 records and one read per write, mean complete cost is 68.92 versus 75.70 ms, even though SLA certification costs more, 32.41 versus 30.92 ms. The component accounting locates the saving in initialization and other maintenance work while retaining the same certificate. Complete profiles and multiplicity sensitivity are reported in Appendix H.8 and Table H.11.

Natural-order corroboration. Across 62 controlled session histories and three blocks, the paired ratio is 0.8921 [0.8306, 0.9693]. The 10.79% paired improvement is distinct from the 7.17% reduction in summed time. Inputs and final evidence match; histories are the resampling units. Reads retain handles, so the experiment isolates maintenance implementations. Rebuilding the entire service after insertion is 19.45% slower than state reuse (Appendix H.4).

Application and model outcomes. The SSP-component closed loop uses available weights to select Direct and saves 14.58% against matched-certificate Compiled Readout, while remaining noninferior to native aggregation. This is avoided matrix maintenance. Separately, 124 new Qwen3-8B generations preserve prompts, input IDs, output tokens, and text in all 62 pairs (Appendix H.5).

The original 68.57-percentage-point current/stale contrast establishes the effect of evidence freshness (Appendix D.2, Table D.5). LongMemEval-V2 substitutions preserve evidence and controller decisions (D.3, Table D.6); the 700 held-out DeltaNet comparisons validate external-state composition with frozen recurrence (D.4, Table D.8). These fidelity results complement the separately measured maintenance gains, preserving the causal distinction emphasized in your review.

The operational contribution is thus supported by a complete chain: residual-aware correction, reusable certified maintenance, and matched service savings, alongside faithful consumer integration. We are grateful for the precise significance question that prompted these additional comparisons and strengthened their interpretation.

AuthorsOpenReview ↗

Q3 - correctness and complete cost

Q3: how do correctness, availability, and full costs compare on matched workloads?

Matched traces quantify availability and complete maintenance cost together, and the revision separately reports operation tails and memory for the mapping service. Your request for a common accounting boundary led to these complementary measurements (Appendices H.6-H.7).

Matched design. Each of two configurations has three independent 25,000-event streams: 20,000 mutations, 5,000 scheduled revisits, and an active-reference read after every event. All policies receive the same stream within a configuration and seed. Miss counts aggregate 90,000 reads per configuration; times are medians of three complete cold-service runs (Table H.8).

Random keys: periodic-32 has 71 misses / 1.797 s, periodic-256 3,235 / 1.414 s, score guard 0 / 6.138 s, and norm guard 0 / 19.549 s.

Correlated keys: periodic-32 has 56,827 misses / 2.258 s, periodic-256 78,975 / 1.589 s, score guard 0 / 23.130 s, and norm guard 0 / 31.705 s.

The same-stream standalone exact locator has zero misses at 0.057 s and 0.052 s. That is the appropriate path for these exact-handle requests. This standalone exact-locator control is reported separately from the Exact Pointer implementation used in the basic-access confirmation (Table H.4), preserving the distinct experimental configurations. Identity verification remains enabled for all policies; misses mean inaccessible active records, not wrong-record returns.

The measured availability benefit. The random periodic-32 streams incur 24, 21, and 26 misses; both guards eliminate them. Score guard uses 836 versus 1,169 rebuilds, 28.5% fewer than periodic-32 in that group, while paying per-candidate checks. It lowers complete cost relative to norm guarding by 68.6% and 27.0% in the two configurations. Load and geometry vary together, so these are distinct operating points rather than a one-factor correlation ablation.

The guarantee concerns every published candidate. The one-write law and an executable two-record witness show how a target-correct write can invalidate another binding before a periodic rebuild. Candidate checking intercepts that state under the stated numerical and trusted-metadata assumptions. Appendix G retains the original 340-rebuild periodic and 1,744-rebuild guarded results. The added independent streams test how those policies generalize beyond that fixed trace. The 37,488 correlated score-guard rebuilds belong to this Delta-policy experiment, separately from geometric Incremental maintenance.

Complete service work is charged. Ledgers include initialization/selection, actual key generation or caching, registry/payload operations, every offered mutation, checking, acceptance/rejection, recovery, and reads. Exact locators incur no matrix-interference checks. Nested check/rebuild timers are counted through their parent update once. Closed-loop totals additionally include the producer, required resolution/conversion, and actual correction consumer; scoring and file output are excluded consistently.

The original 64 MiB key cache, 1.0625 MiB controller, and 54.87-microsecond mean key regeneration stay associated with their original configuration. The session study pairs its runtime improvement with explicit Incremental/Compiled state counts of 3,157,576/3,156,984 bytes. Direct-weighted and native aggregation each use 182,796 numerical bytes, with no binder/gate state. Table H.9 reports process RSS separately, and Appendix G identifies allocator-tracked rebuild workspace (Appendix H.7).

Latency and throughput are traceable. Offered/accepted events, reads, failures, and elapsed time are retained for throughput calculation. Twenty-one separately instrumented mapping runs provide P50/P95/P99, and seven fresh-process measurements provide state/RSS. These describe their measured configurations alongside the multi-trace service totals. The experimental protocols, resource-accounting definitions, and reproducibility procedures are documented in Appendices G and H and the accompanying anonymous supplementary material.

The revision now supplies the comparison your review called for: efficient reference paths are preserved, certified incremental maintenance has a matched operating advantage, and publication reliability is paired with its measured cost. Thank you for the constructive precision of your assessment. It has substantially improved both the evaluation and the statement of the contribution. We respectfully request reassessment on this strengthened theoretical and empirical basis.

AuthorsOpenReview ↗

Clarification of the contribution and practical significance (W2/Q2)

We particularly appreciate your careful distinction between pointer-equivalent fidelity and a substantive shared-state contribution. Your questions led us to strengthen both the mechanism-level analysis and the fairness of our operational comparisons.

The contribution is not that exact pointers cannot preserve references. Rather, SLA addresses a distinct problem: maintaining established references when their locators interact through a shared writable numerical state. A write that correctly updates one association can invalidate another. Our single-write and cumulative interference laws characterize this failure, while the decoding certificate and minimum-Frobenius-norm residual-aware correction provide a principled route to certified maintenance (Section 3, Proposition 5, Appendix H.9).

Crucially, this is not only a correctness result. Even when the independent Compiled Readout baseline receives the same direction cache, residual correction, and publication certificate, SLA-Incremental (our certified incremental maintenance implementation) reduces complete-service cost by 8.34% on matched mixed structural updates (Table H.13). The broader same-certificate dynamic study shows 14.95% savings (Table H.4). Efficient direct execution is retained when shared numerical maintenance is unnecessary.

Your significance question directly motivated this stronger causal attribution and a clearer statement of the research contribution: analyzable reference stability, certified shared-state maintenance, and independently measured operational value. We would greatly appreciate your reassessment in light of these complementary theoretical and empirical results.

Reviewer_Pa8SOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies referential stability in evolving LLM memory, where references should remain valid even when records are updated or relocated. It proposes SLA, which uses a shared associative matrix instead of explicit per-record address mappings, and provides theoretical analysis of update interference and correctness conditions. Experiments on controlled memory updates and LongMemEval show that SLA can preserve stable references, achieving correctness comparable to updated pointers.

Critical strengths
  1. Clear problem formulation. The paper makes a useful distinction between semantic retrieval and referential stability in evolving memory systems.

  2. Solid technical analysis. The paper provides rigorous analysis of shared-state interference and correctness conditions, supported by extensive experiments.

Critical weaknesses
  1. Motivation. It is unclear why shared-state addressing is needed when conventional pointers already solve referential stability. The paper does not identify a convincing scenario where explicit indexing is unsuitable.

  2. Performance. SLA achieves similar correctness to pointers but is slower and uses more memory. Its practical advantage over simpler alternatives remains unclear.

Questions for authors
  1. What application scenarios actually require shared-state addressing instead of explicit pointers? Why is this constraint important?

  2. What advantages does SLA offer over simpler pointer-based methods that justify its additional complexity?

2 comments
AuthorsOpenReview ↗

Application need and low-cost execution

Thank you for your insightful assessment and constructive questions about practical value. Your request to connect the interference analysis to a useful deployment setting has substantially strengthened the paper: the revision now provides that connection through explicit execution choices and matched experiments.

SLA preserves low-cost basic access and provides a faster certified maintenance implementation for dynamic continuous memory. Exact and ordinary continuous access meet the stated noninferiority tolerance; the matched dynamic-service study shows 14.95% lower cost. Section 4.5 (pp. 9-10) and Figure 4 (p. 9) present these results. Appendix H (pp. 54-66) gives the theory, protocols, complete controls, and resource accounting.

W1 / Q1: which applications motivate shared-state addressing, and why does the interface matter?

The relevant application is an evolving association memory whose query and downstream result are continuous vectors. Examples include a map that returns a combination of spatial associations for localization. A pointer to one record supplies one value, whereas this interface requires the combined response. Resolver + Gather, Weighted Gather, Decomposed Readout, and Compiled Readout implement that contract in different ways and are included as equally informed controls (Appendix H.1).

We reproduced the SSP-SLAM View network of Dumont et al. (2023) and verified its continuous memory interface: view inputs are processed by associative memory, whose recalled representations contribute to position correction and the path integrator. Both original CPU entrypoints were executed. Read-only probes confirm that recalled associations are consumed by position correction and feed subsequent state evolution (Appendix H.5, Eq. (40)).

We further constructed a controlled closed-loop evaluation using the spatial-semantic representations and sensory functions introduced by Dumont et al. (2023), enabling a matched comparison of alternative memory implementations. Its map output changes position correction, which changes later update targets. All methods retain the identities and mixture weights supplied by the producer. Supplied weights select SLA-Direct before execution; all 960 formal runs over ten independent environments satisfy the output and feedback-quality requirements. The reproduced SSP-SLAM network confirms that continuous memory recall is consumed by downstream localization, while our component-based closed-loop experiments establish the accuracy and complete-service cost of the compared memory implementations (Appendix H.5, Table H.6).

For requests already solved by an exact locator, SLA keeps that efficient execution. Direct access uses the verified exact implementation, without allocating a binder, factors, or numerical gate. Its paired cost ratio to Exact Pointer is 0.9989, 95% CI [0.9982, 1.0011]. Compiled mode similarly retains the eligible continuous backend. These are alternative execution modes, not stages that every request must traverse (Tables H.1 and H.4).

The reference-preserving branch also has a direct implementation check: all 20 reference-retaining profiles match output bytes, state sequences, and core-function calls, without a per-request proxy. Construction-time selection is charged separately within initialization (Appendix H.8).

The architectural choice follows the application's information and output requirements. Exact and supplied-weight access retain their efficient implementations. For dynamically maintained continuous associations, certified incremental execution achieves a 14.95% reduction in complete service cost against the independently maintained compiled reference under matched certification requirements (Table H.4). All controls retain the metadata supplied by the application. We appreciate how your question sharpened this central design principle: preserve efficient basic access and introduce shared maintenance where its benefit is demonstrated.

AuthorsOpenReview ↗

Benefits, mechanism, and resource costs

W2 / Q2: what advantage justifies the additional complexity?

Certified incremental maintenance lowers complete service cost, while Direct and Compiled preserve low-cost basic execution. Your emphasis on the cost of added machinery motivated the matched-certificate comparisons and full resource accounting below.

Why the maintenance works. For a fixed full-row-rank key matrix KK, define vj=KT(KKT)−1ujv_j=K^T(KK^T)^{-1}u_j, where uju_j selects row jj. The residual-aware update is

B+=B+(tj′−Bkj)vjT.B^{+}=B+(t'_j-Bk_j)v_j^T.

In exact arithmetic, it sets the revised target and preserves every other active-key response. Proposition 5 proves that it is the minimum-Frobenius-norm correction satisfying those constraints. A matched FP32 test uses 30 pairs of identical certified initial states and 1,920 method updates. With a controlled initial residual near 10−310^{-3}, the final target-error median is 1.62×10−81.62\times10^{-8}, versus approximately 10−310^{-3} for target-difference updating. Both methods satisfy the same certificate without refitting (Appendix H.9).

Why cost can fall. Fixed-key directions are reused instead of repeatedly solving the same geometry. Structural changes incrementally update factors and invalidate affected caches. Every stored candidate remains certified. The residual experiment tests correction behavior; the following service comparisons measure the complete implementation's runtime benefit (Appendix H.2).

Dynamic lifecycle. At 256 active records and key dimension 512, independent calibration fixes the mode before evaluation. Across ten input seeds and three paired blocks, the selected Incremental/Compiled ratio is 0.8505 [0.8343, 0.8726], a 14.95% reduction. The independent Compiled control uses the same publication certificate. Initialization, selection, keys, registry/payload operations, all offered mutations, checks, recovery, query production, and reads are charged (Tables H.2-H.5).

Session-order maintenance. On 62 controlled histories following real session order, three paired blocks give 0.8921 [0.8306, 0.9693], or 10.79% paired savings. Total accumulated time separately falls by 7.17%. Both methods receive matching updates and preserve final evidence. Intervals resample histories. Reads retain handles, so this compares shared-maintenance implementations on the same natural-order input. Whole-service rebuilding is 19.45% slower than incremental reuse (Appendix H.4).

Operating coverage. A further 24-profile study varies size/dimension, fixed-key versus structural updates, and 1/8/64 reads after each write. Five calibration seeds precede eight disjoint validation seeds. All 1,728 formal runs meet quality requirements. The four profiles selected for Incremental before validation yield 8.06-16.03% savings with individual 95% intervals below one; the complete profile results and multiplicity sensitivity are retained (Appendix H.8).

Basic paths and memory. Ordinary continuous access gives 0.9950 [0.9844, 1.0102]; it and exact access meet the 2% engineering criterion. In the mapping service, Direct and Weighted Gather each use 182,796 numerical bytes, with no binder/gate allocation. Direct is noninferior to Weighted Gather, Resolver + Gather, and Decomposed Readout, and saves 14.58% against same-certificate Compiled Readout by avoiding unnecessary matrix maintenance. Table H.6 gives the deployment comparisons, Table H.7 the full-mode controls, and Table H.9 the numerical state and process peaks. Tables E.2-E.4 retain the shared-matrix lookup and state measurements, with the 257-fold reduction explicitly comparing Delta and RLS locator tensors.

Real consumer validation. All 62 pairs from 124 fresh Qwen3-8B generations have identical prompts and outputs. This verifies replacement fidelity alongside the separate operational gains.

Taken together, the theory, mechanism controls, and matched measurements support a practical reference-preserving alternative: efficient basic access is retained, and suitable dynamic workloads gain certified incremental maintenance. Your insightful questions substantially improved this connection between the analysis and its practical value. We respectfully ask you to reconsider the rating of the revised manuscript in light of these new results.

Comments on the paper

1 comment
AuthorsOpenReview ↗

shared concerns, revisions, and evidence

Dear Chairs,

Thank you for coordinating this constructive evaluation. We thank all three reviewers for their insightful, complementary guidance: Pa8S sharpened the practical-value question, YrKK clarified the evidence needed to distinguish architectural benefit from fidelity, and zW2F guided the evaluation of stability and complete cost. Their emphasis on practical significance has substantially strengthened the revision.

The revised evidence supports SLA as a reference-preserving alternative to the evaluated pointer-family implementations: basic access retains efficient execution, and suitable dynamic workloads obtain additional certified-maintenance savings. Three lines of evidence answer their questions: low-overhead execution with measurable maintenance gains, a formally characterized corrective mechanism, and independently validated reliability and downstream integration.

1. A concrete maintenance advantage with low-overhead basic access. Exact and ordinary continuous access have cost ratios 0.9989 [0.9982, 1.0011] and 0.9950 [0.9844, 1.0102] to their matched references, both within the 2% criterion (Table H.4). Direct allocates no unused binder. All 20 reference-retaining profiles also match outputs, state sequences, and core calls without per-request proxy work (Appendix H.8).

At 256 records and dimension 512, independently calibrated Incremental execution reduces paired complete-service cost by 14.95%, ratio 0.8505 [0.8343, 0.8726], against independent Compiled Readout using the same certificate. A separate 62-history study gives 10.79% paired savings (Table H.4). In the 24-profile interleaved study, all 1,728 runs meet quality requirements. Four preselected profiles yield 8.06-16.03% savings, with 95% intervals below one. All profiles and multiplicity-sensitive intervals appear (Appendix H.8, Table H.11).

2. Theory linked to an identifiable maintenance mechanism. Our single-write and cumulative interference laws establish why correct initialization alone cannot guarantee stable access under subsequent memory updates. Residual-aware rebinding corrects the actual stored target while preserving other active responses in exact arithmetic, with a minimum-Frobenius-norm property. Thirty matched initial-state pairs and 1,920 method updates verify this behavior in FP32 (Appendix H.9, Proposition 5). Geometric reuse and factor maintenance reduce repeated work; matched-certificate comparisons measure their complete runtime benefit. This connects the shared-state analysis to a corrective mechanism and a measured operating advantage.

Stronger matched control. Even when independent Compiled Readout uses the same 32-direction cache, stored-residual correction, and certificate, Incremental reduces mixed structural-update service cost by 8.34% (Table H.13).

3. Availability, resources, and actual consumers. Three independent streams in each of two configurations compare guarded and periodic policies on matching inputs. Periodic-32 incurs 71/90,000 and 56,827/90,000 active-reference misses, while both guards incur none. Table H.8 reports verification/rebuild time alongside availability; Appendices H.6-H.7 specify admission, rollback, lifecycle evidence, and resource boundaries. Table H.9 gives mapping-state and peak-memory accounting. Table H.10 and Figure H.2 give operation tails, and Figure H.1 gives additive closed-loop costs.

In the controlled SSP-component closed loop, native IDs and weights remain available to all methods. Direct-weighted execution meets quality in all 960 runs, is noninferior to native aggregation, and saves 14.58% against matched-certificate Compiled Readout by avoiding unnecessary matrix maintenance (Table H.6). Separately, 124 fresh Qwen3-8B generations preserve all 62 paired outputs (Appendix H.5). These deployment and fidelity results complement the independently measured Incremental maintenance gains.

Where the revision can be checked. Section 4.5 (pp. 9-10) and Figure 4 (p. 9) present the central evidence. Appendix H (pp. 54-66) gives proofs, protocols, controls, and resource results. The revised manuscript retains the theory and RQ1–RQ4 results, integrating new findings into the abstract, Section 4.5, Discussion, and Conclusion. Each reviewer question is linked to its evidence in the detailed responses.

The reviewers' constructive questions have made the paper's contribution both clearer and better substantiated: analyzable reference stability, certified residual-aware maintenance, and measured service gains within a framework that preserves efficient basic execution. We respectfully ask that the revised manuscript be considered for acceptance on this combined theoretical and empirical basis. We appreciate the opportunity to strengthen the work through this discussion.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.