Paper deep dive
DRAM: Delta-rule Recurrent Associative Memory for Robot Manipulation Policies
Xinyu Zhao, Yixiang Shan, Tao Yang, Runyu Lei, Yiming Zhao, Jiaxin Fan, Zongbao Feng, Peng Jia
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 89%
Last extracted: 9/30/2026, 6:44:22 AM
Summary
The paper introduces DRAM (Delta-rule Recurrent Associative Memory), a plug-and-play memory module for robot manipulation policies. DRAM enables long-horizon memory in pretrained policies without architectural modifications or backbone retraining. It uses a fixed-size associative memory with gated delta-rule linear attention, processing visual patch tokens in parallel within each frame. A read-before-write mechanism ensures historical context is retrieved before the current frame updates the memory state. Experiments demonstrate that DRAM consistently improves performance over short-context baselines and other compact memory designs on diverse manipulation tasks.
Entities (8)
Relation Signals (7)
DRAM → isa → Memory Module
confidence 95% · We introduce DRAM... a plug-and-play memory module
DRAM → uses → Linear Attention
confidence 95% · DRAM maintains a fixed-size associative memory using gated delta-rule linear attention
DRAM → buildson → Delta Rule
confidence 90% · Building on delta-rule memory management... DRAM first retrieves the value currently associated with a key and then writes the residual
DRAM → improves → Robot Manipulation
confidence 90% · Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines
DRAM → outperforms → RoboTTT
confidence 85% · Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines and alternative compact memory designs
DRAM → outperforms → ReMem-VLA
confidence 85% · Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines and alternative compact memory designs
DRAM → outperforms → MemoryVLA
confidence 85% · Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines and alternative compact memory designs
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Robotic manipulation is inherently history-dependent, yet most pretrained robotic policies condition on only the current observation or a short temporal window. Equipping such policies with long-term memory remains challenging: existing approaches either feed the backbone multi-frame observation windows, which substantially increase inference cost, or rely on pre-defined semantic features, which limit task generality and may also require the retraining of the backbone to adapt to the memory. We introduce DRAM (Delta-rule Recurrent Associative Memory), a plug-and-play memory module that can be attached to a wide range of pretrained robotic policies, endowing them with long-horizon memory without architectural modification or backbone retraining, requiring only task-specific post-training of the memory module and action expert. DRAM maintains a fixed-size associative memory using gated delta-rule linear attention, with a modified update that incorporates all tokens within each frame in parallel. An architecture-agnostic readout integrates historical context into action prediction across different policy architectures. Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines and alternative compact memory designs, validating its effectiveness as a fixed-size, post-hoc memory module trained with the backbone frozen.
Tags
Links
- Source: https://arxiv.org/abs/2609.32453v2
- Canonical: https://arxiv.org/abs/2609.32453v2
Trouble viewing inline? Open PDF directly →
Full Text
69,895 characters extracted from source content.
Expand or collapse full text
DRAM: Delta-rule Recurrent Associative Memory for Robot Manipulation PoliciesThanks: Corresponding Author. Xinyu Zhao †thanks: Equal Contribution. Yixiang Shan* Tao Yang Runyu Lei Yiming Zhao Jiaxin Fan Affiliation: Zongbao Feng & Peng Jia Affiliation: Simplexity Robotics Affiliation: zhaoxinyu, shanyixiang, yangtao, leirunyu, -, fanjiaxin, Affiliation: fengzongbao, jiapeng@s-robots.com Abstract Robotic manipulation is inherently history-dependent, yet most pretrained robotic policies condition on only the current observation or a short temporal window. Equipping such policies with long-term memory remains challenging: existing approaches either feed the backbone multi-frame observation windows, which substantially increase inference cost, or rely on pre-defined semantic features, which limit task generality and may also require the retraining of the backbone to adapt to the memory. We introduce DRAM (Delta-rule Recurrent Associative Memory), a plug-and-play memory module that can be attached to a wide range of pretrained robotic policies, endowing them with long-horizon memory without architectural modification or backbone retraining, requiring only task-specific post-training of the memory module and action expert. DRAM maintains a fixed-size associative memory using gated delta-rule linear attention, with a modified update that incorporates all tokens within each frame in parallel. An architecture-agnostic readout integrates historical context into action prediction across different policy architectures. Experiments show that DRAM consistently improves frozen pretrained policies over short-context baselines and alternative compact memory designs, validating its effectiveness as a fixed-size, post-hoc memory module trained with the backbone frozen. 1 Introduction Historical information is a fundamental requirement for robot manipulation over extended horizons (Shi et al., 2026; Li et al., 2026; Jiang et al., 2026). However, many manipulation tasks are only partially observable: the current observation may not reveal objects that were previously visible but have since become occluded, task stages that have already been completed, or the outcomes of earlier interactions. Consequently, visually similar observations may require different actions depending on the preceding history. Therefore, a policy must maintain and retrieve task-relevant history information across time to form a more complete estimate of the environment state and task progress. However, many existing robot policies condition their actions only on the current observation or a short temporal window, preventing historical information outside that window from influencing subsequent decisions and limiting their performance on history-dependent tasks (Li et al., 2026; Jiang et al., 2026). Recent studies have incorporated history as memory into robot policies. Some retain compact recurrent summaries of past observations: RoboTTT compresses visuomotor history into online-updated fast weights (Jiang et al., 2026), and ReMem-VLA propagates temporal context through frame-level and chunk-level recurrent queries (Li et al., 2026). Others store historical features in an explicit memory bank and retrieve task-relevant entries, as in MemoryVLA (Shi et al., 2026). These approaches differ substantially in how history is represented, updated, and injected into the policy, and are instantiated as components of their respective policy architectures. This motivates a memory mechanism that maintains fine-grained historical information with bounded state size and exposes the retrieved information through an architecture-agnostic interface. Linear attention (Choromanski et al., 2021) provides a natural foundation for this purpose; it replaces the softmax similarity with a factorizable kernel and uses the associativity of matrix multiplication to aggregate information before applying the queries (Katharopoulos et al., 2020). Under causal processing, this computation admits a recurrent implementation in which historical associations are maintained in a fixed-size matrix (Katharopoulos et al., 2020; Schlag et al., 2021). Consequently, the size of compressed historical associations does not grow with the number of preceding observations. However, the standard additive update continually superposes new associations onto the existing state, making it difficult to remove previous associations and can eventually cause interference between similar keys (Schlag et al., 2021; Yang et al., 2024). In this work, we introduce DRAM, a Delta-rule Recurrent Associative Memory for robot manipulation policies. Building on delta-rule memory management (Schlag et al., 2021; Yang et al., 2024), instead of unconditionally adding each new association, DRAM first retrieves the value currently associated with a key and then writes the residual between this prediction and the new value. Therefore, the memory of DRAM is updated by correcting its existing association rather than repeatedly accumulating the complete value. This formulation enables DRAM to continuously incorporate new observations into a fixed-size recurrent state while controlling redundant and conflicting writes. Moreover, DRAM operates on visual patch tokens while maintaining recurrent memory updates across frames. At each control step, all visual patches query the shared pre-update memory state carried over from preceding frames. Although they access the same memory snapshot, their distinct queries produce patch-specific historical features, which are fused with the current representations through a zero-initialized residual interface for action prediction. Only after this read operation, the information of the current frame is written into memory using the delta rule, producing the state for the next frame. This read-before-write design prevents the current observation from entering its own retrieval and avoids imposing an artificial sequential order among patches within the same image. Besides, implemented as a residual branch, DRAM preserves the original policy backbone and action-generation components, and can be integrated into different robot-policy backbones without architecture-specific redesign of their action decoders. We evaluate DRAM on diverse robot manipulation tasks across multiple policy backbones, including real-robot experiments. The results show that DRAM consistently improves the performance of backbone policies. Our contributions are summarized as follows: • We introduce DRAM, a delta-rule recurrent associative memory for robot policies. DRAM maintains historical associations in a fixed-size state and updates them by correcting existing memory predictions rather than unconditionally accumulating new values. • We develop a patch-level, read-before-write memory mechanism that retrieves information from preceding frames before updating the recurrent state with the current observation, enabling fine-grained historical information to directly influence action generation. • We provide a lightweight residual interface that makes DRAM plug-and-play across different robot-policy backbones while preserving their original components, and demonstrate consistent improvements across diverse memory-dependent manipulation tasks, including real-robot evaluations. 2 Preliminaries 2.1 Problem Formulation At environment step t, a robot receives a visual observation oto_t, a proprioceptive state sts_t, and a task instruction ℓ , and predicts an action chunk t=at:t+C−1a_t=a_t:t+C-1 of length C. Let XtX_t denote the current-frame features produced by the policy backbone. A policy without persistent memory predicts t∼πθ(⋅∣Xt,st,ℓ).a_t _θ(· X_t,s_t, ). (1) The current inputs may not reveal task-relevant information from earlier interactions. Memory augments this conditioning with a persistent representation of the observation history. 2.2 Recurrent Memory Recurrent memory carries a state MtM_t across successive inputs: Mt=Fψ(Mt−1,Xt),M_t=F_ψ(M_t-1,X_t), (2) where FψF_ψ integrates the current features with the previous state. With a fixed-size state, the storage required for persistent memory is independent of the number of preceding steps. Linear attention provides an associative implementation of this recurrence (Katharopoulos et al., 2020; Schlag et al., 2021). For a generic token sequence, let qi,ki∈ℝ1×dkq_i,k_i ^1× d_k and vi∈ℝ1×dvv_i ^1× d_v, with feature maps absorbed into the queries and keys. Its unnormalized form admits Si=Si−1+ki⊤vi,ri=qiSi,S_i=S_i-1+k_i v_i, r_i=q_iS_i, (3) where Si∈ℝdk×dvS_i ^d_k× d_v compresses historical key–value associations. This matrix-valued recurrence underlies the memory formulation adopted in this work. Other implementations include gated vector states in LSTMs and memory tokens propagated through Transformer layers (Graves, 2012; Bulatov et al., 2022). Despite different state representations and update operators, these mechanisms share the recursive form in equation 2. 2.3 Delta-Rule Associative Memory The additive update in equation 3 superposes new associations without explicitly correcting existing ones. DeltaNet instead updates memory using the error of its current value prediction (Schlag et al., 2021; Yang et al., 2024). For the local associative objective ℒi(S)=12‖kiS−vi‖22L_i(S)= 12\|k_iS-v_i\|_2^2, one gradient step writes the residual vi−kiSv_i-k_iS. A gated formulation additionally applies data-dependent retention (Yang et al., 2025): S¯i−1 S_i-1 =γiSi−1, = _iS_i-1, (4) Si S_i =S¯i−1+βiki⊤(vi−kiS¯i−1), = S_i-1+ _ik_i (v_i-k_i S_i-1 ), where γi∈(0,1) _i∈(0,1) controls retention and βi∈[0,1] _i∈[0,1] controls the correction strength, with unit-normalized keys. Unlike additive accumulation, this update modifies memory according to the discrepancy between stored and incoming associations. The standard recurrence processes tokens sequentially; our method adapts this associative principle to joint updates over the tokens of each environment frame. 3 Method Figure 1: Overview of DRAM. Left: DRAM augments representations XtX_t from a frozen VLA encoder with historical information, producing YtY_t for action prediction. Right: The memory module follows a read–fuse–write procedure. After reading, current-frame associations update the retained memory through a frame-level delta update, yielding StS_t for the next frame. We introduce the Delta-rule Recurrent Associative Memory (DRAM) module, a frame-level recurrent memory for embodied policies that maintains a fixed-size historical state while preserving the spatial structure of the robot’s visual representation and other observations. Our key principle is to decouple the temporal granularity of memory recurrence from the spatial granularity of memory access: each environment frame constitutes one recurrent step, whereas individual visual patches independently read from and write to a shared associative memory. At every control step, the policy explicitly processes only the current observation, while historical information is carried through a persistent Delta-rule-based memory state. The module consists of three primitives: Read, Write, and Fuse. 3.1 Framework Overview Figure 1 illustrates the framework of DRAM. At control step t, the frozen VLM backbone encodes the current image, together with other inputs such as the language instruction and the robot state, and exposes a collection of frame-level latent token sequences, denoted collectively by Xt=XtQ,XtK,XtVX_t=\X_t^Q,X_t^K,X_t^V\, whose shapes and granularity are not fixed a priori. We retain the frame-level latent sequences rather than pooling each observation into a single write vector—and we define the query and write sources of one memory layer as views of these latents: XtQ∈ℝM×DQ,XtK∈ℝN×DK,XtV∈ℝN×DV,X^Q_t ^M× D_Q, X^K_t ^N× D_K, X^V_t ^N× D_V, (5) where DQ,DK,DVD_Q,D_K,D_V are the backbone feature dimensions. The three sources follow two interface patterns depending on the host policy’s architecture: a shared-source interface sets all three to the same sequence (M=NM=N), while a separate-source interface draws the write sources XtK,XtVX^K_t,X^V_t from the backbone latents XtX_t with a flexible query source. We present the general case with M query tokens and N write tokens, and treat sharing as a special instance. Given the normalized sources Zt⋅=LN(Xt⋅)Z^\·\_t=LN(X^\·\_t), the head-wise query, key, and value components are as follows: Qt(h)=Norm(ZtQWQ(h)),Kt(h)=Norm(ZtKWK(h)),Vt(h)=ZtVWV(h),Q_t^(h)=Norm (Z^Q_tW_Q^(h) ), K_t^(h)=Norm (Z^K_tW_K^(h) ), V_t^(h)=Z^V_tW_V^(h), (6) where h∈1,…,Hh∈\1,…,H\ indexes H heads, Norm(⋅)Norm(·) denotes row-wise ℓ2 _2 normalization, and Qt∈ℝH×M×dkQ_t ^H× M× d_k, Kt∈ℝH×N×dkK_t ^H× N× d_k, Vt∈ℝH×N×dvV_t ^H× N× d_v. The rows of KtK_t and VtV_t remain paired within each head. Crucially, their row index is not an environment timestamp: whether encoding spatial position, camera identity, or language order, all tokens of one frame belong to the same physical observation. They therefore form a single recurrent input rather than a sequence of timesteps—the premise of the frame-synchronous write in Section 3.3. In the DRAM module, the historical information is carried by a set of H associative memory states per layer, t=St(h)∈ℝdk×dv|h=1,…,H,S_t= \\,S_t^(h) ^d_k× d_v\, |\,h=1,…,H\, \, (7) whose size is independent of the episode length. Head indices and padding masks are omitted below except where heads interact. With these head-wise representations, the core of memory operation carries out three primitives: Read:Rt Read: R_t =Read(Qt,St−1), =Read(Q_t,\,S_t-1), (8) Fuse:Yt Fuse: Y_t =Fuse(XtQ,Rt), =Fuse(X^Q_t,\,R_t), (9) Write:St Write: S_t =Write(Kt,Vt,St−1,γtβt). =Write(K_t,\,V_t,\,S_t-1;\, _t\, _t). (10) Read retrieves historical information for all queries in parallel from the pre-update state St−1S_t-1. Fuse combines the readout RtR_t with the query-source tokens to produce the memory-augmented representation YtY_t consumed by the downstream policy. Write then updates the state for the next frame: it applies the soft retention gate γt _t to the inherited state, then incorporates the current key–value associations through a single joint update modulated by βt _t. These equations specify dependencies rather than a mandatory serial schedule: retrieval reads St−1S_t-1 rather than the newly written StS_t; retention affects only the state-update branch; and fusion depends only on the query source and the historical readout. The raw readout RtR_t remains available independently of fusion, allowing the policy adapter to decide how retrieved information enters the host policy. We detail the readout path—Read and Fuse—in Section 3.2, the state update—Write—in Section 3.3. 3.2 Memory Access and Historical Fusion At each control step, memory serves the policy before it is updated: the current frame first retrieves history, and the retrieved content is fused into the policy’s token stream. Read: frame-level retrieval from the pre-update state. Before any writing, every query token retrieves from the incoming state: Rt(h)=Qt(h)St−1(h)dk∈ℝM×dv,Rt=∥h=1HRt(h),R_t^(h)= Q_t^(h)S_t-1^(h) d_k ^M× d_v, R_t= \|_h=1^HR_t^(h), (11) where ∥\| concatenates along the feature dimension. Queries are computed from the current frame while St−1S_t-1 contains only past frames, so retrieval conditions on the current observation and task without the current frame leaking into its own readout. Fuse: zero-initialized gated residual. Fusion combines the concatenated readout RtR_t with the query source through a gated residual branch, Yt=Fuse(XtQ,Rt)=XtQ+fO(σ(fG(XtQ))⊙Rt),Y_t=Fuse(X^Q_t,R_t)=X^Q_t+f_O\! (σ\! (f_G(X^Q_t) ) R_t ), (12) where fG:ℝDQ→ℝHdvf_G:R^D_Q\!→\!R^Hd_v is a row-wise affine gate and fO:ℝHdv→ℝDQf_O:R^Hd_v\!→\!R^D_Q is the output projection. We zero-initialize fOf_O, making FUSE an exact identity at initialization; the memory readout thus initially adds no residual change to the query representations. The gate and projection affect only the query stream, and an optional bidirectional intra-frame mixer (attention and MLP) may further process YtY_t within that stream. From readout to action. How the fused representation is consumed depends on whether the query stream shares its source with the write streams (Section 3.1). With separate sources, the readout is a representation of its own: the query slots’ outputs enter the policy as additional context alongside an untouched host token stream (our π0.5 _0.5 (Black et al., 2025) host). With a shared source, history is instead carried by the token stream itself: Fuse returns the fused sequence YtY_t in place of the raw readout, memory layers stack as in an ordinary transformer with a depth independent of the host, and the action head reads YtY_t through its original interface with no modification (our DiT host). In both cases the downstream conditioning interface is unchanged. Appendix B details the two patterns and their host instantiations. 3.3 Frame-Synchronous Joint Write The original delta rule updates memory states one association at a time, a schedule dictated by the sequential nature of text. In embodied policies, however, all tokens of one frame become available simultaneously, and their serialization, whether spatial layout, camera identity, or language order, carries no temporal meaning. We therefore promote the update unit from a single token to a whole frame. Each environment frame triggers exactly one memory transition, in which all of its key–value associations are written jointly. Gates: frame-level retention and token-level write strength. A scalar retention gate per head and frame softly decays the inherited state, γt(h)=exp−exp(ah)ζ(g¯tuγ,h+bγ,h)∈(0,1),S¯t−1(h)=γt(h)St−1(h), _t^(h)= \! \- (a_h)\,ζ( g_t\,u_γ,h+b_γ,h) \∈(0,1), S_t-1^(h)= _t^(h)S_t-1^(h), (13) where g¯t g_t is the mask-aware mean of the write-source rows (Section 3.1), uγ,hu_γ,h a learned direction, aha_h a learned scale, and ζ(⋅)ζ(·) the softplus function. A per-token write gate sets the strength of each association from the corresponding write-source row gt,ig_t,i: βt,i(h)=σ(gt,iuβ,h+bβ,h),β^t,i(h)=min(βt,i(h),0.99),wt,i(h)=piβ^t,i(h)1−β^t,i(h), _t,i^(h)=σ(g_t,iu_β,h+b_β,h), β_t,i^(h)= ( _t,i^(h),0.99), w_t,i^(h)=p_i\, β_t,i^(h)1- β_t,i^(h), (14) with pi∈0,1p_i∈\0,1\ the padding mask. The odds reparameterization w=β^/(1−β^)w= β/(1- β) is chosen so that, for a single unit-norm key, the joint update below reduces exactly to the gated delta rule with strength β β (Appendix C.2); the cap bounds w≤99w≤ 99 for numerical conditioning (Appendix C.4). Update: frame-synchronous joint associative correction. The original delta rule is one gradient step on its prediction error (Sec. 2.3). Instead of applying one such gradient step independently to each token in the latent sequence, we consider resolving all N corrections simultaneously. Suppressing head indices, let S¯=γtSt−1 S= _tS_t-1 and Wt=diag(wt,1,…,wt,N)W_t=diag(w_t,1,…,w_t,N). All N associations of the current frame are written in one transition, defined as the minimizer of St=argminS∈ℝdk×dv12‖S−S¯‖F2+12‖Wt1/2(KtS−Vt)‖F2,S_t= _S ^d_k× d_v\; 12\|S- S\|_F^2+ 12 \|W_t^1/2(K_tS-V_t) \|_F^2, (15) where Kt∈ℝN×dkK_t ^N× d_k and Vt∈ℝN×dvV_t ^N× d_v stack the keys and values of the N write tokens row-wise, and Wt1/2=diag(wt,1,…,wt,N)W_t^1/2=diag( w_t,1,…, w_t,N), so that the second term is simply the weighted sum 12∑iwt,i‖kt,iS−vt,i‖22 12 _iw_t,i\|k_t,iS-v_t,i\|_2^2. In the above equation, the first term anchors the update to retained history, and the second asks one candidate state to explain all current key–value pairs simultaneously. Since the latter constrains only the directions spanned by the current keys, the anchor—selecting the fitting state closest to S¯ S—keeps all unaddressed content intact. Being quadratic in S, Equation 15 is minimized where its gradient vanishes, which yields the normal equation (Idk+Kt⊤WtKt)St=S¯+Kt⊤WtVt(I_d_k+K_t W_tK_t)\,S_t= S+K_t W_tV_t. Since A≜Idk+Kt⊤WtKtA I_d_k+K_t W_tK_t is symmetric positive definite for any non-negative weights, the minimizer is unique with the closed-form solution: St=A−1(S¯+Kt⊤WtVt)=A−1S¯+A−1Kt⊤WtVt.S_t=A^-1 ( S+K_t W_tV_t )=A^-1 S+A^-1K_t W_tV_t. (16) All predictions KtS¯K_t S are evaluated against the single retained state, and A−1A^-1 couples the residual corrections according to the key geometry. Detailed derivation can be found in Appendix C.1. Note that the decay gate and the joint write are not independent forget mechanisms: the historical term in Equation 16 is γtA−1St−1 _tA^-1S_t-1, so in directions constrained by current keys the retained content is attenuated beyond the scalar decay—the joint fit replaces it—while unconstrained directions undergo only soft decay. In practice, A−1A^-1 is never materialized: writing St=S¯+ΔS_t= S+ , the normal equation becomes AΔ=Kt⊤Wt(Vt−KtS¯)A\, =K_t W_t (V_t-K_t S ) (17) which we solve by Cholesky factorization, returning St=S¯+ΔS_t= S+ . Fully padded frames leave St−1S_t-1 untouched; valid frames with all-zero write weights return only the decayed S¯ S. Masks, precision, and gradient flow through the solve are detailed in Appendix C.4. Why not sequential token writes? One could apply the delta rule token-by-token within a frame, iterating Equation 4 N times. This chains N recurrent states indexed by an arbitrary serialization of the current frame: each correction changes the state used to predict later values, so the final state depends on the within-frame order even for identical inputs (a minimal counterexample is in Appendix C.1). Chunked kernels accelerate this recurrence without removing that dependence. We instead treat one frame as one simultaneous observation: Equation 15 is the same local associative objective as the delta rule, optimized jointly rather than greedily. Properties. Three properties matter for embodied use; all are proved in Appendix C. (i) Single-token correspondence. For a single association (k,v)(k,v) with ‖k‖=1\|k\|=1 and weight w=β^/(1−β^)w= β/(1- β), Equation 16 reduces to the gated delta rule of Equation 4 with the clipped gate β β, so the joint-write rule strictly generalizes delta-rule memory management to simultaneous writes. (i) Within-frame permutation invariance. Applying a common permutation to the rows of Kt,VtK_t,V_t and the diagonal entries of WtW_t leaves StS_t unchanged in exact arithmetic: there is no serialization-induced recency bias among tokens of the same frame. (i) Bounded evidence accumulation. n repetitions of one association act with effective strength nw/(1+nw)nw/(1+nw): evidence accumulates monotonically yet saturates below one, so repeated tokens reinforce rather than dilute the write. 3.4 Training with Truncated Backpropagation through Time DRAM is designed for post-hoc integration on a pretrained policy: we train the memory module, the policy-specific adapter, and the action expert, while keeping the vision tower and the VLM backbone fully frozen. This choice is deliberate rather than merely economical. The memory is trained jointly with the action expert through truncated BPTT (backpropagation through time). Co-training the deep VLM with the memory would chain gradients through the solve, the backbone layers, and the memory states of earlier frames—brittle to optimize and prone to destabilizing the pretrained representations the policy depends on. The frozen backbone ensures the stability of the latent feature space, allowing memory to learn what to store, retrieve, and forget on top of frozen features, with all memory parameters optimized solely by the downstream control objective; we introduce no auxiliary reconstruction, retrieval, or memory-specific loss. Control objective. Any host policy objective can supervise the memory. In our setup, the action expert is trained using flow matching under its data-to-noise convention: for a demonstrated action chunk ta_t, ϵ∼(0,I)ε (0,I), and flow time τ=0.999b+0.001τ=0.999\,b+0.001 with b∼Beta(1.5,1)b (1.5,1), tτ=(1−τ)t+τϵ,ut=ϵ−t,ℒFM=‖vθ,ψ(tτ,τ,ct,Rt)−ut‖22,a_t^τ=(1-τ)\,a_t+τ\,ε, u_t=ε-a_t, _FM=E \|\,v_θ,ψ(a_t^τ,τ;\,c_t,R_t)-u_t\, \|_2^2, (18) using the host policy’s padding-aware action reduction. Here ctc_t denotes the current-frame context, θ the action-expert parameters, and ψ the memory and adapter parameters; RtR_t collectively denotes the memory readouts consumed by the adapter. Gradients of ℒFML_FM flow through every memory operation—patch-level retrieval, gated writing, and temporal retention—so the contents of memory are shaped directly by their utility for control rather than by any hand-designed storage criterion. Recurrent unrolling. Training unrolls consecutive frames within a TBPTT window. Inside a window, gradients propagate through historical reads, the retention and write gates, fusion where used, and the differentiable joint solve (Appendix C); recurrent states are detached only at window boundaries, not at activation-checkpoint segment boundaries. Valid-frame losses are averaged over the contributing ranks and accumulated windows. At deployment, each new observation triggers exactly one read–write transition, the action expert denoises only when a new action chunk is required, and the memory persists across chunks and resets across episodes. Note that a bounded persistent state does not bound training-time activation memory, which still grows with the TBPTT window length. 4 Experiments 4.1 Setup Benchmark. Our main evaluation uses the four LIBERO suites (Liu et al., 2023): LIBERO-Spatial, LIBERO-Object, LIBERO-Goal, and LIBERO-10. These suites cover variations in spatial arrangements, objects, and task goals, as well as longer manipulation tasks. Note that LIBERO-10 provides a particularly relevant setting for examining performance over longer execution horizons. Compared methods. We compare DRAM with representative approaches that incorporate historical information into robot policies: MemoryVLA (Shi et al., 2026), HAMLET (Koo et al., 2026), μ (Cherepanov et al., 2026), and ContextVLA (Jang et al., 2025). These methods employ explicit memory banks, historical token aggregation, recurrent memory tokens, or compressed multi-frame context. For ContextVLA, we include its reported results with π0 _0, π0 _0-FAST, and GR00T N1.5. DRAM uses π0.5 _0.5 as its backbone policy in the main comparison. 4.2 Main Results Table 1: Success rates (%) on LIBERO. Bold indicates the best result in each row, including ties. Superscripts indicate the backbone; DRAM uses π0.5 _0.5. Averages are recomputed over the four suites. Published results use their respective training and evaluation protocols. Environment MemoryVLA HAMLET μ ContextVLAπ0 _0 ContextVLAπ0-FAST _0-FAST ContextVLAG DRAM (Ours) LIBERO-Spatial 98.40 99.00 93.00 97.40 98.30 98.40 99.00 LIBERO-Object 98.40 100.00 99.40 98.20 99.20 99.00 100.00 LIBERO-Goal 96.40 99.20 96.60 96.40 95.60 97.20 98.00 LIBERO-10 93.40 92.20 95.80 93.80 90.20 93.40 99.00 Average 96.65 97.60 96.20 96.45 95.83 97.00 99.00 Table 1 summarizes the results. DRAM achieves an average success rate of 99.00%99.00\%, the highest among the compared methods, exceeding the next-best average of 97.60%97.60\% from HAMLET by 1.401.40 percentage points. The largest advantage appears on LIBERO-10, where DRAM reaches 99.00%99.00\%, exceeding the next-best result of 95.80%95.80\% from μ by 3.203.20 percentage points. This result is consistent with the intended role of DRAM in supporting decisions over longer task executions. On LIBERO-Spatial and LIBERO-Object, DRAM achieves 99.00%99.00\% and 100.00%100.00\%, respectively, matching the best reported results in the comparison. On LIBERO-Goal, DRAM obtains 98.00%98.00\%, below HAMLET’s 99.20%99.20\%, indicating that its advantage is not uniform across all suites. These reported results indicate strong overall LIBERO performance. Because the published methods use different training and evaluation protocols, we next compare each backbone with and without DRAM to assess its contribution under matched conditions. Table 2: LIBERO success rates (%) across policy backbones. Bold indicates the better result within each pair, including ties. DiT 0.5 π_0.5 Suite Baseline + DRAM Baseline + DRAM LIBERO-Spatial 83.25 92.00 97.00 99.00 LIBERO-Object 88.00 97.50 99.00 100.00 LIBERO-Goal 91.00 98.00 98.00 98.00 LIBERO-10 75.00 91.00 96.00 99.00 Average 84.31 94.63 97.50 99.00 To examine whether DRAM benefits different policy architectures, we compare each host policy with its DRAM-augmented counterpart on LIBERO. Note that this requires different integration patterns, which are detailed in Appendix B. As shown in Table 2, DRAM improves the DiT policy across all four suites, increasing its average success rate from 84.31%84.31\% to 94.63%94.63\%. The largest improvement occurs on LIBERO-10, where success increases from 75.00%75.00\% to 91.00%91.00\%, a gain of 16.0016.00 percentage points. DRAM also benefits the stronger π0.5 _0.5 backbone, raising its average success rate from 97.50%97.50\% to 99.00%99.00\%. It improves performance on Spatial, Object, and LIBERO-10, while maintaining the 98.00%98.00\% success rate on Goal. Together, these results support the applicability of DRAM to both evaluated backbones, with gains observed at different levels of baseline performance. Table 3: Success rates (%) on RMBench. Bold indicates the best result in each row, including ties. π0.5 _0.5, X-VLA, and Mem-0 results are taken from the RMBench benchmark and use their respective training and evaluation protocols; DRAM uses the π0.5 _0.5 backbone with native-KV integration. Task π0.5 _0.5 X-VLA Mem-0 DRAM π0.5 _0.5 (Ours) Battery Try 16.00 26.00 28.00 65.00 Blocks Ranking Try 6.00 1.00 18.00 45.00 Cover Blocks 0.00 2.00 68.00 70.00 Observe and Pick Up 9.00 9.00 4.00 15.00 Press Button 0.00 0.00 0.00 20.00 Put Back Block 11.00 18.00 90.00 65.00 Rearrange Blocks 13.00 13.00 89.00 95.00 Swap T 15.00 3.00 14.00 45.00 Swap Blocks 24.00 16.00 67.00 100.00 Average 10.40 9.80 42.00 57.80 We further evaluate DRAM on RMBench Chen et al. (2026), a bimanual manipulation benchmark in which task completion explicitly requires episodic memory, covering nine tasks that range from recalling a single past event to accumulating evidence across multiple events. Table 3 compares DRAM, instantiated on π0.5 _0.5 with the native-KV integration pattern, against the published π0.5 _0.5, X-VLA, and Mem-0 results from the benchmark. DRAM attains an average success rate of 57.8%57.8\%, exceeding the strongest baseline, Mem-0, by 15.815.8 percentage points, and achieves the highest success rate on eight of the nine tasks. The gains are most pronounced on tasks that require retaining episode-specific state, such as Battery Try (65%65\% vs. 28%28\%) and Swap T (45%45\% vs. 15%15\%); Put Back Block is the only task on which DRAM trails a baseline (65%65\% vs. 90%90\% from Mem-0). As the published results follow their respective training and evaluation protocols, this comparison is indicative rather than strictly controlled; nevertheless, it corroborates the LIBERO findings on tasks where memory is indispensable. We evaluate DRAM on the π0.5 _0.5 backbone over 5050 rollouts per task with the same training data budget as the benchmarked policies (5050 demonstrations per task); the baseline success rates are taken directly from RMBench Chen et al. (2026), which reports 100100 rollouts per task. 4.3 Flexibility of Memory Integration DRAM separates recurrent memory operations from the policy representations used to construct memory. We examine this flexibility on π0.5 _0.5 through three configurations that use different write sources while retaining the same memory update rule and prefix-based injection interface. Integration configurations. Native KV uses the pre-RoPE keys and values from each aligned VLM layer as memory write sources. Hidden Tokens derives memory keys and values from the hidden tokens of the corresponding VLM layer. Last Hidden uses the final VLM hidden sequence as the write source across memory layers and exposes only the final memory readout. In all configurations, the retrieved features are projected into additional prefix keys and values for the action expert. Table 4: Success rates (%) of different DRAM configurations on LIBERO with π0.5 _0.5 from LeRobot. Averages are recomputed over the four displayed suite-level success rates. Bold indicates the best result in each row. Baseline DRAM (Ours) Suite π0.5 _0.5 Native KV Hidden Tokens Last Hidden LIBERO-Spatial 97.00 99.00 98.50 98.50 LIBERO-Object 99.00 100.00 99.00 99.50 LIBERO-Goal 98.00 98.00 99.50 96.00 LIBERO-10 96.00 99.00 97.50 96.00 Average 97.50 99.00 98.63 97.50 Results. As shown in Table 4, Native KV achieves the best average success rate of 99.00%99.00\%, exceeding the baseline by 1.501.50 percentage points. Hidden Tokens reaches 98.63%98.63\%, while Last Hidden matches the baseline average of 97.50%97.50\%. Thus, the choice of write source affects the benefit of DRAM even with the same memory update rule. 4.4 Sensitivity to Memory Reset Interval To test sensitivity to interruptions of its recurrent state, we evaluate DRAM on LIBERO-10 while resetting all memory states every L observation-frame updates, with L∈8,32,128,256L∈\8,32,128,256\. The full-memory setting resets only between episodes. We use the same trained checkpoint and inference settings, with 3030 rollouts per subtask (300300 total). Figure 2: LIBERO-10 success versus memory reset interval L (in frames). Full resets only between episodes; the dashed line denotes the π0.5 _0.5 baseline without DRAM. As shown in Figure 2, resetting memory every 88, 3232, or 128128 frames yields success rates of approximately 7373–76%76\%, well below both full memory (99.0%99.0\%) and the π0.5 _0.5 baseline without DRAM (96.0%96.0\%). Increasing the interval to 256256 frames raises the success rate to 91.3%91.3\%, although it remains 7.77.7 percentage points below full memory and even still below the no-memory baseline. These results show that the trained policy is sensitive to interruptions of its recurrent state and that longer intervals substantially reduce the performance loss. Periodic resets also alter the memory states encountered later in an episode, so these results characterize the policy’s sensitivity to interrupted memory rather than establish a precise effective memory horizon. 4.5 Real-world Experiments Table 5: Real-world success rates (%). Task DiT DiT + DRAM Insertion 90.0 100.0 Full Task 0.0 85.0 Setup. Using the same DiT-based policy with cross-attention conditioning, we evaluate insertion and a longer, multi-stage task with and without DRAM. Each task-policy setting is evaluated in 20 trials; all other training and evaluation settings are unchanged. Details are provided in Appendix D. Results. As shown in Table 5, DRAM raises insertion success from 90.0% to 100.0% and full-task success from 0.0% to 85.0%. The larger gain on the multi-stage task supports the value of persistent memory in this real-world setting. 5 Related Work 5.1 Memory for Robotic Manipulation Historical context helps robot policies resolve partial observability and track task progress, and existing approaches differ in how they represent and maintain it. MemoryVLA maintains an explicit bank of perceptual and cognitive features, retrieved via cross-attention with redundant entries consolidated (Shi et al., 2026); HAMLET and ContextVLA instead compress history into compact tokens—moment tokens aggregated over a history window (Koo et al., 2026), or a single context token within the VLM backbone (Jang et al., 2025). Others propagate compact recurrent states: μ carries memory tokens through backbone self-attention (Cherepanov et al., 2026), ReMem-VLA maintains frame- and chunk-level recurrent queries (Li et al., 2026), and MEM pairs short-term visual context with a recurrent language summary of longer-term semantics (Torne et al., 2026). Closest to DRAM, RoboTTT scales visuomotor context through fast-weight adaptation (Jiang et al., 2026), inserting test-time-training layers into the action head that encode history by updating small networks during execution. DRAM instead maintains an associative memory of token-level key–value associations, retrieves historical features from the pre-update state, and incorporates each frame through a joint memory update. 5.2 Recurrent Associative Memory Linear attention admits a recurrent formulation that summarizes historical key–value associations in a fixed-size matrix (Katharopoulos et al., 2020). The connection to fast-weight learning provides an associative interpretation of this state and motivates delta-rule updates that correct existing predictions instead of repeatedly accumulating complete values (Schlag et al., 2021). Subsequent work develops efficient parallel algorithms for DeltaNet and combines associative correction with data-dependent forgetting in Gated DeltaNet (Yang et al., 2024; Yang et al., 2025). These mechanisms provide the foundation for DRAM’s memory operations. Our focus is their use with structured visual observations, where tokens of one frame are simultaneously available, and their serialization carries no temporal meaning. DRAM therefore treats each frame as one recurrent input: queries retrieve from the pre-update state, and current associations are incorporated through a single joint optimization anchored to retained history. 5.3 Frame-wise Delta Updates Treating one frame as a simultaneous write unit has emerged independently in video modeling. SANA-WM (Zhu et al., 2026) writes each frame into a linear-attention world model explicitly, scaling keys by 1/U1/ U, while a concurrent analysis (Zhu, 2026) instead solves the per-frame ridge problem, deriving essentially the same closed form and odds-based gate conversion as DRAM. DRAM is concurrent and complementary: the joint write lives in an external, policy-agnostic memory attached to a frozen policy, remains strictly causal at control time, and is trained directly by the control objective under TBPTT. 6 Conclusion We presented DRAM, a recurrent associative memory module that augments pretrained robot policies with persistent historical context. DRAM maintains a fixed-size memory state with token-level associations, retrieves history from the pre-update state, and incorporates each frame through a joint update that imposes no sequential order among tokens of the same frame. Separating memory operations from policy integration lets DRAM support different representation interfaces while preserving the host policy’s components, and experiments on simulated and real-world tasks show consistent gains, most pronounced on longer multi-stage tasks. 7 Author Contributions Xinyu Zhao conceived the idea, led the experiments, and contributed to analyzing the experimental results, writing and revising the manuscript. Yixiang Shan led the experimental design, the analysis of the experimental results, the writing of the initial draft, and contributed to revising the manuscript. Tao Yang, Runyu Lei, Yiming Zhao, and Jiaxin Fan contributed to reviewing and revising the manuscript. Zongbao Feng and Peng Jia supervised the research and contributed to reviewing and revising the manuscript. References Black et al. (2025) K. Black, N. Brown, J. Darpinian, K. Dhabalia, D. Driess, A. Esmail, M. R. Equi, C. Finn, N. Fusai, M. Y. Galliker, D. Ghosh, L. Groom, K. Hausman, B. Ichter, S. Jakubczak, T. Jones, L. Ke, D. LeBlanc, S. Levine, A. Li-Bell, M. Mothukuri, S. Nair, K. Pertsch, A. Z. Ren, L. X. Shi, L. Smith, J. T. Springenberg, K. Stachowicz, J. Tanner, Q. Vuong, H. Walke, A. Walling, H. Wang, L. Yu, and U. Zhilinsky π0.5 _0.5: a vision-language-action model with open-world generalization. In Proceedings of The 9th Conference on Robot Learning, Proceedings of Machine Learning Research, Vol. 305, p. 17–40. Cited by: §3.2. Bulatov et al. (2022) A. Bulatov, Y. Kuratov, and M. Burtsev Recurrent memory transformer. In Advances in Neural Information Processing Systems, Vol. 35, p. 11079–11091. Cited by: §2.2. Chen et al. (2026) T. Chen, Y. Wang, M. Li, Y. Qin, H. Shi, Z. Li, Y. Hu, Y. Zhang, K. Wang, Y. Chen, H. Wang, J. Wang, T. Yang, R. Xu, R. Wu, Y. Mu, Y. Yang, H. Dong, and P. Luo RMBench: memory-dependent robotic manipulation benchmark with insights into policy design. arXiv preprint arXiv:2603.01229. Cited by: §4.2. Cherepanov et al. (2026) E. Cherepanov, N. Kachaev, D. Zelezetsky, A. Bulatov, A. Pshenitsyn, Y. Kuratov, A. Skrynnik, A. I. Panov, and A. K. Kovalev μ : on recurrent memory for partially observable manipulation in vla models. arXiv preprint arXiv:2606.12497. Cited by: §4.1, §5.1. Choromanski et al. (2021) K. Choromanski, V. Likhosherstov, D. Dohan, X. Song, A. Gane, T. Sarlos, P. Hawkins, J. Davis, A. Mohiuddin, L. Kaiser, D. Belanger, L. Colwell, and A. Weller Rethinking attention with performers. In International Conference on Learning Representations, Cited by: §1. Graves (2012) A. Graves Long short-term memory. Supervised sequence labelling with recurrent neural networks, p. 37–45. Cited by: §2.2. Jang et al. (2025) H. Jang, S. Yu, H. Kwon, H. Jeon, Y. Seo, and J. Shin Contextvla: vision-language-action model with amortized multi-frame context. arXiv preprint arXiv:2510.04246. Cited by: §4.1, §5.1. Jiang et al. (2026) Y. Jiang, Y. Chebotar, R. Zheng, F. Hu, Y. Ge, J. Wu, T. Dai, S. Reed, F. Li, Y. Zhu, and L. Fan RoboTTT: context scaling for robot policies. arXiv preprint arXiv:2607.15275. External Links: Link Cited by: §1, §1, §5.1. Katharopoulos et al. (2020) A. Katharopoulos, A. Vyas, N. Pappas, and F. Fleuret Transformers are RNNs: fast autoregressive transformers with linear attention. In Proceedings of the 37th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 119, p. 5156–5165. External Links: Link Cited by: §1, §2.2, §5.2. Koo et al. (2026) M. Koo, D. Choi, T. Kim, K. Lee, C. Kim, Y. Seo, and J. Shin Hamlet: switch your vision-language-action model into a history-aware policy. In International Conference on Learning Representations, Vol. 2026, p. 101537–101558. Cited by: §4.1, §5.1. Li et al. (2026) H. Li, F. Shen, D. Chen, L. Yang, X. Wang, J. Shi, Z. Bing, Z. Liu, and A. Knoll ReMem-VLA: empowering vision-language-action model with memory via dual-level recurrent queries. arXiv preprint arXiv:2603.12942. External Links: Link Cited by: §1, §1, §5.1. Liu et al. (2023) B. Liu, Y. Zhu, C. Gao, Y. Feng, Q. Liu, Y. Zhu, and P. Stone Libero: benchmarking knowledge transfer for lifelong robot learning. Advances in Neural Information Processing Systems 36, p. 44776–44791. Cited by: §4.1. Schlag et al. (2021) I. Schlag, K. Irie, and J. Schmidhuber Linear transformers are secretly fast weight programmers. In Proceedings of the 38th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 139, p. 9355–9366. External Links: Link Cited by: §1, §1, §2.2, §2.3, §5.2. Shi et al. (2026) H. Shi, B. Xie, Y. Liu, L. Sun, F. Liu, T. Wang, E. Zhou, H. Fan, X. Zhang, and G. Huang MemoryVLA: perceptual-cognitive memory in vision-language-action models for robotic manipulation. In The Fourteenth International Conference on Learning Representations, Note: arXiv:2508.19236 External Links: Link Cited by: §1, §1, §4.1, §5.1. Torne et al. (2026) M. Torne, K. Pertsch, H. Walke, K. Vedder, S. Nair, B. Ichter, A. Z. Ren, H. Wang, J. Tang, K. Stachowicz, et al. Mem: multi-scale embodied memory for vision language action models. arXiv preprint arXiv:2603.03596. Cited by: §5.1. Yang et al. (2025) S. Yang, J. Kautz, and A. Hatamizadeh Gated delta networks: improving mamba2 with delta rule. In International Conference on Learning Representations, Cited by: §2.3, §5.2. Yang et al. (2024) S. Yang, B. Wang, Y. Zhang, Y. Shen, and Y. Kim Parallelizing linear transformers with the delta rule over sequence length. In Advances in Neural Information Processing Systems, Vol. 37. Cited by: §1, §1, §2.3, §5.2. Zhu et al. (2026) H. Zhu, H. Liu, Y. Zhao, T. Ye, J. Chen, J. Yu, T. He, S. Han, and E. Xie SANA-WM: efficient minute-scale world modeling with hybrid linear diffusion transformer. arXiv preprint arXiv:2605.15178. Cited by: §5.3. Zhu (2026) H. Zhu Reflections on video DeltaNet. Note: https://w.haoyizhu.site/blog/video-delta-rule/Blog post (in Chinese). Accessed: 2026-09-23 Cited by: §C.2, §5.3. Appendix A The Use of Large Language Models (LLMs) We employ Large Language Models (LLMs) for grammar checking in our paper. Appendix B Flexible Integration Patterns DRAM admits the two integration patterns introduced in Section 3.2: separate-source integration, where the query stream is decoupled from the host’s tokens, and shared-source integration, where the host’s frame tokens themselves carry the memory interface. The choice is dictated by the host architecture rather than by the memory: the Read, Write, and Fuse operations of Section 3 are identical in both. Within each pattern, three further choices are orthogonal: where the write sources are tapped, how the readout is delivered to the policy, and how memory layers align with host layers. We instantiate the two patterns with the π0.5 _0.5 and DiT hosts used in our experiments. B.1 Separate-source integration: the π0.5 _0.5 host With designated query slots (learned slots are the simplest case), the query stream is decoupled from the host’s token stream: the write sources are designated backbone features of the current frame, while the query stream alone evolves across stacked memory layers. The readout then enters the policy as a separate representation—attention prefix slots, appended memory tokens, or the pre-head representation—leaving the host’s own token stream untouched. Our π0.5 _0.5 host follows this pattern. The frozen VLM backbone has 18 transformer layers, and DRAM layers are aligned with them: memory layer ℓ reads and writes using features of backbone layer ℓ , so historical context is exchanged at matching representation depths. The query stream is a set of M learned query slots, and the write sources XtK,XtVX^K_t,X^V_t are tapped from the backbone in one of three configurations, illustrated in Figure 3: (i) Native KV reuses the backbone attention’s own key–value projections of each layer as the write sources, tapping representations the backbone already computes; (i) Hidden tokens tap the hidden token states of each backbone layer and projects them with DRAM’s own WK(h),WV(h)W_K^(h),W_V^(h); (i) Last hidden uses the final-layer VLM hidden tokens as a shared write source across memory layers, allowing the memory bank depth to be chosen independently of the VLM depth; only the final memory readout is passed to the action expert. Section 4.3 compares the three configurations empirically (Table 3). Figure 3: Write-source configurations for the π0.5 _0.5 host (separate-source integration). DRAM layers are aligned with the VLM backbone layers, and the write sources of memory layer ℓ are tapped from (i) the backbone attention’s native key–value projections (Native KV), (i) intermediate hidden tokens (Hidden tokens), or (i) only the final-layer hidden states (Last hidden). Query slots, readout injection, and the memory update are identical across configurations. For the readout, the query slots retrieve from each memory layer, and the fused readouts are injected as prefix slots into the action expert’s attention. The prefix slots use a reserved RoPE index (−1-1), for which rotation of their keys is skipped; the action expert’s original tokens retain their position indices and thus their relative positions. The zero-initialized output projection makes FUSE an identity at initialization, so the memory readout initially adds no residual change to the query representations. B.2 Shared-source integration: the DiT host Without a deep multimodal backbone to tap, the current frame’s own tokens serve as the query, key, and value sources at once, and each memory layer returns the fused sequence Yt(ℓ)Y_t^( ) in place of the raw readout, feeding layer ℓ+1 +1 as in an ordinary transformer. Since history is mixed into the tokens while preserving their structure, the action head consumes YtY_t through its original interface with no modification; one simply designates which layer’s output feeds it. Our DiT host follows this pattern, in the style of GR00T N1.7: a vision tower encodes all camera views of the current frame at once, and the resulting patch tokens are flattened into a single sequence on which a DiT action head conditions through cross-attention. The frame tokens serve as the query, key, and value sources of DRAM (M=NM=N); each memory layer applies the full read–fuse–write procedure, optionally followed by the intra-frame mixer, and memory layers stack with a depth chosen independently of the host. Because history is carried by the tokens themselves—preserving their number, ordering, and positional encoding—the DiT head reads the fused sequence through its original cross-attention interface unchanged. Practical principles. Two guidelines apply across both patterns. First, history-carrying tokens should not disturb the host’s positional scheme: injected readouts are marked as positionless (a reserved RoPE index with unrotated values, as above) or delivered through channels that bypass positional encoding altogether. Second, readout granularity is orthogonal to the write-source choice: layer-aligned readouts suit deep hosts whose representations evolve across layers, whereas a single final-layer readout suffices for shallow hosts or single-layer memory. Appendix C Derivation and Properties of the Frame-Level Joint Write This appendix derives the closed form of the frame-synchronous joint write (Section 3.3), proves the properties stated in the main text, and details its numerical realization, including gradient flow through the solve. Throughout, we suppress the frame index t and the head index h: K∈ℝN×dkK ^N× d_k and V∈ℝN×dvV ^N× d_v stack the unit-normalized keys and the values of the N write tokens of one frame row-wise, ki∈ℝ1×dkk_i ^1× d_k and vi∈ℝ1×dvv_i ^1× d_v denote their i-th rows (so the prediction for token i is the row vector kiSk_iS), W=diag(w1,…,wN)W=diag(w_1,…,w_N) collects the non-negative write weights, and S¯=γtSt−1 S= _tS_t-1 is the retained state. C.1 Normal equation, uniqueness, and closed forms Design of the joint objective. The single-token delta rule takes one explicit gradient step on the local prediction error ℒi(S)=12‖kiS−vi‖22L_i(S)= 12\|k_iS-v_i\|_2^2, evaluated at the retained state: S=S¯−β∇ℒi(S¯)S= S-β\, _i( S). Applying it to the N tokens of a frame one after another chains N such steps, each evaluated at a different intermediate state, so the result depends on the within-frame order: already with a scalar state, γ=1γ=1, β=1β=1 and the two tokens (1,1)(1,1) and (1,0)(1,0), sequential writes end at the last token’s value (00 or 11 depending on the order), whereas fitting both tokens jointly yields 12 12 irrespective of their order. We therefore evaluate all per-token errors against a single candidate state and minimize them jointly, ℒ(S)=12∑i=1Nwi‖kiS−vi‖22,L(S)\;=\; 12 _i=1^Nw_i\,\|k_iS-v_i\|_2^2, (19) which asks one state to explain all current key–value pairs simultaneously. By itself, however, ℒL says nothing about the directions of the state space that the current keys do not span: when N<dkN<d_k the minimizer is not unique, and the history stored in those directions could be altered arbitrarily. We therefore add an anchor term and define the joint write as the proximal step, S=argminS∈ℝdk×dv12‖S−S¯‖F2+ℒ(S),S\;=\; _S ^d_k× d_v\; 12\|S- S\|_F^2\;+\;L(S), (20) This objective balances fitting the current key–value associations against staying close to S¯ S. Components not addressed by the current keys remain unchanged, while addressed components are updated according to the strength of the current evidence. The anchor also fixes the relative weighting—with its weight set to 11, each wiw_i plays the role of a per-token step size, and the odds choice wi=β^i/(1−β^i)w_i= β_i/(1- β_i) makes the single-token reduction reproduce the gated delta rule with strength exactly β^i β_i (Appendix C.2). From sum to matrix form. We write the objective of Equation 20—identical to Equation 15 in Section 3.3—more explicitly: J(S) J(S) =12‖S−S¯‖F2+12∑i=1Nwi‖kiS−vi‖22 = 12\|S- S\|_F^2+ 12 _i=1^Nw_i\|k_iS-v_i\|_2^2 =12‖S−S¯‖F2+12‖[w1(k1S−v1)wN(kNS−vN)]‖F2 = 12\|S- S\|_F^2\;+\; 12 \| bmatrix w_1\,(k_1S-v_1)\\ \\ w_N\,(k_NS-v_N) bmatrix \|_F^2 =12‖S−S¯‖F2+12‖W1/2(KS−V)‖F2. =\; 12\|S- S\|_F^2\;+\; 12 \|W^1/2(KS-V) \|_F^2. (21) By the definition of the Frobenius norm: the i-th row of KS−VKS-V is the row vector kiS−vik_iS-v_i, left-multiplying by W1/2=diag(w1,…,wN)W^1/2=diag( w_1,…, w_N) scales row i by wi w_i, and the squared Frobenius norm sums the per-row squared norms. The matrix form of the second term is thus simply a compact notation for the weighted sum of per-token prediction errors. Gradient and normal equation. Since W is symmetric, the objective expands as J(S) J(S) =12‖S−S¯‖F2+12‖W1/2(KS−V)‖F2 =\; 12\|S- S\|_F^2\;+\; 12 \|W^1/2(KS-V) \|_F^2 =12tr((S−S¯)⊤(S−S¯))+12tr((KS−V)⊤W(KS−V)). =\; 12tr ((S- S) (S- S) )\;+\; 12tr ((KS-V) W\,(KS-V) ). (22) To locate the minimizer, perturb S along an arbitrary direction ΔS∈ℝdk×dv S ^d_k× d_v and expand in ε , using 12‖U+εD‖F2=12‖U‖F2+ε⟨U,D⟩F+ε22‖D‖F2 12\|U+ D\|_F^2= 12\|U\|_F^2+ U,D _F+ ^22\|D\|_F^2 on both terms: J(S+εΔS) J(S+ S) =J(S)+ε[⟨S−S¯,ΔS⟩F+⟨W1/2(KS−V),W1/2KΔS⟩F] =J(S)\;+\; \, [\, S- S,\, S _F\,+\, W^1/2(KS-V),\,W^1/2K S _F\, ] +ε22[‖ΔS‖F2+‖W1/2KΔS‖F2] \;+\; ^22\, [\,\| S\|_F^2\,+\, \|W^1/2K S \|_F^2\, ] =J(S)+ε⟨(S−S¯)+K⊤W(KS−V),ΔS⟩F+ε22⟨ΔS,AΔS⟩F, =J(S)\;+\; \, (S- S)+K W(KS-V),\ S _F\;+\; ^22\, S,\ A\, S _F, (23) where ⟨⋅⟩F · _F is the Frobenius inner product and A≜Idk+K⊤WKA I_d_k+K WK. The second line of Equation 23 moves W1/2KW^1/2K across the inner product by the adjoint rule ⟨X,W1/2KΔS⟩F=⟨K⊤W1/2X,ΔS⟩F X,\,W^1/2K S _F= K W^1/2X,\, S _F (valid since W is symmetric), and collects the quadratic terms via ‖W1/2KΔS‖F2=⟨ΔS,K⊤WKΔS⟩F\|W^1/2K S\|_F^2= S,\,K WK S _F. Since the first-order coefficient holds for every ΔS S, it identifies the gradient, ∇SJ(S)=(S−S¯)+K⊤W(KS−V)∈ℝdk×dv, _SJ(S)\;=\;(S- S)\;+\;K W(KS-V)\;∈\;R^d_k× d_v, (24) an affine map of S: the anchor contributes S−S¯S- S and each token contributes wiki⊤(kiS−vi)w_i\,k_i (k_iS-v_i), its prediction residual pulled back by its key. Setting ∇SJ(S)=0 _SJ(S)=0 yields the normal equation (Idk+K⊤WK)⏟AS=S¯+K⊤WV. (I_d_k+K WK )_A\,S\;=\; S+K WV. (25) The second-order coefficient of Equation 23 is the Hessian quadratic form, and it satisfies ⟨ΔS,AΔS⟩F=‖ΔS‖F2+‖W1/2KΔS‖F2≥‖ΔS‖F2> 0for all ΔS≠0, S,\,A\, S _F\;=\;\| S\|_F^2+ \|W^1/2K S \|_F^2\;≥\;\| S\|_F^2\;>\;0 all S≠ 0, (26) because the Gram matrix K⊤WK=∑i=1Nwiki⊤kiK WK= _i=1^Nw_i\,k_i k_i is positive semidefinite for any non-negative weights. Hence A⪰Idk≻0A I_d_k 0 for any keys—even repeated or rank-deficient ones—J is strictly convex, and the solution of Equation 25 is the unique global minimizer. The identity supplied by the anchor is essential here: without it, the fit term alone has no unique solution whenever the current keys fail to span ℝdkR^d_k. Closed forms. Since A⪰IdkA I_d_k, it is invertible, and left-multiplying Equation 25 by A−1A^-1 gives the aggregate closed form. The correction form follows from rewriting the retained state so that A−1A^-1 cancels: by the definition A≜Idk+K⊤WKA I_d_k+K WK, AS¯=(Idk+K⊤WK)S¯=S¯+K⊤WKS¯,i.e.,S¯=AS¯−K⊤WKS¯.A S\;=\;(I_d_k+K WK)\, S\;=\; S+K WK S, .e., S\;=\;A S-K WK S. (27) Substituting this expression for S¯ S into the aggregate form lets A−1A^-1 act on AS¯A S and recover a bare S¯ S: S S =A−1(S¯+K⊤WV) =A^-1 ( S+K WV ) (aggregate form) =A−1(AS¯−K⊤WKS¯+K⊤WV) =A^-1 (A S-K WK S+K WV ) (substituting Equation 27) =S¯+A−1K⊤W(V−KS¯)=:S¯+Δ. = S+A^-1K W (V-K S )\;=:\; S+ . (correction form) (28) The aggregate form exposes how retained history and new evidence are blended by A−1A^-1; the correction form writes the update as the retained state plus a coupled correction Δ on the prediction residual V−KS¯V-K S, and is the one we compute in practice (Appendix C.4). Equivalently, Δ=−[∇2J]−1∇J(S¯) =-[∇^2J]^-1∇ J( S) is the single Newton step from S¯ S on the quadratic J, which lands exactly at the minimizer. C.2 Single-token correspondence For a single association (k,v)(k,v) with unit-normalized key ‖k‖2=1\|k\|_2=1 and weight w, the system matrix is a rank-one update of the identity, A=Idk+wk⊤kA=I_d_k+w\,k k, and the Sherman–Morrison formula gives A−1=Idk−w1+wkk⊤k⊤k=Idk−w1+wk⊤k,A^-1\;=\;I_d_k- w1+w\,k \,k k\;=\;I_d_k- w1+w\,k k, (29) since kk⊤=‖k‖22=1k =\|k\|_2^2=1. Applying this to the aggregate closed form, S S =A−1(S¯+wk⊤v)=S¯−w1+wk⊤(kS¯)+wk⊤v−w21+wk⊤(kk⊤)v =A^-1 ( S+w\,k v )= S- w1+w\,k (k S)+w\,k v- w^21+w\,k (k )v =S¯+w1+wk⊤(v−kS¯). = S+ w1+w\,k (v-k S ). (30) The odds reparameterization w=β^/(1−β^)w= β/(1- β) of Equation 14 is chosen precisely so that the effective coefficient collapses to the gate itself: w1+w=β^⟹S=S¯+β^k⊤(v−kS¯)=γtSt−1+β^k⊤(v−γtkSt−1), w1+w\;=\; β S\;=\; S+ β\,k (v-k S )\;=\; _tS_t-1+ β\,k (v- _tkS_t-1 ), (31) which is exactly the gated delta rule of Equation 4 with correction strength β β. The frame-synchronous joint write therefore strictly generalizes the gated delta rule: the latter is the N=1N=1 special case of the former. The same equivalence between an odds-parameterized gate and the rank-one closed form is derived concurrently in the analysis of Zhu (2026). The cap β^≤0.99 β≤ 0.99 bounds w≤99w≤ 99, keeping A well conditioned (Appendix C.4). C.3 Permutation invariance and bounded accumulation Permutation invariance (Property i). Let Π∈0,1N×N ∈\0,1\^N× N be a permutation matrix and consider the permuted inputs K′=ΠK = K, V′=ΠV = V, and W′=ΠWΠ⊤W = W (the diagonal entries of W, including the padding mask carried by wi=piβ^i/(1−β^i)w_i=p_i β_i/(1- β_i), are permuted along with the rows). Both sides of the normal equation are unchanged: K′⊤W′K′=K⊤Π⊤ΠWΠ⊤ΠK=K⊤WK,K′⊤W′V′=K⊤WV,K W K =K W K=K WK, K W V =K WV, (32) since Π⊤Π=IN =I_N. Hence A′=A =A; the right-hand side is identical, and the unique minimizer S is the same in exact arithmetic. No ordering of the tokens within a frame—spatial raster, camera identity, or language order—can influence the written state. Bounded evidence accumulation (Property i). Suppose one association (k,v)(k,v) with ‖k‖2=1\|k\|_2=1 and weight w appears n times in a frame. The Gram matrix is K⊤WK=nwk⊤kK WK=nw\,k k, and Sherman–Morrison as in Equation 29–Equation 30 gives S=S¯+nw1+nwk⊤(v−kS¯).S\;=\; S+ nw1+nw\,k (v-k S ). (33) The effective correction strength nw/(1+nw)nw/(1+nw) increases strictly with n for w>0w>0, approaching 11 from below. Repeated evidence therefore reinforces the write—unlike token-count averaging, which would keep the strength at w/(1+w)w/(1+w) regardless of n—while the correction strength remains below 11 for every finite n. C.4 Numerical realization: masking, precision, and gradient flow Masking. Padded write tokens carry pi=0p_i=0, hence wi=0w_i=0: they contribute neither to the Gram matrix nor to the right-hand side, and the mask-aware statistics of the gates (g¯t g_t) use the same mask. Fully padded frames skip the update entirely, leaving St−1S_t-1 untouched (in particular, no decay is applied); valid frames whose write weights are all zero give A=IdkA=I_d_k and return only the decayed state St=S¯S_t= S. Conditioning and the role of the cap. With unit-normalized keys, λmax(K⊤WK)≤∑i=1Nwi‖ki‖22=∑i=1Nwi≤99N _ (K WK)≤ _i=1^Nw_i\,\|k_i\|_2^2= _i=1^Nw_i≤ 99\,N, while the anchor guarantees λmin(A)≥1 _ (A)≥ 1. Hence κ(A)≤ 1+99N,κ(A)\;≤\;1+99\,N, (34) linear in the number of write tokens and independent of the data. The cap β^≤0.99 β≤ 0.99 is what makes this bound possible, and the identity from the anchor term is what makes the lower bound data-independent—the numerical counterpart of its uniqueness role in Appendix C.1. Forward solve. We never materialize A−1A^-1. Writing S=S¯+ΔS= S+ , the normal equation becomes AΔ=K⊤W(V−KS¯)A\, =K W (V-K S ), which we solve by Cholesky factorization A=LL⊤A=L per frame, head, and memory layer; the same factorization is reused for all dvd_v columns of the right-hand side. The Gram matrix and the solve are computed in FP32 with autocast and TF32 disabled, and the persistent states are stored in FP32; the rest of the network is unaffected. The per-frame cost is (O(Ndk2+Ndkdv+dk3+dk2dv)CLOSE(O(Nd_k^2+Nd_kd_v+d_k^3+d_k^2d_v) per head, independent of episode length. Gradient flow. The solve is differentiable, and we backpropagate through it by implicit differentiation rather than through the Cholesky operator. Given the upstream gradient G=∂ℒ/∂S∈ℝdk×dvG= /∂ S ^d_k× d_v at the converged solution, the adjoint variable Λ solves the transposed system—which is the same system, since A is symmetric—reusing the stored factorization: AΛ=G.A\, =G. (35) The input gradients then follow from differentiating AS=S¯+K⊤WVAS= S+K WV: ∂ℒ∂S¯ ∂ S =Λ,∂ℒ∂V=WKΛ,∂ℒ∂wi=(KΛ)i(V−KS)i⊤, = , ∂ V=WK , ∂ w_i= (K )_i (V-KS )_i , (36) ∂ℒ∂K ∂ K =W(V−KS)Λ⊤−WKΛS⊤, =W (V-KS ) \;-\;WK\, S , where (⋅)i(·)_i denotes the i-th row. The weight gradient has a simple interpretation: it is the inner product between what token i retrieves from the update, (KΛ)i(K )_i, and its residual at the solution, (V−KS)i(V-KS)_i. From ∂ℒ/∂S¯ /∂ S, gradients flow further to the retention gate via ∂ℒ/∂γt=⟨Λ,St−1⟩F /∂ _t= ,S_t-1 _F and to the previous state via γtΛ _t , continuing the recurrent chain across the TBPTT window; the readout path contributes its own gradient to St−1S_t-1 through Equation 11. Gradients with respect to wiw_i and the gate pre-activations follow from wi=piβ^i/(1−β^i)w_i=p_i β_i/(1- β_i) by the chain rule. In practice we implement the forward and backward solves inside a custom autograd function that stores L from the forward pass, so that Equation 35 costs one triangular solve pair rather than a refactorization. Appendix D Details of Real-World Experiments We conduct the real-world evaluation on the I7 Pro, a mobile manipulation platform equipped with dual robotic arms and onboard visual sensing, as shown in Figure 4. We consider two manipulation tasks in a CNC workspace: Install and Full. In both tasks, the robot starts with the workpiece already grasped. In the Install task, the arm begins at a predefined pose near the installation target and performs precise alignment and insertion. The Full task extends this procedure into a complete loading sequence: the arm starts from a more distant initial pose, moves to the starting pose of the Install task, and completes the same alignment and insertion procedure. After insertion, the robot opens the gripper to release the workpiece and retracts the arm. Thus, Install focuses on fine manipulation near the target, while Full additionally requires the initial approach, workpiece release, and arm retraction. For each task and method, we conduct 20 evaluation trials and report the success rate. Representative execution stages and corresponding close-up views are shown in Figure 4. Figure 4: Real-world experimental platform and manipulation tasks. (a) The I7 Pro robot. (b) The Install task, which requires precise alignment and insertion from a predefined pose near the target. (c) The Full task, which extends Install with an initial approach, workpiece release, and arm retraction to complete the loading sequence. For each task, three representative execution stages are illustrated using a global view, a close-up view of the manipulation, and a wrist-camera observation. Appendix E Limitations Our evaluation considers episodic manipulation, with memory reset at episode boundaries. Memory management during continuous execution across successive tasks remains unexplored. Future work could investigate when to retain or reset memory as task instructions change.