acceptodds
Under review as a conference paper at ICLR 2027

DT-VLA: Lightweight Continual Adaptation of Dynamic-Temporal Vision-Language-Action Models for Efficient Deployment

Abstract

Today's vision-language-action (VLA) models must keep learning new skills as they are asked to perform new tasks. To date, the dominant recipe has been to fine-tune and redeploy the whole model for each new task, which is slow, memory-heavy, and can even overwrite earlier skills. We present an algorithm that introduces a dynamic and a temporal structure on top of a lightweight design. The dynamic structure brings each new task online by updating only a small task-local component while the shared backbone stays frozen. What earlier skills rely on is never touched, so forgetting caused by later updates is prevented by construction. A switch between skills moves only this small component instead of redeploying the whole model, sharply cutting deployment downtime. The temporal structure records every adaptation as it happens. At deployment it reads that record to schedule each incoming request to the right component, or to flag a request that matches none of them as a genuinely novel task. Therefore, a growing skill set is served without a supplied task identifier. Moreover, memory stays modest even after many skills accumulate, since each dynamic component is tiny. Finally, on a continual stream of held-out manipulation tasks, our algorithm raises the average success rate from 83.1% to 86.9% over the strongest published algorithm in our comparison. It also cuts the switching downtime of a 1,680-request sequence from 6.1 hours to 70.5 seconds. Code is available at https://anonymous.4open.science/r/DT-VLA/.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Vision Language Action, dynamic model

Reviews

Among:
Shape:
1234this paper, Bottom 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.25 over 4 reviews, above 49% of the others.
Reviewer_JFs5OpenReview ↗
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
  1. 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
  1. The "Temporal module," which the paper highlights as a novelty, has not been verified. The temporal recorder gψg_\psi (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 ψ\psi is determined. Its only role is to adjust the threshold τ=τ0+w σ(u⊤hK)\tau=\tau_0+w\,\sigma(u^\top h_K) (Section 4.4, novelty-gate definition), but the two operating points reported in Appendix A.5 (τ=0.7186\tau=0.7186 and 0.65980.6598) and the threshold used in the end-to-end run of Appendix A.7 (τ=0.7114\tau=0.7114, 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 τ\tau as a function of hKh_K. 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.

  2. 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
  1. How is the ψ\psi in gψg_\psi determined? Do the routing and novelty results change when the threshold is set to a fixed value (e.g. constant τ\tau)? Please provide an ablation experiment in which the GRU is removed.

  2. 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.

  3. 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?

  4. 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.

  5. How does GPU memory usage increase as the library grows? The scaling behavior with respect to KK varies depending on whether the increment is kept resident on the GPU or transferred from the host at each switch.

  6. Calibrating (u,τ0,w)(u,\tau_0,w) 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?

  7. 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.

  8. The variable sks_k in the log entry is not defined anywhere in the text.

3 comments

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.

ψ\psi 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ψg_\psi 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.

sks_k is the success rate on task kk immediately after we train its adapter. If nkn_k of NkN_k closed-loop episodes succeed, we record sk=100 nk/Nks_k=100\,n_k/N_k as a percentage. The eight-task benchmark uses 20 episodes per task. The original log entry lists sks_k (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).

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)).

Reviewer_AxiBOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper presents DT-VLA, a framework for continual adaptation and efficient deployment of vision-language-action models. The method first trains a general backbone on held-in tasks and then freezes it. Each incoming task is learned through an independent low-rank increment, allowing new skills to be acquired without modifying the parameters used by previously learned policies. A temporal module maintains an adaptation log, retrieves the appropriate increment when task identity is unavailable, and uses a history-dependent threshold to identify requests requiring adaptation to a new task.

The evaluation uses eight held-out LIBERO tasks spanning four task suites. DT-VLA achieves a reported final average success rate of 86.9%, compared with 83.1% for the full-model fine-tuning baseline. Each task adds approximately 2.2 MB of increment storage, rather than a 2.95 GB full-model checkpoint. Under the evaluated loading protocol, cumulative switching downtime over 1,680 requests decreases from 6.1 hours to 70.5 seconds. The paper also reports identity-free routing, novelty detection, and an end-to-end experiment involving the detection and acquisition of a previously unavailable task.

