We would like to thank the reviewer for taking the time to review our work and the many helpful comments and suggestions. We hope the following replies sufficiently address the raised questions and concerns. We will update the paper accordingly.

Q1, W1: …However, Table 4 shows a significant drop in average sequence length (performance) from N=15 (4.14) to N=20 (2.71) for a 20-step action chunk (Line 322). This suggests that N=20 might be suboptimal or that higher N values can negatively influence performance, which contradicts the intuition that more basis functions provide more representational power. Could the authors elaborate on the trade-offs beyond "compressing vs. representational power"? Is there a specific threshold or relationship between N and T (action sequence length) beyond which performance degrades significantly, or a methodology for finding the optimal N given varying trajectory characteristics?

Thank you for pointing this out, that’s indeed a valuable observation. We investigated the irregular performance drop from N = 15 to N = 20 in more detail. We found that it was due to overfitting in the ridge estimator (line 145~146) when too many basis functions are used. Specifically, the default regularization parameter was set to a very small value ($\lambda=1e-9$), which we found insufficient. After increasing it to $\lambda=1e-4$, BEAST-F with N = 20 also achieves 4.32 on CALVIN ABC. To further validate this, we re-evaluated the the model for N = 15, and added an additional ablation for N = 25. The complete ablation is attached below.

For finding the optimal N, we recommend starting with a number of basis functions equal to half of the sequence length. In practice, we typically sample a batch of action sequences from the dataset (e.g., 100 trajectories or more) and compute the reconstruction mean square error (MSE). An MSE below 1e-2 usually indicates that the chosen number of basis functions allows BEAST to represent the original trajectories well. We then repeat this process to find the minimal number of basis functions that achieves this threshold, thereby maximizing compression. Since BEAST does not require separate tokenizer training, this hyperparameter tuning process can be done in a few minutes across different action spaces and frequencies. We will include this practical tuning guide in the appendix.

Q2: The paper primarily compares BEAST against "binning-based tokenization" (Section 5.1) and other VLA/Diffusion policies that might use simpler action chunking or direct prediction. While BEAST's B-spline approach offers advantages like smoothness and fixed-length tokens, there are other established methods for continuous trajectory parameterization in robotics (e.g., Gaussian Process Motion Priors, Dynamic Movement Primitives, or even learned implicit representations for trajectories). Could the authors discuss how BEAST compares conceptually and/or empirically (if relevant prior work exists) against these alternative trajectory representations, especially concerning their ability to ensure smoothness, achieve compression, and integrate with deep learning architectures?

We appreciate the reviewer’s constructive suggestion. In response, we will include the following discussion in the related works section:

Dynamic Movement Primitives (DMPs)[1] employ a second-order dynamic system with a goal attractor. When we use DMPs to encode action chunks, only trajectory position and velocity at the transitions are continuous, because of its second-order formulation. Additionally, their goal is only converged when time goes to infinity instead of finite time and its resulting position basis functions (after integrating the dynamic system) is asymmetric, as shown Fig. 1 in [2] , which potentially influences its representation capacity. In contrast, the B-Splines representation allows for arbitrary-order smoothness by increasing the spline degree and the basis functions are symmetric, as reported in Fig. 1 top row, in our paper.

To tackle the issues of DMPs, recent works [3, 4] have also explored using B-splines as a Movement Primitives representation. However, these methods mainly focus on reinforcement learning settings and only utilize it as continuous action abstraction.

To our best knowledge, BEAST is the first work that integrates B-splines into imitation learning architectures, generating discrete tokens for VLAs.

Gaussian Process Motion Planner (GPMPs) [5] identifies waypoints as support states and uses Gaussian Process (GP) to interpolates the trajectories. However, GP-based methods are usually constrained to conditioned on low-dimensional conditions, such as via-points. It is unclear how to employ them with high-dimensional conditions, such as images and language. To overcome this issue, Conditional Neural Movement Primitives (CNMPs) [7] was introduced to model trajectories using Conditional Neural Processes (CNPs) [6]. CNMPs need a separate training process and cannot guarantee continuous transitions (see Fig 10 (b) in [2]). In contrast, BEAST requires no separate training for tokenization and guarantee smooth transitions between chunks.

We summarize a comparison of these works in the table below:

