acceptodds
Under review as a conference paper at ICLR 2027

RETENTION IS NOT ENOUGH: SELECTIVE READOUT IN BOUNDED HYBRID MEMORY

Abstract

Correct retention and correct slot selection need not produce a correct answer. We examine this distinction in typed online streams containing shared rules and sparse overrides, with a common 256-byte persistent-state budget for learned systems. Across three frozen workflow fits, 772 of 4,602 exception-query evaluations remain incorrect after decoded-content and addressing checks pass; replacing soft retrieval with the stored top-1 payload rescues only 30. On a separate query subset, masking nonmatching payloads raises rule accuracy from 60.15% to 86.93% at fixed weights, with little change to exception accuracy. Training shared predictors with either a hard match gate or a one-scalar soft-null option largely repairs the failure, without full parameter isolation. The hard gate reaches 99.959% on original-task streams of 8,192 events; the soft null is correct on every sampled workflow query at lengths 2,048 and 8,192. These controlled, prior-informed tasks admit smaller exact programs. Our contribution is a query-aligned diagnosis of retained content, slot selection and downstream use, together with tests of simple rejection-capable readers, rather than a new memory or attention primitive.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
bounded working memory, memory-augmented neural networks, streaming state tracking, proactive interference, memory efficiency

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

This paper investigates why bounded hybrid memory systems can fail despite correctly retaining and retrieving relevant information. The authors distinguish memory retention, slot selection, and downstream use, and propose two selective readout mechanisms: a hard match gate and a soft-null option. Experiments on two controlled online prediction tasks show that suppressing inapplicable memory values substantially improves accuracy without requiring full parameter isolation. However, the main contribution of this paper is a systematic diagnosis of memory-use failures rather than a new memory architecture.

Critical strengths
  1. The paper provides a useful diagnostic framework that separates errors in information retention and retrieval from errors in downstream utilization. Its fixed-weight interventions offer concrete evidence that irrelevant retrieved values can interfere with otherwise correct predictions.

  2. The proposed fixes are simple and effective in the evaluated settings. Hard gating achieves near-perfect accuracy on both task generators while preserving parameter sharing and the same persistent-state budget, demonstrating the potential value of selective readout.

Critical weaknesses
  1. The methodological novelty is limited: the abstract describes the contribution as “a query-aligned diagnosis of retained content, slot selection and downstream use” rather than “a new memory or attention primitive.”

  2. The evaluation is limited to highly controlled, prior-informed tasks with fixed entity descriptors and known finite rule families. The experiments do not test generalization to unseen rules or more diverse memory-intensive tasks. Consequently, it remains unclear whether the identified failure modes and proposed fixes generalize beyond these specific settings.

  3. The robustness and generalizability of the soft-null mechanism remain unclear, as it is evaluated only on the workflow task with a single initialization prior.

Questions for authors
  1. Can the authors evaluate the proposed methods on tasks involving unseen rules, changing entity descriptors, or more diverse memory-dependent behaviors to assess generalization beyond the current task generators?

  2. How sensitive are the hard gate and soft-null reader to the similarity threshold and initialization prior? Can the authors demonstrate robustness across different settings?

1 comment
AuthorsOpenReview ↗

Response to Reviewer aQf4

Thank you for highlighting descriptor robustness and the soft-null prior. We added tests of both.

For descriptor matching, we evaluated frozen readers under Gaussian query noise and nearest-neighbor descriptor blends, keeping stored states, targets, and weights fixed. We also swept the hard-gate reader threshold while leaving the writer threshold at 0.97. Under the stated criterion (at most a one-point overall drop and 1% aggregate routing error), the tested stable threshold range is 0.95–0.99 on clean queries and 0.96–0.975 at σ = 0.02; no tested threshold passes at σ = 0.04. At σ = 0.04, overall accuracy is 95.43% for hard gating, 98.22% for soft null, and 97.94% for path isolation. This exposes differences that are hard to see when all readers are near 100% on clean inputs.

For soft null, we varied the frozen null logit and ran 4,000-update controls with a fixed 19.4 logit, zero null-specific weight decay, and initializations 18/20. All four controls achieve perfect or near-perfect clean test performance in the tested seed. The exact learned scalar is therefore not needed for that clean result, although its value matters to the rule/exception trade-off when descriptors are perturbed.

