acceptodds
Under review as a conference paper at ICLR 2027

AdaMem: Action-Utility Guided Memory Management for Budgeted Long-Horizon Vision-Language-Action Policies

Abstract

Long-horizon robotic manipulation requires preserving task-relevant information beyond the current observation, yet VLA policies operate under limited temporal context and deployment resources. Existing event-memory methods mainly focus on memory admission, while post-admission maintenance is often handled by simple replacement heuristics. We introduce ADAMEM, an action-utility guided memory manager that learns to maintain a bounded episodic memory with a frozen VLA backbone. For each incoming event, ADAMEM evaluates feasible retain, merge, and evict operations according to their predicted effect on future action quality, using counterfactual future-action supervision. ADAMEM-SELECT learns budget-aware raw-frame selection, while ADAMEM-FULL further supports compact representations, temporally ordered merging, and gated latent-memory integration. We also provide a finite-candidate regret analysis and evaluate both offline action-proxy quality and closed-loop performance. Across eight RoboTwin-MeM tasks, ADAMEM consistently improves performance under matched memory budgets. At K = 3, ADAMEM-FULL achieves 90.1% closed-loop success versus 80.9% for Raw-FIFO. These results show that learned memory maintenance can improve long-horizon VLA execution without modifying the action backbone.

Primary area:
applications to robotics, autonomy, planning
Keywords:
vision-language-action models, adaptive memory, long-horizon robotic manipulation, memory management, embodied AI, robot learning

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_VehdOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
3
Read review
Paper summary

AdaMem learns to maintain a bounded episodic memory for a frozen EventVLA policy using counterfactual future-action losses. AdaMem-Select performs raw-frame admission and replacement, while AdaMem-Full additionally introduces compression, temporally ordered merging, and gated latent-memory integration. Experiments on eight RoboTwin-MeM tasks report improved success rates and reduced resource usage over heuristic memory-management baselines.

Critical strengths
  • The paper addresses a practical problem: preserving task-relevant historical evidence under limited memory budgets.
  • Counterfactual action supervision provides a task-oriented criterion for memory selection, and the raw-frame Select variant helps isolate its benefit.
  • Closed-loop evaluations, component ablations, and fixed-event replay provide complementary evidence of improvements within the EventVLA setting.
Critical weaknesses
  • Limited novelty beyond EventVLA. The method inherits EventVLA’s policy and event-proposal pipeline, with the main contribution being a learned memory-maintenance component. Although useful, the paper does not convincingly establish a substantial conceptual advance over existing memory selection, compression, and gated-reading mechanisms.

  • Insufficient analysis of related work. The related-work section largely lists existing methods without clearly explaining AdaMem’s technical distinctions. The authors should include an analytical comparison with relevant approaches such as NativeMEM and Gated Memory Policy. This discussion is necessary to clarify which aspects of AdaMem constitute new contributions beyond existing memory-augmented policies.

  • Evaluation is limited to very small memory capacities. The experiments restrict memory capacity to K∈{1,2,3,5}K\in\{1,2,3,5\}. It remains unclear whether AdaMem retains its advantage over methods that efficiently maintain much longer histories under the same computational and storage budgets. The paper should analyze this trade-off and clarify whether the reported gains primarily reflect better management of a small memory bank or a broader advantage in memory efficiency.

  • Incomplete attribution of the Full variant’s gains. AdaMem-Full introduces trainable compression, merging, and reading modules alongside learned management. A baseline using the same representation and reader with heuristic management is needed to distinguish better memory decisions from additional modeling capacity.

  • Narrow validation scope. Evaluation is restricted to one benchmark and one policy backbone. The short-window action-loss proxy and finite-candidate regret bound do not establish reliable long-term memory management across tasks or architectures.

  • Presentation needs improvement. Text in Figure 2 is too small to read comfortably. Figures 3 and 4 leave substantial whitespace around their content; improving the layout would allow larger labels and clearer visualization.

Questions for authors
  • How does AdaMem-Full compare with heuristic management when the compressor, merger, and latent reader are held identical?
  • How sensitive are the gains to the future-action supervision horizon and the delay between storing evidence and using it?
1 comment
AuthorsOpenReview ↗

Reply to Reviewer Vehd

Thank you for asking what this work teaches beyond adding a memory module.

1. Contribution Beyond EventVLA — W1

The central insight is that event salience and write value are different quantities. A frame can be salient in isolation yet redundant with the current bank; admitting it can displace unique earlier evidence needed later. AdaMem learns to evaluate complete post-update banks via the frozen policy's future action loss rather than independent frame scores. At K=3K=3, raw-only AdaMem-Select gets 692/800 vs. 661/800 (KEM-score) and 647/800 (Raw-FIFO) without adding Full's modules, and bank scoring improves Full over independent scoring (721/800 vs. 672/800). The contribution is this task-supervised write formulation, not new compression, merging, or gating primitives.

2. Relation to NativeMEM & Gated Memory Policy — W2

We will expand Section 2 to compare both works:

  • NativeMEM reduces representation cost by compressing each view-frame into one token via frozen-policy tokenizer supervision and policy fine-tuning.
  • Gated Memory Policy learns when and what history to read during action generation via action-prediction supervision.
  • AdaMem addresses a complementary pre-retrieval stage: which feasible post-update bank survives a capacity-constrained write while keeping the VLA backbone frozen (without claiming general priority or superiority without a shared protocol).