Critical strengths
  1. The paper addresses a practically important deployment problem and demonstrates concrete, measurable benefits. Continual adaptation is evaluated through three relevant outcomes: retained task performance, switching downtime, and storage added per task. This makes the evaluation useful beyond reporting task success alone. Replacing full-model checkpoints with approximately 2.2 MB increments provides a clear mechanism for reducing deployment overhead. The switching measurements, obtained on the same workstation with warm caches and a common deployment code path, substantiate this benefit under the stated loading protocol. This practical contribution is the strongest reason for my positive recommendation.

  2. The design provides a transparent stability mechanism and an initial demonstration of serving requests without supplied task identities. Independent task increments offer a simple and interpretable way to preserve previously learned policy parameters without replaying earlier demonstrations. The paper also goes beyond the identity-given setting by evaluating routing on separate query inputs, testing unseen instruction paraphrases, and reporting novelty detection and an end-to-end adaptation run. Although these evaluations are small, they provide useful initial evidence that the increment library can be managed as a functioning deployment system.

Critical weaknesses
  1. The temporal recorder’s independent contribution remains unclear. The main benefits follow from the frozen backbone and task-specific LoRA increments. A comparison with the same embedding-based retrieval system using a fixed, calibrated novelty threshold is needed to establish the recorder’s added value.

  2. The evaluation limits conclusions about superiority and scalability. Results rely on one eight-task sequence with 20 episodes per task and no multi-seed uncertainty estimates. Different backbones complicate baseline comparisons, while the switching speedup is measured against full-model reloading. Additional deployment baselines and larger identity-free evaluations would strengthen the conclusions.

Questions for authors
  1. With the same backbone, independent task increments, and task embeddings, how does the full method compare with nearest-neighbor retrieval and a fixed threshold calibrated on held-in data? Does the temporal recorder improve novelty detection or end-to-end task success?

  2. How are the parameters of gψg_\psi obtained, given that the recorder is described as requiring no separate training objective? Please clarify its initialization or training procedure, the construction and normalization of increment fingerprints, and the calibration objective for the threshold readout.

  3. Are results available across multiple training seeds or task orders, especially for DT-VLA and the full-model fine-tuning baseline? Per-task results and uncertainty estimates would help assess whether the reported accuracy advantage is consistent.

1 comment

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.

The temporal module helps the robot find learned skills faster in a large library. In our 10,000-task test without IDs, retrieval took 35.4 s with the trained GRU and 72.8 min with the fixed cosine router (Section 5.2.3, Table 1).

W2.

The original 86.9% and 83.1% success rates used supplied task IDs. Figure 4(a) in Section 5.2.1 compares all three methods on the same general backbone. DT-VLA succeeded in 19/24 episodes (79.2%), DMPEL in 7/24 (29.2%), and IsCiL in 15/24 (62.5%). The 311× switching result compares adapter swaps with full-model reloads on our hardware. For the 10,000-task library, Table 1 reports retrieval time.

Q1.

Without task IDs, retrieval from the 10,000-task library took 72.8 min with a fixed cosine threshold and 35.4 s with GRU routing (Section 5.2.3, Table 1). Appendix A.5 reports novelty detection for the original cosine router. The timing test did not measure changes in novelty detection or end-to-end success when adding the GRU.

Q2.

“No separate training objective” described the original frozen recorder. The revised router learns from skill and novelty labels. Its fingerprint uses the scaled LoRA update relative to each frozen weight, standardized on the training tasks (Section 4.2). We chose the original fixed thresholds on development cosine scores. A separate offline fit of the readout to equal targets returned a constant. The revised gate learns to flag new tasks using binary cross-entropy.

Q3.

We kept the eight-task order and DT-VLA’s frozen backbone fixed. With training seeds 1, 2, and 3, DT-VLA reached 76.25%, 72.50%, and 78.75% final success. It led all four baselines at each seed. Its mean lead over VLA-Adapter was 5.4 percentage points (paired 95% t interval, 3.6–7.2 points). Section 5.2.1 and Appendix A.5 give the results.

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

This paper presents DT-VLA, a lightweight approach to continual adaptation of vision-language-action models. It keeps a shared backbone frozen and trains a separate LoRA adapter for each new task. A temporal scheduler selects adapters and identifies unfamiliar requests using task embeddings and an adaptation record. On eight held-out LIBERO tasks, the method reports 86.9% final success, compared with 83.1% for per-task full fine-tuning. Each adapter takes 2.2 MB, and switching downtime over 1,680 requests drops from 6.1 hours to 70.5 seconds. The paper also evaluates routing without task identities and demonstrates one complete adaptation cycle.

