- Rating
- 2
- Confidence
- 3
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper addresses the problem of computation cost of fine-tuning and redeploying the entire VLA model when new task arrives, and proposes DT-VLA. The dynamic part trains an independent LoRA increment for each task on top of the frozen backbone, eliminating forgetting through parameter isolation. The temporal part logs the embeddings and fingerprints of each increment and adjusts the novelty threshold using the hidden state of a GRU recorder to either route incoming requests without a task identity to an existing increment based on cosine similarity or flag them as a novel task. On an 8-task held-out stream extracted from the LIBERO benchmark, DT-VLA achieved an average success rate of 86.9% (compared to 83.1% for the per-task full fine-tuning baseline), with a switching downtime of 70.5 seconds for a 1,680-request sequence (compared to 6.1 hours for a full reload).
Critical strengths
- The problem formulation is valid and practical. I agree with the motivation that deployed robots must acquire new skills without requiring full retraining or redeployment, and the approach of evaluating this performance across the three dimensions of accuracy, time, and memory is valid.
Critical weaknesses
-
The "Temporal module," which the paper highlights as a novelty, has not been verified. The temporal recorder (Section 4.3, Eq. 2 and the sentence following it) is stated as "The recorder requires no separate training objective," so it is unclear how is determined. Its only role is to adjust the threshold (Section 4.4, novelty-gate definition), but the two operating points reported in Appendix A.5 ( and ) and the threshold used in the end-to-end run of Appendix A.7 (, held fixed even as the library grows from 7 to 8 increments) are all constants, which is at odds with the paper's own formulation of as a function of . Also, the timestamp-based candidate restriction (Section 4.4) is described but never evaluated, and there is no ablation that removes the GRU. Therefore, I am concerned that what is actually driving the routing results might simply be a cosine nearest-neighbor search with a fixed threshold applied to the last-layer embedding, which is pooled over the non-visual tokens.
-
The reported comparisons do not isolate the contribution of the proposed method. There are three parts regarding my concerns: (1) DMPEL and IsCiL use their own official backbone and pre-trained checkpoint, and DT-VLA uses an in-domain backbone pre-trained on 32 LIBERO held-in tasks (Section 5.1.2). Thus, it is hard to determine whether the performance benefit is derived from the algorithm itself or from the backbone. (2) The VLA-Adapter baseline is per-task full FT rather than a CL algorithm, so this comparison is actually a case of LoRA vs. full FT. (3) The 311$\times$ reduction of downtime is compared to a scenario where the full 2.95 GB model is reloaded for every request (L413–414). However, it is hard to accept that this is how such a system would actually be deployed in the real world; as the authors acknowledge, the per-switch stall for the CL baselines is 0.004 ms, whereas DT-VLA (40.9 ms) is actually slower (L419–421).
Questions for authors
-
How is the in determined? Do the routing and novelty results change when the threshold is set to a fixed value (e.g. constant )? Please provide an ablation experiment in which the GRU is removed.
-
Please clarify the definition of "switching downtime." Which of the following are included: disk I/O, CPU–GPU transfers, or weight merge/attach on the GPU? Since 12.9 s and 40.9 ms can vary significantly depending on the measurement hardware (e.g. NVMe, PCIe generation), the "time" axis in the contribution section is hardware-dependent.
-
Can you provide results from reimplementing CL baselines (e.g. DMPEL and IsCiL, or CL methods such as ER) on the same general backbone used by DT-VLA?
-
Are there multi-seed results (at least 3 seeds, including confidence intervals)? The current 3.8-point difference over 160 episodes is not statistically supported.
-
How does GPU memory usage increase as the library grows? The scaling behavior with respect to varies depending on whether the increment is kept resident on the GPU or transferred from the host at each switch.
-
Calibrating using held-in data appears to be an additional engineering step involving tuning. Is there evidence that the same threshold remains valid in a new environment (such as the "new subway station" mentioned in the paper's motivation) that differs from the held-in distribution?
-
The AI Use Statement says, "We used Qwen2.5-0.5B as the backbone," but this section appears to be asking about the use of generative AI during the research and writing process. It seems this was entered incorrectly, so please verify it.
-
The variable in the log entry is not defined anywhere in the text.
3 comments
Thank you for the detailed response and the additional experiments. I have reviewed them, but I will keep my score.
(1) The author response confirms that the recorder in the submitted version used random, fixed weights, and that the routing and novelty results in Appendix A.5 come from that version. The trained router's routing accuracy and novelty-detection AUROC are still missing. Retrieval time at 10,000 tasks is a different question from whether the GRU improves routing.
(2) A router trained from labeled requests is the router-dependent design that Section 2.2 argues against. The response does not say whether it is retrained when a skill is added, or how novelty detection handles tasks outside its training labels.
(3) The three new seeds average about 75.8%, against 86.9% in the submission. The same-backbone comparison rests on 24 episodes in total.
The answers to W2, Q2, and Q6–Q8 settle those points. The three above are what my assessment rests on, and the response leaves them open.
Thank you for reading our revision.
(1) The trained GRU and fixed cosine both selected the correct adapter in 720/720 known-task cases (100%). Both reached a novelty AUROC of 1.0000.
(2) DT-VLA uses a learned router without task IDs, as Section 2.2 states. It selects an adapter once per skill request. Earlier policies stay fixed. We update the router on stored old and new features when adding a skill, then check it before use (Section 4.3, lines 264–290). For novelty training, we label new-skill queries as novel when using the old library. At test time, the gate uses library scores to flag new tasks without their class labels (Section 4.4).
(3) The 86.9% result is from the original run. With three added seeds under the same settings, DT-VLA averaged 75.8% and VLA-Adapter 70.4%. DT-VLA ranked first at every seed. Its mean lead was 5.4 points (paired 95% t interval 3.6–7.2; Appendix A.5). The same-backbone test is small, with 24 episodes per method. DT-VLA, DMPEL, and IsCiL achieved 19/24, 7/24, and 15/24 successes, respectively (Figure 4(a)).
We sincerely thank the reviewers for their constructive comments. We revised the paper thoroughly. In the revised submission, we used red color to highlight our revised part. We used blue color to highlight the part that we wish to point out for ease of response (this part remains unchanged in both previous and revised submissions).
W1.
With 10,000 tasks and no task IDs, the no-GRU router with a fixed cosine threshold took 72.8 min. The trained GRU router took 35.4 s (Section 5.2.3, Table 1). The timestamp rule applies only when a request names an acquisition time. The robot acts only if that time selects one skill (Section 4.4).
W2.
Q3 gives the CL comparison on a common backbone. The original 311× switching result compares swapping an adapter with reloading a full policy for each request. A cached full policy has a different switching cost. The reported ratio applies to the full-reload setting.
Q1.
ψ is the set of GRU weights and biases (Section 4.2, p. 5, lines 221–222). In the original experiments, we chose these weights at random and kept them fixed. In the revised router, AdamW learns them jointly with the skill scorer and novelty gate from labeled requests (lines 239–245). The original gψ and its update are in blue (lines 219–222). The explicit definition and training details are in red.
Appendix A.5 reports routing and novelty detection for the original fixed-threshold router. That test did not include the trained GRU. The no-GRU ablation in Table 1 measured retrieval time. With 10,000 tasks and no task IDs, fixed cosine retrieval took 72.8 min and GRU routing took 35.4 s. The separate run with a supplied task ID took 10.7 min (Section 5.2.3).
Q2.
We timed from the loading of the selected policy until device synchronization confirmed it was ready. The full-load path includes file I/O, deserialization, and device transfer. With warm caches on our hardware, full loading took 12.9 ± 0.2 s and adapter switching took 40.9 ± 3.4 ms. These times depend on the storage device and host–GPU link.
Q3.
We reimplemented DMPEL and IsCiL on the same general backbone used by DT-VLA. DT-VLA succeeded in 19/24 episodes (79.2%), DMPEL in 7/24 (29.2%), and IsCiL in 15/24 (62.5%). DT-VLA led by 50.0 and 16.7 percentage points, respectively (Section 5.2.1, Figure 4(a)).
Q4.
We ran all five methods with three additional training seeds and the same eight-task order. DT-VLA reached 76.25% with seed 1, 72.50% with seed 2, and 78.75% with seed 3. It ranked first at every seed (Section 5.2.1). Across these three runs, its mean paired lead over VLA-Adapter was 5.4 percentage points (95% t interval, 3.6–7.2 points). The original 3.8-point lead came from a single run. Figure 12 in Appendix A.5 plots all five methods by seed.
Q5.
The backbone is shared across all skills. Keeping every adapter on the GPU makes adapter memory grow with the library. Loading only the active adapter from host memory keeps the GPU space for adapter weights limited to that adapter. The paper reports storage per skill. Peak GPU memory also depends on this loading policy.
Q6.
We selected the two fixed cosine thresholds in Appendix A.5 on held-in LIBERO data. Some novelty tasks also appear in the evaluation. Transfer to a new environment remains untested.
Q7.
Thank you for pointing this out. We have updated the AI Use Statement to clarify how we used AI tools in writing and revising the paper.
Q8.
sk is the success rate on task k immediately after we train its adapter. If nk of Nk closed-loop episodes succeed, we record sk=100nk/Nk as a percentage. The eight-task benchmark uses 20 episodes per task. The original log entry lists sk (Section 4.3, p. 5, “Adding a skill,” line 259, in blue). We added its definition in red in the same paragraph (lines 260–263).