acceptodds
Under review as a conference paper at ICLR 2027

Frozen transformers can reuse, compose and update state memory

Abstract

A transformer that has read a context carries its computation on that context in every layer. We show that a frozen transformer can answer from a context it no longer has when it keeps one vector per position from a single early layer, the residual activations after its second decoder layer, and reads them back by placing them at placeholder positions of a new prompt and recomputing every layer above; we call these vectors state memory. On multi-round coreference resolution (MRCR) conversations of up to 136,577 tokens, Qwen3.8-27B discarded the text and its entire key/value cache, rebuilt the other 62 of its 64 layers from its bf16 memory and scored 75.5 against 75.0 for full history (the context read as tokens); 96 of 115 greedy answers were identical (83–84% in every range of lengths). Four-bit memory scored within 0.35 F1 of full history on all 150 MultiFieldQA-en questions of LongBench with Granite 4.2 8B and Qwen3.8-27B, and on 128 synthetic handbooks bf16 memory stayed within one percentage point of full history on Granite 4.2 8B, Qwen3.5-27B and Qwen3.5-9B, against 25.5–26.2% with neither. The same frozen model also operated on these memories. On Qwen3.8-27B, four-bit memories of DROP passages and of numerical questions, each written without the other, passed 41 of 52 tests that require the right answer under all four passage–question pairings, as many as full history. Revised ten times by regenerating its text from the memory and a counterfactual correction, a bf16 memory of SQuAD paragraphs scored the same as the corrected full history on every question, and a four-bit memory revised twenty times answered 96.5% of questions against 97.9%. Finally, the model read episodes of an environment’s tool use and wrote a note; a reader holding only the note’s states executed the environment’s tool-call convention on 213 of 256 new requests on Granite 4.2 8B and 195 on Qwen3.8-27B, against 235 and 206 with the episodes in context and 0 from a note written without them. On Granite 4.2 8B, a policy memory written the same way decided 170 of 256 new records exactly, against 130 with the episodes in context, and policy and procedure memories acquired in different environments executed 438 of 1,024 composed workflows, against 202 with both logs in context.

Primary area:
foundation or frontier models, including LLMs
Keywords:
transformer memory, state representations, memory composition, memory updating, context reuse

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

This paper studies whether a frozen transformer can use its own early-layer residual states as a memory of a context. For every position of a context, it stores the residual activations output by layer 1 (the second decoder layer); to read them back, it places a period token at each stored position of a new prompt, overwrites the layer-1 activations there with the stored ones and recomputes all higher layers, without any training. The authors use this state memory in four ways: reading it in place of the source, combining memories written separately, revising a memory without the original text, and writing memory from experience, as the states of a note the model writes after reading tool-use episodes. Across long-context, reading-comprehension and synthetic tasks on Qwen and Granite models, memory performs close to having the text in context in most comparisons, and on the synthetic policy tasks it outperforms having the episodes in context.

Critical strengths
  1. Careful experimental design. The comparisons are well controlled. The four-way swap test is a nice design: since every pairing of two memories has a different correct answer, a reader that ignored either memory could not pass it, and indeed the single-memory controls pass none of these tests (Tables 11 and 16). In Section 6, the 224-state episode windows and the reordering experiment in Figure 5 convincingly rule out that the note memory merely keeps a favorable stretch of the log. The conditions and analyses were also fixed on development data in advance (Appendix B.4). As a result, my concerns are less about whether the comparisons hold than about what state memory is for.

  2. An interesting angle. Treating a frozen model's own layer-1 states as a memory that can be read, combined, revised and even written from experience, without any training, is a fresh angle. Storing residual or activation states in place of the KV cache has been explored before (e.g., HCache; XQuant, arXiv:2508.10395; KV-Direct, arXiv:2603.19664), concurrent work (CoMem) reads intermediate-layer residuals under new queries, and combining or editing precomputed KV caches has also been studied (Prompt Cache, CacheBlend, Li, 2026). To my knowledge, however, revising the residual states of a frozen model or writing them from experience has not been studied before, and this is what I found most interesting in the paper.