Critical strengths

I like that the paper looks beyond success rates and measures what it actually costs to store and switch between skills. Keeping the backbone resident and swapping small adapters gives substantial savings over loading full models on the same hardware (Section 5.2.2). The preservation argument is also straightforward: learning a new adapter leaves existing policies untouched, provided the correct adapter is selected. This makes the approach appealing from a practical deployment standpoint.

Critical weaknesses

The dynamic component is essentially a separate LoRA adapter for each task, so its storage and preservation benefits are expected. What I would like to understand is what the temporal module adds beyond simple retrieval. Adapter selection uses cosine similarity, and the recurrent state only adjusts the novelty threshold. There is no comparison with the same adapter library using a fixed calibrated threshold, and how the recorder’s parameters are obtained is unclear. The main accuracy results use task identities, so they do not answer this question either.

Theorem 1 makes sense for individual policies, but routing can still change when the library grows. This seems particularly important given the reported 0.5% average success with incorrect adapters (Figure 3(c)). The routing and paraphrase tests are encouraging. Still, Appendix A.7 adds only one new task and does not show how the earlier requests perform afterward. I would be more convinced by checking whether those requests still reach the right adapters and succeed after the update.

Questions for authors
  1. Could you clarify how the recurrent recorder’s parameters are initialized or learned, and what exactly goes into an adapter fingerprint?

  2. How much does the temporal scheduler help over nearest-neighbor retrieval with a fixed threshold, using the same adapters, embeddings, and calibration data?

2 comments

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.

The temporal module helps retrieve learned skills faster from a large library. In our test with 10,000 tasks and no task IDs, retrieval took 35.4 s with GRU routing and 72.8 min with fixed-threshold cosine retrieval (Section 5.2.3, Table 1).

W2.

Theorem 1 preserves an old policy when its adapter is selected. Growing the library can change which adapter is chosen. How often the same old requests succeed before and after expansion remains open.

Q1.

The original recorder used frozen random projections, a 256-unit GRU initialized with a zero hidden state, task embeddings, and raw A/B change norms. Sections 4.2–4.3 describe how the trained router uses normalized update fingerprints and learns from routing and novelty labels.

Q2.

With 10,000 tasks and no task IDs, fixed-threshold nearest-neighbor retrieval took 72.8 min. GRU routing took 35.4 s. The fixed-threshold method took 123.4 times as long in this test (Section 5.2.3, Table 1).

The revision partially solves my concerns. However, after going through other reviews, I tend to keep my rating this time due to the limited methodological novelty and missing details.

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

This paper proposes DT-VLA, a continual adaptation framework for VLA models. It freezes a shared backbone and independently trains a LoRA adapter for each new task. During inference, it uses task embeddings and cosine similarity to select an adapter, together with a GRU-based mechanism for adjusting a novelty-detection threshold. Experiments on eight LIBERO tasks report an average success rate of 86.9%, along with reduced storage and model-switching overhead compared with full-model fine-tuning.

Critical strengths
  • Practical problem setting. The paper considers continual task adaptation and deployment efficiency for VLA models, which are relevant practical concerns.
  • Simple implementation. The frozen backbone and task-specific LoRA design allows new tasks to be learned without modifying the parameters used by previous tasks.
Critical weaknesses
  • Limited methodological novelty. The main continual learning mechanism consists of independently trained LoRA adapters over a frozen backbone, a standard parameter-isolation strategy. The claimed zero-forgetting property follows directly from this design. The task selection mechanism also relies on conventional embedding-based retrieval. The paper does not clearly establish its technical contribution beyond combining these existing components, and a direct comparison against independent task-specific LoRA adapters with simple retrieval is missing.

  • Unclear training procedure and questionable necessity of the temporal module. The GRU is introduced to summarize adapter fingerprints and adjust a scalar novelty-detection threshold, but its training procedure is not adequately specified. The paper describes one GRU state update after each task is learned, yet does not explain how the GRU parameters are obtained or whether they are optimized during threshold calibration. More fundamentally, the GRU does not participate in task retrieval itself, and the motivation for using the temporal sequence of adapter parameter statistics to determine a similarity threshold is unclear. Without comparisons against simpler alternatives, such as a fixed threshold, its contribution remains unsubstantiated.

  • Limited consideration of continual knowledge accumulation and scalability. The method largely sidesteps the central challenges of continual learning by independently training and storing a separate LoRA adapter for each task, followed by task-specific retrieval at inference time. Previously acquired adapters are not reused or composed to facilitate learning subsequent tasks, and the shared backbone remains frozen throughout the continual adaptation process. As a result, the framework preserves existing task-specific capabilities without accumulating transferable knowledge across newly learned tasks. Furthermore, allocating a new adapter to every task leads to unbounded linear parameter growth, with no mechanism for knowledge consolidation or capacity management. The method therefore resembles a growing collection of isolated task-specific models rather than a scalable continual learning system that progressively reuses and integrates acquired knowledge.