Q3: The paper frequently highlights that BEAST-F achieves strong results "without relying on additional pretraining" (Line 247) or "without robot data pretraining" (Line 248). While this is a significant advantage, Florence-2 itself is a large pre-trained Vision-Language Model. Could the authors clarify the distinction more explicitly? Is the claim specifically that BEAST-F doesn't require additional robot-specific pretraining (beyond what Florence-2 already has for general vision-language tasks), or that it performs well from scratch (which seems less likely given Florence-2's nature)? A nuanced explanation would prevent potential misinterpretations regarding the extent of "pretraining" involved.

We thank the reviewer for pointing this out, for the “without relying on additional pretraining” we indeed mean without additional robot-specific pretraining. We would highlight this even more in the final version.

W2: Clarity - Notation for B-spline Parameters: There's a slight potential for confusion between the B-spline degree P and the number of control points N (e.g., "Remark 1" stating T=N for P=0 vs. N <= T for P-th degree, and how N is precisely chosen for P > 0 degrees given a T-length action sequence). While explained, a concise clarification on the typical choices of P and N in relation to the action sequence length T in practice would improve understanding.

We thank the reviewer for pointing out the confusion in the notation. We will update the paper accordingly.

In the BEAST tokenizer, there are three key hyperparameters:

• T: the length of an action chunk (i.e., number of actions),
• P: the degree of the B-spline, which determines the level of continuity of the trajectory,
• N: the number of basis functions, i.e., control points per action dimension.

Here we attach a table to demonstrate the relation between P and level of continuity:

In BEAST, we typically choose P = 4 to achieve continuity up to jerk trajectory.

The number of basis functions N determines how many control points are used for each action dimension within one action chunk. A higher N offers higher granularity in trajectory representation but risks overfitting to noise in action sequences. Smaller N, on the other hand, offers better compression but risks underfitting and dexterity loss.

According to the recursive definition of B-splines, N must satisfy N > P [8].

Mathematically, there is no hard dependencies between T and N. In practice, using N ≤ T can compress token sequence length, resulting in more efficient training and inference. For details on how the optimal value of N is determined, please refer to our response to Q1.

To your question regarding Remark 1, when choosing P = 0 and N = T, B-splines are equivalent to action chunking, where each control point correspond exact to an action point.

References:

[1] Ijspeert A. et al., "Dynamical movement primitives: learning attractor models for motor behaviors," Neural Computation 2013.

[2] Li G. et al., "Prodmp: A unified perspective on dynamic and probabilistic movement primitives," IEEE RA-L 2023.

[3] Liao W. et al., "BMP: Bridging the Gap between B-Spline and Movement Primitives," 2nd CoRL Workshop on Learning Effective Abstractions for Planning, 2024.

[4] Kicki P. et al., "Bridging the gap between Learning-to-plan, Motion Primitives and Safe Reinforcement Learning," CoRL 2024.

[5] Mukadam M. et al., "Gaussian process motion planning," IEEE ICRA 2016.

[6] Garnelo M. et al., "Conditional neural processes," ICML 2018.

[7] Seker M. Y. et al., "Conditional Neural Movement Primitives," RSS 2019.

[8] Prautzsch H. et al., Bézier and B-spline Techniques, Springer, Aug. 2002.

As the discussion period is ending soon, we would greatly appreciate it if you could let us know whether our response addressed all of your remaining concerns. If you have any remaining questions or points that require clarification, we are happy to provide additional information. Thanks a lot!

We would like to thank the reviewer for the positive evaluation of our work and the many helpful comments and suggestions. We hope the following replies sufficiently address the raised questions and concerns. We will update the paper accordingly.

W1: some ablation results (e.g., choice of basis functions) suggest non-trivial sensitivity, but there's limited discussion on tuning strategies; paper could better detail failure cases or conditions where BEAST might underperform.

Thank you for pointing this out, that’s indeed a valuable observation. We investigated the irregular performance drop from N = 15 to N = 20 in more detail. We found that it was due to overfitting in the ridge estimator (line 145~146) when too many basis functions are used. Specifically, the default regularization parameter was set to a very small value ($\lambda=1e-9$), which we found insufficient. After increasing it to $\lambda=1e-4$, BEAST-F with N = 20 also achieves 4.32 on CALVIN ABC. To further validate this, we re-evaluated the the model for N = 15, and added an additional ablation for N = 25. The complete ablation is attached below.

