B-spline Policy: Accelerating Manipulation Policies via B-spline Action Representations

ListenSplines Instead of Chunks: Making Robot Policies Fast9:46

Show notes

B-spline Policy (BSP) swaps the discrete action chunks emitted by Diffusion Policy and ACT for continuous B-spline curves — parameterized by knots and control points and predicted as one fixed-size vector. Because the curve is time-continuous and differentiable, controllers can resample it at any rate, temporally rescale it for 2–4× faster execution, and read velocity and acceleration straight off it. We dig into the mechanism, the real-robot and simulation numbers, the load-bearing segment-alignment ablation, and why changing the action head's output space is a lever that composes with the rest of the VLA stack. **Sources** - B-spline Policy: Accelerating Manipulation Policies via B-spline Action Representations

Subscribe to the channel: https://podcast.lumalabs.link/27a25f51ea81d41a8253f46c6133a35e/feed.xml

TL;DR

B-spline Policy (BSP) replaces the fixed-rate discrete action chunks emitted by imitation-learning policies (Diffusion Policy, ACT) with continuous B-spline curves parameterized by knots and control points, predicted directly as a fixed-size vector. Because the curve is time-continuous and analytically differentiable, the low-level controller can sample it at arbitrary frequency, temporally rescale it to execute the same trajectory faster, and read off velocity/acceleration for feedforward PD control. Across three real-world tasks (cube picking, table cleaning, speed stacking) and simulation suites (Push-T, RoboMimic, RoboCasa), BSP reduces task completion time — often by 2–4× — while matching or improving success rates over the vanilla chunking baselines it drops into.

Key claims

B-spline curves can serve as a drop-in replacement for action-chunk outputs in Diffusion Policy and ACT: each demonstration is fit offline to a B-spline via adaptive-knot least-squares, and the policy head predicts the next segment’s control points and knot values as one fixed-size vector [Method / project page].
Temporal rescaling of the predicted spline curve enables 2–4× faster execution without retraining, because the continuous curve can be resampled at any control frequency and traversed in less time [Real-World Results table, project page].
Inference-time segment alignment across successive predictions is critical: without it, consecutive spline segments become discontinuous and high-speed execution collapses out of distribution — an ablation flagged as load-bearing in the analysis [Method / analysis, project page].
On three real robot tasks the paired BSP variant matches or beats the base policy at every speed setting: e.g. Diffusion Policy on Table Cleaning improves from 11/20 (base, 1×) to 15/20 (+BSP, 1×) and reaches 11/20 at 4× while the vanilla 4× baseline degrades similarly, so BSP compresses task time from 41.4 s → 18.05 s with no success-rate loss [Real-World Results table].
BSP matches or improves baseline success rates across Push-T, RoboMimic, and RoboCasa simulation tasks, with the largest lift on the hardest RoboCasa setting (27% → 46% DP, 40% → 60% Regression) [Simulation Results tables].
Because splines are differentiable, the controller can read position, velocity, and acceleration directly off the curve for velocity-aware / feedforward PD control before commanding the robot — a control-side benefit chunk-based policies cannot offer [Method, project page].

Method

BSP factors the policy output into two stages. Offline, each demonstration trajectory is converted into a B-spline: starting from a coarse least-squares fit through the two boundary knots, the pipeline iteratively identifies the sample with the worst reconstruction error and inserts a new knot there, refitting until the largest error falls at or below a threshold. This yields a compact set of control points + knot values per demo. At training time, the policy predicts the next B-spline segment (control points and knots) as one fixed-size vector — this replaces action chunk prediction one-for-one in Diffusion Policy and ACT, so no other architectural changes are needed. At inference, the policy consumes images and proprioception, emits the segment parameters, and the low-level controller aligns each new segment with the previous one’s endpoint to preserve C¹ continuity. The predicted segment can then be temporally scaled (traversed faster/slower than the demonstration) and sampled at the controller’s native rate; because the curve is analytically differentiable, the controller reads desired position, velocity, and acceleration from the B-spline and its derivatives, enabling feedforward PD control.

Results

Cube Picking (DP): 19/20 base (1×, 6.48 s) → 20/20 with BSP (4×, 2.45 s). Regression variant 18/20 → 20/20, 9.84 s → 2.45 s.
Table Cleaning (DP): 11/20 base (1×, 41.4 s) → 15/20 with BSP (1×, 36.97 s) → 11/20 with BSP (4×, 18.05 s), vs DemoSpeedUp baseline at 3/20 for the DP branch and 14/20 for the Regression branch.
Speed Stacking (DP): 14/20 base (1×, 20.47 s) → 14/20 with BSP (1×, 18.13 s) → 7/20 with BSP (4×, 9.62 s); the DemoSpeedUp baseline collapses to 3/20 (DP) and 0/20 (Regression) at the fastest setting.
Push-T: DP 72% → 75% with BSP; Regression 63% → 66%.
RoboMimic Square: DP 79% → 85%; Regression 84% → 94%.
RoboCasa (hardest task): DP 27% → 46% with BSP; Regression 40% → 60%.
Ablation: dropping inference-time segment alignment breaks stable high-speed execution — success becomes highly sensitive to speed as discontinuities push the policy out of distribution [Method / analysis].

Why it’s interesting

Every recipe on the VLA Models page argues over what to condition the action head on — richer VLM backbones (Embodied-R1.5: Evolving Physical Intelligence via Embodied Foundation Models), frozen 3D-trace world models (μ₀: A Scalable 3D Interaction-Trace World Model), action-pretraining at scale (π*0.6: a VLA That Learns From Experience (RECAP)), test-time context memory (In-Context World Modeling for Robotic Control), or offline RL on the head itself (π*0.6: a VLA That Learns From Experience (RECAP)). BSP moves orthogonally: it changes the output space of the action head, keeping the backbones untouched. This makes it a lever that composes with any of the above rather than competing with them — and it is the first filed paper that puts a clean per-task time-vs-success curve on the “action chunks are jittery” complaint the Slack thread is calling out. The B-spline parameterization also gives the low-level controller free access to velocity and acceleration, which most VLA papers either ignore or hand-derive via finite differences, hinting at a shared surface with Playful Agentic Robot Learning‘s argument that contact/impedance control belongs inside the policy interface.