Critical weaknesses
  1. Unclear advantage over keeping the text. My main concern is that the paper does not show what state memory offers over simply putting the text in the prompt. In Sections 3–5, memory is at best on par with full history, with differences within about one point (e.g., 75.5 vs. 75.0 on MRCR, 41 vs. 41 four-way tests on DROP, 935 vs. 935 on SQuAD). Meanwhile, writing a memory requires a pass over the text, revising it requires regenerating the text, and reading it still recomputes all but two layers, yet storage is compared only with the KV cache (Fig. 2b) and read-time compute is not reported.

    Section 6 is the one place where memory outperforms the text in context (170 vs. 130 policy decisions, Table 4). However, no condition gives the reader the note as text, so the gain may come from having the model write the note rather than from the note's states. In the tool-call task, Appendix A.6 likewise suggests that the note's content decides the outcome: the note memory succeeds on 212/214 requests when the note names the echoed field correctly, but on only 1/42 when it does not.

    Taken together, for none of the four uses does the paper show that the corresponding text in context would do worse, and beyond these four uses I find it hard to see what state memory would be useful for. The introduction motivates memory in general, but neither the abstract nor the main text explains why one would prefer state memory to the text; they largely list comparisons instead.

  2. Incomplete release of raw results. The reproducibility statement says that the supplement contains the raw outputs of every experiment, but I could not find observation rows for handbook reuse (Tables 5 and 7–10), handbook composition (Table 11), ten-cycle revision (Table 12) or LoCoMo (Table 14). As a result, none of the results on Qwen3.5-27B and Qwen3.5-9B can currently be checked against released data.

Questions for authors
  1. What can state memory do that the text in the prompt cannot? How do its storage and read-time compute (or latency) compare with keeping the text and re-reading it, and is there a setting in which the states are available but the text is not, or in which reading the states is cheaper or more accurate than reading the text?
  2. In Section 6, how does a reader given the note as text compare with the note memory on the same 256 requests? In other words, does the gain over the episodes come from the states or from the note itself?
  3. Where in the supplement are the raw outputs for Tables 5, 7–12 and 14?
3 comments
AuthorsOpenReview ↗

Response to Reviewer f1xg

We are grateful to f1xg for the careful map of prior work, from HCache, XQuant and KV-Direct to CoMem, Prompt Cache, CacheBlend and Li (2026), and for locating what is new in revising a frozen model's residual states and writing them from experience. The review asks for one comparison, a setting at equal storage or read-time compute where the states do better than the text, and Section 3.4 measures one at equal read-time compute, with the same evenly spaced positions kept.

The review reads parity in Sections 3 to 5 as memory being at best on par with full history. Full history is the frozen model reading the context itself, the upper reference for any stored form of that context, and parity with it is the pass condition of each fidelity test. MRCR at 75.5 against 75.0 over histories of up to 136,577 tokens, LongBench, LoCoMo and the handbooks within one point, and 41 of 52 four-way DROP tests against 41 for full history each show that the stored states lost nothing the answers needed.

That comparison is Section 3.4 and Table 22. A reader given K evenly spaced positions of a handbook, as layer-1 states or as those K tokens, runs a prompt of the same length either way, and from half of the positions upward the Qwen3.5-9B states answered between 4.8 and 10.9 points more, with Qwen3.5-4B following the same pattern and LongBench MultiFieldQA-en adding 4.9 F1 at half of each document. The general response lists every interval. Part of the extra content is each position's neighbourhood, since a linear probe reads the preceding token from 44.7% of states and from 12.0% of embeddings (Appendix G.2).

On cost, one position on Qwen3.8-27B is 10 KiB at bf16 precision and near 2.7 KiB in the four-bit code, beside 64 KiB of key/value cache, and reading it recomputes 62 of the 64 layers, the prefill any reader of that context runs.

Several of the methods the review cites move and join precomputed key/value caches, so Section 4 now joins the caches that our own passage and question writers produced on 24 Granite DROP pairs. Those joined caches got 13 of 96 questions right where the states from the very same writer passes got 47 (Appendix G.5). Each joined cache keeps upper layers computed without its partner, and the state reader rebuilds them with the partner in view.

On question 2, we ran the note as text on all 64 Granite environment sets. In the same 224 positions it executed 213 of 256 requests, the count of its states, with the same outcome on 254, and decided 172 policy records against 171 (Table 2, Appendix G.4). So the policy gain over the fourteen episodes in context, 170 records against 130 and 438 composed workflows against 202, belongs to the note the frozen model chose to write, as the review infers from Appendix A.6, and the states carry that note in full. The revised abstract now reports the tie beside the 170 against 130 result. Section 6 claims exactly this, that a frozen model writes its own memory from experience and a reader holding only that memory's states acts on it.

