ABPolicy: Asynchronous B-Spline Policy

• ABPolicy is an asynchronous flow-matching policy that uses cubic B-spline control points to generate smooth trajectories for robotic manipulation.
• The method integrates bidirectional action prediction with continuity-constrained refitting to reduce intra-chunk jitter and inter-chunk discontinuities.
• Asynchronous inference overlaps computation with execution, enhancing responsiveness in dynamic tasks and reducing completion times.

ABPolicy is an asynchronous flow-matching policy for robotic manipulation that operates in a B-spline control-point action space. It was introduced to address a specific deployment tension in imitation-learned visuomotor control: the robot should move smoothly, yet remain responsive to evolving observations. In the formulation of "ABPolicy: Asynchronous B-Spline Flow Policy for Real-Time and Smooth Robotic Manipulation" (Yang et al., 27 Feb 2026), the method combines continuous cubic B-spline trajectory parameterization, bidirectional action prediction, continuity-constrained refitting, and asynchronous inference to mitigate intra-chunk jitter, inter-chunk discontinuities, and stop-and-go execution.

1. Problem formulation and design objective

ABPolicy is studied in robotic manipulation from observations, with policies trained by imitation learning. The robot receives visual observations and robot state and outputs low-level actions such as arm joint angles and gripper commands. Actions are executed at $30$ Hz on a $6$-DoF AgileX Piper arm with a gripper, using fixed RGB cameras. The paper evaluates both static tasks—fold towel, stack block, hang cup, drawer operation—and dynamic tasks in which objects move on a rotating platform or rack (Yang et al., 27 Feb 2026).

The motivating claim is that many recent chunked diffusion or flow policies operating directly in the raw action space have difficulty achieving smoothness and responsiveness simultaneously. Three failure modes are identified. First, raw per-timestep action prediction does not inherently enforce smoothness, leading to intra-chunk jitter such as oscillatory velocities and acceleration spikes. Second, consecutive chunks may fail to connect smoothly, producing inter-chunk discontinuities at handoff points. Third, synchronous inference induces stop-and-go execution, because the robot waits while the model computes the next chunk.

ABPolicy targets these failure modes by altering both action representation and execution architecture. This suggests that, in the paper’s framing, smoothness is not treated merely as a post-processing problem, and responsiveness is not treated merely as a faster-inference problem. Instead, the method treats both as coupled consequences of chunk parameterization, boundary handling, and scheduling.

2. B-spline action space and policy architecture

The central representational choice is to predict B-spline control points rather than raw action sequences. For a discrete action sequence $\{a_t\}_{t=0}^{T-1}$, the spline trajectory is written as

$s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$

where $c_i$ are spline control points and $N_{i,p}(t)$ are B-spline basis functions of degree $p$. The paper uses cubic B-splines, $p=3$, with an open-uniform clamped knot vector, and applies the fitting independently to each action dimension. The control points are obtained by least squares: $$\{c_i^*\}_{i=0}^{N-1} = \underset{\{c_i\}}{\arg\min} \sum_{t=0}^{T-1} \left( a_t - s(t) \right)^2.$$ The reconstructed continuous trajectory is then $\hat a(t)=s(t)$ (Yang et al., 27 Feb 2026).

The claimed advantage of this representation is structural. A chunk is no longer a list of independent commands, but samples from a single smooth parametric curve. Because the method uses cubic B-splines, the paper attributes to the representation $6$0 continuity, implying smooth position, velocity, and acceleration variation within the chunk. This is the mechanism used to address intra-chunk jitter.

Architecturally, ABPolicy is a conditional generative policy trained with flow matching in control-point space. Its network is based on a DiT architecture with observation fusion via cross-attention. The observation encoder uses frozen DINO-V2 for image features and an MLP for robot-state history. The output is a predicted flow vector over the control-point representation. Relative to adjacent methods discussed in the paper, ABPolicy differs from raw-action chunking by predicting a trajectory parameterization; from DCT-based action representations by using cubic B-splines with local support; and from discretized B-spline tokenization methods such as BEAST by predicting continuous control points rather than quantized tokens.

A direct empirical consequence of the representation choice is the reported improvement in reconstruction fidelity over alternative chunk representations on $6$1-step chunks:

