acceptodds
Under review as a conference paper at ICLR 2027

Trajectory-Calibrated Merging of Embodied Policies

14 views

Abstract

Robot foundation models are increasingly adapted into task specialists to expand their embodied capabilities. Yet these capabilities remain fragmented across separate policies, and existing model-merging methods do not reliably preserve them during closed-loop execution: parameter-space alignment provides only an indirect proxy for behavior, while regression may fail to preserve behavior at states not covered by its calibration inputs. We present Trajectory-Calibrated Regression (TCR), an execution-aware, gradient-free framework that consolidates robot specialists into a single policy. Across two complementary timescales, TCR collects calibration inputs from expert rollouts spanning different stages of task execution and from intermediate states within iterative action generation. To account for representation shifts introduced by merging, TCR recomputes each block's input through the already merged blocks. It then uses each expert's computation within the block to form module inputs and fits merged weights to match the experts' linear outputs. A two-pass calibration procedure further refines the merged policy using separate rollout caches while retaining the frozen specialists as teachers. The resulting model preserves the original inference graph and requires neither expert routing nor additional gradient training. On LIBERO, TCR merges four specialists and achieves 77.83% success across 1,200 evaluation episodes, outperforming FeatCal, RegMean, and direct weight averaging by 9.50, 24.17, and 33.00 percentage points, respectively. We also find that continued training from TCR reaches a higher observed peak success of 97.75%, compared with 94.00% when training from the common base. These results show that calibrating model merging around execution dynamics and evolving internal representations provides an effective path toward preserving diverse embodied skills in a unified policy. Code, experimental results, and visualizations are available at https://anonymous.4open.science/r/vla-merge-6333/README.md.

Primary area:
applications to robotics, autonomy, planning
Keywords:
model merging, vision-language-action models, robot learning, embodied AI, policy consolidation, trajectory calibration

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_NuVWOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

The paper proposed a merging technique (Trajectory-Calibrated Regression; TCR) that creates a merged policy from multiple specialist policies. Specifically, it proposed to do the calibration process by propagating different blocks in the action decoding, caching the intermediate values, and propagating the merging process by fitting later modules on the previously merged representations. Experiments show that the proposed TCR leads to better success rate in most cases across LIBERO, LIBERO-Pro, RoboTwin, and a real world tasks using pi0.5 as the base policy.

Critical strengths
  1. The main idea is very intuitive, merging policies in different stages on calibrated inputs intuitively allows the policy to stay in-distribution better.
  2. Experiments are sufficient, although trying different base VLA models would have strengthen the findings more.
  3. Also tested the continual learning capability of the merged policy.
Critical weaknesses
  1. The main issue with the current draft is writing clarity and many places are hard to understand. Overall there are too many math symbols in the method section and it feels convoluted. Some visual illustrations would have been nicer. More details in the questions below.

  2. As TCR follows the formulation in Eq 1, it only tries to copy the expert motion superficially but is not aware of any of the semantics or interactions among the expert policies. If two policies have overlapping input states but different motions, then the objective optimizes to learn a mean behavior, which might hurt each of the expert behavior.

  3. It seems quite compute-heavy even with the caching mechanism, as the intermediate representations have to be saved for each individual expert policies. This may pose a scaling issue when the base policy has a large number of parameters or there are many expert policies that we want to merge from.

  4. The intermediate generation step components assumes an iterative action decoding module; without it the proposed method reduces to regression-and-replay style of policy merging.

  5. Some in-depth analysis is lacking. For example, the paragraph starting at line 406 only describes the results but didn't explain why that is the case or give any general conclusion.

Questions for authors
  1. It would be helpful if the authors can help clarify the following writing-oriented questions:

    a) line 76: it is unclear what "These dependencies" refer to

    b) line 107: the first bullet point of contribution is your methodology instead of an actual contribution?

    c) line 177: what is the difference between theta and W? is W a subset of theta that is linear?

    d) line 195: why do we need this equation?

    e) line 199: is the definition of the specific entry in W used anywhere later?

    f) line 230: taking the mean of the distribution is a little confusing, especially if the call-inputs are already somewhat hand-wavy.

    g) line 276: why upweigh the experts that are already close? why not incentivize the policy to learn from from the experts that are not well-represented by the mere policy?

    h) line 367: the gap between line 366 and 367 seems to be squeezed, did the authors change the provided template?

  2. It seems like spatial tasks is one of the weakness for the proposed framework (Tables 1 & 11), do the authors have any intuition of why that might be the case? and what property of the TCR does this reflect?

  3. Is there any ablation on using relative weighting for both passes (Equation 9)?

  4. The discussion and limitation section didn't cover limitation?

  5. Appendix B.1. seems to show that having a third calibration pass improves the policy even more, so why stop at two passes? why not keep going until convergence?

11 comments

[Part 1/5]

We thank the reviewer for the constructive comments on presentation, expert conflicts, efficiency, and the interpretation of action agreement.

Below we address all raised concerns. All differences in success rate are absolute.

1. Critical weakness 1: Clarity, notation, and illustrations

TCR does not introduce a new ridge solver. It combines (i) sampling execution states from the frozen experts' closed-loop runs, (ii) sampling intermediate calls within iterative action generation, and (iii) merged-prefix replay adapted to the multimodal VLA computation graph. The last component preserves the actual dependencies among vision features, language-prefix K/V states, flow-time conditioning, and the action expert. Our π0.5\pi_{0.5} implementation covers 418 linear modules (422 adapted tensors), and we verified that replay reproduces the native forward computation for identical weights and inputs. Subsequent passes use the previous merged checkpoint as the prior and fit fresh frozen-expert caches.