On question 3, the supplement now holds the observation rows of handbook reuse (Tables 5 and 7 to 9), generation (Table 10), composition (Table 11), ten-cycle revision (Table 12) and LoCoMo (Table 14) on Granite 4.2 8B, Qwen3.5-27B and Qwen3.5-9B, with scripts that recompute every value of these tables on CPU, together with the rows of every new measurement in the revised PDF.

The review's main concern was what state memory offers over the text. The states answer more at equal read compute with evenly spaced positions, compose where joined caches fail, and carry the model's own note in full, and we ask f1xg to weigh these measurements in the final rating.

I appreciate the authors’ additional experiments and clarifications. I still have concerns about the benefits over text, but would like to hear other reviewers’ views on the significance of these findings before deciding whether to raise my score.

We appreciate f1xg weighing the new measurements. For the reviewers' discussion of significance, we would ask them to weigh what these findings show a frozen model can do with its own early states and no training. Read in place of a 136,577-token context on Qwen3.8-27B, the states matched the context itself (75.5 against 75.0). Memories written separately could be combined, which the key/value caches from the same passes could not do (47 against 13 of 96 questions on Granite 4.2 8B). A memory revised ten times without rereading its source answered the same 935 of 1,056 SQuAD questions as the corrected context. The model also wrote such a memory from its own experience, and it carried a tool convention that no same-size slice of the original episodes carried (213 against at most 5 of 256 requests on Granite). Each trained model sets the deepest layer the states can come from, layer 2 on Qwen3.5-9B and layer 10 on Qwen3.5-27B, although the two share one layout.

Reviewer_P7t5OpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

The paper stores the residual activations after decoder layer 1 (the second layer) at every position of a context. It calls these "state memory". A frozen model reads them back by placing one period token per stored position in a new prompt, overwriting the layer-1 activations at those positions with the stored ones during prefill, and recomputing every layer above.

Critical strengths
  1. Experimental hygiene is unusually good. Protocols, prompts and unit counts are fixed before evaluation (Sec. 2, App. B.4). Bootstrap intervals resample the right independent units: handbooks, conversations, source documents (with near-duplicate grouping in E.5), trajectories and environment sets. Memory hashes are verified across pairings (E.2, F.1), and App. A.4 replays outputs through a second implementation of the oracle.
  2. The four-way swap test (Eq. 2, Fig. 3) is a clean design. The question is the same under all four pairings but the correct answer differs, so a pass cannot come from either memory alone. The single-component controls (Tables 11 and 16: 0/64 and 0/52 four-way passes) confirm this.
Critical weaknesses
  1. The central result of Sec. 3 holds largely by construction, and the paper should say so more plainly. The layer-1 residual at a position is a deterministic function of tokens up to that position. The reader overwrites exactly these values, so in every layer >= 2 the context positions reproduce the writer's computation exactly, up to numerics; Sec. 1 acknowledges this. The only departure is that the question tokens see period tokens at the context positions in layers 0-1. The reader therefore effectively rebuilds 62/64 layers of the full-history KV cache from stored layer inputs. This is essentially the mechanism of HCache (Gao et al., 2025, EuroSys), which the paper cites. That near-parity follows is unsurprising. The layer-8 failures (Table 5) are consistent with this reading: the result depends on almost the whole network being recomputed. Framing this as the model "answering from a context it no longer has" (Abstract, Sec. 8) is misleading. A hidden-size vector per position at layer 1 almost certainly still encodes the token identity, so the context has not been discarded in any meaningful sense.

  2. A key baseline is missing: keep the text itself. The abstract and Sec. 3.1 stress that the reader "discarded the text and its entire key/value cache". But the reader recomputes 62 of 64 layers over every history position, so its prefill cost is essentially that of re-reading the text. The storage is one hidden-size vector per token. Judging from Fig. 2b, that is roughly 1 GiB (bf16) or 0.3 GiB (four-bit) per 100k-token MRCR history, against well under a megabyte for the token IDs. Fig. 2b compares storage only to the KV cache, which is the wrong reference for the claimed use case. The paper does not say what state memory offers over storing and re-prefilling the text: not storage, compute, latency or accuracy. Without that, the practical significance of Sec. 3 is unclear.

