acceptodds
Under review as a conference paper at ICLR 2027

Recompose and Refine Latent Reasoning Flows for Vision-Language-Action Models

Abstract

Latent reasoning enables vision-language-action (VLA) models to transform multimodal observations into task-relevant internal states before generating continuous robot actions. While existing methods learn to generate or refine such states for each policy query, they discard successful reasoning after execution and therefore reconstruct similar computation from scratch. We present *Reasoning and Flow Memory* (FlowMem), a unified VLA model that turns successful latent computation into reusable reasoning experience. Rather than appending a fixed retrieved context, FlowMem dynamically retrieves and recomposes compatible latent fragments as the embodied context evolves, forming a reasoning route that follows the temporal structure and progress of successful computation. The route is then refined using current visual and proprioceptive evidence before it conditions action generation. Experiments on RoboMME and LIBERO-Plus show that FlowMem attains 48.0% and 77.3% success—1.7 and 4.1 points above memory-free policies, respectively—demonstrating the value of reusing successful latent computation for closed-loop VLA control. Anonymous code is available [online](https://anonymous.4open.science/r/FlowMem-C963/README.md).

Primary area:
applications to robotics, autonomy, planning
Keywords:
Vision-Language-Action Models, Latent Reasoning, Reasoning Flow Reuse, Memory-Augmented Policies, Embodied Reasoning, Recurrent Reasoning, Action Generation

Reviews

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

The paper proposes FlowMem, a non-parametric memory mechanism for latent-reasoning VLA models (built on LaST0) that segments latent trajectories from successful training episodes into fragments, retrieves and recomposes trajectory suffixes via constrained search, refines them with cross-attention, and injects them into the flow-matching action expert. Experiments on RoboMME and LIBERO-Plus report improvements in success rate and lower per-episode inference time over LaST0.

Critical strengths
  1. Storing and recomposing latent reasoning trajectories rather than raw observations, action chunks, or text subgoals offers a clean and well-motivated perspective on non-parametric memory for VLA policies.
  2. The counterfactual memory protocol (testing wrong-task, shuffled-order, and mismatched-progress memories) is a sensible experimental design, and the 4.1-point gain on LIBERO-Plus is evaluated over a large sample (10,030 instances).
Critical weaknesses
  1. On RoboMME, both the overall gain over LaST0 (48.0% vs. 46.3% on 800 episodes) and all mechanism-level ablations in Tables 3–5 lie well within single-run binomial evaluation noise (≈1.8% standard error per method), and the benchmark itself does not match the proposed mechanism. Every counterfactual and ablation variant falls between 44.0% and 46.3%, with wrong-task memory (46.1%) and no-refinement (46.3%) performing virtually identically to the no-memory LaST0 baseline (46.3%). Moreover, RoboMME tests within-episode working memory (e.g., counting or object permanence in the current rollout), whereas FlowMem retrieves only from past training episodes based on the current observation and state. Consequently, the RoboMME experiments cannot substantiate the paper's core claims that trajectory ordering, task identity, or progress alignment drive policy performance.
  2. On LIBERO-Plus, the 4.1-point gain is not isolated from extra training and added parameters, and key algorithmic details are missing. The counterfactual memory controls are not run on LIBERO-Plus, making it unclear whether the gain over LaST0 stems from retrieved latent memories or simply from the extra cross-attention module and additional finetuning stage. In fact, the largest gains occur under camera (+8.2) and noise (+10.8) shifts—where visual retrieval should be least reliable—while almost no gain appears under robot initial-state shifts (+0.3), where trajectory recomposition should help most. It is also unclear why training refined memory tokens to reconstruct LaST0's frozen latent Z∗Z^* enables FlowMem to outperform LaST0, and core details (fragment segmentation, constrained search, and memory bank composition) are omitted, preventing reproduction.
Questions for authors
  1. Could the authors run the counterfactual memory controls (wrong-task memory, shuffled order, and a null/random-memory baseline with the same extra training steps and parameters) on LIBERO-Plus to verify whether the 4.1-point improvement comes from memory reuse?
  2. Since the alignment loss trains the refined memory tokens Z′Z' to match LaST0's native latent Z∗Z^*, why does FlowMem outperform LaST0 rather than merely approximating it, and why do the largest gains on LIBERO-Plus occur under visual noise and camera shifts rather than initial-state shifts?
  3. Could the authors provide multi-seed confidence intervals on RoboMME, per-step query latency (unconfounded by episode termination length), and the missing specifications for fragment segmentation, constrained search, and memory bank construction?
3 comments

Statistical reliability and evidence for memory reuse (W1, W2 & Q1, Q3). We thank the reviewer for raising these concerns. Multi-seed results show consistent gains, and new LIBERO-Plus ablations support the effectiveness of memory reuse. FlowMem exceeds budget-matched LaST₀ by +2.92% on RoboMME (95% CI [+0.99%, +4.85%]) and +3.43% on LIBERO-Plus (95% CI [+2.70%, +4.16%]) (Table 1). Following the RoboMME counterfactual protocol, wrong-task, out-of-order, and wrong-progress memory yield 74.8%, 75.1%, and 76.2%, versus 77.3% with correct memory (Table 2). Single-source reuse and removing refinement also reduce success (Table 3), supporting the contribution of memory organization and current-context refinement.

Table 1. Three independent training runs (success rate, %; mean ± standard).

BenchmarkMethodRun 1Run 2Run 3Mean ± Standard
RoboMMEBudget-matched LaST₀45.844.646.545.63 ± 0.94
RoboMMEFlowMem48.049.348.448.54 ± 0.64
LIBERO-PlusBudget-matched LaST₀73.574.074.173.87 ± 0.34
LIBERO-PlusFlowMem77.377.277.477.30 ± 0.13

The 95% CIs for mean differences use two-sided, unpaired Welch t intervals across independent training runs.

Table 2. Newly added memory counterfactuals on LIBERO-Plus (success rate, %).

✓ indicates a retained property; blank cells indicate corrupted properties. LaST₀ is the original memory-free baseline.

MethodTaskOrderProgressSR
LaST₀–––73.2
Wrong task✓74.8
Out of order✓75.1
Wrong progress✓✓76.2
Correct memory✓✓✓77.3

Table 3. Retrieval and composition ablations on LIBERO-Plus (success rate, %).

Valid: valid-route coverage (%); Multi: multi-source query proportion (%).

MethodValidMultiSR
LaST₀––73.2
Nearest state––73.9
Single source100.00.076.5
w/o refinement100.0100.076.7
FlowMem100.0100.077.3

RoboMME’s relevance to cross-episode memory reuse (W1). We thank the reviewer for raising this concern. RoboMME is relevant because cross-episode latent reasoning reuse can help a robot use its current-episode history to complete the task. In PatternLock, the robot must remember the target sequence shown in a demonstration video and retrace it. FlowMem can refine latent reasoning from past successful episodes using the current context to guide execution of this sequence. On RoboMME, FlowMem achieves 48.54%, versus 45.63% for budget-matched LaST₀ (Table 1).

Why outperform LaST₀ when matching its latents (W2 & Q2)? We thank the reviewer for raising this question. FlowMem reuses successful latent reasoning from multiple past trajectories to construct current reasoning, going beyond LaST₀’s prediction from the current context alone. LaST₀ provides the source fragments, but FlowMem recomposes and adapts them to the current situation rather than reproducing a single LaST₀ prediction. Restricting reuse to a single source or removing refinement reduces RoboMME success from 48.0% to 44.0% and 46.3%, respectively (paper, Table 3). The same trend holds on LIBERO-Plus (Table 3), supporting the contributions of multi-source reuse and current-context refinement across both benchmarks.

Why larger gains under camera/noise shifts (W2 & Q2)? We thank the reviewer for raising this question. Under camera/noise shifts, FlowMem can reuse successful latent reasoning to guide current predictions when visual evidence is unreliable. It first filters memories by task, then retrieves relevant fragments based on the current observation and robot state. Recomposition and refinement improve over nearest-state retrieval by 3.90% under camera shifts and 2.54% under noise, versus 1.20% under initial-state shifts (Table 4). These results show larger observed benefits from the complete reuse pathway under visual perturbations. Initial-state shifts additionally require action adaptation to a new robot configuration, which latent reasoning recomposition does not directly resolve.

Table 4. Success rates by perturbation (%).

MethodCameraNoiseInitial-state
Budget-matched LaST₀81.3078.9336.54
Nearest-state84.884.635.9
FlowMem88.7087.1737.14

Segmentation, search, and memory-bank construction (W2 & Q3). We thank the reviewer for requesting these details. We build a fixed memory bank from successful demonstrations, organize latent reasoning entries into fragments, and retrieve compatible fragments for recomposition.

  • Fragment construction. RoboMME provides subgoal annotations, so we group consecutive records with the same subgoal and store one latent reasoning output per stage as a memory entry. LIBERO-Plus lacks these annotations, so we construct fragments during retrieval using windows of up to eight consecutive memory entries. Progress records each fragment’s normalized position in its source trajectory.
  • Search. We filter candidates by task, score them using visual similarity and state distance, and retain the 16 highest-scoring partial sequences at each step. Annotated stages must satisfy preconditions and add new stage effects, without repeated fragments or backward progress within a source trajectory. Temporal windows preserve internal order, and cross-source connections require compatible boundary states.
  • Memory-bank construction. A frozen native policy processes successful training demonstrations to extract latent reasoning. We store the selected outputs with task labels, visual descriptors, robot states, progress, and source identity and order for retrieval and composition. The banks contain 1600 RoboMME trajectories and 432, 454, 428, and 379 trajectories across the four LIBERO suites. Banks remain fixed during second-stage training and evaluation. Evaluation trajectories are excluded, and training retrieval excludes the current source trajectory.

Per-step query latency (Q3). We thank the reviewer for pointing this out. Our previous timing could be affected by episode length; remeasuring latency per query shows reductions of 49.99% on RoboMME and 43.55% on LIBERO-Plus. Each query includes retrieval, recomposition, refinement, and action prediction, excluding model loading, warm-up, and simulation. We compute mean latency per task, then average tasks equally. LIBERO-Plus uses more queries because its evaluation includes more simulation episodes (Table 5).

Table 5. Per-query latency (ms/query).

BenchmarkType / SuiteQueries per methodLaST₀FlowMemReduction
RoboMMECounting418258.4124.3↓51.91%
Permanence246267.3130.9↓51.04%
Reference319425.7211.1↓50.41%
Imitation291281.4150.3↓46.60%
Overall1274308.19154.13↓49.99%
LIBERO-PlusSpatial1192418.0226.8↓45.75%
Object1202424.5240.4↓43.36%
Goal1200419.3234.6↓44.06%
Long1222417.5246.2↓41.04%
Overall4816419.81236.97↓43.55%
Reviewer_SDFiOpenReview ↗

Official Comment by Reviewer SDFi

Thank you for your thoughtful response and for the work you put into addressing my questions during the rebuttal period. After considering your response, I’ve decided to keep my original score.

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

This paper proposes a memory framework for VLA models from latent reasoning. The proposed Reasoning and Flow Memory (FLOWMEM) is constructed by the latent reasoning segments from the successful trajectories. Instead of simply using fixed retrieved context, this method applies dynamically retrieval and recomposes compatible latent segments from previous experience. The goal of the proposed approach is to turn the latent reasoning into reusable experience for embodied memory. The experiments are conducted on two simulation benchmarks, including RoboMME and LIBERO-Plus.

Critical strengths
  1. Memory for VLA models is a long-standing challenge in robotics. Having memory helps the robot to better leverage the experiences to address new tasks, which is crucial for real-world deployment.
  2. Existing works usually adopt text or previous frames as the memory. This work instead repurposes the latent reasoning to construct the embodied memory. The overall idea and motivation is reasonable.
  3. The overall paper is easy to follow and well-structured.
Critical weaknesses
  1. While the latent reasoning performs more efficiently than conventional textual reasoning, the latent reasoning itself lacks the interpretability. How can we know the physical semantics corresponding to each retrieved segment? Does each segment truly represent some meaningful motion primitive? Can these segments be combinable to compose a realistic trajectory? It would be beneficial to provide more clarification and evidence to support the claims.
  2. For the evaluation, RoboMME is a direct evaluation benchmark that assesses the effectiveness of the memory relevant ability. However, as shown in Table 1, the improvement from the memory-less baseline LaST0 is only 1.7% in average, which is relatively incremental. The evidence of the memory design is not that obvious.
  3. This paper solely uses simulation benchmarks for evaluation, but lacks real-robot validation. This paper also doesn’t provide the analysis of the correlation between the used simulation benchmark and real world cases. Due to the sim-to-real gap, the performance in simulation cannot be directly viewed as the effectiveness for real robot scenarios.
Questions for authors
  1. Is the proposed method model-agnostic? Whether the proposed approach can be applied to different VLMs or different model sizes?
3 comments

Physical semantics of latent segments and composition into realistic trajectories (W1). We thank the reviewer for raising this concern. Latent reasoning anticipates future visual and physical states to guide actions [1, 2]; FlowMem reuses this computation rather than executable motion primitives. Table 1 identifies each fragment’s source episode, temporal range, and corresponding physical events, including grasping, lifting, and placing. In task 2053, FlowMem composes compatible fragments from eight source demonstrations, refines them using current observations, and successfully places the soup can and cream cheese box into the basket.

Table 1. Retrieved fragments and execution in LIBERO-Plus task 2053.

Episode IDs and atom ranges identify the source demonstrations and retrieved portions; physical descriptions come from corresponding frames.

Current stageSource episodeAtom rangeSource physical eventsSubsequent execution
Grasp soup can257 / 6548–55 / 47–54Gripper adjusts around the object.Can grasped and lifted.
Place soup can172 / 54100–107 / 96–103Held object approaches basket; height adjusted.Can placed and released.
Lift cream cheese79 / 171238–245 / 207–214Object rises with gripper from table.Box lifted toward basket.
Place cream cheese116 / 47222–229 / 267–274Object lowered; episode 47 also shows release.Box placed; task succeeds.

[1] Qingqing Zhao et al. CoT-VLA: Visual Chain-of-Thought Reasoning for Vision-Language-Action Models. CVPR, 2025. Paper.

[2] Zhuoyang Liu et al. LaST₀: Latent Spatio-Temporal Chain-of-Thought for Robotic Vision-Language-Action Model. ICML, 2026. Paper.

Does the 1.70% RoboMME gain substantiate the memory design (W2)? We thank the reviewer for raising this concern. Multi-seed results show consistent gains, and fixed-weight memory interventions support the effectiveness of the memory design. The paper reports 48.0% versus 46.3% for FlowMem and LaST₀ on RoboMME (paper, Table 1). Our additional three-seed comparison yields 48.54 ± 0.64% versus 45.63 ± 0.94% after continuing baseline training with a matched budget (Tables 2–3). Separately, with the 48.00% full-bank checkpoint fixed, reducing the bank to 25% lowers success to 46.25%, while 75% content mismatch lowers it to 45.50% (Tables 4–5), linking performance to memory availability and content.

Table 2. Three-seed FlowMem results on RoboMME (success rate, %).

SeedCountingPermanenceReferenceImitationAvg.
202775.029.037.550.548.00
225071.028.542.055.549.25
126074.529.539.050.548.38
Mean73.5029.0039.5052.1748.54 ± 0.64

Table 3. Budget-matched continued-training LaST0 (success rate, %).

BenchmarkRun 1Run 2Run 3Mean ± SD
RoboMME45.844.646.545.63 ± 0.94
LIBERO-Plus73.574.074.173.87 ± 0.34

Table 4. Memory-bank size on RoboMME (success rate, %).

SizeCountingPermanenceReferenceImitationAvg.
Full bank75.029.037.550.548.00
25%68.528.537.550.546.25
50%69.028.536.552.546.63
75%72.527.537.551.047.13

Table 5. Memory-bank quality on RoboMME (success rate, %).

Latent contents are replaced with those from other tasks; retrieval metadata remains unchanged.

QualityCountingPermanenceReferenceImitationAvg.
Original bank75.029.037.550.548.00
25% mismatched76.029.537.550.048.25
50% mismatched69.028.038.550.546.50
75% mismatched70.026.036.050.045.50

Missing real-robot validation and simulation-to-reality analysis (W3). We thank the reviewer for raising this concern. RoboMME and LIBERO-Plus capture real-world challenges relevant to memory reuse: temporarily hidden objects, changing viewpoints, visual noise, and altered object layouts or robot starting states. They test whether prior reasoning remains useful under incomplete observations and changed conditions, and whether refinement adapts it to the current scene. For real-world deployment, memory can be constructed from successful robot demonstrations using the same offline procedure. These results support the approach under simulated deployment challenges; real-robot effectiveness remains to be established.

Model-agnostic applicability across VLMs and model sizes (Q1). We thank the reviewer for raising this question. At the design level, FlowMem is model-agnostic within VLAs that use latent reasoning to guide action generation. It does not require a particular VLM backbone or model size. For a new model, we build the memory bank from its latent reasoning on successful demonstrations, then train FlowMem’s memory modules and the model’s action expert to use these memories.

Thanks to the authors for the response. My concern about real-world validation remains unresolved. Although RoboMME and LIBERO-Plus include challenges relevant to real-world deployment, performance on these simulation benchmarks does not establish the method’s effectiveness on real robots. The response provides neither real-robot experiments nor empirical evidence connecting the simulation results to real-world performance. Therefore, the rebuttal partially addresses my original concerns, and I maintain my original score.

Reviewer_W2M6OpenReview ↗
Rating
2
Confidence
1(−2)
Informativeness
3
Presentation
2(−1)
Soundness
2
Read review
Paper summary

This paper introduces FlowMem, a memory-augmented vision-language-action framework that treats successful latent reasoning trajectories as reusable computation rather than transient intermediate states. Successful episodes are decomposed into ordered latent fragments associated with task, state, progress, and transition metadata. At inference time, compatible fragments are retrieved and recomposed across multiple source episodes into a reasoning route, which is subsequently refined using the current embodied context before conditioning action generation.

The method is evaluated on RoboMME and LIBERO-Plus. FlowMem improves over the controlled memory-free LaST0 baseline from 46.3% to 48.0% on RoboMME and from 73.2% to 77.3% on LIBERO-Plus. The paper additionally provides retrieval, memory-counterfactual, and component ablations intended to demonstrate the importance of temporal ordering, multi-source recomposition, progress alignment, and current-context refinement.

Critical strengths
  1. A meaningful formulation of reusable latent reasoning.

The main conceptual contribution is more specific than simply adding memory to a VLA. FlowMem preserves ordered latent reasoning fragments together with progress and transition information, and reconstructs a task-dependent reasoning route from multiple past successful episodes. This is a useful perspective because an isolated similar latent state does not encode how reasoning should evolve from that point onward.

  1. The controlled ablations directly probe the claimed mechanism.

The paper contains stronger diagnostic experiments than many memory-augmented VLA papers. Nearest-state retrieval performs worse than the no-memory baseline, disrupting temporal order substantially degrades performance, and removing either multi-source recomposition or current-context refinement reduces success. These experiments provide evidence that performance is not simply obtained by injecting arbitrary additional latent context.

Critical weaknesses
  1. The reported gains, especially on RoboMME, are relatively small without sufficient statistical evidence.

The main RoboMME improvement is 46.3% to 48.0%, and three of the four aggregate categories improve by only 1.0–1.5 points. Although the evaluation uses a fixed set of 50 episodes for each of 16 tasks, I could not find results across multiple independent training seeds, confidence intervals, or another statistical analysis establishing that the improvement is robust to training stochasticity. This is particularly important because the claimed overall advantage on RoboMME is only 1.7 points.

LIBERO-Plus shows a stronger aggregate improvement, but the gains are highly heterogeneous across perturbations: Camera and Noise improve substantially, whereas Robot and Language improve by only 0.3 and 0.4 points. More uncertainty analysis would help determine how reliable these differences are.

  1. The empirical comparison does not include several of the closest latent-memory/reasoning-memory methods discussed by the paper itself.

The related-work section identifies TRM-VLA, LaMem-VLA, OptimusVLA, and WeaveLA as methods near the intersection of reasoning and memory. However, the main experiments compare mostly with broader VLA or memory baselines, while these closest alternatives are not evaluated under a controlled common backbone/protocol.

This matters because the key contribution is not memory itself, but specifically retaining and reusing latent reasoning computation. A direct comparison against methods that compress or transfer latent policy/reasoning states would make it substantially clearer whether ordered multi-source reasoning-flow recomposition provides an advantage beyond existing latent-memory mechanisms.

Questions for authors
  1. Are the reported FlowMem and LaST0 results obtained from a single trained checkpoint or from multiple independent training seeds? If multiple runs were performed, could the authors report mean ± standard deviation or confidence intervals? In particular, is the 46.3% → 48.0% RoboMME improvement statistically reliable?

  2. Could the authors provide a controlled comparison, if feasible, with the closest latent-memory approaches such as LaMem-VLA or WeaveLA using the same backbone, training data, and evaluation protocol? If this is not feasible, please clarify more concretely what experimental evidence distinguishes FlowMem from these approaches beyond the representational/interface difference described in Related Work.

  3. How sensitive is FlowMem to the size and quality of the successful-episode memory bank? For example, how does performance vary as the number of stored successful trajectories is reduced? This would clarify whether the method learns a reusable reasoning mechanism or depends strongly on dense coverage of the evaluation task distribution.

  4. The memory representation contains explicit progress information and retrieval is constrained within the task/instruction namespace. How is progress determined during memory construction, and how much of FlowMem's gain remains when progress metadata is unavailable or estimated less accurately? This question is important for understanding how readily the method transfers to less structured real-world settings.

6 comments

Statistical reliability of gains over LaST0 (W1 & Q1). We thank the reviewer for raising this concern. Across three independent training seeds, FlowMem consistently outperforms budget-matched LaST0, with mean success-rate differences of +2.92% on RoboMME and +3.43% on LIBERO-Plus. FlowMem achieves 48.54 ± 0.64% and 77.30 ± 0.13%, versus 45.63 ± 0.94% and 73.87 ± 0.34% for budget-matched LaST0 (mean ± standard; Tables 1–3). Table 4 further reports uncertainty across all seven perturbation domains: Camera 88.70 ± 0.58%, Noise 87.17 ± 1.12%, Initial-state 37.14 ± 0.56%, and Language 82.89 ± 0.77%.

Table 1. Three-seed FlowMem results on RoboMME (success rate, %).

SeedCountingPermanenceReferenceImitationAvg.
202775.029.037.550.548.00
225071.028.542.055.549.25
126074.529.539.050.548.38
Mean73.5029.0039.5052.1748.54 ± 0.64

Table 2. Three-seed FlowMem results on LIBERO-Plus (success rate, %).

SeedSpatialObjectGoalLongAvg.
4284.184.062.978.777.27
148885.384.062.577.777.19
422186.384.262.677.577.45
Mean85.2584.0962.6877.9877.30 ± 0.13

Table 3. Budget-matched continued-training LaST0 across three independent runs (success rate, %).

BenchmarkRun 1Run 2Run 3Mean ± Standard
RoboMME45.844.646.545.63 ± 0.94
LIBERO-Plus73.574.074.173.87 ± 0.34

Table 4. Perturbation-wise FlowMem results across three independent training seeds (success rate, %).

PerturbationSeed 42Seed 1488Seed 4221Mean ± Standard
Camera88.488.389.488.70 ± 0.58
Initial-state36.637.037.737.14 ± 0.56
Language82.283.782.782.89 ± 0.77
Light90.290.590.190.28 ± 0.23
Background90.591.091.591.02 ± 0.51
Noise88.386.187.187.17 ± 1.12
Layout71.270.770.470.78 ± 0.40

Controlled comparisons and empirical distinctions from latent-memory methods (W2 & Q2). We thank the reviewer for this suggestion. FlowMem turns successful latent reasoning into reusable experience for constructing current reasoning through ordered, multi-source recomposition and current-context refinement. It improves over budget-matched LaST₀ by +2.92% on RoboMME and +3.43% on LIBERO-Plus (Tables 1–3). Single-source reuse, shuffled order, and removing refinement reduce RoboMME success from 48.0% to 44.0%, 44.4%, and 46.3%, respectively (paper, Tables 3–4). New LIBERO-Plus ablations further support the roles of task relevance, temporal organization, multi-source reuse, and refinement (Tables 5–6). LaMem-VLA’s implementation is unavailable [1]. WeaveLA, now named LoopVLA [2], reports results on the same RoboMME benchmark: 47.17 ± 1.42%, compared with 48.54 ± 0.64% for FlowMem (Table 1).

Table 5. Memory counterfactuals on LIBERO-Plus (success rate, %).

✓ indicates a retained property; blank cells indicate corrupted properties.

MethodTaskOrderProgressSR
LaST₀–––73.2
Wrong task✓74.8
Out of order✓75.1
Wrong progress✓✓76.2
Correct memory✓✓✓77.3

Table 6. Retrieval and composition ablations on LIBERO-Plus.

Valid: valid-route coverage (%); Multi: multi-source query proportion (%).

MethodValidMultiSR (%)
LaST₀––73.2
Nearest state––73.9
Single source100.00.076.5
w/o refinement100.0100.076.7
FlowMem100.0100.077.3

[1] Hongyu Qu et al. Dual Latent Memory in Vision-Language-Action Models for Robotic Manipulation. arXiv:2607.07608, 2026. Paper; Code repository.

[2] Shoujing Zhu et al. LoopVLA: Cross-Subtask Event Memory for Looped Task Execution. arXiv:2606.17463, 2026. Paper.

Memory-bank size, quality, and dependence on dense task coverage (Q3). We thank the reviewer for raising this question. Reducing the memory bank to 25% lowers success from 48.00% to 46.25% (Table 7), whereas replacing 25% of latent contents leaves success comparable at 48.25% (Table 8). With model weights fixed, we retain nested subsets of successful trajectories within each task. Success increases with bank size (Table 7), indicating that reuse benefits from denser within-task memory. For quality, we replace latent reasoning contents with those from other tasks while preserving retrieval metadata. At 50% and 75% mismatch, success falls to 46.50% and 45.50% (Table 8), showing that substantial corruption weakens reuse.

Table 7. Memory-bank size on RoboMME (success rate, %).

SizeCountingPermanenceReferenceImitationAvg.
Full bank75.029.037.550.548.00
25%68.528.537.550.546.25
50%69.028.536.552.546.63
75%72.527.537.551.047.13

Table 8. Memory-bank quality on RoboMME (success rate, %). Retrieval metadata is retained; the specified fraction of reasoning contents is replaced with contents from other tasks.

QualityCountingPermanenceReferenceImitationAvg.
Original bank75.029.037.550.548.00
25% mismatched76.029.537.550.048.25
50% mismatched69.028.038.550.546.50
75% mismatched70.026.036.050.045.50

Progress construction, robustness, and real-world transfer (Q4). We thank the reviewer for raising this question. Relative progress is a fragment’s normalized position in its source trajectory; no true task progress is needed online. For a source trajectory of length NN, a fragment spanning positions ss to ee has progress [s/N,e/N][s/N,e/N]. For example, positions 20–40 in a trajectory of length 100 give [0.2,0.4][0.2,0.4]. This metadata is stored offline and can also be computed from real-world demonstrations. Wrong-progress replaces retrieved fragments with equal-length fragments from the same trajectory, shifted by at least 25% of its length. Under this mismatch, success decreases to 46.1% on RoboMME and 76.2% on LIBERO-Plus, but remains above budget-matched LaST0 (Table 9).

Table 9. Success rate under progress mismatch (%).

MethodRoboMMELIBERO-Plus
Budget-matched LaST045.63 ± 0.9473.87 ± 0.34
FlowMem, correct progress48.077.3
FlowMem, wrong-progress46.176.2

LaST0: Table 3; correct progress: paper, Tables 1–2; RoboMME wrong-progress: paper, Table 4; LIBERO-Plus wrong-progress: newly added results.


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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.