3. Fixed-Module Attribution (KEM-Full vs. AdaMem-Full) — W4, Q1

Holding trained (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega), candidate generator, repair, budgets, and 800 scenes fixed at K=3K=3:

Method (K=3K=3)ModulesSelectorSucc.Rate [95% CI]PickOther 7
Raw-FIFORawFIFO647/80080.9% [78.0,83.5]42/100605/700
AdaMem-SelectRawUtility QψQ_\psi692/80086.5% [84.0,88.7]56/100636/700
KEM-FullFrozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Slot KEM679/80084.9% [82.2,87.2]52/100627/700
AdaMem-FullFrozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Utility QψQ_\psi721/80090.1% [87.9,92.0]68/100653/700

KEM-Full sums S(m)=∑e∈E(m)sKEM(e)/∣E(m)∣S(m)=\sum_{e\in E(m)}s_{\mathrm{KEM}}(e)/\sqrt{|E(m)|} with deterministic tie-breaking (raw slots, depth, timestamps, index). With the compressor, merger, reader, and candidate-update machinery held fixed, replacing KEM-based selection with learned action-utility selection improves success from 679/800 to 721/800 (+5.25 percentage points) (+16 on Ordered Object Picking, +26 on the other seven tasks). This supports a contribution from the selection rule within the trained Full system, beyond the mere presence of compression and reading modules. It does not establish that action-utility guidance is necessary for compression to be beneficial, nor equal compute or separate representation retraining (aggregate rates and marginal Wilson CIs reported without an unverified paired test).

4. Small Banks vs. Long Histories — W3

Across K∈{1,2,3,5}K\in\{1,2,3,5\}, Full beats FIFO by +181, +135, +74, and +63 episodes out of 800. In our evaluated EventVLA B3 configuration, each raw memory frame contributes 256 visual tokens (increasing FIFO from K=3K=3 to 55 raises context from 768 to 1,280 tokens and latency from 42.1 to 56.4 ms on RTX 4090). We remove any implication of strict token/byte matching across Select and Full at equal KK and scope our claim to managing tested small banks rather than larger-KK or long-history compressed policies.

5. Horizon, Scope & Readability — Q2, W5, W6

Offsets {1,2,4,8}\{1,2,4,8\} index future policy queries for write labeling rather than memory expiration, though cues needed after offset 8 receive no direct credit at admission. Retraining window sweeps, controlled cue-to-use delay tests, and cross-backbone/benchmark transfer remain open; we also do not present hypothetical traces as observed logs. Eq. (11) is a single-step proxy proposition under a uniform error assumption not instantiated by empirical MAE, not a return guarantee. We will enlarge Figure 2 labels, crop whitespace in Figures 3–4, add distinct markers/line styles/direct labels in Figure 4, and keep schematics labeled as schematics.

Given that the fixed-module KEM-Full experiment directly isolates the +5.25 percentage-point gain of action-utility selection beyond representation modules—alongside our clarified positioning relative to NativeMEM and Gated Memory Policy—we kindly ask you to reconsider your assessment and raise your score.

Reviewer_PoQEOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes AdaMem, a learned memory-management controller instantiated within EventVLA. Given an incoming event from the inherited event proposal mechanism, the controller evaluates feasible updates to a bounded memory bank and selects the update with the lowest predicted future action loss. AdaMem-Select operates on raw observations through admission and replacement. AdaMem-Full additionally supports compression, temporally ordered merging, and a learned gated reader for integrating latent memories into the action computation. The underlying VLA backbone and action head remain frozen, while the additional memory components are trained.

The controller receives offline supervision by evaluating candidate memory banks against future action targets on fixed observation trajectories. Its objective combines regression and ranking of these candidate losses. The paper also provides a conditional regret bound relative to the finite candidate set and this action-loss proxy.

Experiments use a single EventVLA configuration on eight RoboTwin-MeM tasks, with 100 episodes per task and dynamic capacities K∈(1,2,3,5)K \in (1, 2, 3, 5). At K = 3, the reported success rates are 80.9% for Raw-FIFO, 82.6% for KEM-score, 86.5% for AdaMem-Select, and 90.1% for AdaMem-Full. Additional results include component ablations, utility-prediction metrics, fixed-event replay, confidence intervals, and resource measurements.

Critical strengths

The clearest strength is the proposal to evaluate complete candidate memory banks using supervision derived from the downstream action loss. This formulation can account for interactions between observations and connects retention decisions to the policy's task objective. It provides a plausible learning approach to a specific problem within an existing memory-augmented policy. I regard this as a meaningful conceptual strength, although the experimental scope and missing behavioral analysis substantially limit the conclusions that can be drawn from it.

Critical weaknesses
  1. Limited experimental scope and insufficient analysis of learned memory management. All experiments use the same EventVLA B3 backbone, event proposal mechanism, and eight RoboTwin-MeM tasks. The baselines are mostly simple memory replacement heuristics, such as FIFO, reservoir sampling, and KEM-score. While these comparisons demonstrate improvements within EventVLA, they do not establish how AdaMem compares with other memory-augmented VLA approaches, such as μ\muVLA or MemoryVLA. Evaluation on complementary memory-intensive benchmarks, such as MIKASA-Robo and RoboMME, would also help establish generality.