Representation	Mean Error $6$2	SNR $6$3
256 Discrete Bins	0.0020	41.9 dB
DCT Coefficients (8)	0.0010	44.6 dB
B-spline (Discrete)	0.0025	37.7 dB
B-spline (Continuous)	0.00031	50.7 dB

The same section reports smoothness gains against raw action representation: average velocity zero-crossing rate decreases from $6$4 to $6$5, a reduction of $6$6, and acceleration p95 decreases from $6$7 to $6$8, a reduction of $6$9 (Yang et al., 27 Feb 2026).

3. Bidirectional action prediction and continuity-constrained refitting

ABPolicy does not predict only future actions. At time $\{a_t\}_{t=0}^{T-1}$0, it defines a bidirectional chunk

$\{a_t\}_{t=0}^{T-1}$1

where $\{a_t\}_{t=0}^{T-1}$2 is the number of previous steps and $\{a_t\}_{t=0}^{T-1}$3 the number of future steps. In the reported experiments, $\{a_t\}_{t=0}^{T-1}$4 and $\{a_t\}_{t=0}^{T-1}$5. The paper terms this design Bidirectional Action Prediction, or BiAP (Yang et al., 27 Feb 2026).

The rationale is that continuity is easier to learn if the model explicitly represents a temporal window around the present, rather than predicting only future continuation. A future-only predictor may ignore the exact boundary conditions induced by recent executed motion; a bidirectional predictor is encouraged to align its initial segment with local temporal structure.

BiAP is complemented by Continuity-Constrained Refitting (CCR). The need for CCR arises from asynchronous deployment. An observation is captured, inference begins, and during that inference delay the robot continues to execute previously queued actions. By the time the new chunk arrives, its initial segment may no longer match the motion actually executed. CCR locally adjusts the first few control points of the newly predicted spline so that its leading segment matches the executed action history while later control points remain fixed.

Let $\{a_t\}_{t=0}^{T-1}$6 be the predicted control points and $\{a_t\}_{t=0}^{T-1}$7 the $\{a_t\}_{t=0}^{T-1}$8 actions executed during inference. The optimization modifies only the first $\{a_t\}_{t=0}^{T-1}$9 control points: $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$0 with

$s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$1

Because cubic B-splines have local support, early-point adjustment primarily affects the beginning of the trajectory. The paper’s interpretation is that CCR anchors the new chunk to what actually happened without substantially perturbing the predicted future response.

The block-stacking ablation reported for a static block-stacking task is one of the paper’s strongest pieces of evidence for the combined BiAP+CCR design. Without BiAP, success is $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$2, initial jitter is $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$3, and refitted jitter is $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$4. With BiAP, success rises to $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$5, initial jitter falls to $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$6, and refitted jitter to $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$7. This suggests that BiAP improves the initial alignment before refitting, and that CCR can then achieve lower final boundary mismatch (Yang et al., 27 Feb 2026).

4. Asynchronous inference and learning formulation

The execution architecture separates model inference from action dispatch into parallel threads. While the robot executes the current trajectory, the next trajectory is predicted in the background. Once inference finishes, CCR refits the new spline to the recently executed history and the action queue is updated immediately. The system therefore overlaps inference delay with ongoing execution rather than serializing them (Yang et al., 27 Feb 2026).

The paper reports an inference delay of roughly $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$8 ms using $s(t) = \sum_{i=0}^{N-1} c_i N_{i,p}(t),$9 denoising steps on an NVIDIA RTX 4070 Ti Super. In the authors’ framing, asynchronous execution eliminates execution stalls that would otherwise occur at chunk boundaries under synchronous inference. This is particularly relevant in dynamic tasks, where the world may change during those $c_i$0 ms.

The training objective is standard flow matching, but applied to spline control points rather than raw action trajectories. If $c_i$1 denotes the ground-truth control points for chunk $c_i$2, the method defines

$c_i$3

where $c_i$4 and $c_i$5. The policy $c_i$6 is then trained with

$c_i$7

The target vector field $c_i$8 is constant along the linear interpolation from noise to data. The result is an asynchronous flow-matching policy in the precise sense used by the paper: flow matching specifies the generative training objective, while asynchrony refers to deployment-time concurrency between inference and control.

5. Experimental setting and empirical findings