We have not tested unseen rule families or changing exception identities, so the revised claims remain about the two controlled generators. We now report the observed operating region rather than extrapolate the clean results to those settings.

Reviewer_gm6MOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary
  1. A four-way decomposition of exception-query errors into missing/undecoded content, mis-selection or mixing, harmful use of inapplicable content, and a need for full parameter separation, each tested with a different query subset or training comparison (Table 1).
  2. A query-aligned integrity audit: J_q = K_q ∧ V_q ∧ A_q over key presence, matching-latest-value correctness and top-1 addressing, plus a separate selected-slot check T_q that is verified rather than assumed (Eqs. 11–12).
  3. Fixed-weight, value-only interventions that hold query, recurrent state, confidence and all weights constant while changing only the 7-dimensional retrieved payload (Tables 2–3).
  4. Two minimal readout repairs inside a single shared predictor: a hard descriptor-match gate (Eq. 5) and a one-scalar soft null with a zero-payload candidate (Eqs. 7–8), compared against path isolation (Eq. 9).
  5. A bounded descriptor operating region (Table 16), and an explicit disclosure that the aggregate route-error criterion is prevalence-weighted and therefore permits ~10.67% exception FNR at a 1% threshold when FPR is zero (Eq. 14).
Critical strengths

S1: The query-aligned integrity audit is the right instrument, and it is built carefully. S2: The fixed-weight, value-only intervention isolates exactly one variable. S3: The prevalence-weighting disclosure is exemplary, and rare. S4: Evidence-block hygiene is better than the norm.

Critical weaknesses

The difficulty is that almost everything the paper measures is either saturated or unstable, and the causal chain it needs is never closed. The benchmark's ceiling is reachable three different ways — soft null, path isolation, and a seven-byte hand-written program all score exactly 100.000% — so the headline ranking between "hard gate" and "soft null" is decided by 12 queries out of 16,384 at length 2,048 and 0.3 queries out of 4,096 at length 8,192. Meanwhile the baseline being repaired has a seed standard deviation of 13.16–13.64 points on a 0–100 scale, with per-seed rule accuracies of 50.99%, 52.98% and 76.48%; a 25-point spread across three seeds in a 6,615-parameter model on a 16-way lookup is an optimization pathology, and the paper never asks whether the 62% "coupled failure" is a property of bounded hybrid memory or of this training configuration. Concretely, the exception-loss weight jumps 9.67× at update 2,000 (Eq. 10), and the selected checkpoints for the isolated model land at updates 2,000, 2,250 and 2,000 — exactly at that discontinuity. No curriculum ablation is reported.

The third problem is scope. The architecture is worse than a 64-byte GRU on the rule branch by 40 points (60.15% vs 100%), and on the other generator the same ungated architecture scores 98.20% overall. So the phenomenon the title names is specific to one of two synthetic generators, one training configuration, and a baseline that is dominated by a simpler model. The only fix offered is a threshold at 0.97 that is inherited from the same slot-writer that already uses it to decide overwrites — i.e. the repair restores a consistency the architecture already encodes one module away. The paper says all of this itself: "not the invention of retrieval rejection", "not a new attention primitive", "instances of established rejection/no-op ideas", "our contribution is a query-aligned diagnosis ... rather than a new memory or attention primitive".

Questions for authors
  1. What is the pairwise separability of the 16 learned 7-dimensional payload codes on the frozen coupled checkpoint, and what accuracy does a probe from (payload, query) to value ID achieve on the exception subset? If that probe lands near 83%, are the 772 errors a use failure or an encoding failure?
  2. Does the coupled hybrid beat a 64-byte GRU on rule queries under any configuration you tried? Rule accuracy is 50.99 / 52.98 / 76.48 across seeds versus the GRU's 100.00. What mechanism produces a 40-point rule deficit in a 6,615-parameter model on a 16-way lookup?
  3. Did you ablate Eq. (10), specifically the 1 → 29/3 exception-weight jump at update 2,000? The isolated model's selected checkpoints (2,000 / 2,250 / 2,000) sit exactly at that discontinuity, and the coupled seed SD is 13.6. What happens with a constant exception weight?
  4. Please sweep τ. Over τ ∈ [0.5, 0.99], is 0.97 on a plateau or a cliff, and what are the minimum match cosine and maximum non-match cosine on the test arrays?
  5. With weight_decay = 0 on the null scalar (or ℓ∅ frozen at 19.4), does the soft null still differ from the hard gate? Given that its drift is confounded with decay, what evidence establishes that the learned value is doing any work?
  6. On the original generator the ungated hybrid reaches 98.20% while the workflow coupled model reaches 62.57%. Which generator property is responsible — the nonlinear policy table, asynchronous overwrites, or the fact that workflow override values may coincide with the rule answer? And do integrity-passing errors exist on the original generator at all?
  7. How many of the 4,602 J rows have duplicate decoded keys? The paper notes this is precisely the case where T_q would be weaker than it appears, and also that the count was not persisted.
  8. Soft null and path isolation both score exactly 100.000% on 4,096 queries at length 8,192. What observation could distinguish them on this benchmark, and is there any setting you tried in which isolation beats the gate by more than 3 errors?