More importantly, the paper provides almost no analysis of what the learned memory manager actually does. There are no representative trajectories showing which observations are retained, evicted, compressed, or merged, nor statistics on how these decisions vary across tasks and execution stages. Such analysis is particularly important for a method whose main contribution is adaptive memory management. The evaluation is also restricted to very small memory capacities (K≤5K \leq 5), without studying sensitivity to memory horizon, distractor frequency, or the number of simultaneously relevant events. Furthermore, the policy receives fixed visual anchors outside the managed memory bank, making the actual contribution of the dynamic memory difficult to assess. AdaMem-Full also introduces additional trainable components, including a compressor, merger, and latent reader. Its improvements over raw-frame baselines therefore cannot be attributed solely to better memory selection. Finally, the method depends on EventVLA's frozen event detector, but the influence of missed or incorrectly proposed events is not investigated.

  1. Insufficient implementation details and incomplete experimental validation. Despite the methodological description, several important implementation details remain unclear. The paper relies heavily on EventVLA-specific components without sufficiently distinguishing inherited mechanisms from the proposed contributions. In particular, the exact compressor and merger architectures, the insertion point of the latent reader, the training objectives for these components, and the alternating training and relabeling schedule are not fully specified. The candidate generation procedure and deterministic feasibility repair are also insufficiently described. These omissions make independent reproduction difficult.

The data protocol raises additional questions. The authors mention trajectory-level train/validation/test splits but do not report dataset sizes, split proportions, or the degree of overlap in scene configurations. The construction and relative use of expert-action and teacher-surrogate labels are also unclear. Another concern is the utility objective in Eq. (5), which evaluates only four future query offsets (1, 2, 4, 8) under fixed observations and disabled subsequent memory writes. This short-horizon proxy may not capture the value of information needed much later or account for how memory decisions change future trajectories. The regret bound in Eq. (11) applies only to the enumerated candidates and this proxy objective, not to long-horizon task success.

Finally, the resource and deployment evaluation lacks sufficient detail. The paper does not clearly specify the numerical memory budgets associated with each K or the complete accounting of raw images, latent features, metadata, and temporary allocations. The latency measurements also lack important profiling details, including numerical precision, compilation settings, synchronization, and whether all compression and memory-management costs are included. This makes the claimed deployment advantages difficult to reproduce. As a minor presentation issue, Figure 4 is difficult to read due to similar colors, small labels, and overlapping curves.

Questions for authors
  1. Training data and evaluation protocol. How many trajectories and decision points are used for training, validation, and testing? How are expert and teacher-surrogate labels collected and used? Are scene configurations, object arrangements, and seeds shared across splits? Please also clarify how the training data, relabeling data, closed-loop evaluation episodes, and fixed-event replay trajectories are separated.

  2. Implementation details. Could you provide the exact compressor and merger architectures, the source of the representation hth_t in Eq. (10), and the insertion point of the latent reader? How are these components pretrained, and what is the exact alternating training and relabeling schedule? The candidate generation procedure and deterministic feasibility repair also need a more precise description, preferably with pseudocode.

  3. Deployment and profiling. What hardware and software configurations were used for latency and memory measurements, including precision, compilation, batch size, warm-up, and synchronization? Do the reported costs include candidate generation, scoring, compression, merging, memory reading, and data transfers? How are variable raw/latent memory configurations handled during inference? Please also distinguish memory-bank storage from the total additional runtime memory and explain how the reported control frequency is measured.

  4. Learned memory-management behavior. Could you provide statistics on how frequently AdaMem retains, rejects, replaces, compresses, or merges observations across different tasks, execution stages, and memory budgets? Representative successful and failed memory traces would also help explain what the controller learns, when it differs from FIFO or KEM-score, and whether the retained information actually supports later decisions.

  5. Contribution of the learned manager. AdaMem-Full introduces additional trainable compression, merging, and reading components alongside learned selection. Could you compare learned and heuristic selection while keeping the same compressor, merger, reader, candidate operations, and memory budgets? This would help isolate the contribution of memory management from that of the additional architecture.

  6. Event proposals and utility horizon. How sensitive is AdaMem to the frequency and quality of the frozen EventVLA event proposals, particularly missed or redundant events? Why are future-action utilities evaluated only at offsets 1, 2, 4, and 8, with subsequent memory writes disabled? Can the manager learn to preserve information that becomes useful much later, and how sensitive are the results to these design choices?

  7. Baseline and memory-budget specifications. Which exact EventVLA B3 checkpoint and configuration are used, and where is the updated official 77.5% result reported? Is Raw-FIFO equivalent to the original B3 memory-management strategy, and how exactly does KEM-score differ? Please also specify the context-token and storage budgets for each K, including how K is interpreted when AdaMem-Full uses compressed or merged memory slots.

Evaluating AdaMem on other memory-intensive benchmarks, such as MIKASA-Robo and RoboMME, and comparing it with representative memory-augmented VLA methods would help establish generality beyond EventVLA. Experiments varying memory horizon, distractor frequency, and the number of simultaneously relevant events would also strengthen the long-horizon claims. Finally, testing another VLA backbone or event proposal mechanism would help assess transferability.

Additional Presentation and Specification Issues

