1 Introduction↩︎

Robotic manipulation via visuomotor policy learning has made remarkable progress in recent years [1]–[4]. Yet, despite these advances, task execution speed remains a major bottleneck. In everyday manipulation tasks such as folding a T-shirt, humans typically complete the task in roughly 10 seconds, whereas even state-of-the-art robotic systems often require close to a minute [1], [5], [6]. This gap exposes a fundamental and largely unresolved challenge in visuomotor policy learning—efficiency: how can robots execute complex manipulation tasks quickly, rather than merely complete them successfully?

A key source of inefficiency in modern visuomotor policies lies in the design of action chunking [3], [4]. Most existing approaches parameterize actions as fixed-length chunks sampled uniformly over time. While such chunking can stabilize long-horizon prediction and improve learning performance [7], it also introduces inherent limitations:

• Uniform temporal resolution. Fixed-length chunks assume that every phase of a task requires identical control granularity. In practice, manipulation tasks exhibit strongly non-uniform temporal structure: fast motions such as reaching can be executed rapidly with coarse actions, whereas contact-rich phases such as grasping, alignment, and insertion demand fine-grained precision. Uniform chunking fundamentally misallocates representational capacity across time.

 

• Chunk discontinuities. Stitching together independently predicted action chunks at inference time can introduce discontinuities at chunk boundaries. While such boundary mismatches may be tolerable in low-speed or quasi-static settings, they become highly problematic during high-speed execution, where even small errors can lead to tracking failures or complete task failure.

These limitations motivate a paradigm shift: representing robot actions as continuous curves rather than discrete waypoint chunks. Such a representation is used in classical motion planning [8]–[11] and computer graphics [12], [13], where spline-based representations are widely favored for being smooth, compact, and mathematically tractable. Among spline families, B-splines are especially attractive for visuomotor control: they are smooth by construction, provide compact parameterizations [14]–[16], and can approximate continuous functions arbitrarily well given sufficient knots [14], [17].

In this work, we propose B-spline policy, a visuomotor policy that directly outputs continuous action curves. As illustrated in Fig. 1, rather than predicting discrete-time action chunks, B-spline policy outputs B-spline parameters that define an action curve in continuous-time. This shift from discrete action chunks to continuous action curves provides several key advantages:

• Acceleration via temporal rescaling. Each predicted B-spline segment can be sampled at arbitrary control frequencies and retimed dynamically by scaling the temporal mapping. This allows the robot to execute the identical trajectory at significantly higher speeds without sacrificing fidelity.

 

• Inference-time segment alignment. To ensure stable accelerated execution over the duration of a task, we introduce an inference-time segment alignment mechanism that enforces smooth transitions between the predicted B-spline segments.

 

• Plug-and-play integration. B-spline policy requires minimal modifications to existing imitation learning methods, serving as a drop-in replacement for standard action chunk prediction.

We evaluate B-spline policy across both simulated and real-world manipulation environments. Our real-world setup includes three tasks spanning distinct robotic challenges: precise object manipulation, long-horizon tabletop rearrangement, and bimanual, contact-rich interaction. Integrated into both Diffusion Policy and ACT-style backbones, B-spline policy consistently reduces task completion time while maintaining or improving success rates. Our results demonstrate that B-spline policy yields substantially smoother executions, and that our alignment mechanism is critical for stable, high-speed control.

Our contributions are threefold: (1) we introduce a B‑spline–based action representation with adaptive temporal resolution for visuomotor imitation learning; (2) we propose segment alignment to enable smooth transitions during accelerated policy execution; and (3) We demonstrate across diverse real-world and simulated tasks that B-spline policy substantially reduces task completion times compared to standard action chunking baselines while preserving task success.

2 Related work↩︎

Visuomotor Policy Acceleration. High-speed manipulation has been extensively studied in classical robotics, especially in motion planning and trajectory optimization [18]. However, these techniques are not directly applicable to visuomotor policy learning, where actions must be predicted end-to-end from high-dimensional sensory observations. In policy learning, robot manipulation policies often remain slow, yet performance is still primarily evaluated by success rate [1], [4], [19]–[21], with comparatively less attention to task completion time. Recent works [22]–[24] have begun to address this gap. For example, DemoSpeedup [23] accelerates imitation policies by using action entropy to identify which parts of demonstrations can be safely downsampled, while SAIL [24] frames this problem as a full-stack engineering involving policy consistency, robot dynamics, and latency-aware scheduling. In contrast, our work identifies action chunking as a key algorithmic bottleneck for fast visuomotor control. We therefore introduce B-spline Policy (BSP), which replaces fixed discrete action chunks with continuous B-spline curves, enabling smooth and fast manipulation.