1 comment
AuthorsOpenReview ↗

Response to Reviewer gm6M

Thank you for the detailed technical review. Your concerns about the loss-weight switch and the coupled baseline prompted new controls and changed how we interpret the 62% result. We address the questions below.

Q1 — Payload separability. For the 16 learned 7D codewords, minimum pairwise Euclidean distances are 1.980, 2.572, 2.205 across seeds 92401–92403 (medians 3.091, 3.202, 3.719). Payload-only (128-parameter) and payload-plus-query (384-parameter) linear probes, trained on disjoint episodes and selected on dev, each decode 100% of the 4,602 integrity-passing test values. The original coupled heads answer 79.75%, 77.06%, 92.84% of those queries correctly. Thus the payload is accessible to small readers, though the coupled head does not consistently use it.

Q2–Q3 — Rule deficit and loss-weight switch. Training explains much of the deficit. We held architecture, arrays, seeds, 4,000 updates, and dev-based checkpoint selection fixed:

Workflow L2048OverallRuleException
Natural → balanced62.31 ± 13.63%60.15%83.12%
Constant natural90.54 ± 0.51%98.36%15.00%
Constant balanced82.45 ± 4.72%80.65%99.85%

Both constant-objective fits select update 4,000. No tested coupled fit beats the GRU's 100% rule score, but constant-natural nearly closes the original rule gap while losing exception accuracy. Constant-balanced recovers exceptions but is weaker on rules. The revised Section 5 no longer treats 62% as an architectural limit.

Q4 — Threshold and cosine margins. We held the writer threshold at 0.97 and replayed six frozen checkpoints over 14 reader thresholds. Clean (minimum true-match cosine, maximum wrong-slot cosine) values are:

SeedHard gatePath isolation
92401(0.948, 0.957)(0.993, 0.639)
92402(0.938, 0.963)(0.992, 0.616)
92403(0.965, 0.943)(0.994, 0.652)

Extrema may come from different queries; both readers have zero clean exception top-1 addressing errors. Some true matches nevertheless fall below the hard gate's 0.97 acceptance threshold. Under the stated criterion (≤1-point accuracy drop, ≤1% aggregate routing error), tested thresholds 0.95–0.99 pass on clean data, 0.96–0.975 at Gaussian σ=0.02, and none at σ=0.04, where hard-gate exception FNR is 25.91%.

Q5 — Null scalar. One-seed, 4,000-update training controls with the scalar fixed at 19.4, zero null-specific weight decay, or initializations 18/20 achieve perfect or near-perfect clean accuracy. The exact learned scalar and weight decay are thus not necessary for the clean result. At descriptor noise σ=0.04, soft null scores 98.22% versus 95.43% for hard gating. Frozen-scalar sweeps change the rule/exception trade-off but cannot isolate scalar learning as the cause of this advantage.

Q6 — Original versus workflow. A new three-seed intervention changes only the policy target mapping within workflow (random table → modular rule); exception labels and other arrays remain fixed. All models use 256B state, 6,615 parameters, 4,000 updates.

ReaderRandom tableModular
Coupled62.30 ± 13.63%97.71 ± 1.38%
Hard gate99.83 ± 0.19%99.97 ± 0.03%