W2.1: the distinction between discrete and continuous token modes in some sections could be more explicit;

We apologize for the lack of clarity. To clarify: continuous tokens refer to the normalized B-spline control points used directly, without any quantization. In contrast, discrete tokens are obtained by discrete these control points into uniform bins ranging from 0 to 255. We will update the paper accordingly.

W2.2: Descriptions of integration into large models like Florence-2 may assume familiarity with these architectures.

We agree with the reviewer that a short description of Florence-2 will enhance the clarity, therefore we will include the following description into the appendix for the final version:

Florence-2 [1] is a compact vision-language model with 0.77B parameters, featuring an encoder-decoder language model architecture paired with a DaViT image encoder that efficiently compresses images into sequences into just 50 tokens. Florence-2 offers two unique advantages: First, Florence-2 was pretrained with a large-scale dataset focusing on image-grounding with tasks like bounding box prediction and image segmentation. These objectives are well aligned with robotic manipulation challenges. In addition, its small size and low image token count make it computational and memory efficient and enable us to run VLA experiments on consumer-grade hardware. This combination of task-relevant pretraining and computational efficiency made Florence-2 ideal for exploring our tokenizers within practical resource constraints.

Q1: Section 5.5 shows that BEAST is sensitive to the number of basis functions. Can you provide heuristics or general rules for selecting this parameter across different robot platforms and frequencies?

As we mentioned in our response to W1, the sensitivity was caused by an extremely small regularization parameter in the ridge regression, which has now been addressed. We agree with the reviewer that choosing an appropriate number of basis functions is crucial for the performance of BEAST. As a general heuristic, we recommend starting with a number of basis functions equal to half of the sequence length. In practice, we typically sample a batch of action sequences from the dataset (e.g., 100 trajectories or more) and compute the reconstruction mean square error (MSE). An MSE below 1e-2 usually indicates that the chosen number of basis functions allows BEAST to represent the original trajectories well. We then repeat this process to find the minimal number of basis functions that achieves this threshold, thereby maximizing compression. Since BEAST does not require separate tokenizer training, this hyperparameter tuning process can be done in a few minutes across different action spaces and frequencies.

Q2: Are there scenarios where BEAST fails to outperform traditional tokenizers, such as in highly discontinuous or impulsive control settings?

We assume the reviewer refers to traditional tokenizers such as single-step binning or quantized chunking (i.e., Binning + AC). Action chunking can be interpreted as a special case of zero-degree B-splines, and we provide further discussion on this in Section 4.1. In highly discontinuous or impulsive control scenarios, where sharp changes or sudden actions dominate, we can configure BEAST to replicate traditional tokenizer’s behavior. Specifically, setting the spline degree P = 0 and number of basis functions N = 1 allows BEAST to act as a single-step binning tokenizer, while setting the P = 0 and N = T emulates quantized action chunking. We include a table below for clarity:

Therefore, even in highly discontinuous or impulsive control settings, BEAST does not inherently fail to outperform traditional methods, instead, it includes them as special cases within its formulation. This highlights one of BEAST’s key strengths: its representational flexibility to adapt to a wide range of control characteristics.

Q3: You highlight reduced token counts. Can you elaborate on any observed tradeoffs between compression and policy expressivity beyond MSE?

We agree with the reviewer that there is a trade-off between compression and policy performance. Fewer basis functions yield smoother trajectories and shorter token sequences, improving compression. However, too few may underfit and miss essential trajectory features, resulting in sub-optimal policy performance, especially in tasks that require precise and dexterous control. This can be observed from the table in response to W1, where N = 5 only achieves average sequence length of 3.88, which is noticeable lower than N = {10, 15, 20, 25}. On the other hand, more basis functions improve expressiveness but risks overfitting to noise present in the original action sequences and reduce compression gains. Notably, BEAST does not aim to solely minimize the MSE directly but prioritizes generating smooth trajectories with low MSE.

In line 320 and Table 4., the indices are incorrectly processed as hyperlinks to references.

Thanks for pointing out the typo, we will update the paper accordingly

References:

[1] Xiao, Bin, et al. "Florence-2: Advancing a unified representation for a variety of vision tasks." CVPR 2024.

We would like to thank the reviewer for the positive evaluation of our work and the many helpful comments and suggestions. We hope the following replies sufficiently address the raised questions and concerns. We will update the paper accordingly.