Questions for authors
  • Could the authors compare DT-VLA with a straightforward baseline that independently trains task-specific LoRA adapters and uses embedding similarity for retrieval? This would help clarify the actual technical contribution beyond standard parameter isolation and retrieval.

  • Could the authors clarify how the temporal module is trained, including how adapter fingerprints are constructed, how the GRU parameters are obtained, and whether GRU parameters are jointly optimized during threshold calibration? Additionally, why is a GRU necessary for predicting the novelty threshold? A comparison against a fixed threshold would help establish its value.

2 comments

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.

A guide robot must learn the route through a new subway station and still guide people on familiar routes. Updating one shared policy can harm those earlier skills. Keeping a full model for each skill preserves them, but each model takes space and each reload interrupts service. To our knowledge, this is the first VLA study to frame continual adaptation at deployment around three measures together: success on earlier tasks, cumulative downtime when switching skills, and storage per added skill. We marked the original example and problem statement in blue (Section 1, p. 2, “Motivation,” lines 55–57, and first contribution, lines 70–71).

W2.

The revised GRU uses the history of skills added to the library to score each candidate and set a threshold for each request. Its clearest benefit is faster retrieval in a large library. With 10,000 tasks, the supplied-ID route took 10.7 min. Without IDs, fixed cosine retrieval took 72.8 min and GRU routing took 35.4 s (Section 5.2.3, Table 1). Q2 below gives the training details.

W3.

All skills share one frozen backbone. Each new skill adds one adapter, and earlier adapters stay available. We added a scalability study of total task-file storage (Section 5.2.4, Figure 4(b)). We measured 1,000 tasks, the total storage costs are 2.1 GB for DT-VLA, 13.9 GB for DMPEL, and 47.9 GB for IsCiL, excluding shared backbones. Learning a new skill by reusing old adapters remains open.

Q1.

We added the comparison in Section 5.2.3 (Table 1, p. 10). With 10,000 tasks and no task IDs, retrieving independent task adapters by cosine similarity with a fixed threshold took 72.8 min (B). DT-VLA’s trained GRU router took 35.4 s (C).

Q2.

We train the revised temporal module on labeled development requests. One loss trains it to select the correct skill for known requests. A second trains it to flag new tasks. The backbone and adapters stay fixed (Section 4.2).

For each layer, the adapter fingerprint uses the norm of the scaled LoRA update divided by the norm of the frozen weight. We take the log of one plus this ratio and standardize it on the training tasks (Eq. 1).

The original GRU weights were random and fixed. In the revised router, we first set a constant threshold on calibration data. We then use AdamW to train the GRU weights jointly with the skill scorer and the novelty gate (Section 4.2).

The GRU summarizes the skills added so far, so the threshold can depend on both the library and the request (Section 4.4). With 10,000 tasks and no task IDs, fixed-threshold cosine retrieval took 72.8 min and GRU routing took 35.4 s (Table 1).

Thank you for the substantial revisions and additional experiments. I appreciate the clarification of the GRU training procedure and the new routing and storage measurements. However, my central concern about technical novelty remains. Training a separate LoRA adapter for each task over a frozen backbone and selecting adapters through task embeddings largely follows established parameter-isolation and retrieval designs. Evaluating success, switching time, and storage together is useful for deployment, but it does not by itself establish a new technical mechanism.

The revised GRU may be a more substantive addition, but it is also materially different from the original random, fixed GRU: it is now trained and participates in skill selection. The response’s 10,000-task timing results do not establish its contribution without matched routing accuracy and task success, or an explanation of why the supplied-ID route is slower than GRU routing. Likewise, the storage comparison shows a smaller per-task footprint but does not change the one-adapter-per-task design or its linear growth. I appreciate the work added in the rebuttal, but it does not resolve my main concern, so I will maintain my score.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.