The coupled gain is 35.41 pp, while hard gating changes by 0.14 pp; the gap contracts from 37.53 to 2.26 pp. Policy mapping strongly affects coupled performance within workflow, but does not alone explain every difference between the two generators. We have not performed the full query-aligned audit on the original task. See Appendix K.

Q7 — Duplicate keys. Zero duplicate decoded-key rows among the 4,602 integrity-passing queries; all selected top-1 payloads decode correctly.

Q8 — Distinguishing readers. At workflow L2048, σ=0.04, isolation reaches 97.94%, hard gating 95.43%, and soft null 98.22%. Soft null improves on hard gating in all three seeds at both reported noise levels; its difference from isolation changes sign across seeds. Descriptor stress distinguishes readers more clearly than clean-set error counts.

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

This paper studies the difference between correctly retaining information in memory and correctly using it at inference time. The authors consider a hybrid architecture with recurrent state and a small slot-based memory, and show that even when the correct information is stored and retrieved, the model can still produce incorrect predictions. They propose two simple solutions, a hard match gate and a soft-null option, to suppress irrelevant retrieved information. Both significantly improve accuracy on the evaluated tasks.

Critical strengths

The paper provides a detailed analysis of the gap between memory retention and memory utilization. The fixed-checkpoint interventions help isolate different sources of prediction errors.

Critical weaknesses

Limited novelty. The main observation that irrelevant retrieved information can hurt predictions is well known. The proposed hard gating and soft-null mechanisms are straightforward applications of existing techniques. I am not convinced that the paper provides sufficiently new technical insights.

Questions for authors
  1. What are the key new insights from this work compared to existing research such as gated attention? Beyond the more fine-grained diagnostics, what generalizable conclusions can be drawn from the experiments?

  2. Given that simple specialized programs can solve these tasks perfectly with less memory, what makes the proposed benchmark a meaningful test of memory retention and utilization?

1 comment
AuthorsOpenReview ↗

Response to Reviewer Ab7h

Thank you for your comments, especially the questions about novelty and the specialized programs.

Hard gating and a null retrieval option are established ideas. Our contribution concerns what happens when a model must combine a compressed recurrent rule state with sparse, addressable exceptions under a fixed memory budget, and why the choice of reader matters.

There are three findings we would highlight. First, on the original task, the 256-byte hybrid reaches 98.20% at length 8,192, compared with 90.62% for the same-budget GRU. The GRU handles rule queries but not the exceptions. Second, on workflow, the new objective ablation shows that training changes how a shared reader uses the two memories: constant-natural training favors rules, while constant-balanced training favors exceptions. Separately, linear probes decode all 4,602 integrity-passing exception payloads, even though the coupled head gets 772 of those answers wrong. Third, descriptor perturbations reveal clear differences between hard gating, soft null, and path isolation despite their nearly saturated clean accuracy.

The hand-written programs are useful reference points, and we report them precisely because they solve these tasks with less episode state (62 bytes for the original task; 7 bytes for workflow, plus task-specific static constants). We are not claiming an information-theoretic memory lower bound. The benchmarks let us hold persistent state fixed and examine where learned models lose accuracy: in representation, retrieval, or the use of retrieved content. That is the role of these controlled tasks in the paper.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Revisions

We have uploaded a revised manuscript and added several experiments addressing the reviewers' main concerns. We summarize the key changes here for the Area Chair and reviewers.

1. Training-objective controls. The original coupled reader's 62.31% accuracy is strongly affected by the training schedule. Constant-natural and constant-balanced training improve accuracy to 90.54% and 82.45%, respectively, but exhibit different rule–exception trade-offs. We have revised our interpretation accordingly.

2. Payload decodability. Linear probes correctly decode all 4,602 integrity-passing exception payloads, although the original coupled heads make 772 errors on those queries. This provides further evidence that accessible stored information is not always used correctly.

3. Policy-mapping intervention. A new three-seed experiment changes only the policy mapping within workflow. Coupled accuracy improves from 62.30% to 97.71%, while the gated reader remains above 99.8% under both mappings (Appendix K).

4. Readout robustness. We added threshold sweeps, descriptor perturbations, and soft-null initialization and weight-decay controls. These experiments reveal differences between readers that are largely hidden by their near-perfect clean accuracy.

The revised paper brings these results together with the fixed-budget representation comparison. We have also responded to the specific questions under each review.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.