B-spline Action Representations. Discrete-time action chunking is widely used in visuomotor policy learning [1], [3], [4], [19], [20], [25], [26]. While fixed-length action chunking has been shown to stabilize long-horizon visuomotor learning [7], [27], it imposes a uniform temporal resolution that fails to capture the inherently non-uniform structure of manipulation tasks. In classical motion planning, actions are often parameterized as continuous-time curves, such as B’ezier curves [28] and splines [9]–[11]. These representations provide intrinsic smoothness and analytic derivatives [29], [30]. Motivated by these properties, we adopt B-splines as a continuous action representation for accelerating learned visuomotor policies. Closely related to our work, BEAST [31] proposes a B-spline encoded action tokenizer for efficient action sequence modeling and decoding in VLA policies. DMPs [32] represent robot motions as stable, temporally scalable dynamical systems with learnable forcing terms. In contrast, BSP uses B-splines not as a trajectory encoding or motion primitive, but as a control-oriented continuous action representation and execution pipeline for accelerating end-to-end visuomotor policies.

3 B-spline Action Representations↩︎

In this section, we formulate the B-spline action representation, which shifts visuomotor control from discrete-time action chunk prediction to continuous and smooth B-spline trajectory generation.

3.0.0.1 Discrete Action Chunking.

We focus on learning a robot policy \(\pi(a \mid o)\) from demonstration datasets. The policy maps proprioceptive and visual observations \(o_t\) to an action chunk \(\boldsymbol{a}_t = [\boldsymbol{a}_t,\boldsymbol{a}_{t+1}, \ldots, \boldsymbol{a}_{t+T_a}],\) where \(T_a\) denotes the prediction horizon. This action chunking paradigm is widely adopted in modern robot policies [3], [4], [6], where actions typically correspond to joint positions or end-effector poses.

While predicting action chunks stablizes long-horizon consistency [4], [27], [33], it also introduces two key limitations for fast manipulation. First, fixed-length chunks impose a uniform temporal resolution across the entire task. Second, independently predicted chunks must be stitched together at inference time, which can create boundary discontinuities that become especially problematic during high-speed execution.

3.0.0.2 Continuous Action Curves.

To address these limitations, we parameterize the action space as a continuous B-spline trajectory, rather than a discrete sequence of waypoints.

Formally, a B-spline trajectory is defined by a knot vector \(U\) and a set of control points \(\mathbf{C} = \{c_0, \ldots, c_N\}\). The continuous action at normalized time \(u\) is given by \[\mathbf{a}(u) = \sum_{i=0}^{N} N_{i,p}(u) \cdot c_i .\] where \(N_{i,p}(u)\) is the \(i\)-th B-spline basis function of degree \(p\). In our experiments, we use cubic B-splines, which provide smooth trajectories with continuous velocity and acceleration profiles. This formulation turns the policy output from a fixed list of discrete waypoints into the parameters of a continuous trajectory. The predicted curve can be sampled at any desired control frequency and executed by the low-level controller as a dense stream of commands.

B-splines provide several properties that are particularly useful for fast robot manipulation:
1) Temporal flexibility. Because the action trajectory is defined continuously, the same curve can be sampled at a higher control frequency without changing the policy. This allows the robot to receive dense low-level commands even when the policy runs at a lower inference rate.

2) Temporal rescaling. Given a predicted trajectory \(\mathbf{a}(u)\), we can execute it faster by scaling the mapping between real time and the curve parameter. For a speedup factor \(n\), the robot follows the same action trajectory while traversing the curve more quickly: \(\mathbf{a}_{\mathrm{exec}}(t) = \mathbf{a}(n t)\). This provides a mechanism for accelerating a learned policy without retraining it for each target execution speed.

3) Intrinsic smoothness. B-splines are smooth by construction. Unlike discrete action chunks, which may contain sharp changes between adjacent predictions, a B-spline trajectory produces smooth interpolated actions. This smoothness is especially important under high-speed execution, where abrupt changes in commanded poses can lead to controller tracking errors, overshoot, or task failure.