The paper relies heavily on EventVLA-specific terminology without explaining the inherited system sufficiently. Terms such as visual anchors, KEM, the KEM inference path, and EventVLA B3 should be introduced more clearly. Equation (1) should explicitly describe the EventVLA-based policy interface rather than a general VLA formulation. The event proposal mechanism also needs a more concrete description, including when events are generated and which detector configuration is used. Even K is used in the abstract before its meaning is defined.

Several important parts of the method remain underspecified. The distinction between pre-update and post-update memory states should be made explicit, preferably with an example. Equation (4) describes the candidate operations for AdaMem-Select, but the more complex combinations of compression, merging, insertion, and eviction in AdaMem-Full are not explained precisely. The candidate generation and feasibility repair procedures would benefit from pseudocode. Similarly, Equation (10) does not sufficiently define the representation h_t, the latent reader's insertion point, or the gate parameterization. The relationship between K, memory slots, and mixed-fidelity storage budgets also needs clarification.

The training and evaluation objectives require additional details. For Equation (5), the authors should specify the exact future-query weights, action loss, normalization, and use of expert versus teacher-surrogate labels. Equations (6-8) use normalized utility targets, while the regret bound in Equation (11) refers to the original proxy objective. The relationship between these quantities and the reported utility errors should be explained. The bound itself is straightforward and applies only to the enumerated candidates, not to cumulative online regret or task success. The held-out utility evaluation should also report the number of decision points, candidate-set statistics, aggregation procedure, and treatment of ties. Candidate coverage is mentioned in Section 3.6 but is not clearly reported.

Finally, several experimental and presentation details could be improved. The relationship between Raw-FIFO, the reproduced EventVLA B3 baseline, KEM-score, and reservoir sampling should be stated more explicitly. Figure 4 is difficult to read because of similar colors, thin lines, and crowded labels. More importantly, Figures 1-3 only illustrate the architecture and possible memory operations, without showing actual decisions made by the trained manager. Representative memory traces would make the method easier to understand. The limitations section should also discuss the practical consequences of the frozen event proposal mechanism, short utility horizon, restricted candidate enumeration, and maximum merge depth, rather than mentioning them only as directions for future work.

4 comments
AuthorsOpenReview ↗

Response to Reviewer PoQE (Part 1/2)

Thank you for recognizing complete-bank action supervision as a conceptual strength and for specifying the controls and implementation details needed to evaluate the work. We respond in two parts: Part 1 covers W1, Q1, and Q4–Q6; Part 2 covers W2, Q2–Q3, Q7, and additional specification issues.

1. Contribution, Baselines & Scope — W1

Event salience differs from write value: admitting a redundant salient frame can displace unique earlier evidence. Evaluating complete post-update candidate banks via the frozen policy's future action loss makes this trade-off learnable. At K=3K=3, raw-only AdaMem-Select achieves 692/800 vs. 661/800 (KEM-score) and 647/800 (Raw-FIFO), demonstrating gains without Full's modules. Excluding Ordered Object Picking still leaves 653/700 vs. 605/700 (+6.86 pp) for Full over FIFO. Within-B3 controls do not replace μ\muVLA, MemoryVLA, MIKASA-Robo, or RoboMME comparisons; we restrict conclusions to the evaluated frozen-B3 / RoboTwin-MeM setting.

2. Manager Behavior & Official Task Mechanics — W1, Q4

In official Ordered Object Picking (code), the robot uncovers hidden objects to observe identities in left-to-right spatial order and later picks matching shuffled front objects. Table 2 (K=3K=3) isolates outcome effects: Full 721/800 vs. -8.5 pp without eviction (653), -4.4 pp without merge (686), -2.9 pp without order/intervals (698), and -6.1 pp with independent scoring (672). However, complete per-task/stage/KK counts of mutually exclusive plan categories (with composite precedence rules) and verified step-by-step traces with input-visibility audits remain unexported; we present no reconstructed stories as observed executions.

3. Fixed Anchors Outside the Bank — W1

Anchors are shared identically across methods, so comparisons measure dynamic-bank gains conditional on anchors (not independently ablated). Since public EventVLA also describes recent temporal anchors alongside the initial frame, cue visibility must be checked against the resolved config.

4. Fixed-Module Attribution (KEM-Full vs. AdaMem-Full) — W1, Q5

Holding trained compressor (CϕC_\phi), merger (GϕG_\phi), reader (RωR_\omega), candidate generator, repair, budgets, and 800 initial scenes fixed at K=3K=3:

Method (K=3,n=800K=3, n=800)Modules & ReaderSelectorSucc.Rate [95% Wilson]Pick-OrderOther 7
Raw-FIFO (B3)Raw onlyFIFO647/80080.9% [78.0,83.5]42/100605/700
AdaMem-SelectRaw onlyUtility QψQ_\psi692/80086.5% [84.0,88.7]56/100636/700
KEM-Full (Control)Frozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Slot KEM679/80084.9% [82.2,87.2]52/100627/700
AdaMem-FullFrozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Utility QψQ_\psi721/80090.1% [87.9,92.0]68/100653/700

KEM-Full sums slot scores S(m)=∑e∈E(m)sKEM(e)/∣E(m)∣S(m) = \sum_{e \in E(m)} s_{\mathrm{KEM}}(e)/\sqrt{|E(m)|} with deterministic tie-breaking (raw slots, merge depth, latest timestamps, index). With the compressor, merger, reader, and candidate-update machinery held fixed, replacing KEM-based selection with learned action-utility selection improves success from 679/800 to 721/800 (+5.25 percentage points) (+16 on Ordered Object Picking, +26 on the other seven tasks). This supports a contribution from the selection rule within the trained Full system, beyond the mere presence of compression and reading modules. It does not establish that action-utility guidance is necessary for compression to be beneficial, nor equal compute or separate representation optimization (reported without an unverified paired test).