Questions for authors
  1. Relative to keeping the token IDs and re-prefilling them, what concrete advantage does layer-1 state memory provide: storage, FLOPs, latency or accuracy? Please report wall-clock and FLOPs for the MRCR reader vs (a) re-prefilling the text and (b) loading the KV cache.
  2. Can the context tokens be recovered from the stored layer-1 states, e.g., by nearest-embedding matching or a linear probe? If token recovery is close to 100%, in what sense does the model "no longer have" the context?
  3. For Sec. 6, please add a condition where the reader receives the generated 224-token note as plain text, with no episodes. Do policy (170/256), procedure (213/256) and composition (438/1024) results differ from that baseline? This is the single most important missing experiment.
  4. For revision, is there any setting in which state memory beats the "revised text" baseline? If not, what does the state representation add to text rewriting?
  5. How does HCache's approach (restoring KV from stored activations) differ from the reader in Sec. 2 when both are applied to an entire context? Is the difference only in the capture layer and in recomputing rather than projecting?
2 comments
AuthorsOpenReview ↗

Response to Reviewer P7t5

We thank P7t5 for five questions that each named a measurement, and we ran all five. Two premises of the review do not survive them.

The parity of Section 3 does not follow from the construction, because the same construction at layer 8, which the review cites, scored 32.6% against 87.8% for full history on Qwen3.5-9B and 65.0% against 79.5% on Granite 4.2 8B (Table 5). The revised PDF measures where parity ends (Section 3.3, Tables 20 and 21). On Qwen3.5-9B it held with capture at layers 1 and 2 and broke at layer 3, the model's first full-attention layer. Granite 4.2 8B stayed within 3 points through layer 6 and fell at layer 7, and Qwen3.5-27B, whose configuration has the 9B's layout, held parity through layer 10 (95.5% against 95.9%). The construction is identical in the three models and parity ends at a different depth in each, so the layer-8 failures the review reads as support for its argument are the measurement that refutes it.

On question 2, a linear probe recovered 93.8% of 78,645 held-out tokens from Qwen3.5-9B layer-1 states, against 100% for input embeddings and 0.02% for matched Gaussian vectors (Appendix G.2). The same probe recovered the preceding token from 44.7% of states, against 12.0% from the token's own embedding. The states encode their tokens and part of their context, and the answers show the second part too. With 400 evenly spaced positions per handbook, the states answered 12.3 points more than the same tokens' input embeddings on Qwen3.5-27B [10.2, 14.5] and 11.1 more on Qwen3.5-9B. The revised PDF drops the phrases "discarded the text" and "a context it no longer has" and says what the reader holds, its own layer-1 states and no token of the context.

On question 1 and weakness 2, one stored position on Qwen3.8-27B holds 10 KiB in bf16 or roughly 2.7 KiB at four bits, about 0.95 GiB and 0.26 GiB per 100,000 positions, against 64 KiB per position for the key/value cache. In FLOPs the reader runs the layers above layer 1, 62 of 64, over the stored positions, a prefill of their length, while loading the cache skips that prefill, as Section 2 now states. Against re-prefilling the text, the measured advantage is accuracy at equal compute with the same evenly spaced positions. Given the same number of positions as layer-1 states or as the same tokens as text, both readers run a prefill of the same length, and the Qwen3.5-9B states led by 5.2 points [2.7, 7.7] at half of the positions and 10.9 [8.5, 13.4] at three quarters, with Qwen3.5-4B ahead by 3.4 and 9.8 (Table 22). On LongBench MultiFieldQA-en at half of each document, the states scored 32.7 F1 against 27.8 for the tokens, a lead of 4.9 [1.5, 8.2] over 100 documents.

On question 3, the note read as text now runs on all 64 Granite environment sets (Table 2, Appendix G.4). In the same 224 positions the text executed 213 of 256 requests and the states 213, with the same outcome on 254, and the text decided 172 policy records against 171. Section 3 asks the states to match the text they were written from, and this condition applies that test to memory the model wrote, which the states pass. What lifted the reader over the episodes in context (170 against 130 policy decisions, 438 against 202 composed workflows) was the note the frozen model chose to write, and the reader keeps all of it from 224 states. The revised abstract reports the tie beside that result.

