Paper deep dive
Cross-Model Memory Transfer via Target-Side Reader Adaptation
Mingyuan Li, Guangsheng Yu, Xu Wang, Shaoxiong Ji
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/19/2026, 4:09:55 AM
Summary
This paper investigates cross-model frozen-memory transfer using an Engram-style architecture, where a memory table trained on a source model is frozen and attached to a different target model. The study demonstrates that while the frozen memory content is valuable, successful reuse depends critically on a target-side reader aligned to the target model's architecture. A lightweight, dual-layer, four-branch reader nearly closes the performance gap between same-model and cross-model reuse, achieving an average score of 38.8 on downstream question answering tasks.
Entities (10)
Relation Signals (6)
Dual-Layer Four-Branch Reader → achieves → Question Answering Score 38.8
confidence 95% · a dual-layer, four-branch reader nearly closes the gap ... achieving an average score of 38.8
Engram → uses → External Memory Table
confidence 95% · Engram-style hashed memory occupies a middle regime: it stores learned information in an external, addressable table
Engram → uses → Target-Side Reader
confidence 95% · consumes that table through a small learned reader
Cross-Model Frozen-Memory Transfer → involves → Target-Side Reader
confidence 92% · with only a lightweight reader trained
Target-Side Reader → enables → Memory Reuse
confidence 90% · the transferred table becomes useful only through a reader aligned to the target model
Tokenizer-Agnostic Canonicalization → supports → Cross-Model Transfer
confidence 88% · We use a tokenizer-agnostic canonicalization pipeline to keep memory addresses stable across tokenizers
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Methods for improving knowledge use in large language models typically fall into two regimes. Non-parametric retrieval offers flexible access to external knowledge, but adds retrieval latency, context overhead, and only shallow integration with the backbone. Parametric adaptation is efficient at inference time, but entangles knowledge with model weights and can be hard to update, audit, or transfer. Engram-style hashed memory occupies a middle regime: it stores learned information in an external, addressable table, yet consumes that table through a small learned reader. This raises a basic question: when such a memory is moved across backbones, what matters more, the frozen memory itself or the target-side reader? We study this question through cross-model frozen-memory extraction, in which a memory trained on a source model is frozen and attached to a different target model, with only a lightweight reader trained. Ablations show that learned memory content and correct addressing both matter, but the transferred table becomes useful only through a reader aligned to the target model. In downstream question answering tasks, a dual-layer, four-branch reader nearly closes the gap between same-model and cross-model reuse, achieving an average score of 38.8 under our controlled evaluation protocol. Moreover, when the provider reader is directly compatible with the target interface, the frozen artifact can provide substantial utility without target-side training, while optional reader adaptation yields further improvement. These results suggest that Engram can serve as a reusable external knowledge artifact, provided that the target has access to a compatible reader interface; target-side adaptation can further improve alignment when direct reader reuse is insufficient.
Tags
Links
- Source: https://arxiv.org/abs/2608.17050v1
- Canonical: https://arxiv.org/abs/2608.17050v1
Trouble viewing inline? Open PDF directly →
Full Text
126,290 characters extracted from source content.
Expand or collapse full text
Cross-Model Memory Transfer via Target-Side Reader Adaptation Mingyuan Li Affiliation: Emails: mingyl@utu.fi, guangsheng.yu@uts.edu.au, xu.wang@uts.edu.au, shaoxiong.ji@utu.fi Guangsheng Yu Affiliation: Emails: mingyl@utu.fi, guangsheng.yu@uts.edu.au, xu.wang@uts.edu.au, shaoxiong.ji@utu.fi Xu Wang Affiliation: Emails: mingyl@utu.fi, guangsheng.yu@uts.edu.au, xu.wang@uts.edu.au, shaoxiong.ji@utu.fi Shaoxiong Ji Thanks: Corresponding author. Affiliation: Emails: mingyl@utu.fi, guangsheng.yu@uts.edu.au, xu.wang@uts.edu.au, shaoxiong.ji@utu.fi Abstract Methods for improving knowledge use in large language models typically fall into two regimes. Non-parametric retrieval offers flexible access to external knowledge, but adds retrieval latency, context overhead, and only shallow integration with the backbone. Parametric adaptation is efficient at inference time, but entangles knowledge with model weights and can be hard to update, audit, or transfer. Engram-style hashed memory occupies a middle regime: it stores learned information in an external, addressable table, yet consumes that table through a small learned reader. This raises a basic question: when such a memory is moved across backbones, what matters more, the frozen memory itself or the target-side reader? We study this question through cross-model frozen-memory extraction, in which a memory trained on a source model is frozen and attached to a different target model, with only a lightweight reader trained. Ablations show that learned memory content and correct addressing both matter, but the transferred table becomes useful only through a reader aligned to the target model. In downstream question answering tasks, a dual-layer, four-branch reader nearly closes the gap between same-model and cross-model reuse, achieving an average score of 38.8 under our controlled evaluation protocol. Moreover, when the provider reader is directly compatible with the target interface, the frozen artifact can provide substantial utility without target-side training, while optional reader adaptation yields further improvement. These results suggest that Engram can serve as a reusable external knowledge artifact, provided that the target has access to a compatible reader interface; target-side adaptation can further improve alignment when direct reader reuse is insufficient. 1 Introduction Language models can use knowledge in two familiar ways. Non-parametric methods, such as retrieval-augmented generation (RAG) [25] and nearest-neighbor retrieval [20], keep knowledge outside the backbone and make updates relatively direct, but they pay for that flexibility with retrieval latency, longer contexts, and loose integration between retrieved evidence and generation. Parametric methods, such as continued pretraining, fine-tuning, or learned memory layers tied to a single model [39], avoid retrieval at inference time, but they entangle knowledge with model weights. This makes updates, audits, and transfers across backbones difficult. Engram-style hashed memory [8] occupies an interesting middle ground. It stores learned information in an explicit, addressable external table, yet consumes that table through a small neural interface rather than by inserting raw documents into the context. This hybrid design is attractive because it combines the modularity of external memory with the efficiency of learned representations. But it also exposes a sharper question: is the memory itself reusable or transferable, or is it merely a co-adapted extension of the model that trained it? The distinction matters: a memory table that is not portable is just another form of model-specific parameterization, not a reusable knowledge substrate. Thus, the portability requires an operational test: remove the source backbone and ask whether another model can still extract a useful signal from the frozen memory table. We study this test through cross-model frozen-memory transfer. Given a memory table trained with a source model A, we freeze the table, attach it to a different target model B, and train only a lightweight target-side reader for memory extraction. If the frozen memory still improves the target after the original host is removed, then it contains usable information beyond source-specific co-adaptation. If it fails, then the apparent memory benefit was likely tied to the original backbone. Figure 1 illustrates the life cycle of memory reuse and transfer: source-side memory training, memory export and freezing, and target-side extraction through a new reader. To make this test precise, we separate three roles: (1) addressing decides which entries are read, (2) memory denotes the stored vectors, and (3) reader maps them into the model. We standardize addressing, freeze the memory, and adapt only the reader. This turns portability into a measurable question: can a target model learn to read a fixed memory artifact? We use a tokenizer-agnostic canonicalization pipeline to keep memory addresses stable across tokenizers, freeze the exported source memory, and train only a small target-side reader that projects memory values into the target residual stream. Our central claim is: for portable hashed external memory, memory presence alone is not enough; successful reuse depends on the interface through which a target backbone addresses and consumes the stored representations. Nevertheless, memory content still matters. Transferred memory clearly outperforms permuted-key controls and reaches substantially better downstream Question Answering (QA) performance than random memory under the final evaluation protocol. But the amount of usable signal depends on how well the target model can align and integrate what it retrieves. This view explains why imperfect memory can still help with a capable reader, and why reader design can matter as much as retraining or enlarging the stored table in this regime. We support this claim with a concise chain of evidence, spanning diverse model families and settings. First, a source–target transfer study shows that frozen memory consistently improves target models across different model families and scales, including Pythia [5], Qwen 32, TinyLlama [44], Phi 1, LLaMA [37], and Mistral [18], with relative perplexity reductions of up to 15.7%. A supplementary peer-to-peer setting further confirms that transfer remains beneficial in both directions between models of similar scale. Second, ablation experiments show that transferred memory clearly outperforms the permuted-key and no-memory controls, while scratch-trained target memory remains competitive under the same target-side adaptation budget. This suggests that memory reuse is a joint property of the stored content and the target side reader that makes it usable. Third, on downstream tasks, upgrading the target side reader to a dual-layer, multi-branch architecture nearly closes the gap between same-model and cross-model reuse, with the best configuration reaching an average score of 38.8 across five QA tasks, achieving a new state-of-the-art result (SoTA) and outperforming MLP Memory [39] and selective gains on other knowledge-intensive benchmarks. In summary, our contributions are: • We formulate cross-model frozen-memory reuse as an evaluation problem for external memory, separating portable memory from backbone-specific co-adaptation and measuring whether the target model can extract usable signal from a frozen artifact. • We instantiate this problem with a transfer protocol for Engram-style memory that standardizes addressing across tokenizers, and we propose lightweight target-side readers for memory extraction, including stronger multi-branch, multi-layer variants. • We provide an evidence chain showing that reader design is first-order: consistent gains across diverse model families and settings, ablations that isolate memory content and address integrity, and QA results showing that stronger target-side readers, rather than source-backbone identity alone, drive the best performance and achieve a new SoTA. This paper is organized as follows. Section 2 reviews Engram architecture, related memory mechanisms, and cross-model alignment. Section 3 describes the cross-model frozen-memory transfer protocol, including tokenizer-agnostic addressing, target-side reader design, and training regime. Section 4 presents the experimental setup, research questions, results, and takeaways. Supplementary material in Appendix A provides additional details on canonicalization, memory export, and the reader implementation. Appendix B gives training and evaluation details, including hyperparameters, datasets, and evaluation metrics. Appendix C extends RQ1 in Section 4.1 with exact matrix values and controls for tokenizer mismatch, peer-scale transfer, target scaling, and representational similarity. Appendix D extends RQ3 in Section 4.3 by diagnosing why downstream gains are task-dependent, separating source-corpus specialization, Phase-2 reader-fitting alignment, mixed-corpus behavior, and out-of-domain effects. extends RQ5 in Section 4.5 with additional target-side scaling and early-stopping results. The supplementary material concludes with a computational cost analysis (Appendix F), broader ethics and impact considerations (Appendix G), and limitations (Appendix H). 2 Background and Related Work 2.1 Engram Architecture Engram [8] augments a Transformer-MoE backbone with an external conditional memory. It retrieves static n-gram embeddings through deterministic hashing and injects the retrieved vector into the backbone through a learned gate. The key property for our setting is that Engram separates addressing, storage, and read: the input text determines which memory entry is read, the memory table stores the external vectors, and a small learned reader maps the retrieved vector into the backbone hidden space. This separation makes transfer possible: as long as another model can reproduce the same memory addresses through a shared addressing scheme, the frozen Engram table can be reused through a target-side reader. For each n-gram order n∈[2,N]n∈[2,N] and hash head k∈[1,K]k∈[1,K], a deterministic hash φn,k _n,k maps the canonicalized n-gram gt,ng_t,n to an entry in memory table n,kE_n,k. The retrieved embeddings are concatenated as t,⨁n=2N⨁k=1Kn,k[φn,k(gt,n)].e_t _n=2^N _k=1^KE_n,k[ _n,k(g_t,n)]. (1) Crucially, this lookup depends on the canonicalized input sequence rather than the model hidden state, so the memory table can be treated as an external artifact once the address space is standardized. The retrieved vector is consumed through learned projections and a gate: st s_t =RMSNorm(t)⊤RMSNorm(t)d, = (h_t) (k_t) d, αt _t =σ(sign(st)|st|), =σ\! (sign(s_t) |s_t| ), (2) t _t =Kt, =W_Ke_t, t _t =Vt. =W_Ve_t. Here, KW_K, VW_V, and the gate define the backbone-specific reader. This structural separation makes frozen-memory transfer possible: the source memory table can be frozen and moved to a target model, while only a lightweight target-side reader is trained to extract and align it. 2.2 Memory Mechanisms MoE [35, 13, 11] expands capacity through conditional computation, but its useful signal remains embedded in the host backbone rather than exposed as a reusable memory artifact. Other memory-augmented models also miss the extraction question for one of two reasons: they either retrieve from large dynamic memory banks at inference time [14, 41], or they store information in model-specific hidden spaces, as in KNN-LM [20]. Retrieval-augmented generation and RETRO-style systems [25, 6, 17] are portable at the document level, but the reusable object is a text datastore rather than a trained memory representation. Larger learned memory layers [24, 4, 2, 39] improve capacity or efficient knowledge access, but their stored representations are usually trained and consumed within the same model. Engram differs in the regime relevant here: deterministic hashing provides an explicit address space, the memory table is external and addressable, and a small learned reader mediates read by the backbone. This separation makes a frozen memory artifact well defined and allows portability to be tested as extraction rather than as additional model capacity. A broader qualitative comparison appears in Table 7. 2.3 Cross-Model Alignment Cross-model transfer is often studied as representation or adapter alignment. Embedding-space work suggests that independently trained models can sometimes be connected by simple linear maps between hidden representations [30, 21, 16, 7]. PEFT transfer methods such as Cross-LoRA [42], LoRA-X [12], and Trans-LoRA [38] show that compact adapters or low-rank updates can sometimes be reused across heterogeneous models. These methods are useful baselines for parameter transfer, but they do not directly address frozen external-memory reuse: there is no separate memory table to address, freeze, and extract from after the source backbone is removed. In frozen-memory extraction, alignment starts earlier. The target model must first read the same memory entry as the source-intended lookup, even when their tokenizers differ. Otherwise, the same surface text may be routed to unrelated memory slots, and any downstream hidden-space mapping becomes ill-defined. Our method, therefore, treats alignment as a two-stage problem: tokenizer-agnostic canonicalization aligns the key space, and a lightweight target-side reader aligns the retrieved value space to the target residual stream. 3 Methods Our method recasts Engram as a transferable artifact. We freeze the source memory and fit only a small target-side reader. This requires a shared address space, frozen memory, and a lightweight reader. Relative to native Engram, we make three changes: we (1) freeze the exported source memory, (2) replace model-specific token-ID lookup with tokenizer-agnostic canonicalization, and (3) use a lightweight target-side reader attached by residual injection to read the knowledge from Engram memory. Figure 1 illustrates the overall architecture and training and adaptation procedures, and Algorithm 1 summarizes the training procedure. Figure 1: Overview of the cross-model memory transfer. A memory table trained with source model A is frozen and attached to target model B. Canonicalization keeps the address space fixed across tokenizers, and only the target-side reader (including multi-head and multi-layer variants) is trained. This setup operationalizes whether external memory remains reusable outside its source backbone. 3.1 Tokenizer-Agnostic Addressing The first obstacle to transfer is the address mismatch. Native Engram hashes model-specific token IDs inside the host model, which is sufficient when storage and read happen under one tokenizer, but does not define a stable cross-model address space. If source and target tokenizers segment the same text differently, then identical surface content may be routed to different memory entries. To avoid this failure mode, we build the lookup space on canonicalized decoded text rather than raw token IDs. Let BT_B be the tokenizer of target model B, and let s1:t=decode(B(x1:t))s_1:t=decode(T_B(x_1:t)) denote the decoded target prefix up to position t. We normalize that prefix with a shared canonicalization function P and extract the completed word sequence (w1,…,wm(t))=words((s1:t)),(w_1,…,w_m(t))=words\! (P(s_1:t) ), (3) where words(⋅)words(·) returns the canonicalized word-boundary units implied by the current decoded prefix. Word-boundary addressing is the default for the English-like settings above, but it degenerates for scripts without reliable whitespace segmentation. For such inputs, we replace word units with NFKC-normalized, case-folded non-whitespace Unicode character events and hash character spans using the same deterministic addressing interface. Appendix E evaluates this variant on Chinese and Japanese. In practice, P applies NFKC normalization, lowercasing, accent stripping, and whitespace cleanup. Memory lookup is then performed over canonical word-boundary n-grams rather than model-specific token IDs: t=⨁n=2N⨁j=1Kn,j[φn,j(wm(t)−n+1,…,wm(t))].e_t= _n=2^N _j=1^KE_n,j\! [ _n,j(w_m(t)-n+1,…,w_m(t)) ]. (4) At subword positions inside the same decoded word, the current token reuses the same right-edge word context until a new word boundary appears. The retrieved vector te_t is therefore determined by canonicalized text and the frozen memory artifact, not by target-specific token IDs. Two target models with different tokenizers can still read the same transferred entry as long as they share the same canonicalization and hash specification. Input: Source memory ℰAE_A, target model B, target corpus D, selected injection layers ℒL, branch count R, canonicalization P Output: Target model B augmented with frozen transferred memory // // Phase 1 artifact is already trained; prepare transfer Extract Engram tables n,j\E_n,j\ and hash specification from ℰAE_A; 1 Freeze all transferred tables n,j\E_n,j\ [portable memory artifact]; 2 // // Initialize target-side reader and hooks foreach ℓ∈ℒ do 3 Initialize reader parameters (B,ℓ)W^(B, ); 4 Set (B,ℓ)←K,ℓ,r(B),βℓ,rr=1R,V,ℓ(B)W^(B, )←\W_K, ,r^(B), _ ,r\_r=1^R,W_V, ^(B); 5 if R=1R=1 then 6 Set βℓ,1←0 _ ,1← 0; 7 Register a forward hook at layer ℓ that computes t,ℓo_t, from the current t,ℓh_t, and looked-up te_t, then injects t,ℓ←t,ℓ+t,ℓh_t, _t, +o_t, ; 8 // // Phase 2: Reader-only adaptation for x1:T∈x_1:T do 9 Canonicalize each decoded prefix into shared word-boundary n-grams with P; 10 Look up frozen memory vectors 1:Te_1:T from n,j\E_n,j\; 11 Run the frozen backbone on x1:Tx_1:T with the registered hooks active; 12 Update only reader parameters (B,ℓ)ℓ∈ℒ\W^(B, )\_ using the LM loss [backbone and memory frozen]; 13 Algorithm 1 Cross-Model Frozen-Memory Extraction 3.2 Target-Side Reader Once the address space is shared, the remaining problem is extraction: how should the target model consume a memory vector whose geometry was shaped by a different backbone? We use a shared-value reader family parameterized by branch count R, where a larger R increases target-side alignment capacity without increasing memory size. For branch r∈1,…,Rr∈\1,…,R\ at layer ℓ : t,ℓ(r)=K,ℓ,r(B)t,t,ℓ=V,ℓ(B)t,k_t, ^(r)=W_K, ,r^(B)e_t, _t, =W_V, ^(B)e_t, (5) αt,ℓ(r)=σ(RMSNorm(t,ℓ)⊤RMSNorm(t,ℓ(r))dB+βℓ,r), _t, ^(r)=σ\! ( (h_t, ) (k_t, ^(r)) d_B+ _ ,r ), (6) t,ℓ=1R∑r=1Rαt,ℓ(r)⋅t,ℓ.o_t, = 1R _r=1^R _t, ^(r)·v_t, . (7) The resulting reader output is injected through a residual connection: t,ℓ←t,ℓ+t,ℓ.h_t, _t, +o_t, . (8) The shared value projection forces all branches to operate on the same retrieved content and differ only in how they gate and align it. The added capacity is therefore an extraction mechanism rather than extra storage. The main 3×33× 3 transfer matrix uses R=1R=1; the stronger QA reader uses R=4R=4. Multi-layer injection. The same reader family can be instantiated at one or more target layers ℒL. Single-layer injection is sufficient for the cross-architecture transfer matrix, whereas the best QA configuration uses dual-layer injection at layers 2 and 10 with R=4R=4 branches. 3.3 Training Regime The training objective is the standard next-token language modeling loss on the target corpus. During target-side adaptation, both the exported source memory tables n,j\E_n,j\ and the target backbone parameters θB _B remain frozen; only the reader parameters (B,ℓ)ℓ∈ℒ\W^(B, )\_ are updated. Storage is fixed, and only extraction is learned. Algorithm 1 summarizes the procedure concisely. The key operations are to freeze the exported source memory, canonicalize target inputs into the shared address space, and update only the target-side reader. Deployment modes. The two-phase protocol above describes the general case in which the target requires a model-specific reader. We additionally distinguish between two deployment modes. In direct artifact reuse, a provider exports the frozen memory together with a reader whose residual interface is compatible with the consumer model; the consumer performs no target-side optimization. In reader-adapted reuse, the same frozen memory is retained, but a lightweight target-specific reader is fitted on an available adaptation stream. The first mode minimizes consumer-side cost, while the second provides additional alignment capacity when direct reader reuse is insufficient. Both modes preserve the defining property of the protocol: the transferred memory table itself is never rewritten. 4 Experiments and Results In this section, we address the effect of cross-model memory transfer through 5 research questions. All experiments follow the same protocol: a source memory is trained (Phase 1), then frozen and attached to a target model where only a reader is trained (Phase 2) as illustrated in Figure 1. We evaluate on intrinsic language modeling and downstream QA tasks. Intrinsic evaluations use the memory transfer architecture with a minimal reader, while QA evaluation uses a stronger multi-layer, multi-branch reader. Implementation details are in Appendix B. 4.1 RQ1: Does frozen memory transfer across backbones, tokenizers, and scales? Our first question is whether the exported memory remains useful once detached from the source backbone. We start with a 3×33× 3 source–target matrix spanning three source memories (Pythia-160M [5], Qwen3.5-0.8B, Qwen3.5-9B [32]) and three target models (Pythia-410M, Qwen3.5-4B, TinyLlama-1.1B [44]), all trained with the same 20M-token target-side protocol. Appendix C therefore stress-tests the same conclusion against several alternative explanations. It reports the exact matrix values, introduces parameter-matched and retrieval-based comparisons, removes the small-to-large transfer asymmetry through peer-to-peer transfer, tests whether gains persist as the target scales, and examines whether representational similarity predicts transfer success. (a) Full 3×33× 3 source–target transfer matrix, reported as relative PPL reduction over the no-memory baseline. (b) Target-scale intrinsic transfer: the same transferred Qwen3.5-0.8B memory improves Qwen3.5 targets from 2B to 9B. Figure 2: The full 3x3 transfer matrix and target-scale transfer performance across different model types trained on Wikitext-103. Figure 2 summarizes this result together with the scaling trend. All nine cells in the main matrix in Figure 2(a) show PPL reduction in models with transferred memory over the no-memory baseline, and the same transferred Qwen3.5-0.8B memory continues to help as the target grows from 2B to 9B (Figure 2(b)), compared with the baseline without memory and the random memory control with a randomly initialized, untrained memory of the same architecture and size as the transferred memory. The full matrix in Figure 2(a) gives a positive answer in every one of the nine cells. Transferred memory improves over the no-memory baseline in all source–target pairs, with relative gains from 1.6% to 15.7%. The strongest gain appears in the Qwen3.5-0.8B → TinyLlama-1.1B case, showing that large improvements do not require the source and target to share an architecture or a tokenizer. This is also not only an intrinsic-perplexity effect: Figure 3 later shows selective downstream gains for Qwen3.5 targets from 0.8B to 9B, and Table 16 shows that the same target family retains that pattern under two different source-corpus families. On Qwen3.5-2B specifically, Figure 4 shows the same asymmetry in a more focused form: transferred memory stays ahead of scratch on intrinsic PPL across all three budgets (Figure 4(b)), while the downstream gains are selective rather than universal, with the clearest best-of-budget improvements appearing on BoolQ, RTE, and SciQ (Figure 4(a)). One subtle pattern is that source scaling helps, but not monotonically, for every target. Qwen3.5-0.8B improves over Pythia-160M on all three targets, yet Qwen3.5-9B does not always beat Qwen3.5-0.8B on the most dissimilar target (Pythia-410M), suggesting that transfer depends not only on what the source memory stores, but also on what the target reader can successfully extract. This underscores the importance of the reader’s extraction capability, as supplementary results in Appendix C confirm that transfer is effective in peer-to-peer settings (Section C.3) and even between backbones with low representational similarity (Section C.5). Takeaway. Frozen memory transfer remains effective across backbone families, tokenizer boundaries, and target scales, with gains in all nine main source–target pairs; the same Qwen3.5 target family also retains selective downstream gains beyond perplexity, and successful transfer ultimately depends on whether the target reader can extract the stored structure. 4.2 RQ2: How much does reader design matter? The previous experiments established that memory transfer remains effective even across model families. However, they do not explain where the transfer gains actually come from. One possibility is that most of the benefit is already contained in the transferred memory itself. An alternative explanation is that transfer quality is primarily limited by the target-side reader, i.e., the mechanism responsible for extracting and integrating information from the frozen memory. To distinguish between these possibilities, we keep the transferred memory fixed and vary only the reader architecture. Specifically, we study two aspects of reader design: (i) memory placement, namely the layers at which memory is injected into the target backbone, and (i) retrieval capacity, controlled through the number of reader branches. Our central finding is that reader design is a first-order factor: most of the gain comes from placing the reader at the right layers, while multiple branches further improve performance by accessing the same memory from different perspectives. Table 1: QA accuracy (%) on Mistral-7B-v0.3 for different reader variants and baselines. Budget notation follows Table 2 trained on Wikipedia-2021 [17]. Variant Budget NQ WebQA TriviaQA TruthQA HotpotQA Average Base – 20.6 29.3 57.7 32.1 21.0 32.1 Non-parametric Methods RAG [25] – 22.6 1.9 24.9 -4.4 54.2 -3.4 35.5 3.4 29.8 8.8 33.4(+3.9%) kNN [20] – 21.1 0.4 30.5 1.2 57.8 0.1 32.3 0.2 21.2 0.2 32.6(+1.4%) Parametric Methods CPT – 12.2 -8.5 34.1 4.8 61.2 3.6 29.2 -2.9 16.0 -4.9 30.5(-5.0%) LoRA [15] – 18.2 -2.5 34.5 5.2 61.6 4.0 30.9 -1.2 16.2 -4.7 32.3(+0.5%) MLP Memory [39] – 25.2 4.6 37.5 8.2 61.0 3.3 32.5 0.5 24.1 3.2 36.1(+12.3%) Engram Variants (sorted by Average) LLaMA Frozen 10\10\-R1 10/0 21.8 1.2 29.6 0.3 60.6 2.9 33.1 1.1 22.3 1.4 33.5(+4.4%) Mistral Frozen 10\10\-R1 10/0 21.9 1.2 29.7 0.4 60.8 3.1 32.9 0.8 22.4 1.4 33.5(+4.4%) Mistral 10\10\-R1 10/20 22.1 1.5 31.6 2.4 61.1 3.4 32.8 0.7 22.3 1.3 34.0(+5.8%) LLaMA 10\10\-R1 10/20 22.2 1.5 32.6 3.3 61.2 3.6 32.9 0.8 22.3 1.3 34.2(+6.6%) LLaMA 2,10\2,10\-R1 10/20 30.3 9.7 28.7 -0.6 70.1 12.4 31.0 -1.1 27.4 6.4 37.5(+16.7%) LLaMA 2,10\2,10\-R4 10/20 30.3 9.7 33.7 4.4 69.9 12.3 30.9 -1.2 27.6 6.7 38.5(+19.9%) The first pattern is that a weak or frozen reader improves only a small fraction of the performance. With a single injection layer at 10\10\, the frozen variants achieve only 33.5–33.5 average accuracy, a modest improvement over the 32.1 base model. Training the same single-layer reader raises performance to 34.0–34.2, indicating that target-side adaptation already contributes noticeably even before increasing reader capacity. This suggests that the transferred memory alone is insufficient; the target model must learn how to access it effectively. The largest gain comes from reader placement. Moving from LLaMA 10\10\-R1 to LLaMA 2,10\2,10\-R1 increases average accuracy from 34.2 to 37.5. The improvement is broad rather than dataset-specific: NQ rises from 22.20 to 30.3, TriviaQA from 61.2 to 70.1, and HotpotQA from 22.3 to 27.4. These results suggest that dual-layer injection provides the target model with multiple opportunities to integrate retrieved memory throughout the forward pass, instead of forcing all memory interaction through a single late-layer interface. Reader capacity explains the remaining improvement. Keeping the injection layers fixed at 2,10\2,10\ and increasing the number of branches from R=1R=1 to R=4R=4 raises average accuracy from 37.5 to 38.5. The most visible gain appears on WebQA (28.7 to 33.7), while the strong improvements on NQ, TriviaQA, and HotpotQA are preserved. This behavior is consistent with the intended role of the multi-branch design: different branches provide complementary key-gating pathways over the same shared value representation. The branches, therefore, increase the flexibility with which the target conditions the contribution of a retrieved memory vector, rather than introducing independent stored value directions. Reader structure is not the only capacity factor. We additionally vary the frozen-memory interface width in a controlled Pythia-160M→ -410M diagnostic. Increasing the memory width from 256 to 512 and 1024 reduces test perplexity from 22.368 to 22.157 and 21.808, respectively. However, a width-512 reader injected at two layers reaches 21.522, outperforming the wider width-1024 single-layer configuration. Thus, the default 512-dimensional interface is a design choice rather than a hard architectural bottleneck, and extraction capacity depends jointly on interface width and reader structure. Because changing the width also changes both memory and reader parameter counts, we treat this experiment as a capacity-sensitivity analysis rather than a causal estimate of memory width alone. The same table also places reader improvements in context relative to existing approaches. The strongest transfer configuration, LLaMA 2,10\2,10\-R4, achieves 38.5 average accuracy, outperforming all included baselines, including RAG, kNN-LM, CPT, LoRA, and MLP Memory. Notably, this improvement is obtained without modifying the transferred memory itself, reinforcing the conclusion that extraction quality, rather than memory storage, is the dominant factor governing transfer performance. Takeaway. Reader design is a first-order determinant of transfer quality. Dual-layer injection recovers most of the available gain, while multi-branch gating provides an additional improvement by allowing the same retrieved value representation to be conditioned through multiple target-dependent key-gate pathways. Together, these design choices raise average QA accuracy from 34.2 to 38.5 without changing the transferred memory itself. 4.3 RQ3: When does transferred memory help downstream? Table 2: QA accuracy (%) on Mistral-7B-v0.3 for transfer verification and ablation studies. Deltas are measured against the baseline. Budget == P1/P2 denotes source-memory and target-reader training tokens (millions) trained on Wikipedia-2021. Variant Budget NQ WebQA TriviaQA TruthQA HotpotQA Average Base – 20.6 29.3 57.7 32.1 21.0 32.1 Transfer Verification Mistral 2,10\2,10\-R4 10/20 30.2 9.5 34.0 4.7 70.0 12.3 30.8 -1.3 27.7 6.8 38.5(+20.0%) LLaMA 2,10\2,10\-R4 10/20 30.3 9.7 33.7 4.4 69.9 12.3 30.9 -1.2 27.6 6.7 38.5(+20.0%) Frozen Mistral 2,10\2,10\-R4 10/0 30.5 9.8 30.3 1.0 70.8 13.2 32.2 0.2 27.7 6.8 38.3(+19.2%) Frozen LLaMA 2,10\2,10\-R4 10/0 30.6 10.0 30.3 1.0 70.8 13.1 32.2 0.1 27.6 6.7 38.3(+19.2%) Controls and Ablations Mem-only Mistral 10/0 0.2 -20.4 0.3 -29.0 1.4 -56.3 33.0 0.9 0.2 -20.7 7.0(-78.1%) Mem-only LLaMA 10/0 0.0 -20.6 0.0 -29.3 0.0 -57.7 – 0.0 -21.0 – Permuted 10/0 20.6 0.0 28.9 -0.4 63.1 5.4 32.4 0.3 23.1 2.2 33.6(+4.7%) FFN R4 10/20 19.6 -1.0 27.3 -2.0 58.1 0.5 32.1 -0.0 17.6 -3.4 30.9(-3.7%) Token Scaling (LLaMA2-7B source, 2,10\2,10\-R4) Engram 10/10 30.2 9.5 29.9 0.6 70.4 12.8 31.2 -0.9 27.6 6.7 37.9(+17.8%) Engram 15/15 30.2 9.6 32.7 3.4 70.1 12.4 30.6 -1.5 27.8 6.8 38.3(+19.2%) Engram 20/20 30.3 9.7 33.9 4.6 69.9 12.3 30.7 -1.4 27.6 6.7 38.5(+19.8%) Engram 25/25 30.5 9.9 33.1 3.8 70.0 12.3 30.9 -1.2 27.7 6.7 38.4(+19.6%) Engram 30/30 30.6 10.0 33.9 4.6 70.4 12.7 31.1 -1.0 27.9 7.0 38.8(+20.7%) RQ1–RQ2 established that memory can be transferred across model families and that transfer quality is largely determined by the target-side reader. The remaining question is not whether transfer works, but rather how far it can be pushed and where it begins to break down. We study this question from two complementary perspectives. First, we use QA benchmarks to estimate the upper bound of transfer performance under increasingly strong reader configurations. Second, we evaluate whether these gains generalize beyond QA to broader knowledge-intensive tasks. Throughout this section, a,b\a,b\-Rrr denotes memory injection at layers a,b\a,b\ with r retrieval branches, and “Frozen” indicates evaluation with the source reader without target-side adaptation. Table 2 reveals a clear and surprisingly high transfer ceiling. Under the strongest configuration (2,10\2,10\-R4), same-model and cross-model transfer achieve nearly identical performance (38.5 vs. 38.5 average accuracy), achieving a ceiling once the reader is sufficiently expressive. Performance further saturates with scale: increasing training budgets from 10/10 to 30/30 improves accuracy from 37.9 to 38.8, suggesting diminishing returns in the high-38 regime. Control results confirm that this ceiling is not driven by parameter addition alone. Memory-only variants collapse without a reader, and FFN-based substitutes fall below the base model, while permuting memory keys removes most gains. These results indicate that successful transfer critically depends on the correct retrieval and integration of frozen memory rather than additional capacity. The frozen-reader rows additionally expose a second deployment regime. When the provider reader is directly compatible with the target residual interface, the complete frozen artifact can be reused without target-side training: mean QA remains approximately 38.3 compared with 32.1 for the no-memory target. Optional target-reader fitting further raises the score to approximately 38.5. Thus, target-side adaptation is useful but is not an inherent requirement for every compatible source–target pair. We next examine whether these gains extend beyond QA to a broader set of downstream tasks. Figure 3 shows that transfer benefits are selective rather than universal. The high QA ceiling does not imply that transferred memory improves every downstream objective. We therefore evaluate whether the benefits extend beyond the five QA benchmarks to a broader set of knowledge-intensive and reasoning tasks. The strongest and most consistent gains appear on tasks for which additional factual or evidence-related information is likely to be useful. RTE improves at every evaluated target scale, with gains ranging from +0.7+0.7 to +3.7+3.7 accuracy points. SciQ also remains positive across scales, with improvements of up to +3.7+3.7 points. OpenBookQA shows smaller but consistently positive gains, while BoolQ becomes positive for target models of 2B parameters and above. Together, these results suggest that transferred memory is most useful when the downstream decision can benefit from additional factual associations or evidence support. By contrast, the gains are substantially weaker on tasks whose success is less directly tied to factual retrieval. RACE remains close to zero across model sizes, suggesting that the imported memory contributes little to broad reading-comprehension performance when retrieving factual associations is not the primary bottleneck. Figure 3: Downstream task evaluation. Bars report the change in accuracy (� ) produced by transferred memory relative to the no-memory baseline across six downstream tasks. Results are averaged over five seeds. Positive values indicate that transferred memory improves the target model after target-side adaptation on FineWeb-Edu (FW-9B) [27]. TruthfulQA provides the clearest negative boundary. Performance decreases at every target scale, with changes ranging from −0.2-0.2 to −0.8-0.8 accuracy points. Unlike the other evaluated tasks, TruthfulQA rewards calibrated truthfulness and resistance to commonly repeated misconceptions, rather than the recovery of frequently observed factual associations alone. Additional memory-derived associations can therefore be unhelpful when the task requires the model to reject plausible but misleading information. This result defines an important practical limit: transferred memory is most beneficial when the task rewards access to factual or evidence-related information, but it may be neutral or mildly harmful when success depends on calibration or resistance to memorized misconceptions. Figure 3 establishes this task-dependent pattern, but does not by itself identify why it arises. The observed selectivity could reflect the information encoded in the source memory, the distribution used to fit the target-side reader during Phase 2, or a trade-off between specialization and broader distributional robustness. To separate these factors, Appendix D presents a controlled diagnostic sequence. It first varies source-corpus specialization while matching the Phase 2 fitting distribution, then holds the source memory fixed while varying the reader-fitting corpus. It further examines whether mixed-corpus memory can broaden coverage without removing specialist gains, and finally evaluates whether the adapted reader introduces adverse effects on unrelated language-modeling distributions. These supplementary experiments show that source-memory content and Phase 2 distribution alignment affect the magnitude of the realized gains, but do not remove the central downstream boundary. Improvements remain concentrated on tasks that can exploit factual or evidence-related associations, and do not extend uniformly to broader reading comprehension, reasoning, or truthfulness-oriented evaluation. Takeaway. Memory transfer has a high practical ceiling: with a sufficiently expressive target-side reader, cross-model transfer nearly matches same-model reuse and saturates at approximately 38.5–38.8 average QA accuracy. This ceiling, however, is task-dependent rather than universal. Transferred memory provides the clearest gains on factual and evidence-oriented tasks, has little effect on broader reading comprehension, and can be mildly harmful on TruthfulQA, where calibrated resistance to misleading associations is important. 4.4 RQ4: Does transferred memory improve answer-token support in question answering? Our fourth question is whether transferred memory measurably improves support for the correct answer, rather than merely changing final task accuracy in a hard-to-interpret way. By answer-token support, we mean the log-probability that the target model assigns to a valid gold-answer continuation at the positions where that answer is generated. To test this, we compare four inference settings on the same LLaMA-2-7B → Mistral-7B dual-layer QA system used in Table 3: transferred memory, random memory, memory disabled, and an answer-position memory ablation. We compute the length-normalized gold-answer log-probability for an alias a as: sc(i,a),1La∑t=1Lalogpc(yi,ta∣xi,yi,<ta),s_c(i,a) 1L_a _t=1^L_a p_c (y^a_i,t x_i,y^a_i,<t ), (9) where pcp_c is the target model distribution under condition c∈trans,rand,disabled,ablatedc∈\trans,rand,disabled,ablated\, and LaL_a is the token length of alias a. The probability is computed with teacher forcing: the model is given the prompt and the gold-answer prefix, and we evaluate the log-probability assigned to the next gold-answer token. For questions with multiple valid aliases iA_i, the question-level score is: sc(i),maxa∈isc(i,a).s_c(i) _a _is_c(i,a). (10) For datasets with a single annotated answer, iA_i contains only that answer. Finally, the mean score difference over the dataset D is: �logp(c1−c2),1||∑i∈(sc1(i)−sc2(i)), p(c_1-c_2) 1|D| _i (s_c_1(i)-s_c_2(i) ), (11) where D is the evaluation set. In Table 3, we report �logp(trans−rand) p(trans-rand), �logp(trans−disabled) p(trans-disabled), and �logp(trans−ablated) p(trans-ablated). The first two differences ask whether transferred memory helps more than either an untrained table or no memory at all. The third asks whether zeroing the memory channel only at answer-prediction positions reduces gold-answer likelihood. For NQ and TriviaQA, where many examples have multiple valid aliases, the analysis scores all annotated aliases and keeps the best-valid gold continuation rather than forcing the first alias in the dataset. Table 3: QA memory-contribution trained on Wikipedia-2021 analysis for LLaMA-2-7B [37] → Mistral-7B-v0.3 [18] with dual-layer injection. The �logp p columns report mean per-example differences in length-normalized gold-answer log-probability. Positive values indicate that transferred memory makes the gold answer more likely. Task Transferred Random Disabled Ablated �logp p (Trans. - Random) �logp p (Trans. - Disabled) �logp p (Trans. - Ablated) NQ 25.1 20.1 18.3 26.2 +0.035 +0.032 -0.013 WebQA 32.3 27.4 31.1 33.6 +0.147 +0.197 -0.001 TriviaQA 72.5 65.5 58.9 72.5 +0.047 +0.072 -0.000 TruthQA 30.8 32.6 31.7 30.9 -0.581 -0.258 -0.029 HotpotQA 27.1 22.9 18.6 27.2 +0.022 +0.019 -0.009 Transferred memory beats random memory and memory-disabled evaluation on four of the five QA subsets, both in task score and in gold-answer log-probability. The cleanest gains appear on WebQA and TriviaQA. On WebQA, transferred improves mean gold-answer log-probability by +0.147+0.147 over random memory and +0.197+0.197 over memory-disabled inference. On TriviaQA, after fixing alias-aware gold-answer scoring, transferred also improves gold-answer log-probability by +0.047+0.047 over random memory and +0.072+0.072 over memory-disabled inference, aligning the logit-level analysis with the task-level F1 gains. NQ and HotpotQA show the same direction with smaller positive margins. TruthfulQA remains the main negative case. Transferred is worse than both random memory and memory-disabled inference there, both in MC-average and in gold-answer log-probability. This matches the broader boundary condition already visible in RQ3: transferred memory is most useful on factual retrieval-style QA, but not on truthfulness-style calibration. The ablation column sharpens the interpretation. For every task, transferred minus answer-position ablation is near zero or slightly negative rather than strongly positive. That means the main benefit is not coming from a simple direct injection of the correct answer token at the final prediction positions. Instead, the evidence points to an indirect effect: transferred memory improves the model’s overall answer-supporting state on factual QA tasks, but direct answer-token memory contribution is weak and sometimes slightly harmful. Taken together, RQ4 supports a narrower claim than “memory use causes the gain”. The gain is real on NQ, WebQA, TriviaQA, and HotpotQA, and the corrected alias-aware analysis strengthens that claim for TriviaQA in particular. The results are therefore more consistent with improved factual support after target-side integration than with raw answer-position copying. Takeaway. Transferred memory improves answer-token support selectively but positively: transferred memory increases gold-answer support on NQ, WebQA, TriviaQA, and HotpotQA relative to both random memory and no memory, with the corrected alias-aware TriviaQA analysis removing the main contradictory case, while the near-zero answer-position ablation effects indicate that the gain comes more from useful factual support than from direct answer-token injection. 4.5 RQ5: How data-efficient is frozen-memory transfer? We first ask whether frozen-memory transfer reduces the amount of target-side training required to reach competitive performance. Across both Pythia and Qwen model pairs, transferred memory reaches strong intrinsic performance substantially earlier than learning a new memory from scratch, indicating improved target-side data efficiency. The downstream gains are also positive, although their magnitude remains task-dependent. Controlled scaling on Pythia. Table 4 provides a controlled comparison on Pythia-160M → Pythia-410M by tracking the same transfer setting across 5M, 20M, and 50M target-side training tokens. Table 4: Scaling analysis for frozen-memory transfer on Pythia-160M → Pythia-410M. Results report test perplexity as a function of target-side training tokens, averaged over 3 seeds. Condition Trainable Params 5M 20M 50M Transferred 1.05M 21.821.8 21.521.5 21.5†21.5 From scratch 34.6M 21.921.9 21.821.8 21.621.6 †Early stopped at step 1,500 (≈ 12M tokens); validation PPL diverges beyond this point. Transferred memory is already competitive after only 5M target-side tokens and essentially saturates by 20M, reaching a test PPL of 21.5. In contrast, training a new target memory from scratch improves more gradually and approaches a comparable PPL only at the largest token budget. This difference is particularly notable because the transferred condition updates only 1.05M trainable parameters, compared with 34.6M for the from-scratch condition, corresponding to roughly 3%3\% as many trainable parameters. The 50M transferred entry is reported at its best early-stopped checkpoint. Although the nominal training budget is 50M tokens, validation perplexity begins to diverge after approximately 12M tokens, and the best checkpoint therefore matches rather than improves upon the 20M result. Taken together, these results suggest that Phase 2 is primarily adapting and reusing structure already learned in the source memory rather than relearning an equivalent memory representation from the target corpus alone. Scaling to a larger target model. We next test whether the same trend persists at a larger scale using Qwen3.5-0.8B → Qwen3.5-2B. Figure 4 reports both intrinsic perplexity and downstream QA performance as the amount of target-side training data increases. (a) Qwen3.5-2B downstream QA scaling: average zero-shot accuracy across BoolQ, RTE, and SciQ as a function of target-side training tokens. (b) Qwen3.5-2B intrinsic scaling: test perplexity versus target-side training tokens for scratch and transferred memory. Figure 4: Target-side scaling for Qwen3.5-0.8B → Qwen3.5-2B with the source memory trained on WikiText-103. Transferred memory maintains a consistent intrinsic perplexity advantage, while downstream improvements remain positive but task-dependent. The Qwen results reinforce the Pythia scaling study. Transferred adaptation achieves lower test perplexity than scratch training across all evaluated target-side token budgets, showing that the intrinsic data-efficiency advantage is not restricted to the smaller Pythia setting. The downstream results show a similar but less uniform trend: transferred memory improves BoolQ, RTE, and SciQ by +1.5+1.5, +2.5+2.5, and +0.8+0.8 points, respectively. These results also clarify the distinction between intrinsic adaptation and downstream utility. The perplexity advantage of transfer is stable across token budgets, whereas the magnitude of downstream improvement depends on the task. Thus, transferred memory provides a consistently better target-side initialization, but the extent to which this advantage translates into downstream accuracy still depends on whether the reader can extract and route the stored signal in a task-compatible manner. Takeaway. Frozen-memory transfer is target-data efficient: it reaches strong perplexity with substantially fewer target-side updates than learning a new memory from scratch, while downstream gains remain positive but task-dependent. 4.6 RQ6: What drives the gains from memory transfer? Having established the target-side data-efficiency advantage of transfer, we next ask what actually drives the downstream gains. In particular, we test whether the improvement can be explained simply by adding trainable target-side parameters, or whether successful transfer depends on the transferred memory content, its addressing structure, and the reader used to access it. We study this question on LLaMA-2-7B [37] → Mistral-7B-v0.3 [18] using the same dual-layer QA setting that produces our strongest downstream results. Table 5 compares the full transferred reader against controls designed to isolate the main components of the transfer mechanism. “Transferred (R=4R=4)” denotes the full dual-layer four-branch reader. “No gate” removes context-dependent gating and always injects memory values. “Affine stitch” replaces the reader with a single affine memory-to-hidden-state mapping. “Permuted keys” preserves the memory table but destroys addressing integrity through index permutation. “Random memory” replaces the learned memory table with an untrained one. “Train from scratch” learns a fresh target memory under the same downstream training setup. Finally, “FFN only” replaces memory lookup with a parameter-matched residual feed-forward module, while “No memory baseline” corresponds to the underlying Mistral-7B model without memory augmentation. Table 5: Ablation study of frozen-memory transfer on LLaMA-2-7B → Mistral-7B-v0.3, with the source memory trained on Wikipedia-2021. Results report held-out test perplexity and downstream QA performance. Condition Test PPL ↓ 95% CI NQ WebQA TriviaQA TruthQA HotpotQA Avg ↑ No memory baseline 9.99.9 [9.8,10.1][9.8,10.1] 20.620.6 29.329.3 57.757.7 32.132.1 21.021.0 32.132.1 Transferred (R=4R=4) 8.78.7 [8.6,8.9][8.6,8.9] 30.330.3 33.733.7 69.969.9 30.930.9 27.627.6 38.538.5 Interface Simplifications No gate 10.110.1 [9.9,10.3][9.9,10.3] 24.224.2 27.727.7 61.661.6 31.031.0 24.124.1 33.733.7 Affine stitch 9.59.5 [9.4,9.7][9.4,9.7] 25.025.0 29.229.2 62.862.8 30.430.4 23.923.9 34.334.3 Content and Training Controls Permuted keys 8.78.7 [8.5,8.8][8.5,8.8] 18.318.3 34.534.5 57.757.7 30.630.6 21.421.4 32.532.5 Random memory 8.78.7 [8.6,8.9][8.6,8.9] 23.023.0 27.127.1 65.165.1 33.633.6 24.124.1 34.634.6 Train from scratch 8.18.1 [8.0,8.2][8.0,8.2] 29.929.9 33.033.0 70.470.4 30.930.9 27.927.9 38.438.4 No-memory Control FFN only (param-matched R=4R=4) 7.47.4 [7.2,7.5][7.2,7.5] 25.525.5 27.927.9 64.164.1 31.631.6 23.623.6 34.534.5 Parameter count alone does not explain the gains. The full transferred reader improves average QA from 32.1 for the no-memory baseline to 38.5. More importantly, it clearly outperforms the parameter-matched FFN control, which reaches only 34.5 average accuracy. The difference cannot be attributed to intrinsic language-model fit: the FFN-only control actually obtains the lowest perplexity in the table (7.4 versus 8.7 for transfer), yet remains 4.0 points behind on average QA. The task-level results show the same pattern. The transferred reader outperforms the parameter-matched FFN on NQ, WebQA, TriviaQA, and HotpotQA, with particularly clear margins on NQ (30.330.3 versus 25.525.5), TriviaQA (69.969.9 versus 64.164.1), and HotpotQA (27.627.6 versus 23.623.6). The FFN control is slightly stronger only on TruthQA. Thus, simply attaching an equally parameterized target-side residual module does not reproduce the downstream behavior of transferred memory. The reader interface is critical. Removing context-dependent gating reduces average QA from 38.5 to 33.7, a drop of 4.8 points. Replacing the reader with a single affine stitch similarly reduces the average to 34.3, a 4.2-point decrease. These results indicate that transfer quality depends not only on the presence of a memory table, but also on a sufficiently expressive interface for selecting, transforming, and routing retrieved information into the target model. Addressing integrity and memory structure matter. Permuting the memory keys while retaining the same underlying table reduces average QA from 38.5 to 32.5. This is the largest degradation among the memory-content controls and shows that preserving the association between addresses and stored values is important for downstream reuse. Replacing the transferred table with random memory also decreases average QA to 34.6. Interestingly, random memory achieves the same test PPL as the transferred condition (8.7), yet performs substantially worse on downstream QA. This provides another example in which intrinsic perplexity alone does not predict whether a memory representation will be useful for downstream tasks. Transfer primarily improves initialization rather than the asymptotic ceiling. Training a fresh target memory from scratch eventually reaches an average QA score of 38.4, essentially matching the 38.5 obtained by transfer. We therefore do not interpret transfer as providing a substantially higher asymptotic performance ceiling. Instead, together with the scaling results in Section 4.5, the evidence supports a more specific interpretation: the transferred memory provides a structured initialization that can reach useful target-side performance with substantially less adaptation than learning an equivalent memory representation from scratch. This distinction also explains why perplexity and downstream QA do not rank all controls identically. For example, the parameter-matched FFN reaches the best intrinsic PPL but substantially worse QA, while scratch memory eventually matches transferred QA after sufficient target-side optimization. Successful transfer therefore depends on the interaction between memory structure, addressing, and the reader interface, rather than on parameter count or perplexity reduction alone. Takeaway. The downstream gains cannot be explained by parameter count alone: successful transfer depends on meaningful memory addressing and a sufficiently expressive reader interface, while its main advantage over scratch training is better target-side data efficiency rather than a higher asymptotic ceiling. 5 Conclusion We study whether a learned external memory remains useful after it is detached from the backbone that trained it and attached to a different one. For Engram-style hashed memory, the answer is yes: frozen memory improves the target across tokenizers, hidden sizes, and architectures, including every cell of the main 3×33× 3 transfer matrix and both directions of peer transfer. The main lesson is that portability depends not only on the frozen table but also on the target-side reader: stronger readers nearly close the same-model/cross-model gap on QA, and transferred memory clearly beats permuted-key and FFN-only controls while substantially outperforming random memory on the final QA evaluation. More broadly, cross-model frozen-memory extraction turns external-memory portability into an evaluation framework: a memory artifact should be judged by whether a new backbone can address it, align to it, and extract useful signal without retraining the stored table. Acknowledgments The authors wish to acknowledge CSC – IT Center for Science, Finland, for computational resources. Computational facilities were provided by the UTS eResearch High Performance Computer Cluster. Shaoxiong Ji gratefully acknowledges the support of Foundation PS through the PS Fellowship. References Abouelenin et al. (2025) A. Abouelenin, A. Ashfaq, A. Atkinson, H. Awadalla, N. Bach, J. Bao, A. Benhaim, M. Cai, V. Chaudhary, C. Chen, et al. Phi-4-mini technical report: compact yet powerful multimodal language models via mixture-of-loras. arXiv preprint arXiv:2503.01743. External Links: Link Cited by: §B.1, §C.3, §1. Behrouz and Zhong (2025) A. Behrouz and P. Zhong Titans: learning to memorize at test time. arXiv preprint arXiv:2501.00663. External Links: Link Cited by: §2.2. Berant et al. (2013) J. Berant, A. Chou, R. Frostig, and P. Liang Semantic parsing on freebase from question-answer pairs. In Proceedings of the 2013 conference on empirical methods in natural language processing, p. 1533–1544. Cited by: §B.3. Berges et al. (2025) V. Berges, B. Oguz, D. HAZIZA, W. Yih, L. Zettlemoyer, and G. Ghosh Memory layers at scale. In Forty-second International Conference on Machine Learning, External Links: Link Cited by: §2.2. Biderman et al. (2023) S. Biderman, H. Schoelkopf, Q. G. Anthony, H. Bradley, K. O’Brien, E. Hallahan, M. A. Khan, S. Purohit, U. S. Prashanth, E. Raff, A. Skowron, L. Sutawika, and O. van der Wal Pythia: a suite for analyzing large language models across training and scaling. In Proceedings of the 40th International Conference on Machine Learning (ICML), External Links: Link Cited by: §B.1, §1, §4.1. Borgeaud et al. (2022) S. Borgeaud, A. Mensch, J. Hoffmann, T. Cai, E. Rutherford, K. Millican, G. van den Driessche, J. Lespiau, B. Damoc, A. Clark, D. de Las Casas, A. Guy, J. Menick, R. Ring, T. Hennigan, S. Huang, L. Maggiore, C. Jones, A. Cassirer, A. Brock, M. Paganini, G. Irving, O. Vinyals, S. Osindero, K. Simonyan, J. W. Rae, E. Elsen, and L. Sifre Improving language models by retrieving from trillions of tokens. In Proceedings of the 39th International Conference on Machine Learning (ICML), p. 2206–2240. External Links: Link Cited by: §2.2. Chen et al. (2025) A. Chen, J. Merullo, A. Stolfo, and E. Pavlick Transferring linear features across language models with model stitching. External Links: 2506.06609, Link Cited by: §A.4, §2.3. Cheng et al. (2026) X. Cheng, W. Zeng, D. Dai, Q. Chen, B. Wang, Z. Xie, K. Huang, X. Yu, Z. Hao, Y. Li, H. Zhang, H. Zhang, D. Zhao, and W. Liang Conditional memory via scalable lookup: a new axis of sparsity for large language models. arXiv preprint arXiv:2601.07372. External Links: Link Cited by: §1, §2.1. Clark et al. (2019) C. Clark, K. Lee, M. Chang, T. Kwiatkowski, M. Collins, and K. Toutanova BoolQ: exploring the surprising difficulty of natural yes/no questions. In Proceedings of NAACL-HLT, p. 2924–2936. Cited by: §B.3. Dagan et al. (2006) I. Dagan, O. Glickman, and B. Magnini The PASCAL recognising textual entailment challenge. In Machine Learning Challenges. Evaluating Predictive Uncertainty, Visual Object Classification, and Recognising Tectual Entailment, J. Quiñonero-Candela, I. Dagan, B. Magnini, and F. d’Alché-Buc (Eds.), Berlin, Heidelberg, p. 177–190. External Links: ISBN 978-3-540-33428-6 Cited by: §B.3. Dai et al. (2024) D. Dai, C. Deng, C. Zhao, R. X. Xu, H. Gao, D. Chen, J. Li, W. Zeng, X. Yu, Y. Wu, Z. Xie, Y. K. Li, P. Huang, F. Luo, C. Ruan, Z. Sui, and W. Liang DeepSeekMoE: towards ultimate expert specialization in mixture-of-experts language models. arXiv preprint arXiv:2401.06066. External Links: Link Cited by: §2.2. Farhadzadeh et al. (2025) F. Farhadzadeh, D. Das, S. Borse, and F. Porikli LoRA-x: bridging foundation models with training-free cross-model adaptation. External Links: 2501.16559, Link Cited by: §2.3. Fedus et al. (2022) W. Fedus, B. Zoph, and N. Shazeer Switch transformers: scaling to trillion parameter models with simple and efficient sparsity. Journal of Machine Learning Research 23 (120), p. 1–39. External Links: Link Cited by: §2.2. Graves et al. (2014) A. Graves, G. Wayne, and I. Danihelka Neural turing machines. External Links: 1410.5401, Link Cited by: §2.2. Hu et al. (2022) E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen LoRA: low-rank adaptation of large language models. In Proceedings of the 10th International Conference on Learning Representations (ICLR), External Links: Link Cited by: Table 12, Table 1. Huh et al. (2024) M. Huh, B. Cheung, T. Wang, and P. Isola The platonic representation hypothesis. In Proceedings of the 41st International Conference on Machine Learning (ICML), External Links: Link Cited by: §A.4, §2.3. Izacard et al. (2023) G. Izacard, P. Lewis, M. Lomeli, L. Hosseini, F. Petroni, T. Schick, J. Dwivedi-Yu, A. Joulin, S. Riedel, and E. Grave Atlas: few-shot learning with retrieval augmented language models. Journal of Machine Learning Research 24 (251), p. 1–43. External Links: Link Cited by: §B.3, §2.2, Table 1, Table 1. Jiang et al. (2023) A. Q. Jiang, A. Sablayrolles, A. Mensch, C. Bamford, D. S. Chaplot, D. de las Casas, F. Bressand, G. Lengyel, G. Lample, L. Saulnier, L. R. Lavaud, M. Lachaux, P. Stock, T. L. Scao, T. Lavril, T. Wang, T. Lacroix, and W. E. Sayed Mistral 7b. External Links: 2310.06825, Link Cited by: §B.1, §1, §4.6, Table 3, Table 3. Joshi et al. (2017) M. Joshi, E. Choi, D. S. Weld, and L. Zettlemoyer Triviaqa: a large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 1601–1611. Cited by: §B.3. Khandelwal et al. (2020) U. Khandelwal, O. Levy, D. Jurafsky, L. Zettlemoyer, and M. Lewis Generalization through memorization: nearest neighbor language models. In Proceedings of the 8th International Conference on Learning Representations (ICLR), External Links: Link Cited by: Table 12, §1, §2.2, Table 1. Kornblith et al. (2019) S. Kornblith, M. Norouzi, H. Lee, and G. E. Hinton Similarity of neural network representations revisited. In Proceedings of the 36th International Conference on Machine Learning (ICML), External Links: Link Cited by: §A.4, §C.5, §2.3. Kwiatkowski et al. (2019) T. Kwiatkowski, J. Palomaki, O. Redfield, M. Collins, A. Parikh, C. Alberti, D. Epstein, I. Polosukhin, J. Devlin, K. Lee, et al. Natural questions: a benchmark for question answering research. Transactions of the Association for Computational Linguistics 7, p. 453–466. Cited by: §B.3. Lai et al. (2017) G. Lai, Q. Xie, H. Liu, Y. Yang, and E. Hovy RACE: large-scale reading comprehension dataset from examinations. In Proceedings of EMNLP, p. 785–794. Cited by: §B.3. Lample et al. (2019) G. Lample, A. Sablayrolles, M. Ranzato, L. Denoyer, and H. Jégou Large memory layers with product keys. In Advances in Neural Information Processing Systems 32 (NeurIPS), External Links: Link Cited by: §2.2. Lewis et al. (2020) P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W. Yih, T. Rocktäschel, S. Riedel, and D. Kiela Retrieval-augmented generation for knowledge-intensive NLP tasks. In Advances in Neural Information Processing Systems 33 (NeurIPS), External Links: Link Cited by: §1, §2.2, Table 1. Lin et al. (2022) S. Lin, J. Hilton, and O. Evans TruthfulQA: measuring how models mimic human falsehoods. In Proceedings of ACL, p. 3214–3252. Cited by: §B.3, §B.3. [27] A. Lozhkov, L. B. Allal, L. von Werra, and T. Wolf Fineweb-edu: the finest collection of educational content, 2024. URL https://huggingface. co/datasets/HuggingFaceFW/fineweb-edu. Cited by: §B.3, §D.1, Figure 3, Figure 3. Merity et al. (2017) S. Merity, C. Xiong, J. Bradbury, and R. Socher Pointer sentinel mixture models. In Proceedings of the 5th International Conference on Learning Representations (ICLR), External Links: Link Cited by: §B.3, §B.3, §D.5. Mihaylov et al. (2018) T. Mihaylov, P. Clark, T. Khot, and A. Sabharwal Can a suit of armor conduct electricity? a new dataset for open book question answering. In Proceedings of EMNLP, p. 2381–2391. Cited by: §B.3. Mikolov et al. (2013) T. Mikolov, Q. V. Le, and I. Sutskever Exploiting similarities among languages for machine translation. arXiv preprint arXiv:1309.4168. External Links: Link Cited by: §A.4, §2.3. Paperno et al. (2016) D. Paperno, G. Kruszewski, A. Lazaridou, N. Q. Pham, R. Bernardi, S. Pezzelle, M. Baroni, G. Boleda, and R. Fernández The LAMBADA dataset: word prediction requiring a broad discourse context. In Proceedings of the 54th Annual Meeting of the Association for Computational Linguistics (ACL), p. 1525–1534. External Links: Document Cited by: §B.3, §D.5. Qwen Team (2025) Qwen Team Qwen3 technical report. arXiv preprint arXiv:2505.09388. Cited by: §B.1, §1, §4.1. Raffel et al. (2020) C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, and P. J. Liu Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research 21 (140), p. 1–67. Cited by: §B.3, §D.5. Sanjeev and Troynikov (2024) S. Sanjeev and A. Troynikov Embedding adapters. Technical report Chroma. Note: Accessed on July 8, 2024 External Links: Link Cited by: §A.4. Shazeer et al. (2017) N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. V. Le, G. E. Hinton, and J. Dean Outrageously large neural networks: the sparsely-gated mixture-of-experts layer. In Proceedings of the 5th International Conference on Learning Representations (ICLR), External Links: Link Cited by: §2.2. Su et al. (2025) D. Su, K. Kong, Y. Lin, J. Jennings, B. Norick, M. Kliegl, M. Patwary, M. Shoeybi, and B. Catanzaro Nemotron-c: transforming common crawl into a refined long-horizon pretraining dataset. External Links: 2412.02595, Link Cited by: §B.3. Touvron et al. (2023) H. Touvron, L. Martin, K. Stone, P. Albert, A. Almahairi, Y. Babaei, N. Bashlykov, S. Batra, P. Bhargava, S. Bhosale, et al. Llama 2: open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288. Cited by: §B.1, §1, §4.6, Table 3, Table 3. Wang et al. (2024) R. Wang, S. Ghosh, D. Cox, D. Antognini, A. Oliva, R. Feris, and L. Karlinsky Trans-LoRA: Towards data-free transferable parameter efficient finetuning. External Links: 2405.17258, Link Cited by: §2.3. Wei et al. (2026) R. Wei, J. Cao, J. Wang, J. Kai, Q. Guo, B. Zhou, and Z. Lin MLP memory: a retriever-pretrained memory for large language models. External Links: 2508.01832, Link Cited by: §B.3, §1, §1, §2.2, Table 1. Welbl et al. (2017) J. Welbl, N. F. Liu, and M. Gardner Crowdsourcing multiple choice science questions. In Proceedings of the 3rd Workshop on Noisy User-generated Text, p. 94–106. Cited by: §B.3. Weston et al. (2015) J. Weston, S. Chopra, and A. Bordes Memory networks. External Links: 1410.3916, Link Cited by: §2.2. Xia et al. (2025) F. Xia, M. Liao, Y. Fang, D. Li, Y. Xie, W. Li, Y. Li, D. Xia, and J. Huang Cross-lora: a data-free lora transfer framework across heterogeneous llms. External Links: 2508.05232, Link Cited by: Table 12, §2.3. Yang et al. (2018) Z. Yang, P. Qi, S. Zhang, Y. Bengio, W. Cohen, R. Salakhutdinov, and C. D. Manning HotpotQA: a dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 conference on empirical methods in natural language processing, p. 2369–2380. Cited by: §B.3. Zhang et al. (2024) P. Zhang, G. Zeng, T. Wang, and W. Lu TinyLlama: an open-source small language model. arXiv preprint arXiv:2401.02385. External Links: Link Cited by: §B.1, §1, §4.1. Appendix A Supplementary Formalization and Method Details This section supplies notation and formal details for Section 3. A.1 Notations Table 6 summarizes the notation used throughout this paper. Table 6: Notation used throughout this paper. Symbol Meaning A,BA,B Source model and target model, respectively. dA,dBd_A,d_B Hidden dimensions of source model A and target model B, respectively. ℰAE_A Frozen Engram memory artifact learned with source model A, comprising the tables En,k\E_n,k\. En,kE_n,k Memory table associated with N-gram order n and hash head k, where En,k∈RM×dheadE_n,k ^M× d_head. NmaxN_ Maximum N-gram order used for memory addressing, with n∈2,…,Nmaxn∈\2,…,N_ \. K Number of independent hash heads for each N-gram order. H Total number of hash heads, H=(Nmax−1)KH=(N_ -1)K. M Number of rows in each hash-head memory table. dheadd_head Dimensionality of the embedding row retrieved from one hash-head table. te_t Concatenated memory vector retrieved at token position t. dmemd_mem Dimensionality of te_t, where dmem=Hdheadd_mem=Hd_head. P Canonicalization function mapping a raw decoded string to its canonical form. V,V′V,V Raw vocabulary and canonical vocabulary, respectively. φn,k _n,k Deterministic hash function for N-gram order n and hash head k. t,ℓh_t, Target-backbone hidden state at token position t and layer ℓ . ℒL Set of target-backbone layers at which memory readers are injected. S Number of memory injection sites, S=|ℒ|S=|L|. R Number of reader branches at each injection site. K,ℓ,r(B)W_K, ,r^(B) Branch-specific key-projection matrix for branch r at target layer ℓ . V,ℓ(B)W_V, ^(B) Value-projection matrix shared across the R branches at target layer ℓ . αt,ℓ(r) _t, ^(r) Context-aware scalar gate for token t, layer ℓ , and branch r. βℓ,r _ ,r Learnable scalar gate bias for branch r at injection layer ℓ . (B)W^(B) Complete target-side reader parameter set, including all key and value projections, normalization parameters, and gate biases. b,Tb,T Batch size and sequence length, respectively. A.2 Memory Transfer Conditions Let model A be a source model equipped with a trained Engram memory table ℰAE_A, and let model B be a target model with hidden dimension dBd_B, tokenizer BT_B, and potentially a different architecture. We ask whether the frozen memory ℰAE_A can provide extractable external knowledge to B through a lightweight reader (B)W^(B), even when dB,dAd_B≠ d_A and B,AT_B _A. We allow lightweight target-side reader training, and we do not assume zero-data or universal transfer across all memory architectures. Under this scope, successful extraction is meaningful only if three conditions can be met simultaneously: • Deterministic addressing: memory lookup indices depend only on the input token sequence through a fixed canonicalization-and-hashing pipeline. They do not depend on the backbone’s internal hidden states. The same text can therefore map to the same memory entries across backbones, provided the key pipeline is standardized. • Architectural decoupling: the memory table ℰE is extracted through learned projection matrices KW_K and VW_V. These projections are natural reader interfaces because they already mediate between the memory space and the backbone hidden space. • Gate-based robustness: even if some transferred memory entries are imperfectly aligned, the sigmoid gate αt _t can softly suppress their contribution. In practice, this requires the reader to learn a sufficiently negative match score and/or bias for unhelpful memory, thereby reducing interference with the hidden state. The remainder of this section turns these conditions into a concrete decomposition. The key space determines which memory slot is selected for a piece of text (Section A.3); the value space determines how the vector stored in that slot is interpreted by the target backbone (Section A.4). Transfer, therefore, requires both address agreement and a reader that maps the retrieved vector into the target residual stream, with gating available to limit interference when alignment is incomplete (Section A.5). A.3 Key-Space Unification The first obstacle is address compatibility. In Engram’s original design, the hash key is computed over model-specific canonical token IDs. For example, if model A assigns token ID 1823 to “San” and model B assigns ID 47, the resulting hash indices differ even when the underlying text is the same, so the two models would read unrelated memory entries. To remove this mismatch, we define a tokenizer-agnostic canonical key pipeline. Let decode(⋅)decode(·) denote the mapping from a tokenizer’s token sequence to its surface string. For a shared decoded text prefix, both models first normalize the same surface form before hashing: (decode(A(x1:tAtext)))=(decode(B(x1:tBtext))),P\! (decode(T_A(x^text_1:t_A)) )=P\! (decode(T_B(x^text_1:t_B)) ), (12) where xtext1:tAx^text_1:t_A and xtext1:tBx^text_1:t_B denote source and target token prefixes that decode to the same text span, and P applies NFKC normalization, lowercasing, and accent stripping. In this construction, both models map the same decoded text to the same canonical form before hashing, so they can compute identical lookup indices into the shared memory table. Subword boundary misalignment. The remaining difficulty is that tokenizers may segment the same word into different subword sequences. Three mitigations are available, in increasing order of robustness: (i) the original NFKC-based canonicalization when vocabularies overlap heavily; (i) word-boundary N-grams computed over decoded strings; and (i) character- or byte-level N-gram hashing. We adopt strategy (i) as a practical middle ground: it substantially reduces tokenizer dependence without moving all the way to byte-level modeling. Our current experiments cover GPT-NeoX (Pythia), LLaMA, Qwen, and Phi tokenizers; languages or tokenizers without clean word boundaries may require the byte-level alternative. A.4 Value-Space Alignment via Reader Key agreement ensures that the target model reads the same memory entry as the source model; it does not ensure that the retrieved vector is meaningful in the target residual stream. Model A’s memory vectors t∈Rdmeme_t ^d_mem were shaped by gradients flowing through A’s hidden geometry, which model B does not share. Research on embedding space alignment [30, 21, 34] suggests that representational spaces of models trained on similar data are often related by an approximately linear transformation. The Platonic Representation Hypothesis [16] offers one interpretation of this phenomenon, and 7 showed empirically that affine maps can transfer linear features across LLMs. This motivates the smallest plausible bridge between source memory and target backbone: V(B):Rdmem→RdB,K(B):Rdmem→RdB.W_V^(B):R^d_mem ^d_B, _K^(B):R^d_mem ^d_B. (13) The memory table ℰAE_A remains frozen; only the reader parameters (B)W^(B) are trained. For typical configurations (dmem=512d_mem=512, dB=4096d_B=4096), the reader size is |(B)|=2⋅dmem⋅dB+2⋅dB≈4.2M.|W^(B)|=2· d_mem· d_B+2· d_B≈ 4.2M. (14) This is well within the LoRA-scale budget and small relative to multi-billion-parameter backbones. The linear choice is deliberate: it isolates whether cross-model reuse is already feasible under a minimal alignment assumption before introducing richer readers. A.5 Gating as a Robustness Mechanism The transfer mechanism also needs a fallback when the transferred memory is unhelpful. The context-aware gate provides exactly such a mechanism. If a memory entry is poorly aligned, for example because of a hash collision or because the source geometry does not translate cleanly to the target, the key vector t=K(B)tk_t=W_K^(B)e_t will be geometrically dissimilar to the backbone query th_t. By learning a sufficiently negative match score or bias in those cases, the reader can push αt _t toward zero and suppress the memory contribution. The model can therefore tolerate a non-trivial amount of noisy or only partially aligned transferred memory without forcing that signal into the residual stream. This self-suppression is analogous to a soft mask in attention, but it operates on the memory channel itself and requires no explicit confidence model. A.6 Comparison with Existing Knowledge-Augmentation Methods and Native Engram Our source memory and target reader are trained with next-token prediction rather than task-specific labels. Consequently, a single fitted reader can be evaluated across multiple downstream tasks without being retrained for each task. This does not, however, imply universal downstream improvements. As shown in RQ5 (Section 4.5), transferred memory provides stable intrinsic perplexity gains, whereas downstream improvements remain task-dependent and depend on the alignment among the memory corpus, target model, reader interface, and evaluation objective. Table 7 situates frozen-memory extraction relative to retrieval-based, native-memory, and model-editing approaches. The main design distinction is that our method retains an explicit external memory while making the stored artifact portable across backbones through reader-only fitting. Table 7: Qualitative comparison of knowledge augmentation approaches. ✓ = fully supported, ∘ = partially supported, ✗ = not supported. Property KNN-LM RAG RETRO Mem. Layers LLM Mod. Engram Ours O(1)O(1) retrieval ✗ ✗ ✗ ✗ ✗ ✓ ✓ Parametric (trained) ✗ ✗ ✓ ✓ ✓ ✓ ✓ Cross-model portable ✗ ✓ ✗ ✗ ∘ ✗ ✓ Surgical deletion ✗ ✓ ✗ ✗ ✗ ✓ ✓ No context overhead ✗ ✗ ∘ ✓ ✓ ✓ ✓ Reader-only integration N/A N/A ✗ ✗ ✗ ✗ ✓ Differences from Native Engram Table 8 makes the architectural changes explicit at the formula level. Relative to native Engram, the transfer-oriented version uses shared canonical hashing, freezes the exported table, and replaces within-block integration with a target-side residual reader. Table 8: Formula-level comparison between original Engram and our transfer-oriented reader. We replace the native within-block module with a target-side reader over frozen hashed memory. Aspect Original Engram Transfer-oriented Engram Reader Memory indexing Layer-specific compressed-token n-gram hashing: rt(l,n,j)=(⨁k=0n−1c(xt−k)⋅ak(l))modpl,n,jr_t^(l,n,j)= ( _k=0^n-1c(x_t-k)· a_k^(l) ) p_l,n,j Shared canonical hashing: rt(n,j)=(H(canon_ngramt(n))⊕sj)modMr_t^(n,j)= (H(canon\_ngram_t^(n)) s_j ) M Memory representation Layer-specific Engram embedding: et(l)=Concatn,jl,n,j[rt(l,n,j)]e_t^(l)=Concat_n,jE_l,n,j[r_t^(l,n,j)] Shared memory vector: mt=Concatjj[rt(j)](dmem=512)m_t=Concat_jT_j[r_t^(j)] 9.24994pt(d_mem=512) Key / gate st s_t =⟨RMSNorm(Wket),RMSNorm(ht)⟩d = (W_ke_t),RMSNorm(h_t) d αt _t =σ(sign(st)|st|) =σ\! (sign(s_t) |s_t| ) kt(r)=Wk(r)mt,vt=Wvmtk_t^(r)=W_k^(r)m_t, 9.24994ptv_t=W_vm_t αt(r)=σ(⟨RMSNorm(ht),RMSNorm(kt(r))⟩d+βr) _t^(r)=σ\! ( (h_t),RMSNorm(k_t^(r)) d+ _r ) Output update ut=αtWvet,ot=ut+ShortConv(ut)u_t= _tW_ve_t, 9.24994pto_t=u_t+ShortConv(u_t) ot=1R∑r=1Rαt(r)vt,ht←ht+oto_t= 1R _r=1^R _t^(r)v_t, 9.24994pth_t← h_t+o_t Branch structure Native multi-branch inside backbone Explicit reader branches (R controls capacity) Injection Internal transformer block component Post-layer hook injection (e.g., layers 2 and 10) Training Joint training with backbone Two-stage: source training + frozen memory + target reader fitting Appendix B Implementation Details B.1 Models We evaluate transfer across six independently developed model families with different architectures, tokenizers, and parameter scales: Pythia [5], TinyLlama [44], Qwen3.5 [32], Phi-4-mini [1], LLaMA 2 [37], and Mistral [18]. These choices are designed to separate several sources of transfer difficulty, including model scale, architectural mismatch, tokenizer mismatch, and differences in pre-training or post-training. The main transfer matrix uses Pythia, Qwen3.5, and TinyLlama because together they provide both same-family and cross-family transfer settings across a wide range of model sizes. The Pythia pair offers a controlled same-tokenizer comparison, while transfers to TinyLlama and Qwen3.5 introduce a tokenizer and architectural mismatch. The peer-transfer study adds Phi-4-mini to test whether memory remains portable between similarly scaled but independently trained model families, rather than only from smaller to larger models. The corpus-matched downstream suite uses Qwen3.5 source and target models, so that source scale, target scale, and corpus alignment can be varied within a single model family while keeping the broader architecture and tokenizer family controlled. This makes it easier to attribute downstream differences to memory content, target capacity, and reader fitting, rather than to unrelated model-family-level changes. The QA experiments in Table 1 and associated ablations use LLaMA 2 as the memory source and Mistral as the target backbone. This pair provides a stronger cross-family setting at the 7B scale, with comparable model capacity but independently trained backbones and distinct tokenization and representation spaces. It therefore offers a demanding test of whether the reader can recover useful factual knowledge from a frozen source memory without relying on parameter scale or within-family compatibility. Table 9 lists the checkpoints, experimental roles, hidden dimensions, checkpoint types, and tokenizer families used in these experiments. Table 9: Models and checkpoints used in the transfer experiments. “Source” denotes memory construction, and “target” denotes reader fitting for a frozen memory. Here, d is the residual hidden size used by the memory interface. Family Model Experimental role Params. d Checkpoint Hugging Face identifier Pythia Pythia-160M Source: main matrix 160M 768 Base EleutherAI/pythia-160m Pythia-410M Target: main matrix 410M 1024 Base EleutherAI/pythia-410m Qwen3.5 Qwen3.5-0.8B Source: main matrix, scaling Target: downstream 0.8B 1024 Base Qwen/Qwen3.5-0.8B-Base Qwen3.5-2B Target: scaling, downstream 2B 2048 Base Qwen/Qwen3.5-2B-Base Qwen3.5-4B Source: peer, downstream Target: main matrix, peer, scaling, downstream 4B 2560 Base Qwen/Qwen3.5-4B-Base Qwen3.5-9B Source: main matrix, downstream Target: scaling, downstream 9B 4096 Base Qwen/Qwen3.5-9B-Base TinyLlama TinyLlama-1.1B Target: main matrix 1.1B 2048 Chat-/instruction- tuned TinyLlama/TinyLlama-1.1B-Chat-v1.0 Phi Phi-4-mini-instruct Source and target: peer transfer 3.8B 3072 Instruction-tuned microsoft/Phi-4-mini-instruct LLaMA 2 LLaMA-2-7B Source: open-domain QA, ablation 7B 4096 Base meta-llama/Llama-2-7b-hf Mistral Mistral-7B-v0.3 Target: open-domain QA, ablation Source: self-transfer control 7B 4096 Base mistralai/Mistral-7B-v0.3 Pythia uses the GPT-NeoX tokenizer, and the Qwen3.5 models share the Qwen3.5 tokenizer. TinyLlama and LLaMA-2 use LLaMA-family tokenizers, Phi-4-mini-instruct uses the tokenizer distributed with the Phi checkpoint, and Mistral-7B-v0.3 uses the Mistral tokenizer. These differences in the tokenizer and hidden size require the target reader to bridge representational and, in cross-tokenizer settings, tokenization boundaries rather than simply reusing a dimension-compatible memory interface. B.2 Architecture Configuration Memory Configuration The source Engram memory uses Nmax=3N_ =3 (bigram and trigram), K=4K=4 hash heads per order, table size M=65,536M=65,536, and head dimension dhead=64d_head=64, yielding dmem=512d_mem=512 and approximately 33.5M total memory parameters. Reader Configuration We use the reader configuration appropriate to each experimental regime rather than fitting a separate reader for each evaluation benchmark. For the experiments in Table 1, we use a single-layer one-branch reader, a dual-layer one-branch reader, and a stronger dual-layer, four-branch reader. Table 1 seems to be about different readers. For the LLaMA-2-7B → Mistral-7B-v0.3 transfer ablation experiments in Table 5, memory is injected at layers 2 and 10, with four branch-specific key/gating paths at each site and a shared value projection. This reader is fitted with 2048-token Wikipedia-2021 sequences and is then applied zero-shot to the task prompts, without task-specific reader training. For the other experiments, we use the minimal single-layer, single-branch reader from Section 3.2. The reader is attached at the default relative depth L/3L/3, where L is the number of transformer layers, and the target backbone and exported memory remain frozen while only the reader is optimized. The reader is fitted with the default 512-token training sequences and is then applied zero-shot to the task prompts, without task-specific reader training. These configuration choices reflect the purpose of each experiment. The QA reader-design study in Table 1 intentionally varies reader depth and branch capacity to measure how interface expressivity affects extraction from frozen memory, while the ablation study in Table 5 uses the strongest validated reader to isolate the roles of gating, addressing, and memory content. B.3 Data, Training and Evaluation We select the training corpora to match the purpose of each experimental regime rather than using a single corpus throughout. WikiText-103 provides a compact and reproducible language-modeling benchmark for the controlled transfer matrix, scaling, and representation analyses. FineWeb-Edu and the Nemotron-C subsets provide substantially broader and more domain-diverse text for studying downstream transfer and corpus alignment. The five QA (NQ, WebQA, TriviaQA, TruthQA, HotpotQA) experiments use Wikipedia-2021 because their evaluation tasks emphasize factual and encyclopedic knowledge. Finally, LAMBADA, WikiText-103, and C4 are used in the distribution-shift experiments so that each fitted reader can be evaluated both on its training distribution and on corpora with different genres, structures, and provenances. For Figures 2(b), 4(b) and 5 and Tables 11 and 4 experiments, we use WikiText-103 [28]. The loader removes empty records, tokenizes each remaining text with the active model tokenizer without special tokens, concatenates the resulting token stream, and partitions it into fixed, non-overlapping sequences. The standard sequence length is 512 tokens; the standard train and test splits are used for training and final evaluation, respectively. Because the loader discards the incomplete final sequence and the evaluation data are batched with “drop-last”, the test loader contains 34 or 36 batches in the standard runs due to tokenizer-dependent token counts, rather than because the evaluation size is manually set to one of those values. For experiments in Figure 3 and Tables 16, 17 and 20, we use FineWeb-Edu [27] (HuggingFaceFW/fineweb-edu, “sample-10BT”), a broad educational web corpus, for source-memory and reader fitting. The domain-alignment experiments additionally use Nemotron-C HQ-DQA [36] and Nemotron-C HQ from nvidia/Nemotron-C-v2.1; the former is a QA-heavy STEM subset and the latter is a broader organic-web subset used as a corpus-size and structure control. The resulting reader is evaluated zero-shot on RTE [10], BoolQ [9], openBookQA [29], SciQ [40], TruthfulQA [26], and RACE [23]. For QA tasks in Table 1 to Table 5, it contains Natural Questions (NQ) [22], WebQA [3], TriviaQA [19], TruthfulQA [26], and HotpotQA [43]. The default corpus for the LLaMA-2-7B → Mistral-7B-v0.3 experiments is the pre-tokenized December-2021 English Wikipedia [17] release (Rubin-Wei/enwiki-dec2021-preprocessed-mistral), distributed with the MLP Memory data pipeline [39]. It provides train and test splits; the implementation maps a requested validation split to test and, when the active tokenizer differs from Mistral’s, decodes and re-tokenizes the windows before chunking them. The out-of-domain language-modeling evaluation in Section D.5 uses LAMBADA [31], WikiText-103 [28], and the English C4 validation set [33]. LAMBADA and WikiText-103 are considered out-of-domain only when the reader is fitted to a different corpus. LAMBADA contains narrative text requiring long-range contextual prediction, whereas WikiText-103 consists of curated encyclopedic articles; both differ substantially in genre and provenance from broad web corpora such as C4 and FineWeb-Edu. Training protocol. The principal settings are summarized in Table 10. All phases optimize the next-token language-modeling objective; no task labels are used to fit a reader. Table 10: Principal training and evaluation settings. “LR / warm-up” reports the learning rate and number of warm-up steps. Unless otherwise noted, training uses cosine decay, AdamW with weight decay 0.010.01, and gradient-norm clipping at 1.01.0. Alternative-corpus experiments follow the intrinsic reader-fitting protocol with LAMBADA or English C4 replacing WikiText-103. OOD rows are evaluation-only. Regime / phase Corpus Budget / cap Seq. / batch LR / warm-up Trainable components and exceptions Primary training settings RQ1 4.1 Phase 1 WikiText-103 50M tokens 512 / 16 3×10−53× 10^-5 1,000 Source backbone, memory, and source reader are trainable. For Qwen3.5 sources, the memory learning rate is 10−310^-3. RQ1 4.1 Phase 2 WikiText-103 20M tokens 512 / 16 3×10−53× 10^-5 500 Only the target reader is trainable; the target backbone and transferred memory remain frozen. Figure 3 Phase 1 FineWeb-Edu 50M tokens 512 / 2 10−310^-3 / 1,000 Source backbone, memory, and source reader trained end-to-end; gradient checkpointing Figure 3 Phase 2 FineWeb-Edu 20M tokens 512 / 4 3×10−53× 10^-5 / 500 Target reader only; target backbone and transferred memory frozen; gradient checkpointing; early stopping patience 5 Table 1 to Table 5 Phase 1 Wikipedia-2021 10–30M tokens 2048 / 1 3×10−53× 10^-5 1,000 The source memory and reader are trainable; the source backbone is frozen. Early stopping uses patience 3. Table 1 to Table 5 Phase 2 Wikipedia-2021 10–30M tokens 2048 / 1 3×10−53× 10^-5 500 Only the target reader is trainable; the target backbone and transferred memory remain frozen. Early stopping uses patience 3. Alternative-corpus training LAMBADA Phase 1 LAMBADA train split 50M tokens 512 / 16 3×10−53× 10^-5 1,000 Source backbone, memory, and source reader are trainable. The finite training split is cycled as needed. LAMBADA Phase 2 LAMBADA train split 20M tokens 512 / 16 3×10−53× 10^-5 500 Only the target reader is trainable; the target backbone and transferred memory remain frozen. C4 Phase 1 English C4 train stream 50M tokens 512 / 16 3×10−53× 10^-5 1,000 Source backbone, memory, and source reader are trainable. C4 Phase 2 English C4 train stream 20M tokens 512 / 16 3×10−53× 10^-5 500 Only the target reader is trainable; the target backbone and transferred memory remain frozen. Out-of-domain evaluation without additional training LAMBADA lambada, test 2M eval tokens 512 / 16 — Evaluation only; source memory, reader, and target backbone remain frozen. WikiText-103 wikitext-103, test 2M eval tokens 512 / 16 — Evaluation-only distribution-shift probe; no trainable components. C4 allenai/c4, English validation 5M eval tokens 512 / 16 — Evaluation-only streaming web-text probe; no trainable components. For the standard Pythia source configurations, Phase 1 is end-to-end; the large Qwen and LLaMA source runs freeze the source backbone when required by the memory budget. After Phase 1, the exported memory table is frozen and attached to the target model. For Phase 2, only the target-side reader is optimized. Conditions and metrics. Across transfer experiments, we compare a Baseline target with no memory, a Transferred condition with a trained frozen source memory, and a Random memory condition with an untrained table of the same architecture. Unless noted otherwise, all conditions use three seeds (42, 137, 2024). For the performance of Table 1 and Table 2 we use F1 score as the main result, and multiple-choice average and follow the official code and checkpoint to evaluate for MLP memory. For the other downstream tasks, we report the accuracy. We report test perplexity (PPL, ↓ ) with 95% bootstrap confidence intervals and use paired t-tests on per-batch perplexities. The experiments in the appendix run on a single NVIDIA H100 NVL GPU. The experiments in the main text are conducted on the LUMI supercomputer operated by CSC – IT Center for Science, Finland, using the LUMI-G partition equipped with AMD Instinct MI250X GPUs. Evaluation-set overlap audit. We compare all 31,807 downstream evaluation questions against the exact Phase-1 and Phase-2 training streams used in the QA experiments. Natural Questions, WebQuestions, and HotpotQA contain no exact question matches. The remaining exact matches consist of four duplicated TriviaQA rows (0.013%) and one generic TruthfulQA question without its gold answer. Partial 8-gram overlaps predominantly correspond to shared phrasing rather than direct question-answer leakage. Thus, the reader training streams use no benchmark supervision, although they are not strictly overlap-free. Since the pretraining corpora of the underlying foundation models are unavailable, we interpret the QA results as controlled comparisons rather than as a contamination-free state-of-the-art claim. Appendix C Supplementary Evidence for RQ1 The main 3×3 matrix in Section 4.1 answers the primary question of whether a frozen memory remains useful after being moved to a different backbone. The experiments below test whether that conclusion survives several plausible alternative explanations. Specifically, we examine whether the gains depend on shared tokenization, arise only when transferring from a smaller to a larger model, disappear for stronger targets, or can be explained by similarity between source and target representations. C.1 Full Cross-Architecture Matrix Table 11 reports the complete cross-architecture results for all nine source–target combinations used in the main transfer study in Figure 2(a). For each source memory, we compare three conditions on each target model: the target backbone without memory augmentation (Baseline), the frozen source memory integrated through a fitted target reader (Transferred), and a size-matched randomly initialized memory evaluated under the same reader fitting protocol (Random). The transferred-memory condition improves test perplexity in every source–target pair, with relative reductions ranging from 1.6%1.6\% to 15.7%15.7\%. The strongest improvement occurs for Qwen3.5-0.8B → TinyLlama-1.1B, while the random-memory control generally improves less than the corresponding transferred memory. Table 11: Full cross-architecture transfer matrix: test PPL (↓ ) for 3 source memories × 3 target models. Random replaces the learned source memory with a size-matched randomly initialized memory under the same fitting protocol. Mean ± std over 3 seeds. Deltas shown next to the transferred result are relative to the no-memory baseline; negative values indicate better PPL. A displayed standard deviation of 0.00.0 indicates a value below 0.050.05 after rounding to one decimal place. Target Baseline Transferred Random Pythia-160M source Pythia-410M 21.921.9 21.6±0.121.6± 0.1 -1.6% 21.9±0.021.9± 0.0 Qwen3.5-4B 10.810.8 10.1±0.010.1± 0.0 -6.8% 10.3±0.010.3± 0.0 TinyLlama-1.1B 10.610.6 9.5±0.09.5± 0.0 -10.6% 10.0±0.010.0± 0.0 Qwen3.5-0.8B source Pythia-410M 22.922.9 21.4±0.021.4± 0.0 -6.8% 22.1±0.022.1± 0.0 Qwen3.5-4B 10.510.5 9.6±0.09.6± 0.0 -8.9% 10.2±0.010.2± 0.0 TinyLlama-1.1B 10.810.8 9.1±0.09.1± 0.0 -15.7% 9.3±0.09.3± 0.0 Qwen3.5-9B source Pythia-410M 22.622.6 21.6±0.021.6± 0.0 -4.3% 22.3±0.022.3± 0.0 Qwen3.5-4B 10.510.5 9.4±0.09.4± 0.0 -10.3% 10.2±0.010.2± 0.0 TinyLlama-1.1B 10.410.4 9.1±0.09.1± 0.0 -12.2% 9.3±0.09.3± 0.0 C.2 Supplement Transfer Comparisons Experiments This section supplements the transfer comparison experiments in the same-tokenizer and cross-tokenizer transfer settings and compares against parameter-matched baselines and an external retrieval reference. Table 12 isolates the simplest transfer setting, where the source and target share the Pythia family and tokenizer, and asks whether frozen memory still helps when comparing against parameter-matched alternatives. The result is still favorable to the transferred memory. It outperforms both random memory and the iso-parameter LoRA baselines, while kNN-LM remains a stronger but much more expensive non-parametric reference because it requires a retrieval datastore and nearest-neighbor search at inference time. Table 12: Same-tokenizer transfer (Pythia-160M → Pythia-410M). Mean ± std over 3 seeds. Deltas in the PPL column are relative to the no-memory baseline; negative values indicate better PPL. LoRA and Cross-LoRA are iso-parameter baselines (1.03M parameters, same 20M token budget). KNN-LM uses a 5M-token datastore with k=1024k=1024 retrieval at inference time. Condition Test PPL ↓ 95% CI Params / Cost Baseline (no memory) 21.921.9 [20.6,23.4][20.6,23.4] — Transfer Conditions Random memory 21.9±0.021.9± 0.0 -0.2% [20.6,23.3][20.6,23.3] 1.05M Transferred memory 21.6±0.121.6± 0.1 -1.6% [20.2,23.0][20.2,23.0] 1.05M Parameter-Matched Baselines LoRA (rank 7) [15] 23.3±0.823.3± 0.8 +6.5% [21.9,24.9][21.9,24.9] 1.03M Cross-LoRA [42] 23.9±0.623.9± 0.6 +9.3% [22.5,25.5][22.5,25.5] 1.03M External Retrieval Reference KNN-LM [20]† 20.420.4 -7.1% [19.3,21.5][19.3,21.5] 5M-tok store †Non-parametric; requires k=1024k=1024 nearest-neighbor search per token at inference. Table 13 moves to the harder Pythia → TinyLlama case, where tokenizer mismatch is unavoidable, and transfer depends on the shared canonicalization pipeline. Even in this setting, transferred memory reduces PPL from 10.63 to 9.50 and clearly beats random memory. This supports the claim that the exported memory is not tied to the source tokenizer as long as the target reader is given a compatible canonical interface. Table 13: Cross-tokenizer transfer (Pythia-160M → TinyLlama-1.1B). Mean ± std over 3 seeds. Deltas in the PPL column are relative to the no-memory baseline; negative values indicate better PPL. Reader parameters: 2.10M. Condition Test PPL ↓ 95% CI Params Baseline (no memory) 10.610.6 [10.0,11.3][10.0,11.3] — Transfer Conditions Random memory 10.0±0.010.0± 0.0 -5.9% [9.4,10.7][9.4,10.7] 2.10M Transferred memory 9.5±0.09.5± 0.0 -10.6% [8.9,10.2][8.9,10.2] 2.10M C.3 Peer-to-Peer Transfer This section tests whether transfer remains useful once the source and target are both strong mid-scale models rather than a small source feeding a much larger target. Table 14 shows the results of peer-to-peer transfer between Phi-4-mini [1] (3.8B) and Qwen3.5-4B. Table 14: Peer-to-peer transfer between Phi-4-mini (3.8B) and Qwen3.5-4B. Source memories trained on WikiText-103 (50M tokens). Mean ± std over 3 seeds. Deltas shown next to the transferred result are relative to the no-memory baseline; negative values indicate better PPL. Direction Baseline Transferred Random Phi-4-mini → Qwen3.5-4B 10.510.5 9.5±0.09.5± 0.0 -10.1% 10.2±0.010.2± 0.0 Qwen3.5-4B → Phi-4-mini 12.612.6 11.5±0.011.5± 0.0 -9.2% 12.3±0.012.3± 0.0 The gains remain bidirectional: Phi → Qwen improves by 10.1%, and Qwen → Phi improves by 9.2%. Random memory is substantially weaker in both directions, even though it uses the same target-side reader architecture and optimization budget. Thus, the observed gains cannot be attributed solely to the additional parameter capacity introduced by the reader. C.4 Target Model Scaling Table 15 keeps the source fixed and scales the target from 2B to 9B parameters to check whether the transfer disappears once the target becomes stronger. Table 15: Target model scaling: Qwen3.5-0.8B source → Qwen3.5-2B, 4B, 9B. Mean ± std over 3 seeds. Deltas shown next to the transferred result are relative to the no-memory baseline; negative values indicate better PPL. Baselines are eval-only (no reader training). Target Baseline Transferred Random Qwen3.5-2B 13.713.7 11.7±0.011.7± 0.0 -14.1% 12.6±0.012.6± 0.0 Qwen3.5-4B 10.510.5 9.6±0.09.6± 0.0 -8.9% 10.2±0.010.2± 0.0 Qwen3.5-9B 9.39.3 8.5±0.08.5± 0.0 -8.3% 9.0±0.09.0± 0.0 The gains persist across all three target sizes. The largest relative improvement appears at 2B, but even the 9B target still benefits, which suggests that stronger backbones reduce but do not eliminate the value of the transferred memory. C.5 Analysis of Backbone Representations We use centered kernel alignment (CKA) [21] to measure the similarity between hidden representations produced by different target backbones. Linear CKA compares the geometry of two representation matrices and is invariant to isotropic scaling and orthogonal transformations, making it suitable for comparing models with different hidden dimensions. We use WikiText-103 to training with sequence length 512. For each backbone, we extract hidden states from the Transformer block located approximately one third of the way through the network, ⌊L/3⌋ L/3 , where L is the total number of Transformer blocks. This corresponds to block 4 of 12 for Pythia-160M, block 8 of 24 for Pythia-410M, and block 7 of 22 for TinyLlama-1.1B. We process the same set of input sequences with each model, mean-pool the hidden states over non-padding tokens to obtain one representation per sequence, and compute pairwise linear CKA between the resulting representation matrices. We select the one-third-depth layer to compare intermediate representations after substantial contextual processing, while avoiding the stronger model-specific specialization that may occur near the output layer. Figure 5: Linear CKA similarity between mean-pooled backbone representations at layer ⌊L/3⌋ L/3 for the three models shown in the matrix. Figure 5 provides a representation-level view of why transfer need not track backbone similarity monotonically. The two Pythia models exhibit substantially higher representational similarity, with a CKA score of 0.5950.595, than either model does with TinyLlama, for which the scores are only 0.0130.013 and 0.0070.007. Nevertheless, Pythia-160M → TinyLlama-1.1B is among the strongest cross-tokenizer transfer settings in Table 11, reducing perplexity by 10.6%10.6\%. By comparison, the more representationally similar Pythia-160M → Pythia-410M pair improves perplexity by only 1.6%1.6\%. Representational similarity alone does not predict the magnitude of transfer gains in these experiments. Nevertheless, this result is consistent with the reader analysis in Section 4.2: successful transfer depends on whether the target reader can recover and route useful information from the frozen memory, rather than requiring the source and target backbones to have closely aligned intermediate representation spaces. Also, the wording of "the main text’s claim" is bad. Appendix D Supplementary Analysis of Corpus-Dependent Downstream Transfer for RQ3 These analyses extend RQ3 in Section 4.3 by separating corpus specialization, reader alignment, mixed-corpus behavior, and out-of-domain effects. D.1 Reference Downstream Pattern Figure 3 reports the full six-task evaluation under FineWeb-Edu [27] aligned Phase 2 training, so the table is not duplicated here. RTE and SciQ improve most consistently, BoolQ becomes positive for targets of 2B parameters and above, and TruthfulQA remains slightly negative at every scale. This pattern motivates the following diagnostics: corpus specialization in Section D.2, Phase 2 reader alignment in Section D.3, mixed-corpus training in Section D.4, and unrelated-corpus evaluation in Section D.5. D.2 Source-Corpus Specialization Table 16 compares two source-corpus families under matched Phase 2 adaptation: a broad educational web corpus (FW) and a narrower QA-heavy corpus (Nemo HQ-DQA). Table 16: Domain alignment ablation with corpus-matched Phase 2 readers. Positive gains are shown in green and negative changes in red. Target Source RTE ↑ BoolQ ↑ OpenBookQA ↑ SciQ ↑ TruthfulQA ↑ RACE ↑ Qwen-0.8B FW-avg +6.1 -0.6 +0.7 +1.8 -0.1 -0.2 Nemo-avg +7.9 +4.1∗ +1.1 +8.4∗ -0.8 +1.1∗ Qwen-2B FW-avg +2.7 +3.2 +0.3 +3.5 -0.4 -0.0 Nemo-avg +8.7∗ +14.6∗ +0.5 -0.7 +0.0 +1.1∗ Qwen-4B FW-avg +1.3 -0.2 +0.6 +0.9 -0.5 +0.1 Nemo-avg +0.4 +0.6 +0.2 -6.3 -2.9 -0.4 Qwen-9B FW-avg +0.5 +0.6 +0.2 +2.7 -0.7 +1.0 Nemo-avg -4.6 +2.1∗ -0.3 -3.7 +0.2 +1.4 ∗Nemo-avg >> FW-avg by ≥2≥ 2 percentage points. The main pattern is that domain-specialized memory helps most on smaller targets and QA-style tasks. Nemo-avg is especially strong on Qwen3.5-0.8B and Qwen3.5-2B for BoolQ, RTE, and SciQ, but the advantage is less uniform on 4B and 9B targets, showing that specialization helps most when the target still needs strong external support. Table 17 controls for corpus size on Qwen3.5-2B by comparing an 8B-token STEM question-answering corpus (HQ-DQA) with a broader 26B-token general web corpus (HQ). Here, the smaller STEM question-answering corpus substantially outperforms the larger general web corpus on BoolQ and RTE and also improves RACE. Table 17: Corpus structure vs. size on Qwen-2B: accuracy change (�% \%) under corpus-matched Phase 2 readers. Positive gains are shown in green and negative changes in red. Source corpus BoolQ ↑ RTE ↑ OBQA ↑ SciQ ↑ TQA ↑ RACE ↑ HQ-DQA (8B, STEM Q&A) +15.3 ± 0.3 +8.9 ± 4.7 +0.3 ± 0.2 +0.9 ± 3.0 +0.3 ± 0.2 +1.4 ± 0.4 HQ (26B, organic web) +3.0 ± 0.4 +1.2 ± 2.1 +0.5 ± 0.1 -0.5 ± 0.0 +0.2 ± 0.3 -0.4 ± 0.2 FW-avg (reference) +3.2 +2.7 +0.3 +3.5 -0.4 -0.0 D.3 Phase-2 Reader-Fitting Alignment Table 18 probes the failure mode suggested in the main text: stronger source memories can look worse downstream if the target-side reader is trained on a mismatched Phase 2 objective. Table 18: Reader alignment: downstream accuracy change (�% \%) under mismatched vs. matched Phase 2 adaptation. Positive gains are shown in green and negative changes in red. Source Phase 2 BoolQ �%↑ \% RTE �%↑ \% SciQ �%↑ \% Mismatched Phase 2 (WikiText-103) 10M WikiText-103 +8.3 ± 0.5 +7.7 ± 3.9 -4.5 ± 0.5 50M WikiText-103 +6.6 ± 0.4 +6.1 ± 4.7 -1.8 ± 0.6 200M WikiText-103 +0.0 ± 0.0 +2.9 ± 4.7 -1.4 ± 0.6 Matched Phase 2 (HQ-DQA) 10M HQ-DQA +14.1 ± 1.2 +10.7 ± 4.0 -2.3 ± 3.0 50M HQ-DQA +15.3 ± 0.3 +8.9 ± 6.2 +0.9 ± 3.7 200M HQ-DQA +14.0 ± 0.8 +6.6 ± 4.9 +2.9 ± 4.6 Under WikiText-103 Phase 2 adaptation, increasing source training from 10M to 200M tokens steadily hurts BoolQ transfer. Once Phase 2 is moved to the matched HQ-DQA distribution, however, all three source budgets recover to roughly 14–15% BoolQ gain, which shows that the apparent degradation is primarily an alignment problem at the reader rather than a problem with the frozen memory itself. Table 19 gives a mechanistic view of the same effect through gate statistics. Table 19: Gate activation statistics during BoolQ evaluation versus Phase 2 WikiText-103 training. Longer source training suppresses the gate globally; BoolQ shows a lower mean gate, while the near-closed-gate fraction rises on both distributions under mismatch. Source Gate mean Frac. <0.1<0.1 tokens WikiText-103 BoolQ WikiText-103 BoolQ 10M 0.6 0.5 5.6% 3.6% 50M 0.6 0.5 9.1% 2.9% 200M 0.5 0.4 17.5% 15.3% Longer source training suppresses the gate more strongly overall, and this is visible on BoolQ prompts both in the lower mean gate and in the rise of near-closed gates. At 200M source tokens, the mean gate on BoolQ drops to 0.352 and the fraction of near-closed gates rises to 15.3%, while WikiText-103 has a slightly higher near-closed fraction at 17.5% on the same threshold metric, consistent with broad suppression under reader mismatch rather than a BoolQ-only effect. D.4 Broadening Specialist Memory through Corpus Mixing Table 20 tests whether a strong specialist memory can be broadened without destroying the downstream gains that make it useful in the first place. The answer is mostly yes. A 50/50 HQ-DQA + FineWeb-Edu mix preserves the DQA aggregate and slightly exceeds the specialist reference, while sequential mixing and the orthogonal code mixture also retain most of the specialist advantage. The main tradeoff is that broader mixtures help coverage more than they help the QA-focused aggregate itself. Table 20: Mixed-corpus memory study on Qwen3.5-2B. Positive gains are shown in green and negative changes in red. The two rightmost columns report aggregate scores: DQA-agg == mean(BoolQ, RTE, SciQ); Br-agg == mean(OBQA, TruthfulQA, RACE). Design BoolQ ↑ RTE ↑ OBQA ↑ SciQ ↑ TQA ↑ RACE ↑ DQA-agg ↑ Br-agg ↑ Single-corpus references HQ-DQA ref. +15.3 ± 0.3 +8.9 ± 4.7 +0.3 ± 0.2 +0.9 ± 3.0 +0.3 ± 0.2 +1.4 ± 0.4 +8.4 +0.7 FW-Edu ref. +2.5 ± 1.7 +1.9 ± 0.2 -0.0 ± 0.2 +3.2 ± 0.6 -0.2 ± 0.2 +0.1 ± 0.1 +2.5 -0.1 Mixed or broadened memories 50/50 mix +14.3 ± 1.1 +11.7 ± 3.5 +0.4 ± 0.4 -0.5 ± 3.8 +0.3 ± 0.3 +0.5 ± 0.3 +8.5 +0.4 Sequential HQ→ +13.6 ± 1.0 +11.9 ± 2.8 -0.0 ± 0.2 -1.7 ± 2.7 +0.1 ± 0.4 +0.2 ± 0.3 +7.9 +0.1 Orthogonal + Code +14.4 ± 0.9 +9.8 ± 2.6 +0.4 ± 0.3 -0.4 ± 3.4 -0.2 ± 0.7 +1.3 ± 0.4 +7.9 +0.5 D.5 Out-of-Domain Side Effects Table 21 checks whether a reader trained in the WikiText-103 transfer setting systematically distorts language-modeling behavior on unrelated corpora, without additional adaptation. LAMBADA emphasizes long-range narrative completion, WikiText-103 provides a separately curated language-modeling test set, and C4 represents broad web text; together, they probe distribution shift away from the Phase 2 training corpus. Table 21: Out-of-domain evaluation: test PPL (↓ ) for baseline vs. transferred memory. Negative � indicates improvement. Target Model Dataset Baseline Transferred � (%) Pythia-410M LAMBADA 41.041.0 41.041.0 +0.0% WikiText-103 22.622.6 22.1 -2.4% C4 24.924.9 24.8 -0.3% TinyLlama-1.1B LAMBADA 23.623.6 23.5 -0.7% WikiText-103 10.610.6 10.1 -5.0% C4 11.711.7 11.6 -0.2% The OOD effect is mostly neutral. Both targets get a modest improvement on WikiText-103 [28], while LAMBADA [31] and C4 [33] stay very close to the baseline in either direction. This supports the paper’s boundary claim that transferred memory is not universally helpful, but it is also usually not catastrophically harmful outside the aligned regime. D.6 Reader–Evaluation Distribution Mismatch To isolate whether transfer requires identical reader-training and evaluation distributions, we fix a WikiText-trained Pythia-160M source memory and fit Pythia-410M readers on either WikiText-103 or C4. We then evaluate each reader on both corpora. Table 22: Cross-corpus reader fitting and evaluation. Lower PPL is better. Reader corpus Eval. corpus No memory Transfer � WikiText WikiText 22.616 22.113 -0.502 WikiText C4 24.726 24.663 -0.062 C4 WikiText 22.616 22.538 -0.078 C4 C4 24.726 24.604 -0.122 Results in Table 22 show that transfer improves over the no-memory target in all four conditions, so reader-training and evaluation corpora need not be identical. However, the substantially larger matched WikiText gain shows that the amount of recoverable signal remains distribution-sensitive. We therefore distinguish portability, which persists under moderate corpus mismatch, from transfer magnitude, which depends on alignment among the stored memory, reader-fitting distribution, and evaluation distribution. Appendix E Multilingual Transfer Word-boundary units are the default addressing granularity in our English-like experiments, but they are not appropriate for writing systems without reliable whitespace segmentation. For such inputs, we replace word units with NFKC-normalized, case-folded non-whitespace Unicode character events and apply the same deterministic hashing procedure to character spans. This preserves the model-independent addressing principle while changing only the canonical unit used to form n-grams. This character-span variant restores non-degenerate cross-tokenizer addressing for Chinese and Japanese and yields positive transfer gains in both languages, as shown in Table 23. We then trained Qwen2.5-0.5B source memories and Llama-3.2-1B target readers separately on Chinese and Japanese Wikipedia, using character-span hashing, four branches at layers 2/10, fixed held-out 262K-token test splits, and seeds 42/137/2024. Table 23: Character-span addressing for non-segmented languages. Results are averaged over three seeds. Language No-memory PPL Transfer PPL Rel. improvement Chinese 20.1248 19.6718±0.003319.6718± 0.0033 2.251% Japanese 15.3555 15.1985±0.025115.1985± 0.0251 1.023% Appendix F Computational Cost Analysis We count multiply-adds (MAdds) for dense projections and report memory addressing separately, since a table lookup is a memory-traffic operation rather than a dense matrix multiplication. Let NmaxN_ denote the maximum n-gram order and let K denote the number of independent hash heads used for each order n∈2,…,Nmaxn∈\2,…,N_ \. The total number of hash heads is therefore H=(Nmax−1)K.H=(N_ -1)K. (15) R be the number of reader branches at one injection site, and S be the number of injection sites. For the default memory configuration, Nmax=3N_ =3, K=4K=4, H=8H=8, and the dimension of memory dmem=Hdhead=512d_mem=Hd_head=512, where dheadd_head is the dimension of the embedding row retrieved by one hash head. and dmemd_mem is the memory vector. Each token, therefore, requires H deterministic hash indices and H embedding-row reads, together supplying Hdhead=512Hd_head=512 memory values. This cost is O(Nmax+H)O(N_ +H) hash operations and O(Hdhead)O(Hd_head) memory traffic per site and does not grow with the table size M; in particular, it does not perform a nearest-neighbor search over the M=65,536M=65,536 rows. At one injection site of the target-side reader, the shared-value, R-branch reader performs one dmem×dBd_mem\!×\!d_B value projection and R key projections of the same shape, and dBd_B for the hidden dimension of target model B. If not, change it. The remaining reader operations include RMS normalization, R key-query dot products, sigmoid gates, scalar–vector products, and branch aggregation. These operations require O(RdB)O(Rd_B) work. We refer to this as the non-projection, lower-order term because it scales linearly with dBd_B, whereas the dense projections scale as dmemdBd_memd_B. With dmem=512d_mem=512, the projection term is substantially larger in the evaluated configurations. Lower than what? Thus, the dominant reader cost for a sequence of length T and batch size B is Creader=BTS[(R+1)dmemdB+O(RdB)]MAdds,C_reader=BTS [(R+1)d_memd_B+O(Rd_B) ] , (16) or, per token and ignoring the lower-order gate terms, S(R+1)dmemdBS(R+1)d_memd_B. The single-layer, single-branch reader has R=S=1R=S=1, giving 2⋅512⋅dB2· 512· d_B MAdds per token: 1.051.05M at dB=1024d_B=1024 (Pythia-410M) and 4.194.19M at dB=4096d_B=4096 (the 7B configurations). The dual-layer, four-branch QA reader has S=2S=2 and R=4R=4, so its dominant projection cost is 2⋅5⋅512⋅4096=20.972· 5· 512· 4096=20.97M MAdds per token. The shared value projection is counted once per injection site, not once per branch. For completeness, the corresponding trainable reader parameter count is Preader=S[(R+1)dmemdB+(R+1)dB+R],P_reader=S [(R+1)d_memd_B+(R+1)d_B+R ], (17) where the second term accounts for the RMSNorm weights and the final term for the branch-specific gate biases. This gives approximately 4.204.20M parameters for the one-site, one-branch reader at dB=4096d_B=4096, and 21.0121.01M parameters for the two-site, four-branch reader used in the QA configuration. These reader parameters are the only additional trainable parameters in Phase 2; the transferred 33.633.6M-parameter memory table and the target backbone remain frozen. The comparison with attention should be read as a projection-only lower bound. A standard self-attention layer has four dense projections, giving 4dB24d_B^2 MAdds per token before counting the sequence-dependent attention score and value products. This is 4.194.19M at dB=1024d_B=1024 and 67.1167.11M at dB=4096d_B=4096, compared with 1.051.05M and 4.194.19M for the single-branch reader. The additional attention products contribute O(TdB)O(Td_B) work per token for a length-T sequence, whereas the reader contribution remains constant per token. Consequently, the reader adds a small fixed overhead to each injected layer and does not change the transformer’s quadratic dependence on sequence length. During Phase 2, freezing the backbone and memory removes their optimizer-state and parameter-update costs, although their forward computation and the backward path needed to train the reader are still executed. Amortization across consumers. The practical advantage of a transferable artifact emerges when the same provider memory is reused across multiple targets. Using the measured payload times above, the cumulative cost of transfer to N adapted targets is Ctransfer(N)=0.653+3.798N,C_transfer(N)=0.653+3.798N, whereas training a fresh target-specific memory for each consumer costs Cfresh(N)=3.871N.C_fresh(N)=3.871N. Under these measurements, the one-time provider cost is amortized after approximately nine adapted consumers by payload time. Using allocated GPU-hours gives a corresponding break-even point of approximately eleven consumers. These numbers are system- and configuration-specific rather than universal thresholds, but they illustrate the lifecycle regime in which reusable memory artifacts become advantageous. When the provider reader is directly compatible with the consumer, target-side adaptation is unnecessary: the measured consumer cost is zero training tokens and zero parameter updates, while mean QA rises from 32.12 to 38.31. The optional reader fitting raises it further to 38.50. F.1 Measured System and Lifecycle Cost Table 24: Measured cost for the LLaMA-2-7B→ -7B-v0.3 using QA experiment configuration on LUMI supercomputer. Condition Tokens Train time GPU-hours Peak inf. memory Prefill No memory 0 0 0 13.658±0.02013.658± 0.020 GiB 55.10±0.0655.10± 0.06 ms Phase-1 source artifact 4.096M 0.653 h 3.154 – – Fresh Mistral memory 19.968M 3.871 h 15.760 – – Matched FFN 19.968M 3.680 h 14.929 13.736±0.02013.736± 0.020 GiB 55.32±0.4955.32± 0.49 ms Transfer, incl. Phase 1 4.096M+19.968M 4.451 h 18.623 13.881±0.02013.881± 0.020 GiB 57.69±0.4057.69± 0.40 ms Section F.1 shows the cost for transfer experiments from LLaMA-2-7B to Mistral-7B-v0.3. Relative to the no-memory target, the transferred configuration adds 0.223 GiB of peak inference memory and 2.60 ms of prefill latency in this measured setup. The Phase-1 source artifact is a one-time provider cost: the recorded run processes 4.096M tokens in 0.653 hours. Each adapted consumer then trains only the 21.01M-parameter reader, while the memory and backbone remain frozen. Appendix G Ethics and Broader Impact Transferred memory raises both opportunities and risks. On the positive side, a frozen external memory can reduce repeated backbone retraining and make factual updates more modular. On the negative side, the same mechanism can propagate memorized or provenance-sensitive content across multiple target models if the source memory is not audited. Engram’s advantage is that its stored knowledge is explicit and addressable: entries can be inspected, removed, or replaced without retraining the backbone. Appendix H Limitations Scale and availability. Our experiments cover source and target models up to 9B parameters, but do not systematically characterize how target-side reader capacity should scale with backbone size, memory size, training data, or source–target heterogeneity. In particular, our two-phase protocol first trains the memory with the source model and then freezes both the transferred memory and the target backbone while adapting only the reader. We therefore do not explore joint training of the backbone, memory, and reader, nor establish a scaling law relating reader depth, branch count, injection placement, and parameter count to model scale. Although the present results show that stronger readers substantially improve frozen-memory extraction, it remains unclear whether the same reader configurations remain sufficient for much larger models or whether reader capacity must grow with the backbone or memory. We equip an existing multi-billion-parameter model with Engram and train it. So saying those multi-billion-parameter Engram models don’t exist is not a good argument. Addressing and language diversity. Our default word-boundary addressing is effective for the evaluated English-like settings, but it is not universally tokenizer- or language-independent. In particular, whitespace-based word units degenerate for non-segmented Chinese and Japanese. We show that replacing word units with normalized character spans repairs this specific failure mode and produces positive transfer on Chinese and Japanese Wikipedia. These experiments demonstrate that the model-independent addressing principle can extend beyond whitespace-delimited text, but they do not establish a universally optimal canonical unit. Code, noisy Unicode, mixed-script text, byte-level tokenizers, and additional writing systems may require character-, byte-, or task-specific span definitions. More generally, portability requires agreement on both the canonicalization procedure and the granularity from which memory addresses are formed. More aggressive tokenizer mismatch may require a stronger key pipeline than the word-boundary canonicalization used here. Reader scope. Our capacity diagnostics further show that both interface width and reader placement affect extraction quality; the default dmem=512d_mem=512 setting should therefore be viewed as an evaluated operating point rather than a fixed architectural requirement. The target-side reader is a central component of our transfer framework, but the present study evaluates only a deliberately lightweight subset of the possible reader design space. The main transfer matrix uses a single-branch linear reader, while the QA experiments extend it with shared-value multi-branch reading and multi-layer injection. These controlled designs make it possible to isolate the role of target-side extraction while keeping the number of trainable parameters small. Nevertheless, more heterogeneous source–target pairs may benefit from nonlinear transformations, adaptive branch aggregation, layer-dependent value projections, or learned injection placement. Such extensions could improve extraction capacity, but would also increase computation and make it harder to distinguish reusable memory content from capacity introduced by the reader itself. In addition, our results indicate that the usefulness of context-dependent gating varies with the source and target distributions. A broader study across corpus shifts and model families is needed to characterize when gating is essential and when a simpler reader is sufficient.