5. Capacities, Delays, Proposals & Data Separation — W1, W2, Q1, Q6

  • Untested dimensions (Q6): Tested capacities are K∈{1,2,3,5}K \in \{1, 2, 3, 5\} (+181 to +63 over FIFO); larger-KK, supervision-window sweeps, distractor-frequency, cue-to-use delay, simultaneously relevant cue count, and synthetic proposal-perturbation sweeps were not run (stated as limitations). Resolved proposer revision, threshold, and cooldown parameters will be documented from the run config.
  • Data separation (Q1): Trajectory-level splits separate demos from successful B3 teacher rollouts, with Stage 3 relabeling on training trajectories only and Fixed-Event Replay on held-out test scenarios without fitting. Exact split counts, decision points, source sampling ratios, and scene-template/seed disjointness checks will be exported from the dataset manifest into an Appendix table.
AuthorsOpenReview ↗

Response to Reviewer PoQE (Part 2/2)

6. Modules, Candidates & Training — W2, Q2; Additional Issues

  • Module interface (Q2): We will restrict Eq. (1) to B3, define KK and M−/M+M^-/M^+ before use, separate inherited modules from added modules (2L/4H/256d scorer; 8-query 8×2568 \times 256 compressor; depth-2 merger; gated reader with empty-bank bypass), and document exact projections, hth_t, reader hook before B3's deterministic head (not diffusion), gate init, and masks from code.
  • Candidates & repair (Q2): Rejected candidates never mutate the live bank. We will add Algorithm 1 and enumerator pre/post-repair candidate counts detailing operation combinations, repair order (compressing oldest raw before evicting oldest down to feasible empty bank), deduplication keys, and tie-breaking.
  • Training schedule (Q2): Stage 1 trains representation/reader modules with frozen B3; Stage 2 freezes them and trains the scorer via Huber + soft ranking (λrank=0.5,τ=1\lambda_{\mathrm{rank}} = 0.5, \tau = 1); Stage 3 alternates manager rollouts and counterfactual relabeling on visited banks. Exact stage objectives, optimizers, updates, relabel intervals, and freeze masks will be populated from executed configs.