On question 4, revised memory matched the revised-text reference over ten and twenty cycles, with 1,540 against 1,520 of 1,760 on Granite, 433 against 429 of 440 on Qwen3.5-27B and 3,244 against 3,255 of 3,360 on Qwen3.8-27B (Section 5). Section 5 tests whether the frozen model can revise its own stored state without its source text, and it did so at the reference's accuracy.

On question 5, HCache restores one context's key/value cache from stored activations so that the same context is served again faster. Our reader differs once memories written separately meet in one prompt. A restored or joined cache carries upper layers that each memory computed without the other, while the state reader recomputes them with both memories present. On 24 DROP pairs with Granite 4.2 8B, the joined caches of separate passage and question writers gave 13 correct answers of 96, against 47 from the states those same passes wrote and 43 from full history (Appendix G.5).

With the construction argument refuted by its own Table 5 and every question answered by a measurement, we hope P7t5 will revisit the rating.

I have raised the score

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

This paper demonstrates that by retaining only the Layer-1 residual states of a context and appending a new prompt, a frozen model can recompute the remaining layers to accurately answer questions about that context. On the MRCR benchmark, this approach achieves exact recall over long conversations, almost matching the performance of a full-context KV cache. While this allows long contexts to be stored in low-bit memory, it comes at the cost of recomputing all layers above Layer 1 during inference. The authors also perform a comprehensive series of memory experiments, including four-way swap tests on DROP, memory revision without source text, and distilling experiential logs into "note memories" for downstream tasks.

Critical strengths
  1. Keeping only the Layer-1 residual states of a context, and recomputing the remaining layers can perform downstream tasks.

  2. The authors designed several different tasks, and the results are interesting.

Critical weaknesses
  1. The recompute phase is very expensive, serving as a clear trade-off between memory usage and computation.
Questions for authors

As the recompute phase is very expensive, serving as a clear trade-off between memory usage and computation, please report the computing time in experiments.

1 comment
AuthorsOpenReview ↗

Response to Reviewer esYn

We appreciate esYn's summary, which covers all four operations, from MRCR read in place of its source to the four-way swap tests on DROP, revision without the source text and note memories written from experience, and for asking what a read costs.

The review describes the recompute as very expensive. A read recomputes the layers above layer 1 over the memory positions, 62 of the 64 layers on Qwen3.8-27B, so in FLOPs it costs about as much as prefilling the same number of tokens. That is the cost any reader holding the context as text already pays. We timed it on one RTX 5090 with Qwen3.5-9B in bf16. Answering one question about a 32,768-token context, with 16 generated tokens and medians of five runs, took 3.34 s from memory, 3.33 s from the text and 0.40 s from a stored key/value cache, and writing the memory took 0.17 s, since the writer stops after layer 1. The trade-off the review describes holds against a stored key/value cache, which needs no prefill and takes 64 KiB per position on Qwen3.8-27B, where the memory needs 10 KiB per position in bf16 or roughly 2.7 KiB at four bits, between a sixth and a twenty-fourth of that.

At the same read compute and the same evenly spaced positions, the states also answer more than the same tokens as text. Holding K evenly spaced positions as states or as the same K tokens gives prompts of equal length, and at half of the positions the Qwen3.5-9B states answered 5.2 points more, at three quarters 10.9 (Section 3.4, Table 22), while LongBench MultiFieldQA-en at half of each document gave 32.7 F1 against 27.8.

The revised PDF also measures how high the capture point can move (Section 3.3, Table 20). On Qwen3.5-9B memory matched full history with capture at layers 1 and 2 and fell at layer 3, its first full-attention layer, Granite 4.2 8B held within 2.8 points through layer 6, and Qwen3.5-27B matched at layer 8 and held parity through layer 10, so how deep a read can start depends on the trained model. At layer 1 the result held on MRCR histories of up to 136,577 tokens, with bf16 memory at 75.5 against 75.0 over all 115 conversations (Table 1).

Composition gains a control against caches. For 24 Granite DROP pairs we joined the key/value caches that separate passage and question writers produced, and they answered 13 of 96 questions, where the states from the same writers answered 47 and full history 43 (Appendix G.5). The policy memory the model wrote from its own episodes decided 170 of 256 unseen records against 130 with the episodes in context, and read as text the same note decided 172, so the states carry everything the model wrote (Table 2, Appendix G.4).

Comments on the paper

1 comment
AuthorsOpenReview ↗

Response to all reviewers