4) Local error isolation. each control point only affects a limited portion of the trajectory. This locality makes the representation stable and compact. Errors in one control point do not globally distort the entire predicted action sequence.

B-splines offer a natural continuous representation for robot actions, however, using them in a visuomotor policy requires several design choices. In particular, we need to convert discrete demonstrations into B-spline targets, represent non-uniform knots with a fixed-size policy output, and execute consecutive spline segments smoothly. We describe these components in the next section.

4 B-spline Policy↩︎

In this section, we describe how to build a visuomotor policy with B-spline actions and convert discrete demonstrations into fixed-size B-spline targets.

Adaptive B-spline Fitting from Demonstrations. To train B-spline policy, we first convert discrete demonstration trajectories into continuous B-spline trajectories. Given a sequence of demonstration actions, we fit a degree-\(p\) B-spline that approximates the original trajectory within an error tolerance. We use an adaptive fitting procedure based on the classical FITPACK strategy [16], [34], [35], which iteratively inserts knots into trajectory regions with the largest reconstruction error.
As shown in Fig. 2, this adaptive knot placement allocates representation capacity where it is needed most: fewer knots are allocated to smooth regions, while density increases in high-curvature segments. As a result, the fitted B-spline provides a compact continuous representation of the demonstration trajectory while maintaining bounded approximation error, as summarized in Algorithm 4.

Fixing the Policy Output Size. After fitting B-splines to the demonstrations, we train a policy to predict B-spline parameters from observations. Directly predicting a full-trajectory spline is inefficient, so the policy outputs the next B-spline segment at each step.
Because B-splines have local support, any trajectory segment can be represented by a fixed number of nearby control points and knots. Unlike discrete action chunks, however, a fixed number of control points does not imply a fixed time horizon because knot intervals may vary. The policy therefore predicts both the control points and knot values, outputting a fixed-size vector of local B-spline parameters, \([U; C]\), that can be used with standard imitation learning architectures with minimal modification.
In practice, evaluating a degree-\(p\) B-spline segment requires neighboring control points and knots for boundary support. We append future control points when available and repeat the final control point near the end of a trajectory, producing fixed-size training targets while preserving valid B-spline evaluation.

4.0.0.1 High-frequency Execution and Temporal Rescaling.

During inference, we decouple the policy inference rate from the low-level control rate. The visuomotor policy runs at a relatively low frequency and predicts a future B-spline segment. The low-level controller then samples this continuous segment at a much higher frequency to generate dense robot commands.

This design is important for fast manipulation. When executing a policy faster than the demonstration, discrete action chunks may become too sparse or discontinuous for reliable tracking. In contrast, a B-spline segment can be sampled densely after temporal rescaling, allowing the controller to receive smooth high-frequency commands even when the policy itself runs at a lower rate.

Because the predicted trajectory is continuous, we can directly adjust its execution speed by changing the mapping between real time and the spline parameter. Given a predicted trajectory \(\mathbf{a}(u)\) and a target speedup factor \(n\), the executed action is \(\mathbf{a}_{\mathrm{exec}}(t) = \mathbf{a}(nt)\). This preserves the geometric shape of the predicted action trajectory while traversing it faster in real time.

Pipelined Execution with Segment Alignment. For long-horizon tasks, the policy repeatedly predicts new B-spline segments while the robot is executing the previous one. A naive pipelined implementation assumes that the beginning of the newly predicted segment aligns with the unexecuted tail of the previous segment. In practice, this assumption is often violated due to policy prediction noise, inference latency, and controller tracking error. As a result, directly switching to the new segment can introduce discontinuities at segment boundaries.

To address this issue, we introduce an inference-time segment alignment mechanism. Let \(a_{\text{last}}\) denote the most recently executed action, and let \(S{\mathrm{new}}(t)\) denote the newly predicted B-spline segment evaluated at relative time \(t\). Instead of starting the new segment at a fixed time determined only by inference latency, we search for the point on the new segment that best matches the current executed action: \[\label{eq:align-time} t^\star = \arg\min_{0 \leq t \leq \lambda T_{\mathrm{inf}}} \mathrm{MSE}\big(S_{\mathrm{new}}(t), a_{\text{last}}\big),\tag{1}\]