7. Eq. (5) Loss, Normalization & Metrics — W2, Q6; Additional Issues

  • Native B3 L1L_1 loss (Q6): Native B3 predicts actions directly with deterministic L1L_1 error (code), so no diffusion draw enters labels; offsets {1,2,4,8}\{1, 2, 4, 8\} use query weights 1/∣Qvalid∣1/|Q_{\mathrm{valid}}| with writes disabled (replay loss 0.284 →\to 0.186 →\to 0.138 shares B3's proxy).
  • Metrics & Eq. (11): Under J~=(J−μ)/s\tilde{J} = (J - \mu)/s, Eq. (11) is reframed as a normalized-scale Proposition rather than a certified bound from MAE=0.038\mathrm{MAE} = 0.038. Pairwise accuracy gives 0.50.5 to predicted ties on non-tied targets; Kendall's τb\tau_b uses its tie-adjusted denominator; candidate coverage is the fraction of decisions with a feasible candidate strictly better than Raw-FIFO (an improvement-opportunity rate relative to FIFO, not policy-class coverage); and MAE/regret export scales (0.0520.052 vs. 0.3540.354), held-out decision/candidate counts, and weights will be verified in the export script.

8. Baselines, Profiling & Presentation — W2, Q3, Q7; Additional Issues

  • Baselines & budgets (Q7): Reproduced B3/Raw-FIFO achieves 647/800 overall and 42/100 on Ordered Object Picking, matching the maintainers' correction (77.5%, 41%). We will tie baseline conventions to exact checkpoints/configs, remove the mixed-representation budget-matching claim, and reconcile per-KK active tokens, padded lengths, storage, metadata, and anchors (768 vs. 384 tokens; 1.86 vs. 0.62 MB at K=3K=3).
  • Profiling (Q3): On RTX 4090, fevent=1000/(tpolicy+tmgr)f_{\mathrm{event}} = 1000/(t_{\mathrm{policy}} + t_{\mathrm{mgr}}) gives 21.92 Hz (21.9 Hz, 42.2+3.42 ms42.2+3.42\text{ ms}) for Select and 26.08 Hz (26.1 Hz, correcting 26.0, 31.5+6.85 ms31.5+6.85\text{ ms}) for Full. We will distinguish the amortized query-rate estimate fquery=1000/(tpolicy+ρ tmgr)f_{\mathrm{query}} = 1000/(t_{\mathrm{policy}} + \rho\, t_{\mathrm{mgr}}) from the derived event-step rate computed from mean component latencies (neither establishes a worst-case latency guarantee), and supply precision, compilation, warm-up, sync, transfers, occupancy, and parameter/buffer memory details.
  • Presentation: We will enlarge Fig. 4 with direct labels/markers, keep schematics labeled as schematics, and expand Limitations (missed proposals, short window, restricted candidates, depth-2/compression loss). We do hope this strengthened evidence warrants raising your evaluation score.
Reviewer_PoQEOpenReview ↗

Thank you

Thank you for the detailed rebuttal and additional clarifications. The new KEM-Full control provides useful evidence that the learned selection mechanism contributes to the performance improvements. However, my main concerns regarding the limited experimental scope, missing analysis of actual memory-management decisions, insufficient evaluation of long-horizon retention and event-proposal robustness, and incomplete reproducibility details remain unresolved. I therefore maintain my original score of 2 and leave all other scores unchanged.

AuthorsOpenReview ↗

Follow-up to Reviewer PoQE: Memory-Management Analysis and Reproducibility Details

Thank you for confirming KEM-Full supports learned action-utility selection. Below are our K=3K=3 behavioral audit, implementation specs, and clarified boundaries.

1. Memory-Management Decisions & Trace (K=3,N=800K=3, N=800)

Auditing K=3K=3 AdaMem-Full (eval-k3-v1: 5,912 proposals; 1,592 pre-capacity admissions, 4,320 full-bank decisions at ∣Mt−∣=3|M_t^-|=3) under mutually exclusive precedence (merge_ordered > compress_single > replace_raw > reject_incoming):

  • Decisions: Full-bank updates (4,320) execute merge_ordered 31.2% (1,348), compress_single 24.1% (1,041), replace_raw 27.2% (1,175), and reject_incoming 17.5% (756). Early (t/T∈[0,1/3)t/T\in[0,1/3)) to Late ([2/3,1][2/3,1]) shifts: replace_raw 41.8% →\to 15.6%, merge_ordered 21.4% →\to 39.3%, reject_incoming 10.2% →\to 24.5%. On Ordered Object Picking, merge_ordered is 38.4% (235/612) vs. 18.1% (88/485) on Block Return. These characterize decision frequencies rather than causal proof of cue protection.
  • Trace (episode_id=14, Ordered Object Picking): In official pick_objects_in_order (code), front targets shuffle at init while covered objects set left-to-right order. Uncovering (t=28,64t=28,64) reveals identities; once covers close (t=82t=82), they vanish from oto_t. AdaMem-Full keeps reveal cues in its 1-raw + 2-latent budget (≤272\le 272 active tokens, ≤0.62 MB\le 0.62\text{ MB}), merges grasp/place steps (t=112,145t=112,145; {e28,e64,e112}→{e28,e64,eˉ112,145}\{e_{28},e_{64},e_{112}\}\to\{e_{28},e_{64},\bar{e}_{112,145}\}), and rejects a transit-frame proposal (t=178t=178) before picking front objects. This trace illustrates the executed updates in one successful episode; it does not establish causal use of the retained cues (a paired failure trace and full multi-input visibility audit remain to be added).

2. Long-Horizon & Proposal-Filtering Scope

  • Operating points: On Ordered Object Picking, AdaMem-Full gets 68/100 vs. 42/100 (Raw-FIFO, +26.0 pp) and 52/100 (KEM-Full, +16.0 pp). Across K∈{1,2,3,5}K\in\{1,2,3,5\}, AdaMem-Full at K=2K=2 gets 673/800 vs. 670/800 for Raw-FIFO at K=5K=5 (+3 episodes)—a descriptive operating-point result, not a controlled delay test, long-window sweep, or token/byte-matched benchmark.
  • Rejections: Executing reject_incoming on 17.5% of full-bank decisions (24.5% late) documents observed rejection on the upstream stream; it does not verify redundancy of every rejected frame, isolate causal impact, or replace proposal-corruption tests.

3. Implementation, Data & Profiling Specs (Appendix)

  • Data splits: Offline data has 4,000 unique trajectories (500/task), split by trajectory/seed: Train (3,200; 23,680 decisions: 1,600 scripted demos + 1,600 successful frozen-B3 rollouts, 1:1 sampling, seeds 10000–13199); Val (400; 2,960 decisions, seeds 20000–20399); Offline Test (400; 2,960 decisions, seeds 30000–30399). Stage 3 relabeling uses Train only, disjoint from the 800 closed-loop test episodes (seeds 0–799, also Fixed-Event Replay without fitting). Layout-overlap checks and commit/checkpoint hashes go in the Appendix.
  • Modules, candidates & training: CϕC_\phi (2L/4H cross-attn, d=256d=256, FFN 1024, 8 queries →8×256\to 8\times 256); GϕG_\phi (2L Transformer, d=256d=256, sinusoidal Δτij\Delta\tau_{ij} + order emb., max depth 2); RωR_\omega (2L/4H cross-attn, d=256d=256) hooks into ht∈RB×L×Dh_t\in\mathbb{R}^{B\times L\times D} before B3's deterministic L1L_1 head (zero-init tanh⁡\tanh gate; empty-bank bypass). Enumerated plans (mean 9.4, max 14 at K=3K=3) undergo deterministic repair (compress oldest raw via CϕC_\phi, then evict oldest down to empty bank, Caux=64 BC_{\mathrm{aux}}=64\text{ B}) and tuple deduplication (pseudocode in Appendix). Stage 1 trains (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega) (2.18M params), 20 epochs (AdamW, lr=10−4\mathrm{lr}=10^{-4}, bs 32, B3 L1L_1 loss); Stage 2 freezes them and trains QψQ_\psi (1.64M params), 15 epochs (lr=3×10−4\mathrm{lr}=3\times 10^{-4}, bs 64, λrank=0.5,τ=1\lambda_{\mathrm{rank}}=0.5,\tau=1); Stage 3 fine-tunes QψQ_\psi, 6 epochs (lr=10−4\mathrm{lr}=10^{-4}, relabel every 2 epochs).
  • Proposer & RTX 4090 profiling: EventVLA B3 (eventvla-b3-robotwin, KEM threshold 0.50, cooldown 4 steps, static anchor Vt={o0}V_t=\{o_0\}); BF16, bs 1, 50 warm-up steps, torch.cuda.synchronize(), and ρ=0.24\rho=0.24 updates/query (estimated policy-query rate 30.2 Hz from component means alone vs. 26.1 Hz per event step, not a measured end-to-end control frequency; 0.62 MB resident bank separated from 7.29 MiB params and 1.45 MB peak buffers).

Together with KEM-Full (+5.25 pp), these decision statistics, trace, and implementation specs address parts of the behavioral-analysis and reproducibility concerns. While retaining limitations on proposal corruption and cross-backbone/benchmark transfer, we hope this evidence warrants reconsidering your score.

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

The paper proposes AdaMem, a learned memory manager for bounded episodic memory in vision-language-action policies. At each event proposal, AdaMem enumerates feasible retain/reject/replace/merge plans and scores complete candidate memory banks with a set Transformer trained by counterfactual future-action loss. AdaMem-Select keeps raw-frame memory, while AdaMem-Full adds compression, ordered pairwise merging, and a gated latent reader. Experiments use EventVLA B3 on eight RoboTwin-MeM tasks and report gains over FIFO/KEM-style baselines under several memory capacities.

Critical strengths

The formulation of memory maintenance as structured selection over complete post-admission memory banks is sensible and better motivated than independent per-frame scoring. The explicit context-token and resident-memory budgets are also the right abstraction.

Counterfactual future-action supervision is a reasonable way to label memory decisions, and the fixed-event replay evaluation is a useful attempt to separate memory quality from downstream simulator drift.

The empirical section is fairly thorough: multiple capacities, utility metrics, component ablations, deployment measurements, confidence intervals, and paired significance tests. The gains over Raw-FIFO and KEM-score are consistent enough to be interesting.

Critical weaknesses

The novelty is narrower than the framing suggests. The core contribution is a learned set-level scorer over candidate memory states, plus compression/merging engineering. The regret bound in Eq. (11) is a standard finite-candidate bound under bounded estimator error; it does not establish anything specific about AdaMem, especially since the paper reports exhaustive search with δ = 0 and an empirical MAE of 0.038. The theory reads more like a sanity check than a contribution.

The “matched-budget” claim is not convincingly operationalized. K is a slot count, not a token or byte budget. At K = 3, AdaMem-Full uses 384 context tokens and 0.62 MB, while AdaMem-Select uses 768 tokens and 1.86 MB. That is not a budget-matched comparison unless raw-only baselines are also constrained to 384 tokens/0.62 MB. Otherwise the improvement conflates better memory decisions with operating at a different fidelity/resource point.

Generalization evidence is thin. Only one frozen backbone (EventVLA B3) and one simulated benchmark family are used. Task-level gains are uneven, and much of the difficult-task improvement is concentrated on Ordered Object Picking; several other tasks are near saturation. This makes it hard to tell whether the method addresses long-horizon memory generally or one benchmark’s event structure.

Some evaluation details weaken the causal story. Ablations are only at K = 3 and lack confidence intervals. McNemar tests are reported for three K = 3 comparisons but not corrected across capacities. The fixed-event replay still uses the same B3 action loss that trained the manager, so proxy and manager may share biases. The manager latency (6.85 ms vs. 3.42 ms for Select) is also not fully broken down in the end-to-end deployment accounting.

Questions for authors

For Eq. (5), when the action head uses diffusion/flow matching and the same noise is reused across candidates, how do you prevent candidate labels from being dominated by a single noise draw, and what are the query weights? Can you provide budget-matched curves where every method receives identical Bctx and Bstore, including a raw-only baseline constrained to 384 tokens/0.62 MB? What control rules out that the gains come from the extra manager parameters/compute rather than memory selection, e.g. a random feasible plan with the same manager architecture, or a manager trained to predict task success rather than action loss? Finally, given δ = 0 and an empirical MAE of 0.038, what nontrivial guarantee does Eq. (11) actually provide for this system?

1 comment
AuthorsOpenReview ↗

Response to Reviewer UTpU

Thank you for recognizing complete-bank evaluation and for your feedback.

1. Contribution & Eq. (11) — W1, Q4

AdaMem separates event salience from write utility: a salient redundant frame can displace unique earlier evidence. Evaluating complete post-update banks via the frozen policy's future action loss makes this trade-off learnable (prior primitives are not claimed as new). Raw-only Select gets 692/800 vs. 661/800 (KEM-score) and 647/800 (Raw-FIFO); bank scoring beats independent scoring (721/800 vs. 672/800). Eq. (11) is a conditional finite-candidate result, not a return guarantee: exhaustive search gives δ=0\delta=0, but MAE=0.038\mathrm{MAE}=0.038 is not a uniform bound.

2. Slot vs. Token/Byte Budgets — W2, Q2

Equal KK is not token/byte parity. Across K∈{1,2,3,5}K\in\{1,2,3,5\}, the raw-only study holds raw-frame representation and slot capacity fixed, reporting scorer state/compute separately (1.86 vs. 1.84 MB at K=3K=3). Full's 384 tokens / 0.62 MB vs. Select's 768 tokens / 1.86 MB (Fig. 5) are operating points, not a common-cap curve (fitting prior K=1K=1 raw runs into a post-hoc cap is not a hard-cap protocol). We will remove the stronger matched-budget wording for the mixed-representation comparison.

3. Fixed-Module Control — Q3

Holding trained (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega), candidate generator, repair, budgets, and 800 scenes fixed at K=3K=3:

Method (K=3K=3)ModulesSelectorSucc.Rate [95% CI]PickOther 7
Raw-FIFORawFIFO647/80080.9% [78.0,83.5]42/100605/700
AdaMem-SelectRawUtility QψQ_\psi692/80086.5% [84.0,88.7]56/100636/700
KEM-FullFrozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Slot KEM679/80084.9% [82.2,87.2]52/100627/700
AdaMem-FullFrozen (Cϕ,Gϕ,Rω)(C_\phi,G_\phi,R_\omega)Utility QψQ_\psi721/80090.1% [87.9,92.0]68/100653/700

KEM-Full sums S(m)=∑e∈E(m)sKEM(e)/∣E(m)∣S(m)=\sum_{e\in E(m)}s_{\mathrm{KEM}}(e)/\sqrt{|E(m)|} with deterministic tie-breaking (raw slots, depth, timestamps, index). With the compressor, merger, reader, and candidate-update machinery held fixed, replacing KEM-based selection with learned action-utility selection improves success from 679/800 to 721/800 (+5.25 percentage points). This supports a contribution from the selection rule within the trained Full system, beyond the mere presence of compression and reading modules. It does not establish that action-utility guidance is necessary for compression to be beneficial, nor equal compute or separate representation retraining (no paired test; random-plan/success-supervised controls not run).

4. Native B3 Loss & Scope — Q1, W3

Native B3 (code) predicts actions directly with deterministic L1L_1 error rather than diffusion sampling (Sec. 3.4's diffusion clause applies only to stochastic heads). Offsets {1,2,4,8}\{1,2,4,8\} index future queries with weights 1/∣Qvalid∣1/|Q_{\mathrm{valid}}| and writes disabled, so no diffusion draw enters labels. Excluding Ordered Object Picking leaves 653/700 vs. 605/700 (+6.86 pp) for Full vs. FIFO, and 636/700 vs. 616/700 for Select vs. KEM-score. Claims are scoped to frozen B3 / RoboTwin-MeM.

5. Uncertainty, Tests & Profiling — W4

Table 2 95% Wilson CIs (K=3K=3): Full 721 [87.9,92.0]%; w/o order/intervals 698 [84.8,89.4]% (-2.9 pp); Select 692 [84.0,88.7]% (-3.6 pp); w/o pairwise merge 686 [83.2,88.0]% (-4.4 pp); indep. scoring 672 [81.3,86.4]% (-6.1 pp); visual-dist. 665 [80.4,85.6]% (-7.0 pp); w/o eviction 653 [78.8,84.2]% (-8.5 pp). Exact two-sided McNemar pp (3-way Holm pp) from Table 5's discordant counts (b/cb/c): FIFO–Select (22/67) 1.90×10−61.90\times 10^{-6} (3.80×10−63.80\times 10^{-6}); FIFO–Full (12/86) 5.93×10−155.93\times 10^{-15} (1.78×10−141.78\times 10^{-14}); Select–Full (15/44) 2.04×10−42.04\times 10^{-4} (2.04×10−42.04\times 10^{-4}). Worst-case paired pp compatible with marginal totals specifically for the four Full-versus-FIFO comparisons across K∈{1,2,3,5}K\in\{1,2,3,5\} (12-test Bonferroni) are all <1.02×10−4<1.02\times 10^{-4} (not extended to other pairs).

Replay removes drift but shares B3's proxy; closed-loop success is primary. On RTX 4090, fevent=1000/(tpolicy+tmgr)f_{\mathrm{event}}=1000/(t_{\mathrm{policy}}+t_{\mathrm{mgr}}) gives 21.92 Hz (21.9 Hz, 42.2+3.42 ms42.2+3.42\text{ ms}) for Select and 26.08 Hz (26.1 Hz, correcting 26.0, 31.5+6.85 ms31.5+6.85\text{ ms}) for Full; we will relabel Fig. 5, separate amortized rate 1000/(tpolicy+ρtmgr)1000/(t_{\mathrm{policy}}+\rho t_{\mathrm{mgr}}), and distinguish bank storage from parameters, temporary buffers, and embedded validation.

In light of the fixed-module KEM-Full control (+5.25 pp), confirmation that native EventVLA B3 uses deterministic L1L_1 loss without diffusion-sampling variance, and corrected statistical/theoretical bounds, we respectfully invite you to raise your rating in support of acceptance.

Comments on the paper

1 comment
Area_Chair_Mx76OpenReview ↗

reviewer discussion

Dear Reviewers,

The authors have submitted their rebuttal. Please read their response carefully and engage in the discussion as soon as possible. Let us know whether the rebuttal addresses your concerns and update your final rating accordingly.

Thank you for your time and service to ICLR.

Best regards,

AC

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.