We have revised the presentation to make TCR’s core idea and calibration procedure easier to follow. In the revised manuscript, we have reorganized the method section around these three dependency axes: in Sec. 3.2, the paragraphs “Across task execution” and “Within action generation” cover execution time and generator calls, and Sec. 3.3 covers network propagation. We have also redrawn Figure 1 to illustrate the data flow, and removed unnecessary notation. Point-by-point clarifications are provided under Q1(a–h).

To help readers understand the method, we have also prepared a more accessible technical walkthrough on our anonymous website (https://anonymous.4open.science/r/policy-calibration-5320/index.html).

2. Critical weakness 2: Do conflicting expert actions collapse into average behavior?

TCR does not average final actions. It matches each expert's linear-module outputs on task-conditioned inputs, allowing observations, robot states, and language instructions to separate distinct target behaviors.

Table 11 in Appendix B.5 of the revised manuscript reports action MSE and cosine similarity with the assigned specialist. To directly test whether the merged action is shifted toward the other experts, we define an action-compromise projection:

t &= \frac{(a_{\mathrm{merge}}-a_{\mathrm{owner}})^\top(\bar a_{\mathrm{other}}-a_{\mathrm{owner}})}{\lVert\bar a_{\mathrm{other}}-a_{\mathrm{owner}}\rVert_2^2},\\ \bar a_{\mathrm{other}} &= \frac{1}{3}\sum_{j\neq\mathrm{owner}} a_j. \end{aligned}$$ Here $a_{\mathrm{owner}}$ is the action of the specialist assigned to the current task, and $\bar a_{\mathrm{other}}$ is the mean action of the other three specialists. $t=0$ indicates no displacement along this direction, and $t=0.75$ corresponds to the equally weighted average of all four expert actions. Over 400 matched expert-execution requests with identical initial generation noise, we obtain: | Method | Soup | RegMean++ | FeatCal | **TCR** | | ------------------------------ | ----: | --------: | ------: | --------------: | | Action-compromise projection ↓ | 0.600 | 0.471 | 0.373 | **0.341–0.345** | In 308 critical gripper decisions where the assigned expert and the other experts favor opposite open/close directions, TCR does not produce a half-open intermediate decision. Across 1,500 Goal-suite rollouts, wrong-target selections per 100 episodes are 0.3 (TCR), 5.3 (FeatCal), 12.7 (RegMean++), and 15.7 (Soup). Overall, TCR largely preserves task-conditioned actions and target selection; the remaining errors arise from high-conflict action modules and fine manipulation. We have added the paragraph “Compromise toward other experts” and Table 12 to Appendix B.5 of the revised manuscript. The paragraph gives the definition of the projection (Eq. 16), the measurement protocol, and the gripper-conflict result; Table 12 lists the compromise index and the Goal wrong-target selections for each method.

[Part 2/5]

3. Critical weakness 3: Cache size, computation, and scaling

The original four-expert configuration (two passes, 5.77M regression rows) requires approximately 1.03 h on a single A100-80GB, summing the profiled collection and construction stages, with a peak memory of 32.8 GiB. Deployment uses a single static model without expert routing.

For comparison, FeatCal profiled twice under the same protocol requires 1.55 h and 1.91 h, with 86–87% of the time spent in its solve/export stage. The 42.9 GiB listed for FeatCal in our cost table was sampled per device and included memory used by another job; sampled per process, the peak is 20.5 GiB. The original TCR implementation therefore uses more memory than FeatCal, and its advantage lies mainly in construction time. We have corrected two entries in the cost table (Table 15 in Appendix B.7 of the revised manuscript; Table 13 in the submission): FeatCal's peak is now 20.5 GiB, and TCR's peak is updated from 31.75 GiB to 32.8 GiB, the process peak of the two-pass build confirmed in two independent measurements.

To examine how cost scales with the number of experts, we measured one-pass construction. For M>4M>4, the bank consists of repeated copies of the original four experts.

Number of expertsOne-pass constructionPeak allocated memory
4692 s18.62 GiB
8824 s26.12 GiB
121,207 s34.80 GiB
201,788 s52.18 GiB

All entries were measured on an exclusive A100-80GB. The number of regression rows grows linearly (1.11M per expert). Least-squares fits give T(M)≈343+71.3MT(M)\approx 343+71.3M s and P(M)≈9.7+2.11MP(M)\approx 9.7+2.11M GiB, i.e., approximately 1.2 minutes and 2.11 GiB per additional expert; individual time increments are not uniform because weight loading and I/O vary between runs.

As the number of experts increases, the main bottleneck is the dual solve in the original implementation, whose N×NN\times N kernel grows quadratically with the number of regression rows. For the largest module, the kernel alone occupies 10.9 GiB at M=12M=12 and 30.2 GiB at M=20M=20; the solve also requires factorization workspace alongside the cached features and model weights, and the dual build at M=20M=20 ran out of memory on an A100-80GB. The primal form uses a d×dd\times d kernel (1.0 GiB at d=16,384d=16{,}384), and the 20-expert build completes.

The memory reduction consists of two parts. First, each block accesses only one prefix K/V layer, so we keep all 18 layers in host memory from load time, transfer one layer at a time to the GPU, and release tensors that are no longer needed. This reduces the four-expert peak from 30.82 GiB to 20.85 GiB while leaving the SHA-256 hash of the exported checkpoint unchanged. Second, the primal solve further reduces the peak to 18.62 GiB. The two forms are algebraically equivalent; the resulting weights differ by 2.331×10−32.331\times10^{-3} in relative ℓ2\ell_2.

In a separately profiled four-expert one-pass build of 711 s, the time divides into 178 s for the solves, 184 s for feature capture and replay, and approximately 349 s of fixed overhead for loading weights, verifying replay references, and writing the checkpoint. Since the solve accounts for about a quarter of the total, further savings would come mainly from I/O.

[Part 3/5]

4. Critical weakness 4: Dependence on an iterative action decoder

Intermediate generation calls are not specific to π0.5\pi_{0.5}. The π0\pi_0/π0.5\pi_{0.5}, GR00T N1, and SmolVLA families generate continuous actions with flow matching, and RDT employs diffusion; all of these expose intermediate states that can be sampled for calibration. The multi-call component therefore applies to this broader class of iterative VLA decoders.

For a non-iterative decoder, intermediate calls are absent, but execution-stage sampling, matching of expert-module outputs, multimodal merged-prefix replay, and sequential passes remain applicable given an architecture-specific replay adapter. On π0.5\pi_{0.5}, a same-request, matched-row comparison yields 79.11% for multi-call versus 74.75% for final-only (+4.36%).

We further conducted LIBERO merging experiments on GR00T N1.6 to test TCR beyond π0.5\pi_{0.5}, merging publicly released Spatial and Object specialists fine-tuned from the same base (3.29B parameters). Every method produces one fixed set of weights that serves both suites; tasks are distinguished only by the language instruction, without task-specific parameters, adapters, routing, or normalization. The two specialists differ in 1.62B parameters (49.3%), including the action-head DiT (1.09B), the action encoder (0.23B), language-model layers 12–15 (0.20B), the state encoder, and the action decoder; TCR calibrates 99.9% of these parameters. All methods start from the same Soup and use the hyperparameters of the paper without tuning. Because no static demonstration set is available for GR00T, RegMean++ and FeatCal use expert-execution inputs for calibration. Each method is evaluated on 180 episodes:

MethodSuccess
Specialists97.22%
Soup2.78%
RegMean++8.33%
FeatCal2.78%
TCR57.22%

TCR reaches 57.22% success, whereas no other merging method exceeds 8.33%. The low baseline scores reflect how far apart the two specialists are. We measure the action error of Soup relative to the action difference between the two specialists: this ratio is 1.08–1.22 on GR00T, meaning that Soup deviates from each specialist more than the other specialist does, compared with 0.51–0.76 for our π0.5\pi_{0.5} specialists. In addition, FeatCal's anchor, 2⋅Soup−base2\cdot\text{Soup}-\text{base}, assumes that the base and the specialists share a parameterization. In GR00T, a set of action-head projection layers is randomly initialized in the base, and the deployed specialists have their action normalization folded into these layers. The anchor is therefore not informative, and FeatCal performs at the level of Soup (2.78% for both). RegMean++ does not use this anchor and reaches 8.33%, so TCR's margin over it (48.89%) is unaffected by the anchor issue.

5. Critical weakness 5: Why does action agreement relate to closed-loop success?

We have expanded the last paragraph of Sec. 4.3 (“Does action agreement accompany skill retention?”) and added Figure 2 to investigate why methods with lower action MSE sometimes succeed less often (the analysis at line 406). We held the offline MSE ranking fixed and varied which suites contributed to closed-loop success. Across nine methods, the Spearman correlation between negative MSE and success was 0.86 overall, rising to 0.95 on Spatial, Object, and Goal but falling to 0.52 on Long alone. One reversal makes this concrete. KnOTS-TIES has lower MSE than TIES-Merging and higher mean success on the first three suites (61.11% vs. 52.22%), yet lower success on Long (6.67% vs. 20.33%). This exposes a limitation of action agreement as a diagnostic: it captures behavior at expert-visited states, while a single missed interaction can leave a long-horizon policy in a state where its ability to recover was never tested offline.

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

TCR merges compatible embodied-policy specialists through gradient-free, prior-centered ridge regression. It collects observations throughout expert rollouts and intermediate inputs from native action generation, recomputes block inputs through the merged prefix, and fits linear modules using expert-local features. Two passes use separate expert caches and different expert-weighting rules. The resulting policy retains the original inference graph. For four π0.5 LIBERO specialists, TCR achieves 77.83% success versus 68.33% for FeatCal. The paper also reports physical-robot experiments, LIBERO-PRO and RoboTwin evaluations, and further training from merged initializations.

Critical strengths
  1. The 9.50-point improvement over FeatCal on LIBERO is practically meaningful, particularly on Goal and Long. The physical-robot result, 30/40 successes versus FeatCal’s 23/40, provides additional evidence beyond simulation, although the trial budget is small. Preserving one static checkpoint and the native inference graph is a relevant deployment advantage.

  2. The paper accounts for multimodal dependencies across 418 linear modules and validates replay against native forward computation. Observation-source, prefix, cache-reuse, and union-budget controls help explain the recipe. Reporting failures, task-level uncertainty, and the distinction between action agreement and closed-loop success makes the evidence easier to assess.

Critical weaknesses
  1. Regression and merged-prefix replay are inherited components, so execution coverage is central to the contribution. Yet removing intermediate calls also reduces first-pass rows from 4,441,200 to 1,480,400; the 4.66-point drop therefore does not isolate generation-stage coverage. The budget-matched observation-source comparison is more informative, but its task-bootstrap interval is [−0.75, 11.00] points (Appendix B.6). TCR also uses 5.77M rows versus FeatCal’s 4.44M, with different inputs, passes, and solver details. The union-cache controls are useful, but do not resolve these particular attribution issues. The results support the complete recipe more strongly than the distinct contribution of each new ingredient.

  2. The main comparison is conditional on one expert bank, and Appendix C.1 states that the formal evaluation reset bank had been inspected during development, despite configurations being fixed before formal evaluation. An untouched reset bank would give a cleaner estimate. All evaluated architectures are π0.5; on RoboTwin, TCR achieves only 15.56% versus 57.78% for specialists and 13.33% for RegMean++, a difference of four successes in 180 episodes.

Questions for authors
  1. Does intermediate-call calibration still help when the final-call control has the same number of distinct regression rows? How much of the LIBERO gap remains when FeatCal receives the same rollout/generation input pool and cumulative row budget?
  2. Can the main comparison be repeated on a fresh reset bank not inspected during development, with paired task-level uncertainty for TCR versus FeatCal? Please distinguish calibration-construction variability from repeated evaluation of fixed checkpoints.
  3. On RoboTwin, does the small gain over RegMean++ persist across additional evaluation repeats, and which failure modes account for the large remaining gap to the specialists?
6 comments

[Part 1/3]

We thank the reviewer for recognizing the LIBERO and real-robot results and the advantage of deploying a single static merged policy.

We clarify the contribution and the scope of the expert bank, and address all raised concerns. All differences in success rate are absolute.

1. Method contribution and existing component ablations

TCR draws calibration inputs from two sources: the states encountered by the frozen specialists during closed-loop execution, and the intermediate flow calls within each action-generation request. These are combined with merged-prefix replay adapted to the VLA computation graph, which in π0.5\pi_{0.5} recomputes features across the vision branch, language-prefix K/V, time conditioning, and action expert in their actual dependency order. The implementation covers 418 linear modules (422 adapted tensors), and replay is verified against the native forward computation. The second pass uses the previous merged weights as its prior and processes a separate frozen-expert cache.

Sec. 4.3 / Table 3 includes the no-rollout, final-call-only, and no-merged-replay ablations. The new experiments control two confounds in these results: the number of regression rows contributed by generator calls, and the inputs and budget provided to FeatCal.

2. Expert-bank scope and cross-backbone generalization (major weakness 2)

We added merges of experts from different training stages of the same backbone, as well as an evaluation on a second VLA backbone.

Different expert fine-tuning stages. We repeated the four-expert merge with π0.5\pi_{0.5} checkpoints at 10k and 15k fine-tuning steps, comparing methods within each stage:

Specialist training stageSpecialist referenceFeatCalTCR
10k96.42%68.33%77.83%
15k96.75%68.75%77.58%

At both stages, TCR exceeds FeatCal by 9.50% and 8.83%, respectively.

Another policy architecture. To address the concern that all evaluated architectures are π0.5\pi_{0.5}, we conducted LIBERO merging experiments on GR00T N1.6, merging publicly released Spatial and Object specialists fine-tuned from the same base (3.29B parameters). Every method produces one fixed set of weights that serves both suites; tasks are distinguished only by the language instruction, without task-specific parameters, adapters, routing, or normalization. The two specialists differ in 1.62B parameters (49.3%), including the action-head DiT (1.09B), the action encoder (0.23B), language-model layers 12–15 (0.20B), the state encoder, and the action decoder; TCR calibrates 99.9% of these parameters. All methods start from the same Soup and use the hyperparameters of the paper without tuning. Because no static demonstration set is available for GR00T, RegMean++ and FeatCal use expert-execution inputs for calibration. Each method is evaluated on 180 episodes:

MethodSuccess
Specialists97.22%
Soup2.78%
RegMean++8.33%
FeatCal2.78%
TCR57.22%

TCR reaches 57.22% success, whereas no other merging method exceeds 8.33%. The low baseline scores reflect how far apart the two specialists are. We measure the action error of Soup relative to the action difference between the two specialists: this ratio is 1.08–1.22 on GR00T, meaning that Soup deviates from each specialist more than the other specialist does, compared with 0.51–0.76 for our π0.5\pi_{0.5} specialists. In addition, FeatCal's anchor, 2⋅Soup−base2\cdot\text{Soup}-\text{base}, assumes that the base and the specialists share a parameterization. In GR00T, a set of action-head projection layers is randomly initialized in the base, and the deployed specialists have their action normalization folded into these layers. The anchor is therefore not informative, and FeatCal performs at the level of Soup (2.78% for both). RegMean++ does not use this anchor and reaches 8.33%, so TCR's margin over it (48.89%) is unaffected by the anchor issue.

[Part 2/3]

3. Q1: Independent value of intermediate calls and fair FeatCal comparison

Does multi-call calibration help only because it adds regression rows? We paired multi-call and final-only calibration on the same expert execution requests and matched their effective row counts. For each budget, we constructed three independent merged policies with different calibration seeds; build k of both arms used the same requests and was evaluated on 1,200 paired episodes from the independent reset bank.

Matched budgetMulti-call (mean ± SD)Final-only (mean ± SD)Mean difference
Two passes, 2.66M rows77.44 ± 1.50%74.11 ± 1.77%+3.33%
Full 5.77M rows79.11 ± 2.37%74.75 ± 0.74%+4.36%

All six paired build differences are positive (+2.83% to +6.08%). For the full-budget final-only control, we draw three independent initial-noise samples per existing expert request to fill the same row budget, without collecting additional execution states or using intermediate flow calls. In the first pass, the vision and language weights of the two arms are bit-identical, so the difference lies in the action branch. Under this control, covering different stages of action generation improves success beyond the effect of additional rows.

We have added this study to Appendix B.2 of the revised manuscript (paragraph “Generation-stage coverage at matched row budgets” and Table 9).

What remains when FeatCal receives the same inputs and budget? We compare three FeatCal variants. All FeatCal variants retain FeatCal's own calibration objective, anchor, interpolation, and regularization, and all are evaluated on the independent LIBERO reset bank (1,200 episodes). FeatCal is the configuration of Table 1 (68.33% under the submission protocol). TCR-Matched follows the main TCR recipe with calibration caches shared with FeatCal-Matched; the main TCR builds achieve 78.58% on the same reset bank:

VariantCalibration inputsEffective rowsSuccess
FeatCalStatic observations (original setting)4.44M68.17%
FeatCal-ExecExpert execution states4.44M70.92%
FeatCal-MatchedSame execution requests and generation-call inputs as TCR-Matched5.79M72.17%
TCR-MatchedSame inputs as FeatCal-Matched5.77M79.67%

The row budgets of FeatCal-Matched and TCR-Matched differ by 0.26%, and TCR-Matched leads by 7.50%.

4. Q2: Independent reset bank and sources of variability

We conducted a new LIBERO evaluation on a reset bank generated on September 17, 2026 and not used for model development, model selection, or hyperparameter tuning. It contains 40 tasks × 30 held-out initializations = 1,200 episodes, and all methods share the same per-episode reset assignments. Intervals for the main comparisons are obtained from a 40-task cluster-paired bootstrap.

MethodIndependent-bank success
TCR78.58%
FeatCal68.17%
RegMean++60.33%
Soup44.58%
TCR without execution rollouts73.89%

The paired differences are TCR − FeatCal = +10.42% [5.61%, 15.19%] and TCR − no-rollout = +4.69% [1.58%, 7.94%] (95% task-cluster intervals). The main advantage holds on instances not used during development. On the independent reset bank, the paired 95% interval for the rollout ablation excludes zero, providing clearer statistical evidence for the contribution of execution-trajectory calibration.

We also separated model-construction variability (a new calibration cache and an independently merged checkpoint) from evaluation variability at a fixed checkpoint:

Sample SD of success rateTCRFeatCal-Exec
Across three independently constructed models (SD of build means)1.37%0.60%
Across repeated evaluations of a fixed checkpoint1.32%0.58%

The first row measures the spread across separately constructed models; the second measures the spread when the merged weights are fixed and only the evaluation is repeated. The FeatCal column uses FeatCal-Exec, defined in Q1.

[Part 3/3]

5. Q3: RoboTwin replication and failure modes

We expanded RoboTwin to three paired repeats per method, i.e., 540 episodes per policy on the same task/reset assignments:

PolicyRepeat 1Repeat 2Repeat 3Overall
Specialist reference57.78%56.11%56.67%56.85%
RegMean++13.33%11.11%11.67%12.04%
TCR15.56%20.56%16.67%17.59%

TCR outperforms RegMean++ in all three repeats, with 95/540 vs. 65/540 successful episodes (+5.56%). The specialists remain substantially stronger than both.

To analyze this gap, we replayed 1,246 physical-state trajectories, verified them against the recorded resets and outcomes, and classified failures as grasp, contact precision, bimanual coordination, or placement:

Outcome / failure class (540 episodes per policy)TCRRegMean++Specialists
Successful episodes9565307
Grasp failure11413822
Contact/precision failure16318284
Bimanual coordination failure354512
Placement failure133110115

Compared with the specialists, TCR has 212 more failed episodes: 92 more grasp failures and 79 more contact/precision failures, together 171 (81%), whereas bimanual-coordination and placement failures increase by only 23 and 18. Compared with RegMean++, TCR has 24, 19, and 10 fewer grasp, contact/precision, and bimanual-coordination failures and 23 more placement failures, for a net gain of 30 successful episodes.

Together with the target-selection statistics on LIBERO Goal, these results locate the loss after static merging mainly in low-level manipulation precision rather than in target selection: on RoboTwin, 81% of TCR's additional failures relative to the specialists come from grasping and contact precision, and on LIBERO Goal, TCR selects a wrong target in only 0.3 of every 100 episodes (Table 12 in Appendix B.5 of the revised manuscript), with all other failures being execution failures on the instructed object. The repeated runs are reported in Table 18 of Appendix C.7 of the revised manuscript (paragraph “Repeated evaluation on RoboTwin”), and the failure classification in the paragraph “Failure modes on RoboTwin.”

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

This paper aims at the problem of consolidating multiple independently trained robot policy specialists into a single unified model without joint retraining or expert routing at inference. The authors propose Trajectory-Calibrated Regression, a gradient-free merging framework that fits merged weights using inputs sampled from expert rollout trajectories rather than static demonstration sets. TCR combines three core design choices: (1) calibration inputs cover both cross-episode execution states and intermediate internal states inside the iterative action generator; (2) blockwise merged-prefix replay recomputes features through already merged layers before fitting each subsequent block, to compensate for representation shifts; (3) a two-pass calibration procedure first refines the weight average with relative-error weighting on one rollout cache, then further refines the checkpoint with uniform weighting on a separate cache. Evaluated on LIBERO with four π₀.₅ task specialists, TCR achieves 77.83% success rate. The paper also reports real-robot results, cross-benchmark transfer to LIBERO-PRO and RoboTwin 2.0, and improved peak performance when continuing joint training from the merged checkpoint.

Critical strengths
  1. The paper correctly identifies cascading error dynamics in closed-loop embodied control: small action deviations change future observations, which amplify performance degradation over time. Calibrating on actual execution trajectories rather than static offline observations is a well-motivated direction for robot policy merging.

  2. The paper provides stepwise ablation of rollout inputs, intermediate generation calls, and merged-prefix replay, quantifying each component’s contribution to final task success and offering reasonable transparency into how the method works.

  3. Experiments span simulated benchmarks, a physical robot platform, cross-benchmark generalization, and continued training analysis, covering both static function matching and closed-loop task success. The inclusion of hardware validation adds practical relevance.

  4. The final product is a single static policy that retains the original inference graph, requiring no expert router, no online selection, and no additional gradient training at deployment. This is a practical advantage over ensemble or routing-based consolidation methods.

Critical weaknesses
  1. The core framework of TCR is a direct extension of RegMean++, which already introduced sequential blockwise replay for regression-based merging. The primary additions are engineering refinements rather than fundamental conceptual breakthroughs. The underlying ridge regression formulation, prior-centered fitting, and blockwise replay pipeline remain largely identical to prior regression merging methods. Given the already dense body of model merging literature, this incremental advance does not meet the novelty bar expected at ICLR.

  2. All experiments use specialists fine-tuned from the exact same base model (π₀.₅) with identical architecture, tokenizer, normalization, and action representation. This is a maximally compatible merging scenario where interference is inherently low. The paper never tests TCR on more heterogeneous experts, for example, specialists trained from different base models, different architectures, or different data distributions, which is the more challenging and practically relevant merging scenario. It is therefore unclear whether the method generalizes beyond this controlled, low-difficulty setting.

  3. TCR requires collecting full rollout trajectories including internal intermediate generator states (noisy action chunks, flow times) from every expert, resulting in 5.77 million regression rows, over an hour of merging time, and 31.75 GB peak memory. This calibration cost is substantially higher than simpler baselines, yet the absolute performance gain over the next best baseline (FeatCal) is only 9.5 percentage points on LIBERO. The paper provides no cost-benefit analysis and does not justify whether this large increase in data collection and compute is worth the modest improvement in task success. For real-robot deployment, collecting full trajectory and internal state data from every specialist would be even more expensive and logistically impractical.

  4. The comparison with FeatCal is handicapped: FeatCal is implemented with only single-step (t=1) inputs and no intermediate generator states, while TCR benefits from full intermediate call sampling. Since FeatCal was originally proposed for layer-wise feature calibration, not trajectory-level execution matching, this implementation choice artificially inflates TCR’s relative advantage. Furthermore, the paper does not compare against recent dedicated robot policy merging methods such as MergeVLA, dismissing them with the excuse of different expert construction. Without comparison to the strongest relevant baselines under matched calibration budgets, the claimed state-of-the-art performance is not credible.

  5. The ablation study cannot disentangle two competing explanations: (a) the execution-aware calibration mechanism itself is superior, or (b) TCR simply uses more and more diverse calibration data than baselines that use only static initial observations. For example, the “No rollouts” variant not only changes the input source but also changes the input distribution and effective sample diversity. There is no control experiment that matches the exact number and diversity of calibration samples across methods to isolate the pure effect of trajectory-aware calibration. It is plausible that much of the gain comes simply from using more calibration data, not from the proposed design principles.

  6. The two-pass procedure lacks strong theoretical motivation. Supplementary results show that repeating calibration on the same cache (A→A) already yields most of the gain, indicating that the improvement comes largely from re-fitting the model more times, not from fresh trajectory data. Adding a third pass (A→B→B) decreases performance, which is a classic signature of overfitting to the finite calibration set. The paper acknowledges this non-monotonic pattern but provides no analysis or remedy, leaving substantial concerns about generalization beyond the tested task distribution.

  7. TCR requires full access to the internal intermediate computation states of each expert policy (e.g., latent action noise, flow time counters, hidden states at each generation step). In practice, when merging models from different teams, different codebases, or black-box checkpoints, these internal states are usually unavailable. This restriction means TCR can only be applied to fully homologous, white-box specialists from the same codebase, which severely narrows its real-world utility.

  8. On more challenging benchmarks, performance drops sharply: 43.19% on LIBERO-PRO and only 15.56% on RoboTwin 2.0, far below the expert reference performance. While TCR still ranks highest among merging methods, the absolute performance is so low that the merged policy is barely functional on more complex or out-of-distribution tasks. This suggests that the method does not solve the core problem of severe skill degradation after merging.

Questions for authors

see above.

8 comments

[Part 1/6]

We thank the reviewer for recognizing the value of execution-aware calibration, closed-loop evaluation, and deployment as a single static policy.

Below we address all raised concerns. All differences in success rate are absolute.

1. Novelty relative to RegMean++

Problem. Merging embodied policies differs from merging static predictors in where the calibration inputs come from. RegMean-style methods fit each module on a fixed input set drawn from a dataset. A VLA policy encounters inputs it produces itself: the states it visits depend on its earlier actions, and in precision-sensitive manipulation such as grasping, placement, and stacking, a small action deviation changes physical contact and every subsequent observation; within each action request, each flow call receives the noisy action produced by the preceding calls. The calibration distribution that matters is therefore the distribution of module inputs induced by each expert's closed-loop execution and iterative generation, which a static dataset does not cover. For module ll, TCR solves min⁡W ∑iωi Ex∼dil∥Wx−Wix∥22+λ∥W−P∥F2,\min_W\ \sum_i \omega_i\,\mathbb{E}_{x\sim d_i^l}\lVert Wx-W_ix\rVert_2^2+\lambda\lVert W-P\rVert_F^2,

where dild_i^l is the distribution of the module's input along expert ii's executions and generation calls, recomputed through the merged prefix, ωi\omega_i is the expert weight (relative-error weighting in the first pass and uniform in later passes), and PP is the prior (Eq. (5) of the revised manuscript). RegMean-style methods solve a closely related least-squares problem with dild_i^l given by a static dataset.

TCR addresses this problem through three coordinated designs. First, execution-trajectory calibration collects observations and robot states across different stages of frozen experts’ closed-loop rollouts. Second, multi-call generation calibration retains multiple Flow Calls within each action-generation request, covering intermediate noisy action states and flow times that the observation alone does not specify. Third, multi-pass calibration with fresh trajectory caches uses the current merged model as the prior for the next pass while continuing to fit frozen expert outputs on newly collected execution inputs.

These designs extend calibration across two temporal scales-task execution and action generation-and progressively refine the merged policy.

RegMean++ provides the foundation of regression-based merging and sequential feature replay. TCR’s contribution lies in the calibration mechanism that jointly addresses these two temporal scales and incorporates successive updates using fresh expert trajectories. To implement this mechanism in a VLA, we adapt merged-prefix replay to the cross-branch dependencies among visual-language prefix K/V, time conditioning, and the Action Expert, so that downstream modules are fitted using features produced by already-merged upstream modules.

Our experiments support the effectiveness of this framework.

Under the configurations reported in Tables 1 and 2, TCR achieves 77.83% on LIBERO and 75.0% on the real robot, compared with 58.17% and 50.0% for RegMean++, respectively. These overall comparisons are complemented by component ablations in Table 3. Each part of this formulation changes the calibration distribution and is tested separately: on an independent LIBERO reset bank, removing execution rollouts lowers success by 4.69%; keeping only the final generation call at matched row budgets lowers it by 3.33% and 4.36% (Response 5); and reusing a cache instead of collecting fresh trajectories stops improvement at 74.00%, compared with 80.42% after five passes with fresh caches (Response 6).

[Part 2/6]

2. Generalization beyond one π0.5\pi_{0.5} expert bank

We added validation along two axes: the expert bank and the backbone.

Different expert training stages. We have added experiments using π0.5\pi_{0.5} specialists from two fine-tuning stages:

Expert fine-tuning stepsExpertsFeatCalTCR
10k96.42%68.33%77.83%
15k96.75%68.75%77.58%

Across both stages, TCR outperforms FeatCal by 9.50% and 8.83%, respectively. These results support robustness to the expert training stage within the same backbone. In addition, Response 7 reports merging experiments with publicly released third-party π0.5\pi_{0.5} specialists that we did not train.

An additional backbone. We have conducted LIBERO merging experiments on GR00T N1.6, merging publicly released Spatial and Object specialists fine-tuned from the same base (3.29B parameters). Every method produces one fixed set of weights that serves both suites; tasks are distinguished only by the language instruction, without task-specific parameters, adapters, routing, or normalization. The two specialists differ in 1.62B parameters (49.3%), including the action-head DiT (1.09B), the action encoder (0.23B), language-model layers 12–15 (0.20B), the state encoder, and the action decoder; TCR calibrates 99.9% of these parameters. All methods start from the same Soup and use the hyperparameters of the paper without tuning. Because no static demonstration set is available for GR00T, RegMean++ and FeatCal use expert-execution inputs for calibration. Each method is evaluated on 180 episodes:

MethodSuccess
Specialists97.22%
Soup2.78%
RegMean++8.33%
FeatCal2.78%
TCR57.22%

TCR reaches 57.22% success, whereas no other merging method exceeds 8.33%. The low baseline scores reflect how far apart the two specialists are. We measure the action error of Soup relative to the action difference between the two specialists: this ratio is 1.08–1.22 on GR00T, meaning that Soup deviates from each specialist more than the other specialist does, compared with 0.51–0.76 for our π0.5\pi_{0.5} specialists. In addition, FeatCal's anchor, 2⋅Soup−base2\cdot\text{Soup}-\text{base}, assumes that the base and the specialists share a parameterization. In GR00T, a set of action-head projection layers is randomly initialized in the base, and the deployed specialists have their action normalization folded into these layers. The anchor is therefore not informative, and FeatCal performs at the level of Soup (2.78% for both). RegMean++ does not use this anchor and reaches 8.33%, so TCR's margin over it (48.89%) is unaffected by the anchor issue.

[Part 3/6]

3. Calibration and deployment cost

Construction cost. The original four-expert TCR configuration (two passes, 5.77M regression rows) requires approximately 1.03 h on a single A100-80GB, summing the profiled collection and construction stages, with a peak memory of 32.8 GiB; the merged result is a single static policy that requires no expert routing at inference. Under the same exact-checkpoint protocol, FeatCal requires 1.55 h and 1.91 h in two profiled runs, with 86–87% of the time spent in its solve/export stage (4,859 s and 5,938 s), whereas TCR's solve over all 418 modules takes 178 s per pass. The memory entry for FeatCal in our cost table requires a correction: the reported 42.9 GiB was sampled per device and included memory used by another job, and per-process sampling gives 20.5 GiB. The original TCR implementation therefore uses more memory than FeatCal, and its advantage lies in construction time. We have corrected two entries in the cost table (Table 15 in Appendix B.7 of the revised manuscript; Table 13 in the submission): FeatCal's peak is now 20.5 GiB, and TCR's peak is updated from 31.75 GiB to 32.8 GiB, the process peak of the two-pass build confirmed in two independent measurements.

Physical-robot collection. In the PiperX experiment, each expert contributed only 10 autonomous execution trajectories. An operator only placed and reset objects between trials, and no teleoperated demonstrations or frame-level labels were required; module features are computed offline through merged-prefix replay. Table 2 of the submission reports success rates of 75.0% for TCR, 57.5% for FeatCal, and 87.5% for the specialists on the physical tasks.

Scaling with the number of experts. We measured the one-pass construction cost using banks in which M>4M>4 is formed by repeating the original four experts:

Number of expertsConstruction timePeak allocated GPU memory
4692 s18.62 GiB
8824 s26.12 GiB
121,207 s34.80 GiB
201,788 s52.18 GiB

All entries were measured on an exclusive A100-80GB. Least-squares fits give about 1.2 minutes of construction time and 2.11 GiB of peak memory per additional expert. These measurements use two memory optimizations: layer-wise offloading of the prefix K/V cache, and a primal solve in place of the dual form, which requires an N×NN\times N kernel. They reduce the four-expert peak from 30.82 GiB to 18.62 GiB and allow the 20-expert build to fit on a single 80 GB GPU. The expert-count scaling curves (Figure 5) and a breakdown of construction time have been added to Appendix B.7 of the revised manuscript, in the paragraph “Scaling with the number of experts.”

Comments on the paper

2 comments

We thank all reviewers for their constructive feedback. The main concerns have been addressed as follows; details are given in the individual responses.

  1. Fair comparison and independent evaluation. With the same calibration inputs and a nearly identical budget, TCR outperforms FeatCal by 7.50% (79.67% vs. 72.17%). On a new LIBERO reset bank not used for development, TCR leads FeatCal by 10.42%.
  2. Generality. On a second architecture, GR00T N1.6, TCR reaches 57.22%, while no other merging method exceeds 8.33%. When merging public third-party π0.5\pi_{0.5} checkpoints from LIBERO and RoboCasa, TCR achieves the best two-domain average (50.13%).
  3. Clarity and cost. We have clarified the problem definition and method presentation (Sec. 3), and added the cost-scaling analysis and corrected cost entries (Appendix B.7).

All substantive revisions in the revised manuscript are marked in blue.

AuthorsOpenReview ↗

Final Author Response: Summary of Rebuttal and Addressed Concerns

Dear Area Chair and Reviewers,

As the discussion period concludes, we sincerely thank all the reviewers for their time, constructive feedback, and the engaging discussions. We have conducted extensive additional experiments and provided detailed point-by-point responses to address the main concerns. Below is a summary of how we have addressed the specific issues raised by each reviewer.


To Reviewer p2eK

We greatly appreciate your positive assessment and are glad that our detailed responses addressed your concerns. Specifically:

  • Independent value of intermediate calls: Addressed by providing matched-budget experiments (+4.36% gain).
  • Inspected reset bank issue: Addressed by evaluating on a completely fresh reset bank, where TCR outperforms FeatCal by +10.42%.
  • RoboTwin replication & Failure modes: Provided 3 repeats and a detailed failure-mode classification (identifying grasp and contact precision as the main loss sources).

We thank you for confirming that we answered most of your questions and for maintaining your positive review.


To Reviewer NuVW

We thank you for your constructive feedback on clarity, expert conflicts, and computation. We addressed your concerns through the following revisions:

  • Clarity & Expert Conflicts: Reorganized the method section and added the action-compromise projection to explicitly demonstrate that TCR preserves task-conditioned actions rather than collapsing into average behavior.
  • Computation & Theory: Added comprehensive analyses on construction cost scaling (linear time/memory growth), applicability to other iterative decoders, and a theoretical/empirical discussion on the method’s upper bounds and limitations.

We sincerely appreciate your acknowledgment that most of your concerns have been addressed, and we are grateful that you increased your rating to a weak accept and maintained your positive stance.


To Reviewer 5ENZ

Although we did not receive a follow-up response, we have extensively addressed all the critical concerns raised in your review within our rebuttal. Specifically:

  • Novelty & Generalization: We added experiments on the GR00T N1.6 backbone (where TCR achieves 57.22% vs. baselines <8.33%) and evaluated on public third-party checkpoints across different benchmarks to demonstrate generality beyond the π0.5 expert bank.
  • Fair Comparison: We added a matched-budget comparison (FeatCal-Matched) and controlled for generation-stage coverage, proving TCR retains a +7.50% advantage under identical inputs and row budgets.
  • Cost & Theory: We updated the memory cost table (corrected to 20.5 GiB for FeatCal), provided scaling analyses for up to 20 experts, and provided the theoretical derivation for why sequential passes (A→B) outperform pooled passes.
  • Low Absolute Success: We added repeated evaluations on RoboTwin and failure-mode analyses, demonstrating that TCR consistently outperforms RegMean++ across repeats and retains ~85.1% of specialist performance on LIBERO-PRO.

Conclusion: We have thoroughly revised the manuscript and added substantial new evidence (including new backbones, public checkpoints, fresh reset banks, and matched-budget ablations). We kindly ask the Area Chair to consider these comprehensive revisions and the positive feedback from the reviewers.

Thank you again for your time and guidance.

Best regards, The Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.