where \(T^{\text{inf}}\) is the measured inference latency and \(\lambda > 1\) slightly enlarges the search window for robustness. The controller then begins executing the new segment from \(t^\star\).

This alignment step reduces boundary mismatch between consecutive B-spline segments and prevents small discontinuities from accumulating over time. As shown in our experiments, this becomes especially important under high-speed execution, where even small jumps in commanded actions can lead to tracking errors or task failure.

5 Experiments↩︎

We integrate B-spline policy with two imitation-learning backbones: (i) Diffusion Policy [4], denoted as Diff.+BSP, and (ii) Action Chunking with Transformers (ACT) [3], denoted as Reg.+BSP. We evaluate B-spline policy along two main metrics: (1) success rate, measured across a diverse set of tasks, and (2) average completion time, measured by the mean task completion time across successful rollouts. To this end, we evaluate our method against baseline policies on three real-world tasks that span diverse manipulation challenges: Cube Picking, which requires precise object manipulation; Table Cleaning, which involves long-horizon tabletop rearrangement; and Speed Stacking, which emphasizes bimanual, contact-rich interaction. We also benchmark B-spline policy in simulation environments on Push-T [4], [36], RoboMimic [37] and RoboCasa [38].

5.1 Real-world Experiments↩︎

Task setup. In real-world experiments, we evaluate B-spline policy in the real world on three challenging tasks, as illustrated in Fig. 5. 1) Cube Picking. The robot is required to pick a cube and place it into a box on the table. We collect 200 demonstrations using cubes of four different colors. During both training and evaluation, only a single cube is present in the scene. The cube has a side length of \(3\,\mathrm{cm}\), requiring precise grasping and placement. 2) Table Cleaning. This long-horizon manipulation task presents a significant challenge: the robot must clear a table by sequentially completing two subtasks: (i) picking two beverage cans and placing them into a designated plastic tray, and (ii) picking two empty bowls and placing them into a second tray, stacking the second bowl on top of the first. We collect 300 demonstrations for this task. 3) Speed Stacking. The robot must first construct a cup pyramid (2–1) from identical cups and then collapse it into a single nested stack using two arms. Cups are randomly initialized within a clutter-free workspace. We collect 200 demonstrations and evaluate performance across diverse initial configurations.

All experiments use 6-DoF ARX5 robot arms. For Cube Picking and Table Cleaning, we use a single third-person camera. For Speed Stacking, we employ two wrist-mounted cameras in addition to a fixed third-person camera placed between the two arms.

Baselines and Evaluation protocol. We compare B-spline policy against three classes of baselines: (1) Diffusion policy [4] and Regression policy [3], which executes them at the original demonstration or control frequency. (2) Diffusion policy-\(n\)X and Regression policy-\(n\)X, which naively increase the execution frequency by a factor of \(n\). This represents the most direct baseline for accelerating task execution. (3) DemoSpeedup [23], which accelerates execution by temporally downsampling demonstration trajectories. For each real-world task, we evaluate all methods on 20 rollouts with distinct object layouts. To ensure fair comparisons, we first record a fixed set of test configurations using the camera system; for subsequent evaluations, the environment is reset by matching object placements to these recorded configurations. The distribution of all test configurations is shown in Fig. 5. For grasping actions in Cube Picking and Table Cleaning, we allow up to three grasp attempts as recovery. We report the average completion time, measured from the start at the home pose to the final gripper opening that marks task completion, averaged over all successful rollouts.

1.2pt

5.2 Real-world Results↩︎

Table 1 reports the overall success rates and average completion times. We organize our analysis around the following key findings.

Finding 1: BSP consistently shortens task completion time. As highlighted in Tab. 1, across all configurations, integrating BSP consistently reduces Avg. time, regardless of whether it is paired with a Diffusion or Regression policy. The efficiency of BSP acceleration is particularly pronounced in the long-horizon Table Cleaning task. Specifically, at a 4X speedup, integrating BSP with the Regression policy compresses the average completion time from \(23.57\text{s}\) to \(11.80\text{s}\) (\(50\%\) reduction in duration), while simultaneously preserving task success rate (\(13/20\) vs. \(14/20\)).