The reviews asked for four specific controls (token recovery, the note read as text, the cost of a read and the raw rows), and the revision runs every one. The revised PDF also measures how far the capture layer can move in each model, and it compares the states with the same tokens at equal read compute and with key/value caches when memories written apart are joined.

P7t5 writes that the parity of Section 3 holds largely by construction. The construction is identical at every capture layer and in every model, so if it fixed the outcome, parity would hold wherever it is applied, and it ended at different depths in different models. On Qwen3.5-9B, memory written at layer 8 scored 32.6% against 87.8% for full history (Table 5). The revised PDF moves the capture layer through layers 1 to 8 on the same 128 handbooks (Section 3.3, Table 20). Qwen3.5-9B matched full history at layers 1 and 2 (87.5% and 87.4% against 87.7%) and fell at layer 3, its first full-attention layer, to 81.6%. Granite 4.2 8B, with full attention in every layer, stayed within 2.8 points through layer 6 and fell to 69.5% against 79.8% at layer 7. Qwen3.5-27B, built with the 9B's layout, matched at layer 8 (95.8% against 95.9%), and a new run on the same handbooks kept parity through layer 10 (95.5%) and found it falling from layer 12, to 91.7% at layer 16 and 63.9% at layer 24 (Table 21). Parity is a measured property of each trained model, and layer 1 lies inside the matching range of every model we tested.

Section 2 of the revised PDF now gives the cost of a read. On Qwen3.8-27B a read recomputes 62 of the 64 layers over the memory positions, which is the prefill any reader of that context runs, and a stored position takes 10 KiB in bf16 and about 2.7 KiB at four bits, a sixth to a twenty-fourth of the 64 KiB the key/value cache needs.

At equal read compute, with the same evenly spaced positions kept, the states answer more than the same tokens as text. Section 3.4 gives the reader the same number of positions either as layer-1 states or as the same tokens as text, so both readers run a prefill of the same length. On Qwen3.5-9B the states led by 5.2 points [2.7, 7.7] at half of the positions, 10.9 [8.5, 13.4] at three quarters and 4.8 [3.0, 6.7] at nine tenths, and Qwen3.5-4B led by 3.4, 9.8 and 3.7 (Table 22). On LongBench MultiFieldQA-en with half of each document kept, the 9B states scored 32.7 F1 against 27.8, a lead of 4.9 [1.5, 8.2] over 100 documents. Against the input embeddings of the same 400 tokens the states answered 12.3 points more on Qwen3.5-27B [10.2, 14.5] and 11.1 more on Qwen3.5-9B. A linear probe recovers a state's own token 93.8% of the time and its preceding token 44.7% of the time, against 12.0% from the token alone (Appendix G.2), so each state holds its token and part of its context.

The states also compose where the standard store of precomputed context does not. On 24 DROP pairs with Granite 4.2 8B, the key/value caches of separately written passages and questions, joined at the same positions, answered 13 of 96 questions. The layer-1 states of the same writer passes answered 47 and full history 43, a gap over the caches of 34 answers [21, 48] (Appendix G.5). A joined cache keeps each memory's upper layers as they were computed alone, and the state reader recomputes them with the other memory present. On the full DROP set with Qwen3.8-27B, four-bit state memories passed 41 of 52 four-way swap tests, the count of full history, and either memory alone passed none.

P7t5 and f1xg asked for the note read as text in Section 6. On all 64 Granite environment sets the note as text executed 213 of 256 requests against 213 from its states, with the same outcome on 254, and decided 172 of 256 policy records against 171 (Appendix G.4). This is the fidelity test of Section 3 applied to memory the model wrote, and the states pass it. The gain over the episodes in context, 170 against 130 policy decisions and 438 against 202 composed workflows, comes from what the frozen model chose to keep, and a reader holding only the 224 states of its note keeps all of it. The revised abstract reports this tie beside the 170 against 130 result, and Section 3.1 and Figure 1 now say that the reader's prompt holds a period in place of each context token.

Revision was compared with the revised text over every cycle, with 3,244 against 3,255 of 3,360 over twenty cycles on Qwen3.8-27B. The frozen model revised its own stored state without reading its source text again, and the revised memory matched the reader that held the revised text.

The supplement now holds the raw rows of Tables 5, 7 to 12 and 14 that f1xg could not find, with CPU scripts that recompute each value.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.