--- title: 'Text2Mem: Textual Memory Operations' url: https://www.emergentmind.com/topics/text2mem type: topic --- # Text2Mem: Textual Memory Operations Searching arXiv for the cited Text2Mem-related papers to ground the article in current records. Text2Mem refers to systems that map textual descriptions of changes into explicit memory operations, and related work uses the term more broadly for mechanisms that read a context once, convert it into a compact memory state, and answer later queries from that state without re-accessing the original context [2606.24040][2603.13875]. In current arXiv literature, the label spans several technical families: explicit associative memories whose core state is writable and forgettable, optimization-based memory writers that adapt a compact state at test time, prompt-to-parameter adaptation schemes that treat a prompt as transient training data, application-layer episodic and semantic memory stacks for conversational or agent systems, and standardized languages for memory control across heterogeneous backends [2502.12851][2406.16069][2605.20724][2509.11145]. ## 1. Scope, precursors, and historical development Several earlier architectures already instantiate the central Text2Mem pattern: text is transformed into a memory substrate that is later read during generation. In neural machine translation, MemDec augments the decoder with a fixed-size external memory matrix \(M_t^b \in \mathbb{R}^{n \times m}\), read and written once at each decoding step with content-based addressing, and improves Chinese–English translation by \(4.8\) BLEU upon Groundhog and \(5.3\) BLEU upon Moses [1606.02003]. In long-document summarization, Mem2Mem introduces readable and writable external memories on both encoder and decoder sides, compresses an input article into a compact set of sentence representations, performs implicit extraction without labels, and attains results competitive with transformer-based summarization methods while using 16 times fewer parameters [2010.11322]. The same pattern extends beyond pure text. VX2TEXT converts video, audio, speech, and text into language-space embeddings by modality-specific tokenizers, performs multimodal fusion in the language space, and generates open-ended text with a transformer encoder–decoder, outperforming prior methods on captioning, question answering, and audio-visual scene-aware dialog [2101.12059]. A plausible implication is that Text2Mem is not restricted to textual inputs alone; it also covers pipelines in which non-textual signals are first rendered into language-like memory representations before retrieval or generation. More recent work makes the memory interpretation explicit. MeMo proposes language models with explicit multi-layer correlation matrix memories (CMMs), FastMem performs “fast memorization of the prompt” by updating only the last FFN module before inference, GradMem writes long contexts into a fixed set of prefix memory tokens by test-time gradient descent, CALMem implements a dual memory outside the model, Metis structures agent experience into text and code memory, and Text2Mem itself is formalized as a memory operation language in a backend-agnostic control plane [2502.12851][2406.16069][2603.13875][2605.20724][2606.24151][2509.11145]. ## 2. Associative-memory and transactional substrates The most explicit architectural instantiation is MeMo. Its memory primitive is the classical correlation matrix memory $$ C = \sum_i k_i v_i^{\top}, $$ with retrieval by $$ \hat{v} = C^{\top} k. $$ Multi-layer MeMo stacks several such memories, $$ \mathcal{C}_{\mathrm{MeMo}} = \{C^{(1)}, C^{(2)}, \ldots, C^{(L)}, C^{(\mathrm{out})}\}, $$ so that higher layers compose tokens into higher-level sequence representations and \(C^{(\mathrm{out})}\) stores next-token associations [2502.12851][2606.24040]. At the interface level, MeMo exposes explicit architectural operations $$ \mathrm{memo}(S,y), \quad \mathrm{forget}(S,y), \quad \mathrm{retrieve}(S), $$ where \(S\) is a sequence and \(y\) is the associated next token or value. This is the critical departure from transformer-style implicit memorization: memorization, retrieval, and forgetting are callable operations rather than distributed side effects of gradient descent [2606.24040]. The version-aware extension of Multi-layer MeMo turns these primitives into a transactional Text2Mem layer. A primitive edit is $$ e_j = (S_j, y_j, \lambda_j), \qquad \lambda_j \in \{+1,-1\}, $$ and a high-level operation is an ordered transaction $$ \tau = \langle e_1; e_2; \ldots; e_m \rangle. $$ The paper’s key claim is that a version-aware operation is rarely a single MeMo association; it is an ordered program of forgetting, memorizing, preserving historical chains, and recording an inverse program [2606.24040]. This transaction model supports operations such as `replace`, `obsolete`, `keep-history`, `rollback`, and `trace`. For multi-token continuations, MeMo decomposes a continuation \(Y=[y_1,\ldots,y_n]\) into a chain of next-token associations, so a replacement is implemented as forgetting the old chain and memorizing the new one. History preservation is achieved by writing versioned sequences, so the “latest” view can suppress an outdated fact while version-conditioned queries still retrieve the old fact. Rollback is defined by reversing the transaction order and negating the signs: $$ \tau^{-1} = \langle (\ell_m,S_m,y_m,-\lambda_m); \ldots; (\ell_1,S_1,y_1,-\lambda_1)\rangle. $$ Two auxiliary CMMs turn this into a memory system for changes themselves. The Version CMM maps version transitions and slot indices to transaction handles, and the Transaction CMM maps transaction handles to executable change content and inverse programs. The framework also accepts structured diff-level inputs. A structured assertion \((v,s,r,o)\) is serialized as $$ \sigma(v,s,r) = [\mathrm{VERSION}, v, \mathrm{SUBJECT}, s, \mathrm{RELATION}, r], $$ so writing and removing an assertion are simply \(\mathrm{memo}(\sigma(v,s,r), o)\) and \(\mathrm{forget}(\sigma(v,s,r), o)\) [2606.24040]. In this formulation, Text2Mem is not merely “text to vector”; it is text to an auditable, reversible, version-aware edit program over explicit memories. ## 3. Optimization-based writing and parametric fast memory A second family keeps the base language model frozen and learns a per-context memory state at test time. GradMem studies the context-removal setting in which the model must answer queries without access to the original context after a write phase. Its memory is a fixed-size matrix of prefix memory tokens, $$ \mathcal{M} \in \mathbb{R}^{m \times d}, $$ prepended to the query during reading. Writing is driven by a self-supervised context reconstruction loss, $$ \mathcal{L}_{\mathrm{write}}(\mathcal{M};C) = -\sum_{i=1}^{N} \log f_\theta\!\left(t_i \mid [\mathcal{M}; t_{