How Finite Brains Generalize Without Bound: Spatial Memory as a Universal Computer
Authors: Yuhang He, Si Wu
Organizations: School of Psychological and Cognitive Sciences, Peking University, Beijing, China · IDG/McGovern Institute for Brain Research, Peking University, Beijing, China · Peking-Tsinghua Center for Life Sciences, Academy for Advanced Interdisciplinary Studies, Peking University, Beijing, China · Center of Quantitative Biology, Peking University, Beijing, China · Key Laboratory of Machine Perception (Ministry of Education), Peking University, Beijing, China
A child who learns to add small numbers adds numbers of any length. LSTMs and Transformers trained on short sequences fail on longer ones. We trace the difference to what a learner reads when it decides. A position, a count or a time keeps taking new values as the input grows: it is a coordinate, and a learner that reads one meets in every long input values its experience never covered. Whether two things are the same has the same two answers at every size: it is a coincidence, and a learner that reads only coincidences finds in a long input nothing that short inputs lacked, so finite experience fixes its rule for every size. The memory carries the size of the input and the rule stays finite, and this determines the memory a generalizing brain can have: a memory that grows while what the learner reads of it stays finite has to look the same from every place, so it is made of cycles, and the past is reached by asking what happened when the cycles last stood where they stand now. The cycles are the grid modules, the cells that detect their return the place cells, the records the hippocampal index; a prefrontal controller moves the cycles and never sees them. Reading only coincidences costs no power: what finite experience fixes in such a learner is what Turing machines compute in step with their input, which is why a circuit that evolved to find the way home can learn arithmetic and grammar. In a network of neurons this machine of cycles is the dynamics seen through its symmetry, and symbols are its invariants. Trained on strings up to 40 symbols, the machine is at least 99% correct, on average over lengths 41 to 500, on nine of fifteen benchmark tasks, five of them tasks that no LSTM or Transformer solves; given new cycles after training it reverses strings of 15,015 symbols without error and fails beyond that on the curve the theory predicts; and its controllers run unchanged on neurons.
Figures & tables
Figure 1: A learner that reads coincidences. (a) Two learners reverse a string: one files each symbol under its position, and every position beyond its training is new to it; the other moves a counter up while it listens and down while it answers, and reads what it heard when the counter last showed its present value (arcs). (b) Situations met on inputs up to length N : new ones at every length for a learner that reads its position, none beyond a small N∗ for a procedure that reads coincidences. (c) A clock of coprime rings: one move turns every ring, rings of 3 and 4 form a cycle of 12 states on a torus, and a cell tuned to one state of both fires where they agree. (d) The machine of Eq. ( 1 ) and its parts in the brain. (e) Programs are movements of clocks (dots: readings; arcs: reads): a clock that walks back reverses, a clock sent home copies, a clock that follows depth is a stack, and a clock that returns handles nesting.
Figure 2: One system, three descriptions. (a) The parts of the machine in the brain. (b) The same computation described three times: a Turing machine’s tape is a clock whose cells are records and its head the reading (Theorem 3 ); a clock is a ring of neurons whose bump stands in one of p wells, read by Π and Q , and a place cell fires where the bump returns (Theorem 4 ); the finite table, the controller and the prefrontal circuit are one rule. (c) Two rings of Eq. ( 2 ), with 5 and 3 wells, under a sequence of moves, and the reading Q∘Π after each. (d) Place cells recruited as a clock of rings 2,3,5,7,11 advances: recruitment stops at 2,310 cells when all rings must agree, at 210 or 30 when one or two may differ. (e) A clock released after 40 moves runs back through its last readings by itself (top); above τ/τv adaptation makes a bump travel (bottom). (f) A count is exact up to its clock’s range and then repeats; an estimate reads a graded magnitude. Brain outline adapted from Servier Medical Art, CC BY 3.0.
Figure 3: Rules learned on short inputs, tested at every length. (a) Accuracy at every test length after training on lengths 1 to 40 : the machine (three seeds), LSTMs and Transformers. (b) Clock readings of trained machines: in reversal a clock walks back, in duplication a clock returns home and runs forward. (c) Reversal with clocks exchanged after training: dots are measured, lines the accuracy the theory predicts with no free parameter (Section 2.3 ). (d) The first error moves with the range L . (e) Accuracy at length 500 with graded clocks, with the step index, with the phases given to the controller, and without noise. (f) Score after training up to length 10 , 20 or 40 , with the N∗ of each task.
Figure 4: The machine as neural dynamics and as a computer. (a) Trained controllers run on neurons: agreement with the symbolic output on every test input. (b) Clock slips against noise, with and without wells. (c) Place cells that tolerate one or two disagreeing rings: agreement against the span divided by the predicted range. (d) Replay order in reversal and duplication. (e) A schoolbook multiplier written as a three-tape machine, run on clocks with and without time to think; circles: the same machine on neurons. (f) Sorting k kinds of symbol: no run with fewer than k−1 clocks fits, and one run of three with k−1 clocks sorts exactly.
Appendix figures & tables25 assets
Supplementary material from the paper’s appendix.
Appendix
Statement
What it says
Proof
Theorem 1 , the hole
a coordinate leaves the rule open; coincidences fix it
Appendix A.2
Lemma 1
acting as the procedure up to N∗ fixes it within range
Appendix A.2
Proposition 1 , clocks are cycles
a finite, reversible, commuting clock is a cycle or a torus
Appendix A.3
Characters and coincidence
commuting linear moves give independent periodic components
Appendix A.4
Homogeneity
a memory that looks the same everywhere gives finitely many situations
Appendix A.5
Cost of coprime cycles
the range grows faster than any power of the number of units
Appendix A.6
Appendix
Table 1: The formal results and where they are proved.
Symbol
Meaning
Value
Code
K
neurons per well
16
K
a
width of the recurrent kernel (neurons)
2
width
J0
recurrent strength
1
J0
k
global inhibition
0.5kc
k_frac
ϵ
depth of the bias that makes the wells
1
eps
ν0 , T1
gain of a move pulse, duration per well
4.6 , 4τ
speed , T1
Appendix
Table 2: Parameters of the network. The inhibition kc=J02/(82πa) is the largest that sustains a bump without bias ( Wu et al., 2008 ) . A pulse moves every bump to the intended well for every gain ν0 from about 4.2 to 4.8 ; the value used lies inside this range.
Task
C
R
situations
N∗
procedure
Even pairs
0
0
14
3
compare the first and the last symbol
Modular arithmetic
0
0
505
15
running value, product and sign
Parity
0
0
6
2
running parity
Cycle navigation
0
0
20
3
running position on a cycle of five
Stack manipulation
1
1
25
4
a clock follows the depth; walk down to answer
Reverse string
1
1
8
2
forward while listening, back while answering
Appendix
Table 3: Reference controllers. C : clocks; R : heads; situations: distinct combinations of controller state, input symbol and records found, met on 200 random inputs at every length up to 60 ; N∗ : the length after which no new situation appears.
Attempt
Schedule
Noise on the controller
1, 3
standard, 12,000 steps
none up to step 7,000 , rising to 0.5 at step 8,000
2, 4
standard, 12,000 steps
0.5 throughout
5
long, 20,000 steps
none up to step 8,000 , rising slowly to 0.5 at step 13,500
6
long, 20,000 steps
0.5 throughout
Appendix
Table 4: The restart ladder. The long schedule has 20,000 steps: T=1 up to step 13,500 , falling to 0.05 at step 18,500 , and the discrete phase from step 19,000 .
Task
seed 0
seed 1
seed 2
even pairs
89.9 / 89.5
100.0 / 100.0
100.0 / 100.0
modular arithmetic
99.7 / 100.0
98.5 / 99.6
99.9 / 100.0
parity
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
cycle navigation
75.8 / 98.8
50.1 / 98.0
100.0 / 100.0
stack manipulation
100.0 / 100.0
76.1 / 77.2
100.0 / 100.0
reversal
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
Appendix
Table 5: Plain relaxation (plain read, constant step size, no discrete phase, three attempts): test score (%) / best validation accuracy at training lengths (%).
Level
Task
Asked for
Input
Answer
Regular
Even pairs
whether the first and last symbols differ
100001
0
Modular arithmetic
the value of an expression modulo 5
4+2-0-0
1
Parity
whether the number of ones is odd
000110
0
Cycle navigation
the end position on a cycle of five
-1 0 0 +1 0 0
0
Context free
Stack manipulation
the final stack, read from the top
110 PUSH1 PUSH1 PUSH1
Reverse string
the string reversed
100111
111001
Appendix
Table 6: The fifteen tasks , grouped by the level of the Chomsky hierarchy at which Delétang et al. (2023) place them, with one input and its answer. Numbers are written lowest bit first, except in the square root task. Positions in odds first are counted from zero.
Figure 5: Accuracy at every test length (mean over the 32 inputs of each length, smoothed over ten consecutive lengths). Blue: the three seeds of the machine; dashed gray: LSTM; light gray: Transformer with rotary positions; thin line: 99% .
Task
LSTM
Stack-RNN
Tape-RNN
Transformer
This work
max
Clocks
Regular
Even pairs
100.0
100.0
100.0
100.0
100.0 ± 0.0
100.0
0
Modular arithmetic
100.0
100.0
100.0
28.1
99.9 ± 0.1
100.0
0
Parity
100.0
100.0
100.0
52.6
100.0 ± 0.0
100.0
0
Cycle navigation
100.0
100.0
100.0
73.6
89.5 ± 18.1
100.0
0
Context free
Stack manipulation
59.1
100.0
100.0
77.9
100.0 ± 0.0
100.0
1
Reverse string
60.9
100.0
100.0
95.1
100.0 ± 0.0
100.0
1
Appendix
Table 7: Fifteen tasks, trained on lengths 1 to 40 and tested on 41 to 500 (% of correct output symbols), grouped as regular, context free and context sensitive. LSTM, Stack-RNN and Tape-RNN: best of 30 runs of Delétang et al. (2023) ; the Tape-RNN’s head can also jump by the input length. Transformer: best of eleven positional encodings of Ruoss et al. (2023) , whose randomized encodings draw training positions from 1 to 2,048 , so that every test position is seen. This work: mean ± s.d. and maximum over three seeds; bold: solved. Clocks: the number our procedure of Appendix C uses; × : no procedure in step with the input is known. Over a binary alphabet a running parity finds the missing duplicate without a clock, which is why the LSTM and the Transformer solve it.
Task
seed 0
seed 1
seed 2
even pairs
100.0 / 100.0 / 1
100.0 / 100.0 / 1
100.0 / 100.0 / 1
modular arithmetic
99.8 / 100.0 / 1
99.8 / 100.0 / 1
100.0 / 100.0 / 1
parity
100.0 / 100.0 / 1
100.0 / 100.0 / 1
100.0 / 100.0 / 1
cycle navigation
99.9 / 100.0 / 1
68.6 / 100.0 / 1
100.0 / 100.0 / 2
stack manipulation
100.0 / 100.0 / 1
100.0 / 100.0 / 1
100.0 / 100.0 / 2
reversal
100.0 / 100.0 / 1
100.0 / 100.0 / 1
100.0 / 100.0 / 1
Appendix
Table 8: Benchmark runs of the machine: test score (%, lengths 41–500) / best validation accuracy at training lengths (%, lengths 31–40) / attempt kept.
Task
LSTM
Transformer, rotary
Transformer, no positions
This work
even pairs
100.0 (3)
50.4 (3)
50.2 (0)
100.0 (3)
modular arithmetic
99.7 (3)
20.0 (0)
20.2 (0)
99.9 (3)
parity
100.0 (3)
49.9 (0)
49.7 (0)
100.0 (3)
cycle navigation
50.2 (3)
22.7 (3)
24.1 (2)
89.5 (3)
stack manipulation
62.5 (0)
49.0 (0)
50.1 (0)
100.0 (3)
reversal
59.8 (0)
50.8 (3)
52.8 (0)
100.0 (3)
Appendix
Table 9: Networks trained under one protocol: test score (%, lengths 41–500, mean over three seeds) and, in parentheses, the number of runs that fit their training lengths.
Task
seed
L=60
L=210
L=2,310
L=15,015
stack manipulation
0
57
206
2,287
13,514
stack manipulation
1
63
231
2,426
14,715
stack manipulation
2
45
158
1,732
11,261
reversal
0
61
212
2,333
15,165
reversal
1
61
212
2,333
15,165
reversal
2
61
212
2,333
15,165
Appendix
Table 10: Clock exchange: the smallest sampled length with an output that differs from the unbounded clocks, for every benchmark machine that fits and extrapolates, with the cycles of L=60 , 210 , 2,310 and 15,015 (–: no difference up to 2L ).
Task
graded clocks
step index
phases
no noise
modular arithmetic
100.0 / 100.0 / 100.0
37.5 / 62.5 / 28.1
84.4 / 96.9 / 100.0
100.0 / 100.0 / 100.0
stack manipulation
59.1 / 61.6 / 57.3
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
reversal
61.0 / 51.2 / 70.5
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
duplication
50.0 / 52.8 / 50.5
100.0 / 100.0 / 100.0
100.0 / 99.8 / 100.0
100.0 / 100.0 / 100.0
binary addition
49.7 / 50.0 / 47.9
95.0 / 99.7 / 99.5
100.0 / 99.8 / 98.1
99.5 / (48.8) / 99.6
Appendix
Table 11: Forbidden readings: accuracy (%) at length 500 , seeds 0 / 1 / 2 (in parentheses: runs that do not fit their training lengths).
Task
N∗
N=10
N=20
N=40
reversal
2
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
duplication
3
100.0 / 100.0 / 100.0
100.0 / 100.0 / 98.6
100.0 / 100.0 / 100.0
stack manipulation
4
100.0 / 100.0 / 99.3
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
odds first
5
75.5 / 100.0 / 100.0
100.0 / 100.0 / 100.0
100.0 / 100.0 / 100.0
binary addition
9
83.2 / 72.2 / 76.5
99.1 / 97.5 / 98.6
99.8 / 98.9 / 99.5
modular arithmetic
15
67.4 / 71.5 / 67.3
100.0 / 99.8 / 100.0
99.8 / 99.8 / 100.0
Appendix
Table 12: Training on short inputs: test score (%, lengths 41–500) of machines trained on lengths 1 – N , seeds 0 / 1 / 2. N∗ : size by which the reference procedure meets all its situations. N=40 is the benchmark.
C
seed 0
seed 1
seed 2
1
22.2 / 52.9
32.7 / 44.7
46.3 / 57.8
2
52.8 / 54.0
50.7 / 59.0
54.1 / 54.7
3
41.6 / 44.8
70.8 / 77.4
64.4 / 68.3
4
63.5 / 78.4
100.0 / 100.0
69.2 / 65.4
Appendix
Table 13: Bucket sort with C clocks: test score (%, lengths 41–497 for C=3 , 41–500 for C=3 ) / best validation accuracy at training lengths (%), seeds 0, 1, 2.
k
C
seed 0
seed 1
seed 2
3
1
64.6 / 67.7
70.2 / 71.1
61.5 / 69.5
3
2
80.8 / 87.3
95.1 / 87.1
100.0 / 100.0
4
2
55.6 / 77.4
51.5 / 48.9
53.8 / 57.1
4
3
65.3 / 73.7
100.0 / 100.0
92.7 / 89.5
Appendix
Table 14: Bucket sort over k kinds of symbol with C clocks: test score (%, lengths 41–500) / best validation accuracy (%), seeds 0 / 1 / 2.
Task
seed
input
first answer step
answer
stack manipulation
0
+1 , 0 / home , +1 / −1
−1 , −2 , −1
−1 , −2 , −1
1
0 / +1 , −1 / +1 , −1 / −2
0 , +1 , home
−1 / 0 , +1 , home
2
+1 / −1 , +1 / −1 , home / 0 / +1
+1 , −1 , +1
+1 , −1 , +1
reversal
0
+1 , +1 , +1
+1 , +1 , −1
+1 , −1 , −1
1
+1 , +1 , +1
−1 , −1 , +1
−1 , −1 , −2 / +1
2
0 / −2 , +1 , +1
−2 , home , −2
−1 , home , −1
Appendix
Table 15: How the clocks of trained machines move: for each clock (in order), the moves that make up at least 20% of its moves while the input arrives, at the first answer step, and while the answer is given, most frequent first.
Figure 6: Clock movements of trained machines (seed 0 , one input each; shaded: input). Lines: clock readings; arcs: reads during the answer, from the present step to the record found. (a) Reversal: a clock walks back. (b) Duplication: a clock returns home and runs forward again. (c) Stack manipulation: clocks follow the depth and walk down to answer. (d) Odds first: clocks move two readings per step. (e) Binary addition: a clock returns home and advances with the digits of the answer. (f) Fraction of the records found that are returned by heads at each offset, over all tasks and seeds.
Task
n=41
n=100
n=200
n=500
even pairs
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
modular arithmetic
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
parity
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
cycle navigation
100.0 / 100.0
100.0 / 97.9
100.0 / 91.7
100.0 / 87.5
stack manipulation
100.0 / 100.0
100.0 / 99.9
100.0 / 100.0
100.0 / 100.0
reversal
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
100.0 / 100.0
Appendix
Table 16: Trained controllers on neural clocks and place cells (no noise): agreement of the output symbols with the symbolic machine (%) / accuracy of the neural machine (%), mean over the runs that fit, by length.
Variant
Task
accuracy at each length
broad
stack manipulation
41: 100.0, 100: 99.9, 200: 100.0
broad
reversal
41: 100.0, 100: 100.0, 200: 100.0
broad
duplication
41: 100.0, 100: 100.0, 200: 100.0
broad
odds first
41: 100.0, 100: 100.0, 200: 100.0
broad
binary addition
41: 99.8, 100: 99.5, 200: 99.4
noise0.6
stack manipulation
41: 100.0, 100: 99.9, 200: 100.0
Appendix
Table 17: Variants of the neural machine: accuracy (%) by length, mean over three seeds. noise: noise of strength σ on every neuron; partial j : place cells that fire when all but j rings agree; nowells: no wells, σ=0.3 ; broad: recurrent kernel twice as wide.
Clocks
0
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
1.1
1.2
wells
0
0
0
0
0
0
0
3.0e-02
5.7e-01
8.3e-01
8.7e-01
no wells
5.0e-03
3.7e-02
5.0e-02
6.3e-02
7.9e-02
1.0e-01
1.2e-01
1.4e-01
1.7e-01
2.4e-01
6.7e-01
Appendix
Table 18: Neural clocks alone: slips per step under random moves, by noise strength σ ( 16 clocks of rings 2,3,5,7,11 , 2,000 steps each).
m
ϵ=0
ϵ=0.5
ϵ=1
0.3, 0.05
0.3, 0.1
1, 0.05
1, 0.1
0
0.0000
0.0000
0.0000
−0.118
−2.280
−0.034
−0.070
0.01
0.0000
0.0000
0.0000
−0.084
−1.923
−0.026
−0.061
0.015
0.0001
0.0000
0.0000
–
–
–
–
0.02
0.0004
0.0000
0.0000
−0.056
−1.076
−0.017
−0.053
0.025
0.0013
0.0000
0.0000
–
–
–
–
0.03
0.0019
0.0000
0.0000
−0.030
−0.197
−0.009
−0.046
Appendix
Table 19: Adaptation in one ring of 11 wells ( τ/τv=0.02 ). Left: speed (wells per τ ; the sign gives the direction) of a bump released with a trail of adaptation, by adaptation m and well depth ϵ ( † : the bump dies). Right: lead (wells; negative: lag) of a bump without wells that follows an input of strength A moving at v neurons per τ , for A,v as in the header.
Figure 7: Compiled Turing machines with bounded clocks. Fraction of runs of compiled random Turing machines that agree with direct simulation, against the head range divided by L , for L=60 , 210 and 2,310 (the three lines coincide); every run whose head range stays below L is exact.
Tapes
unbounded
L=60 , in
beyond
L=210 , in
beyond
L=2310 , in
beyond
1
400/400
284/284
2/116
358/358
1/42
400/400
–
2
400/400
243/243
0/157
330/330
0/70
400/400
–
3
400/400
241/241
0/159
321/321
1/79
400/400
–
Appendix
Table 20: Compiled random Turing machines ( 20 machines per number of tapes, 8 states, 3 symbols; inputs of lengths 10 to 1,000 ): runs that agree with direct simulation, with unbounded clocks and, with bounded clocks, among the inputs whose head range is below or at least L .
n
steps to think
with time
without
5
64
100.0
20.6
10
136
100.0
40.2
20
356
100.0
47.5
40
1,096
100.0
46.7
64
2,512
100.0
52.0
100
5,716
100.0
51.1
Appendix
Table 21: Schoolbook multiplication compiled from a three-tape Turing machine: accuracy (%) on the benchmark inputs of length n with (n−1)2/2+8n+16 steps to think and with none.
Architecture
Coordinate read
Discrete
Range
RNN, LSTM, state space model
a graded state that drifts with length
no
none
Transformer
positions, or distances by a graded similarity
no
the trained lengths
Stack-RNN, Tape-RNN
a blended head; jumps by the input length
no
the memory size
This work
none
yes
product of coprime periods
Appendix
Table 22: What architectures read. Coordinate: a quantity in the situation whose values grow with the input. Discrete: states that sit in wells. Range: how the reach of addressing is set.
Looped transformers compute by applying one block repeatedly, so they can run for more loops than they were trained with. Recurrent reasoners are known to overthink: iterating past the trained depth can turn a correct answer into a wrong one. Such a late error can reflect failed computation, loss of retention, or a state that later computation cannot reuse. We separate these cases in in-context Mealy-machine execution, where a simulator supplies intermediate targets and exact counterfactuals for hidden-state interventions. Models trained to answer at loop 32 are fully correct there but keep only 22% of these answers at loop 64. Retention depends on what training asks for: supervising one randomly chosen position per example, instead of always the last, keeps 99.8%, and randomizing the number of training loops also helps; truncating gradients, as in progressive training against overthinking, does not. The computation itself is exact: position k is computed at loop k, and swapping its loop-k hidden vector for the one from another input redirects every later position to that input's exact continuation (237/237 pairs in each of ten models). Retention, however, is not reuse. Even in models that keep nearly all answers, holding each position k fixed from loop k drops accuracy to 4--6%, whereas holding it from loop k+4 is harmless. A released recurrent maze network trained to avoid overthinking behaves the same way. Learning to compute is thus not learning to retain, and avoiding overthinking does not make a state reusable when its answer first appears.
Peilong Zhou, Hongtao Zhang, Yulong Huang +3
SKLP, Institute of Computing Technology, Chinese Academy of Sciences · University of Chinese Academy of Sciences · School of Advanced Interdisciplinary Sciences +1
Chain-of-thought prompting and looped Transformers both give a fixed model more test-time computation, but they differ in what they remember. Chain-of-thought stores intermediate state in generated tokens that remain in the context, whereas a looped Transformer carries state through recurrent hidden activations. We argue that this persistent mutable memory is a central resource for test-time reasoning. We compare three memory regimes, the compressed latent loop, the full sequence-state loop, and the chain-of-thought scratchpad. Our main result shows that a compressed loop is limited by the size of its recurrent state. Running the loop longer adds computation but does not by itself create a growing scratchpad, so a loop with a small recurrent state remains a small-space reasoner even when run for many steps. Under a standard complexity assumption, such loops cannot decide problems that are P-complete under logspace reductions, whereas polynomial-length chain-of-thought can. The separation is specific to compressed loops, as full sequence-state loops carry state at every input position and live in a memory-rich regime closer to explicit scratchpads. Controlled pointer-chasing and associative-recall sweeps illustrate this memory-budget view, with performance sensitive to whether the persistent-state budget matches the task's working-memory demand.
Haozhou Zhang
Department of Mathematics and Statistics University of Idaho
ZenBrain is a seven-layer, neuroscience-derived architecture for agent memory in LLM agents. An open library holds the seven layers, a MemoryCoordinator and nine foundational algorithms; six Predictive Memory Architecture components run in a private production system. In the open library at version 0.5.1, decay acts only on working memory and nothing is replayed. Ablating one component at a time exposes an effect we call cooperative masking. The ablation runs in a simulation harness that switches fifteen components as stand-ins at simulated values, not as production code. Under moderate load, fourteen of the fifteen ablations look costless. Raising decay, the horizon, the corpus and the queries, with no change to the components, moves ten of the fifteen in the same direction on all ten seeds - nine losses (Delta-Q down to -93.7%) and one gain. With ten seeds this is the one p-value the normal approximation of the Wilcoxon test can reach (5.06e-3), and it does not pass the Bonferroni-corrected level for fifteen contrasts (3.33e-3). On LongMemEval_S (500 questions), the evaluated ZenBrain arm - a Python port of a scoring class from our test harness, not the seven-layer system - answers 47.7% of the questions correctly under a binary judge (95% interval [43.3, 52.1]). With the compared systems' adapters repaired, Letta reaches 48.4% and Mem0 47.2%. ZenBrain reaches 91.3% of a full-context baseline's accuracy with 1/109.7 of its input tokens in the answer step; building the memory is not counted. Of nine head-to-head comparisons of the retrieved context (3 competitors x 3 LLM judges), three hold at Bonferroni-corrected significance, all against A-Mem, and the remaining six show no significant difference. On LoCoMo, the routing results of version 8 came from placeholder embeddings; with text-embedding-3-small, the flat variant (F1 0.059) lies above the full system (0.058).