The experimental platform is a $c_i$9-DoF AgileX Piper manipulator with a parallel gripper and two fixed Intel RealSense D435 RGB cameras. The control rate is $N_{i,p}(t)$0 Hz, and the action space consists of arm joint angles plus continuous gripper aperture. Seven tasks are used: three dynamic tasks on a rotating platform or rack with approximately $N_{i,p}(t)$1 s per revolution—stack block, push block, and hang cup—and four static tasks—fold towel, stack block, hang cup, and put block into drawer. Dynamic tasks use $N_{i,p}(t)$2 demonstrations per task, static tasks use $N_{i,p}(t)$3, and evaluation uses $N_{i,p}(t)$4 runs per task (Yang et al., 27 Feb 2026).

The principal task metrics are success rate and completion time. Smoothness is assessed using mean reconstruction error, SNR, velocity zero-crossing rate, $N_{i,p}(t)$5th percentile acceleration, and boundary jitter or discontinuity measures. The abstract also states that ABPolicy reduces trajectory jerk.

On dynamic tasks, asynchronous execution substantially improves success relative to synchronous execution. The reported values are: stack block, $N_{i,p}(t)$6 versus $N_{i,p}(t)$7; push block, $N_{i,p}(t)$8 versus $N_{i,p}(t)$9; hang cup, $p$0 versus $p$1. The average improvement is $p$2. Compared with Diffusion Policy, the same async ABPolicy scores $p$3 versus $p$4 on dynamic stack block, $p$5 versus $p$6 on push block, and $p$7 versus $p$8 on dynamic hang cup.

On static tasks, the principal benefit is faster completion rather than uniformly higher success. Average completion time decreases by $p$9. The reported examples are fold towel, $p=3$0; hang cup, $p=3$1; and drawer operation, $p=3$2. Static success rates are mixed: stack block changes from $p=3$3 in sync mode to $p=3$4 in async mode, fold towel from $p=3$5 to $p=3$6, hang cup from $p=3$7 to $p=3$8, and drawer operation remains $p=3$9. The paper therefore does not claim uniform static-task success gains; the stronger result is responsiveness in dynamic settings and throughput in static ones.

Taken together, the experiments support three distinct empirical claims. First, continuous B-spline control-point prediction improves fidelity and suppresses intra-chunk oscillation. Second, BiAP combined with CCR reduces inter-chunk discontinuity. Third, asynchronous scheduling improves real-time responsiveness, especially when the environment evolves during inference. A plausible implication is that the method’s performance gains derive from the interaction of all three mechanisms rather than from any single modification in isolation.

6. Scope, limitations, and relation to adjacent methods

ABPolicy is presented as a manipulation policy, but the paper’s own synthesis describes it more broadly as a trajectory representation, stitching, and scheduling framework for making chunked generative manipulation policies practical in real time (Yang et al., 27 Feb 2026).

Several limitations are also identified. The paper’s explicit limitation discussion is light, but the described method and experiments reveal clear boundaries. ABPolicy still predicts chunks, so latency is hidden rather than eliminated; observations may still be stale if the environment changes extremely quickly relative to chunk length or inference speed. CCR aligns new trajectories to executed history through local least-squares fitting, but it does not explicitly impose robot dynamics feasibility or hard derivative-matching constraints. The representation assumes that useful action chunks are well approximated by smooth low-dimensional trajectories, which may become less suitable for abrupt contact-rich switching or very sharp corrective behavior. The text provided does not deeply analyze sensitivity to hyperparameters such as chunk horizons, number of control points, or the number of free control points in CCR. Baseline breadth is also limited in the main manipulation table, where the strongest comparisons are sync versus async, raw versus spline, and the BiAP ablation, with less extensive end-to-end benchmarking against many recent real-time chunking methods.

The paper is careful to position ABPolicy relative to adjacent approaches. Compared with raw-action chunking, it imposes smoothness through continuous cubic B-splines. Compared with DCT-based compression, it emphasizes local support and trajectory continuity. Compared with weighted fusion approaches such as those used in methods like SmolVLA or RTC, it enforces boundary continuity through control-point refitting rather than whole-chunk blending. Compared with synchronous flow or diffusion policies, it explicitly addresses deployment-time concurrency.

A common misconception would be to reduce ABPolicy to a change in network architecture alone. The paper suggests a different interpretation: the method depends on a joint redesign of action space, chunk boundary handling, and inference scheduling. In that sense, its core contribution is not only a new policy parameterization, but a systems-level recipe for smooth and reactive robot manipulation.