Finding 2: BSP preserves task success, but aggressive speedup can exceed controller limits. BSP achieves faster execution while generally maintaining task success. Across diffusion and regression comparisons, BSP matches or improves success rate in 14 out of 18 settings. This trend is particularly clear for the regression backbone: BSP improves the long-horizon Table Cleaning success from 13/20 to 18/20 at both \(1\times\) and \(2\times\) speedup, and improves Speed Stacking from 8/20 to 16/20 at \(1\times\) speedup and from 4/20 to 13/20 at \(2\times\) speedup.
At the same time, the results reveal a natural trade-off between execution speed and task robustness. For example, on Speed Stacking, Regression+BSP outperforms the baselines at \(1\times\) and \(2\times\) speedup, but fails at \(4\times\), achieving zero success because the aggressive BSP temporal scaling pushes the robot beyond the tracking limits of its low-level controller.

Finding 3: BSP produces smoother trajectories. During the experiments, we observed that B-spline policy produces substantially smoother executions than the baselines. We provide qualitative comparisons between B-spline policy and Diffusion Policy on the Speed Stacking task in Fig. 6, where we overlay the executed trajectories on video frames. B-spline policy yields smoother and faster motions, while the action chunks produced by Diffusion Policy often result in jerky executions due to discontinuities between consecutive chunks. Please visit our website for video results.

Finding 4: Inference-time segment alignment is critical for BSP. Consistent with the smoother trajectories observed in Finding 3, we further find that trajectory continuity across consecutive spline segments is critical for stable high-speed execution. To better understand this, we conduct an ablation study on inference-time segment alignment on Speed Stacking task. As shown in Fig. 7, segment alignment becomes increasingly important at higher execution speeds: when continuity is not enforced, success becomes highly sensitive to execution speed. From the policy perspective, such discontinuities effectively induce out-of-distribution (OOD) inputs, forcing the policy to spend additional steps replanning to return to the in-distribution regime, or causing outright task failure.

5.3 Simulation Benchmarks↩︎

For reproducibility, we also evaluate B-spline policy on simulated manipulation tasks to assess whether continuous B-spline action representations achieve performance comparable to standard action-chunking imitation learning methods on Push-T [4], [36], RoboMimic [37] and RoboCasa [38].

Quantitative performance. As shown in Table [tbl:tab:sim-results], B-spline policy matches or outperforms the corresponding base policies across all evaluated tasks, except the RoboMimic Lift task. On the more challenging RoboCasa tasks, B-spline policy consistently outperforms the baseline methods, demonstrating improved robustness in long-horizon manipulation scenarios. Overall, these results indicate that representing actions as B-spline trajectories does not compromise imitation learning performance and can yield consistent gains over discrete-time action-chunking representations.

Acceleration in simulation. Accelerating policies in simulation requires modifying the environment and low-level controllers to support the high-frequency execution required by BSP, which then requires re-collecting datasets, making it difficult to directly measure policy acceleration in each simulation benchmark. Therefore, we conduct this study on Push-T, a representative task that is easy to modify. We collect 100 demonstrations in the PushT-speedup environment at 200 Hz. BSP is trained directly on the 200 Hz trajectories, while the diffusion policy baseline is trained on 10 Hz trajectories downsampled from the same data. For each checkpoint, we evaluate 50 rollouts and report the average score. We define a rollout as successful if its score exceeds 0.9, which indicates near-complete coverage. For each successful rollout, we record the first time step at which the score exceeds 0.9, and report the average of this time across successful rollouts. For each setting, we evaluate the best three checkpoints and report the mean of these metrics.
As shown in Table [tbl:tab:pusht], BSP consistently improves both the average score and completion time across all target speedups. The gains become pronounced at higher speedups: at \(4\times\), Diff.+BSP achieves a higher average score (\(0.73\) vs. \(0.59\)) while reducing completion time by more than half (\(7.19\)s to \(2.87\)s). This is because faster execution enables the Push-T agent to perform more corrective pushes within the maximum rollout time, leading to higher final coverage scores.

6 Limitations↩︎

6.0.0.1 Hardware Constraints and Policy Acceleration Limits.

As detailed in Section [finding2], aggressively accelerating the policy introduces a drop in robustness; specifically, the Speed Stacking task drops to a 0% success rate under a 4x speedup. This failure is primarily driven by the physical constraints of the low-cost robotic arms used in our experiments, whose low-level controllers lack the stiffness and accuracy required to track rapid action commands. We believe that integrating improved low-level controllers would significantly improve tracking robustness at extreme speeds, which we plan to explore in future work.