Q1: Why do you choose DaViT and Florence to build your VLA model, instead of using more commonly adopted backbones such as DINO or SigLIP?

We chose DaViT as vision encoder because Florence-2 was pre-trained with DaViT, we maintained DaViT to preserve the learned multimodal alignment between visual and language representations. Replacing DaViT with another vision encoder like DINO or SigLIP could break this carefully learned alignment.

We chose Florence-2 as our VLM backbone for two main reasons:

1. Florence-2 was pre-trained on a large-scale dataset focusing on image-grounding tasks, such as bounding box prediction and image segmentation. These objectives are well aligned with robotic manipulation tasks.
2. With only 0.77B trainable parameters, Florence-2 is significantly more compact and computationally efficient than larger alternatives like PaliGemma (3B) used by pi0 [3] or Llama-2 (7B) by OpenVLA [5]. This makes it a practical backbone for our work, which emphasizes efficiency and tokenizer design rather than maximizing backbone performance.

Q2: Why do you combine with ACT or replace ACT’s action modeling, given that ACT is unrelated to discrete action modeling?

The idea is to demonstrate that BEAST can also be used to generate continuous tokens. While ACT already generates continuous actions, it typically requires temporal ensemble [1,2] across predictions to smooth trajectories. In contrast, the BEAST formulation inherently ensures trajectory smoothness and continuity in transitions. Through empirical experiments, we demonstrate that the BEAST-enhanced ACT achieves these benefits without compromising performance.

Q3: Why not integrate your method into PI0 or OpenVLA to demonstrate that your action modeling approach can improve existing VLA models? While PI0 uses DiT to predict continuous actions and is not based on discrete action modeling, it still serves as a strong and relevant baseline to show your action modeling strategy can even outperform DiT's action modeling.

We fully agree with the reviewer that integrating BEAST with PI0 and OpenVLA backbone would strengthen our argument. However, extremely high computational resources demand and closed-source, proprietary datasets make this kind of comparison extremely difficult. OpenVLA, for instance, employs Llama-2 7B as its backbone and was pretrained using 21,500 A100 GPU hours (equivalent to 14 days on a clusters of 64 A100s) [5]. PI0 and PI0-FAST are pretrained on large closed-source, proprietary dataset (they use a large pretrained dataset ~10000 hours with only 9.1% open-source data and 903M timesteps closed-source data [3]). Furthermore, the pretraining pipelines for PI0 and PI0-FAST are not publicly available, making integrating BEAST extremely challenge.

To still provide a meaningful and fair comparison, we instead combined FAST tokenization[4] and OpenVLA tokenization[5] with Florence-2 model. This enables a fair assessment of performance between different tokenizers. Here are the results on the most challenging LIBERO-Long benchmark and Calvin ABC→D generalization benchmark. BEAST tokenizer with parallel decoding (BEAST-F-PD) achieves the highest task completion in both benchmark, followed by BEAST with autoregressive (BEAST-F-AR), yielding equal or better performance than FAST and OpenVLA tokenizers.

Additionally, to simulate a minimal “PI0-style” alternative without requiring large-scale pretraining, we conduct an additional experiment on combining BEAST’s continuous tokens with flow-matching loss and a mixture-of-expert backbone [6]. The resulting model, BEAST-Flow achieves performance comparable to the Flow policy with action chunking on LIBERO-Long, and outperforms it on Calvin-ABC, while predicting only half as many tokens. The full results are presented in the table below. These results highlights the effectiveness of BEAST within a flow-matching framework.

References:

[1] Zhao T. et al., "Learning fine-grained bimanual manipulation with low-cost hardware," RSS 2023.

[2] Li Q. et al., "Cogact: A foundational vision-language-action model for synergizing cognition and action in robotic manipulation," arXiv preprint arXiv:2411.19650, Nov. 2024.

[3] Black K. et al., "$\pi_0$: A Vision-Language-Action Flow Model for General Robot Control," RSS 2025.

[4] Pertsch K. et al., "FAST: Efficient action tokenization for vision-language-action models," RSS 2025.

[5] Kim M. et al., "OpenVLA: An open-source vision-language-action model," CoRL 2024.

[6] Reuss M. et al., "Efficient diffusion transformer policies with mixture of expert denoisers for multitask learning," ICLR 2025.