7 Conclusion↩︎

We propose B-spline policy, a novel action representation that parameterizes the actions as continuous curves using B-splines. B-spline policy improves trajectory smoothness and enables faster task completion with robust success rate. To ensure stability during high-speed execution, we propose an inference-time segment alignment mechanism that effectively mitigates boundary discontinuities between successive spline segments. Extensive empirical evaluations across diverse simulated and real-world manipulation tasks demonstrate that BSP significantly reduces task completion times, while consistently preserving or enhancing success rates over standard baselines.

8 Appendix↩︎

8.1 Implement Details↩︎

B-spline action representation. We represent action trajectories using cubic B-splines with degree \(k=3\). In simulation, we follow standard benchmark settings and use a delta end-effector action space. In real-world experiments, we use absolute joint-position actions.

Adaptive b-spline fitting from demonstrations. We fit a B-spline to each demonstration trajectory using the adaptive knot insertion procedure in Alg. 4. For most tasks, we use a small fitting tolerance \(\varepsilon=0.002\) to preserve high-precision behaviors. For Push-T, we use \(\varepsilon=1\) because the action magnitude is substantially larger than in the other benchmarks, with values ranging roughly from \(0\) to \(512\).

Model training of B-spline policy. We train B-spline policy model to predict a fixed-size parameter segment consisting of 16 knots and their corresponding control points, including six boundary-support knots. Because observations are not aligned to knot or control-point indices, at each observation step, the model predicts the nearest future segment containing the next 16 knots and control points. In simulation, all models use the RoboMimic visual encoder. In real-world experiments, diffusion uses the same visual encoder, whereas the regression uses a DINOv2 visual encoder.

Model training of action-chunk policies. For a fair comparison, all action-chunk baseline policies (Diffusion/Regression) are also trained to predict 16 future actions. Each baseline is trained for the same number of epochs as its B-spline counterpart. The visual encoder is the same as B-spline policy.

DemoSpeedup. We implement the DemoSpeedup based on the diffusion policy. The method uses two key hyperparameters, which are the downsampling rates for the precision and non-precision phases. We found that downsampling the precision phase by a factor \(\ge 2\) prevents the policy from completing the task reliably. We therefore set the precision-phase downsampling rate to 1. For the non-precision phase, we use a downsampling rate of 4 for Cube Pickingand Table Cleaning. We use 2 for Speed Stackingbecause it requires higher accuracy.

Controller. In simulation, actions are delta end-effector commands. We sample B-spline actions at 100 Hz, but we do not apply segment alignment because it does not have a clear physical interpretation for delta actions. In real-world experiments, actions are absolute joint positions. We sample actions from each predicted B-spline segment at 100 Hz. For phase alignment, we set the search window to \([0,\lambda T^{\mathrm{inf}}]\) with \(\lambda T^{\mathrm{inf}} = u_{\max}(S)/2\), where \(u_{\max}(S)\) denotes the segment horizon in the spline parameter domain.

Knot validity projection. A valid B-spline requires a nondecreasing knot vector, which standard imitation-learning regressors do not enforce. In practice predicted knots are almost always monotonic; for any knot \(u_i\) that violates the constraint we apply \(u_i \leftarrow \max(u_i,\, u_{i-1} + \delta)\) with a small constant \(\delta > 0\), restoring validity with minimal perturbation.

Inference techniques. During inference, pipelined execution with segmentment alignment is applied. Here we detailed the complete procedure in Algorithm 8.

8.2 Additional experiments results↩︎

Ablation on fitting error tolerance. Representing actions with B-splines introduces a fitting tolerance \(\varepsilon\). This typically yields fewer knot and control point pairs than the original demonstrations. Tab. 2 reports success rate and compression ratio under different tolerances. We define the compression ratio as the number of original actions divided by the number of knot–control-point pairs. As \(\varepsilon\) increases, the compression ratio increases substantially while success rate remains relatively stable. This suggests that performance is not highly sensitive to \(\varepsilon\) within a reasonable range, and a moderately larger tolerance can reduce computational cost.

References↩︎

---

1. Equal contribution.↩︎