ChunkFlow: Towards Continuity-Consistent Chunked Policy Learning
July 14, 2026
Abstract
Vision–language action (VLA) models increasingly adopt chunked action heads to satisfy real-time constraints; however, this introduces boundary jitter: overlapping regions between consecutive chunks often yield inconsistent predictions, degrading temporal coherence and the task success rate. Existing methods, such as inference-time blending, merely reweight mismatched proposals without correcting underlying errors, leading to residual accumulation under biased or noisy histories. We propose ChunkFlow, a seam-aware training-and-execution framework for chunked policies that aligns chunk structure with boundary execution. It partitions each chunk into frozen, editable, and future zones, applies deterministic overlap blending at execution, and trains raw predictions with seam and first- and second-order continuity losses. History corruption and scheduled sampling improve robustness to executed-history errors, while an AWAC fine-tuning stage adapts the policy without removing these structural regularizers. Under mild smoothness assumptions, pre-blending seam discrepancies provably decay with increasing overlap. Experiments on CALVIN, LIBERO, and real robots show an improved success-stability trade-off with low-latency inference. Project page: https://cytoderm-ai.github.io/chunkflow.
1 Introduction↩︎
Recent advances in robotic manipulation increasingly leverage vision–language action (VLA) models to translate open-ended instructions into executable behaviors. To enable real-time control, modern VLA architectures typically employ action-chunking heads, which emit short action sequences (chunks) per decision step [1]–[5]. This design amortizes inference costs and improves deployment efficiency, but it introduces a critical failure mode: temporal discontinuities at chunk boundaries. Since each chunk is predicted under slightly shifted observations and histories, overlaps between chunks often yield conflicting actions—causing jitter, degraded coherence, and task failure. This raises a fundamental question: how can we retain task effectiveness while ensuring smooth, consistent transitions across chunked predictions?
Most existing mitigations handle boundary artifacts heuristically at inference time or overlook execution semantics during training. RTC [6] applies online interpolation to smooth seams, but such inference-only blending reweights misaligned chunk predictions without correcting upstream errors, causing residuals to accumulate under noisy or biased histories. Moreover, the absence of training-time seam supervision yields weak boundary gradients, preventing policies from internalizing blendable structure. Mainstream VLA pipelines—e.g., OpenVLA [3], GR2 [2], TraceVLA [7]—apply uniform chunk-wise losses and ignore execution-indexed semantics (frozen, editable, future), leaving boundary inconsistencies unresolved. Other approaches explore chunked control via flow/diffusion models [8], [9], skill abstraction [10], [11], or behavior priors [12]; while effective offline, these lack executed-history feedback and seam-aware learning, limiting deployment-time alignment.
Figure 1: Real-world rollout on Strip-cloth grasping. We deploy ChunkFlow on a manipulation task where the robot extracts a strip from a cloth stack and places it at a target location. Top: keyframes. Bottom: EE roll-angle traces over the first 200 steps, labeled as jitter \(\Delta a\), velocity \(\Delta^2 a\), and acceleration \(\Delta^3 a\) (finite differences of the EE roll angle). Compared to PI0.5 [13], ChunkFlow reduces boundary-induced spikes and high-frequency artifacts across all three signals (consistent with lower MSD-\(\Delta a\), MSD-\(\Delta^2 a\), and MSD-\(\Delta^3 a\)), supporting smoother execution..
In this work, we present ChunkFlow, a seam-aware training-and-execution framework for chunked policies with three integrated components. Structure-aligned overlap blending. Each chunk is divided into frozen, editable, and future zones, and adjacent chunks are deterministically reconciled without an extra policy forward pass. Unlike inference-only smoothing [6], the overlap structure is exposed during training through pre-blending seam supervision. Continuity-regularized policy optimization. First- and second-order penalties and a raw seam loss encourage temporally consistent predictions, while history corruption and scheduled sampling reduce exposure bias. Structure-preserving advantage-weighted fine-tuning. AWAC [14] with expectile critics [15] adapts the policy from post-blended histories while retaining seam and continuity regularization. Under mild smoothness assumptions, seam discrepancy decreases with overlap. Thus, the contribution lies in seam-aware training and execution for chunked policies, rather than VLA backbone design.
We evaluate ChunkFlow on CALVIN [16], LIBERO [17], and two real-robot tasks on a self-developed arm [18]. Across these settings, ChunkFlow improves the success–smoothness trade-off while retaining low-latency execution, reaching an average sequence length of 4.30 on CALVIN, 93.4% success rate on LIBERO, 4.43 ms amortized reasoning latency, and 9/10 successes on the real-robot tasks.
![Figure 2: Overview of ChunkFlow. The policy generates temporally overlapping action chunks, which are deterministically blended at boundaries to ensure seam continuity. Training integrates supervised regularization and reinforcement fine-tuning for stable long-horizon execution. Each predicted chunk is partitioned into three segments: frozen (gray, length d), editable seam (purple-to-pink gradient, length O), and future (yellow, length s), corresponding to index ranges [1{:}d], [d{+}1{:}d{+}O], and [d{+}O{+}1{:}L], respectively.](/article/2607.12992/figures/chunkflow_v11.png "fig:")
2 Related Work↩︎
2.1 Action Chunking and VLA↩︎
Chunked action generation is widely adopted in visuomotor learning for improving long-horizon consistency [8], [19], [20], often using generative backbones—diffusion and flow models [9], [21], vector quantization [10], [22], or token-based priors [12]—to model long-range dependencies, including extensions via world models and temporal abstractions [23]–[25]. Despite success offline, most methods overlook seam inconsistencies in overlapping regions, causing jitter and instability during deployment. Similarly, large-scale VLA models like OpenVLA, GR2, TraceVLA, and Seer [2], [3], [7] scale instruction-conditioned control with vision–language pretraining [5], [26], [27] but lack explicit handling of execution-time continuity. We address these gaps via a seam-aware chunked execution layer beneath the VLA encoder, aligning chunk boundaries through deterministic overlap blending and a boundary consistency loss without modifying the multimodal front-end.
2.2 Temporal Alignment and Smoothness for Chunked Policy Execution↩︎
Temporal consistency is critical for stable long-horizon control. Prior work enforces intra-chunk smoothness using total-variation, curvature, or jerk penalties [8], [19]–[21], and generative planners [2], [9], [28], [29] implicitly regularize motion through extended temporal context. Other efforts explicitly introduce smooth policy updates or temporally consistent rollouts in RL [30], [31], while hierarchical behavior regularizers [32] further reduce high-frequency artifacts. However, these approaches largely overlook seam mismatches—conflicts in overlapping regions—that disrupt rollout stitching in chunked controllers. Imitation-and-RL pipelines [8], [10], [20] adopt advantage-weighted updates, expectile critics [9], [19], or latent KL constraints [3], [7], [12]; yet they still ignore overlap semantics. In contrast, we embed seam-aware execution as a structural prior, aligning BC and RL updates with deterministic overlap blending and boundary-aware continuity losses to ensure stable long-horizon behavior.
3 Method↩︎
3.1 Problem Setup↩︎
We study instruction-conditioned control in continuous action spaces. At each decision index \(k\), a chunked policy outputs an \(L\)-step action sequence: \[a^{(k)}_{1:L} \sim \pi_\theta\!\left(\cdot~\middle|~o_{s_k:s_k+L-1},~h_{s_k},~l\right),\] where \(a^{(k)}_t \in \mathbb{R}^d\), \(h_{s_k} = (a^{(k)}_{s_k-p}, \dots, a^{(k)}_{s_k-1})\) is a \(p\)-step action history (zero-padded at the start of the episode), and \(s_k = 1 + (k{-}1)S\) with a stride of \(S = L{-}O\). Overlapping chunk boundaries (\(O{>}0\)) allow for smoother transitions but can also introduce redundant or inconsistent predictions in shared steps.
We define the seam discrepancy in the overlapping region as \[\delta^{(k)}_t = a^{(k)}_t - a^{(k{-}1)}_{t+L-O}, \qquad t = 1, \dots, O.\] The objective is to learn a chunked policy \(\pi_\theta\) that imitates expert behavior under instruction \(l\) while minimizing \(\delta^{(k)}_t\), yielding coherent and smooth action streams for long-horizon execution.
3.2 Continuity-Consistent Policy Execution via Chunked Action Sequences↩︎
ChunkFlow is a seam-aware policy framework that generates temporally extended action chunks with enforced continuity across overlapping regions. At each index \(k\), the policy \(\pi_\theta\) predicts a chunk of \(L\) actions \(a^{(k)}_{1:L}\), conditioned on local observations \(o_{s_k:s_k+L-1}\), a short action history \(h_{s_k}\), and high-level instruction \(l\). Consecutive chunks overlap for \(O\) steps, allowing deterministic blending at the seam to align the head of chunk \(k\) with the tail of chunk \(k{-}1\) (Fig. 2). To promote long-horizon stability, training includes first- and second-order smoothness regularization and history perturbation for robustness. The policy is initialized via behavior cloning under these constraints and is further refined with advantage-weighted updates while preserving seam structure. During inference, each chunk commits its first \(S{=}L{-}O\) steps, blending the overlap and executing the rest directly, enabling low-latency rollout with smooth transitions and adaptive execution.
3.3 Deterministic Overlap Blending for Seamless Chunk Transitions↩︎
Chunked inference improves planning granularity but often introduces discontinuities in overlapping regions between consecutive chunks, resulting in trajectory jitter that undermines real-time stability. We propose a parameter-free overlap blending mechanism to enforce smooth transitions without introducing latency. Let \(a^{(k-1)}_t\) and \(a^{(k)}_t\) denote the predicted actions from chunks \(k{-}1\) and \(k\) in an overlapping region of length \(O\). The executed action at time \(s_k{+}t{-}1\) is: \[\tilde{a}_{s_k + t - 1} = w_t\,a^{(k)}_t + (1 - w_t)\,a^{(k-1)}_{t + L - O}, \quad t = 1, \dots, O, \label{eq:blend}\tag{1}\] where the interpolation weight \(w_t \in [0,1]\) is as follows: \[w_t = \begin{cases} 0, & O = 1,\\[4pt] \frac{t - 1}{O - 1}, & O > 1 \end{cases} \quad\text{(use raw a^{(k)}_{1:L} when O = 0)}. \label{eq:overlap95weight}\tag{2}\] This linearly shifts control from the prior chunk to the current one, requiring only \(\mathcal{O}(d)\) flops per overlap step.
To enforce consistency during training, we introduce a boundary loss: \[L_{\text{bdry}} = \lambda_B \sum_{t=1}^{O} \left\| a^{(k)}_t - a^{(k-1)}_{t + L - O} \right\|_2^2,\] which penalizes seam discrepancies \(\delta^{(k)}_t = a^{(k)}_t - a^{(k-1)}_{t + L - O}\) (cf. Sec. 3.1). This regularization improves pre-blending agreement and enhances rollout continuity. As blending is deterministic and latency-free, it remains suitable for real-time execution and mitigates residual boundary artifacts at test time.
Theoretical Justification. Under local Lipschitz continuity of \(\pi_\theta\) and motion-proportional input drift, the expected seam error satisfies: \[\mathbb{E}\!\left[ \big\| \delta^{(k)}_t \big\|_2^2 \right] = \mathcal{O}((L - O)^2),\] i.e., increasing \(O\) quadratically suppresses boundary mismatch, consistent with empirical results in Table 3.
3.4 History-Conditioned Policy with Continuity Regularization↩︎
While overlap blending smooths transitions at chunk boundaries, it does not reduce prediction errors—only interpolates conflicting outputs. When the policy depends on recent action history for temporal context, residual errors can accumulate across chunks, especially under noisy or biased inputs. To mitigate this, we adopt a history-conditioned formulation where the policy receives the current observation \(o_t\), an ordered \(p\)-step history \(h_{s_k} = (a^{(k)}_{s_k-p}, \dots, a^{(k)}_{s_k-1})\), and a language instruction \(l\): \[a^{(k)}_t = \pi_\theta(o_t, h_{s_k}, l).\] During execution, the history at the next chunk \(\tilde{h}_{s_{k+1}}\) is formed using post-blending actions \(\tilde{a}_t\) (per Eq. 1 ), capturing realistic feedback from prior executions.
To improve robustness and reduce horizon-wise drift, we introduce a temporal continuity prior: \[\begin{align} L_{\text{cont}} &= \lambda_{\text{TV}} \sum_{t=2}^{T} \|a^{(k)}_t - a^{(k)}_{t-1}\|_1 \\ &\quad + \lambda_{D2} \sum_{t=3}^{T} \|a^{(k)}_t - 2a^{(k)}_{t-1} + a^{(k)}_{t-2}\|_2^2, \nonumber \end{align}\] where the first-order term enforces total variation regularity, and the second-order term penalizes curvature (jerk). This reduces one-step prediction error and suppresses high-frequency instability across chunks. To simulate imperfect rollout scenarios, we apply stochastic corruption to the history during training: \[\begin{align} a^{(k)}_{t-i} &\leftarrow \begin{cases} \bar a_{t-i} + \epsilon,\quad \epsilon \sim \mathcal{N}(0,\sigma^2), & \text{w.p. } 1-q,\\ \mathbf{0}, & \text{w.p. } q, \end{cases} \notag \\ a^{(k)}_{t-i} &\leftarrow (1{-}\alpha)\,a^{(k)}_{t-i} + \alpha\,\hat{a}_{t-i},\quad i=1{:}p, \label{eq:history95dropout} \end{align}\tag{3}\] where \(q\) is the dropout rate, and \(\alpha\in[0,1]\) is the scheduled sampling ratio. The resulting noisy sequence forms \(h_{s_k}\) during training, while clean post-blending actions \(\tilde{a}_t\) are used at test time. We define the supervised training objective as: \[L_{\text{sup}} = L_{\text{BC}} + L_{\text{cont}} + L_{\text{bdry}},\] where \(L_{\text{BC}}\) aligns actions with demonstrations, \(L_{\text{cont}}\) enforces local smoothness, and \(L_{\text{bdry}}\) (from Sec. 3.3) ensures chunk-level consistency. These losses operate on raw predictions \(a^{(k)}\), while execution histories are constructed from \(\tilde{a}_t\). Under mild smoothness assumptions, the long-horizon deviation can be bounded as follows. If \(\pi_\theta\) is \(L_\pi\)-Lipschitz and the history noise is bounded by \(\epsilon\), with \(L_{\text{cont}}\) inducing a contraction \(\rho < 1\), the cumulative deviation satisfies: \[\sum_{t=1}^{T}\|a^{(k)}_t - a^{(k)\star}_t\| \;\le\; \frac{L_\pi}{1 - \rho}\,T\,\epsilon,\] where \(a^{(k)\star}_t\) denotes the trajectory under clean histories, establishing the link between local regularization and long-horizon stability.
3.5 Continuity-Constrained Advantage-Weighted Fine-Tuning↩︎
While continuity-regularized imitation fosters coherent transitions, it remains limited by the coverage and quality of expert demonstrations. To overcome this, we introduce a reinforcement fine-tuning stage that enables reward-aligned adaptation while preserving the structural priors learned during pretraining. Trajectories are collected using executed (post-blending) actions \(\tilde{a}_t\) (Eq. 1 ), and training-time histories may be perturbed, as in Eq. 3 , to improve robustness. The policy continues to operate in chunked form, but advantage estimation and updates are performed step-wise within each chunk.
We define the decision state as \(s_t = (o_t, \tilde{h}_{s_k}, l)\), where \(\tilde{h}_{s_k} = (\tilde{a}_{s_k-p}, \dots, \tilde{a}_{s_k-1})\) encodes recently executed actions. We use benchmark-defined sparse success rewards \(r_t\) (0/1, terminal for long-horizon tasks). A critic pair \((Q_\phi, V_\phi)\) is trained via temporal-difference regression and expectile value fitting: \[\label{eq:loss95qv} \begin{align} L_Q(\phi) &= \mathbb{E}\!\left[\left(Q_\phi(s_t, \tilde{a}_t) - (r_t + \gamma V_\phi(s_{t+1}))\right)^2\right], \\ L_V(\phi) &= \mathbb{E}\!\left[\rho_{\tau_e}\!\left(A_\phi(s_t, \tilde{a}_t)\right) A_\phi(s_t, \tilde{a}_t)^2 \right], \\ A_\phi(s_t, \tilde{a}_t) &= Q_\phi(s_t, \tilde{a}_t) - V_\phi(s_t). \end{align}\tag{4}\] where \(\rho_{\tau_e}(u)=|\tau_e - \mathbf{1}\{u < 0\}|\) defines the asymmetric expectile weight. The resulting advantage informs a clipped exponential update weight: \[w(s_t, \tilde{a}_t) = \mathrm{clip}\!\left( \exp\!\left(\max(0, A_\phi(s_t, \tilde{a}_t)) / \tau \right), 1,\; w_{\max} \right), \label{eq:adv95weight}\tag{5}\] where \(\tau\) is the temperature. Positive-advantage actions are amplified, while suboptimal ones are downweighted. The chunked policy is then updated via: \[L_{\mathrm{AWAC}}(\theta) = -\,\mathbb{E}\!\left[ \sum_{t \in \text{chunk}(k)} w(s_t, \tilde{a}_t)\, \log \pi_\theta(\tilde{a}_t \mid s_t) \right].\]
To maintain temporal consistency, we retain the same regularization used in imitation. Specifically, we apply total variation and curvature penalties, along with a boundary alignment term: \[\begin{align}
L_{\mathrm{cont+bdry}}(\theta)
&= \lambda_{\mathrm{TV}} \sum_{t \in \text{chunk}(k)} \left\|a^{(k)}_t - a^{(k)}_{t-1}\right\|_1 \\
&\quad + \lambda_{D2} \sum_{t \in \text{chunk}(k)} \left\|a^{(k)}_t - 2a^{(k)}_{t-1} + a^{(k)}_{t-2}\right\|_2^2 \nonumber \\
&\quad + \alpha \sum_{t=1}^{O} \left\|a^{(k)}_{t} - \texttt{sg}\!\left(a^{(k-1)}_{t+L-O}\right)\right\|_2^2. \nonumber
\end{align}\] where sg denotes stop-gradient to avoid cyclic dependencies across chunks. These losses operate on predicted actions \(a^{(k)}\), while the critic and advantage are evaluated on executed
actions \(\tilde{a}_t\). The final training objective integrates all components: \[\begin{align}
L_{\mathrm{total}}(\theta)
=\;\;& L_{\mathrm{AWAC}}(\theta)
+ L_{\mathrm{cont+bdry}}(\theta) \notag \\
&+ \beta\,\mathbb{E}_s\!\left[
D_{\mathrm{KL}}\!\big(\pi_\theta(\cdot|s)\,\|\,\pi_{\theta_{\mathrm{old}}}(\cdot|s)\big)
\right] \notag\\
&- \lambda_H\,\mathbb{E}_s\!\left[\mathcal{H}(\pi_\theta(\cdot|s))\right],
\label{eq:loss95total}
\end{align}\tag{6}\] where the KL regularizer and entropy bonus stabilize fine-tuning. This reinforcement stage enables reward-driven improvements without sacrificing temporal smoothness or structural coherence across chunk boundaries.
4 Experiment↩︎
4.1 Dataset and Evaluation Metric↩︎
Dataset. We evaluate three instruction-conditioned settings: the standard CALVIN benchmark [16], the long-horizon LIBERO-Long benchmark [17], and a real-world dataset collected using a 6-DoF collaborative arm [18]. The real-world setting includes two compositional manipulation tasks: (1) Cloth Strip Grasping, which requires sequentially extracting a single strip from a cluttered stack, demanding fine-grained visual discrimination and consistent motion to avoid entanglement; and (2) Block Insertion, which involves picking a block from a randomized location and inserting it into a tight fixture, requiring contact-aware control and smooth alignment. Both tasks are instruction-driven and span nontrivial temporal dependencies.
Evaluation Metrics. We assess task success and action structure. On CALVIN, we report the average episode length (Avg. Len) for 5-step tasks; on LIBERO-Long, we report the official long-horizon success rate (Long SR). Action smoothness is measured by first-, second-, and third-order mean squared differences: MSD-\(\Delta a = \tfrac{1}{T} \sum_t \|a_t - a_{t-1}\|^2\), MSD-\(\Delta^2 a = \tfrac{1}{T} \sum_t \|a_t - 2a_{t-1} + a_{t-2}\|^2\), and MSD-\(\Delta^3 a = \tfrac{1}{T} \sum_t \|a_t - 3a_{t-1} + 3a_{t-2} - a_{t-3}\|^2\), capturing velocity, acceleration, and jerk. Seam consistency is evaluated via Bjump, the mean discrepancy in the overlap region \(\mathcal{B}\), i.e., \(\tfrac{1}{|\mathcal{B}|} \sum_{b \in \mathcal{B}} \|a^{(k)}_b - a^{(k-1)}_b\|\), and Bratio, its normalization by \(\tfrac{1}{T} \sum_t \|a_t\|\). Spectral artifacts are measured by high-frequency energy ratio HF_ratio = \(\sum_{\omega \in \Omega_{\text{high}}} |\mathcal{F}(a)(\omega)|^2 / \sum_{\omega} |\mathcal{F}(a)(\omega)|^2\), with \(\mathcal{F}(a)\) the Fourier transform. Finally, total variation TV-L1 = \(\tfrac{1}{T} \sum_t \|a_t - a_{t-1}\|_1\) captures local shifts missed by MSD.
4.2 Main Results↩︎
Implementation Details. Training used four NVIDIA A800s per job (over 32 GPUs across all runs); inference used one A800 in FP16. ChunkFlow adds no inference-time network: deterministic blending is parameter-free and requires no extra policy forward pass, while seam/continuity losses and the AWAC critic are used only during training. Thus, deployment remains a single policy despite the added training cost. To compare controllers with different rollout rates and chunk sizes, we report the Average Reasoning Latency (ARL), the amortized cost per executed action: \(\text{ARL}=\frac{\sum_{c=1}^{K}T_c}{|\mathcal{A}|}\), where \(|\mathcal{A}|=\sum_{c=1}^{K}|\mathbf{a}_c|\). For chunked rollout, \(|\mathbf{a}_1|=L\) and \(|\mathbf{a}_c|=L-O\) for \(c\geq2\).
Comparisons. We evaluate ChunkFlow against representative controllers on CALVIN ABC–D, including classic BC/RL, diffusion-based, and autoregressive VLA models. Table 1 reports task success and smoothness metrics across temporal, spectral, and boundary dimensions. Classic methods (e.g., HULC [33], SPIL [34]) lack structural modeling, resulting in high-frequency jitter (HF_ratio \(\geq\) 1.0), severe boundary artifacts (Bratio \(>\) 2.0), and poor success rates (\(\leq\)1.7). Diffusion models such as FLOWER [35] and 3D Diffuser Actor [36] improve global coherence but exhibit large high-order curvature (e.g., MSD-\(\Delta^3 a\) \(=\) 1.191), reflecting aliasing and seam inconsistency.
VLA baselines (e.g., GR-1 [37], Seer [38]) benefit from stronger temporal memory and yield lower second-order variation (MSD-\(\Delta^2 a\) \(\approx\) 0.16–0.24); yet, they still suffer from unregularized seams, leading to boundary misalignment and unstable long-horizon execution (e.g., Bratio \(>\) 2.2). In contrast, ChunkFlow provides a strong smoothness-success trade-off: it achieves competitive task success (4.30), the lowest first-/second-order variation (MSD-\(\Delta a\)=0.075, MSD-\(\Delta^2a\)=0.154), Bjump (0.209), HF ratio (0.431), and TV-L1 (0.001), while GR-1 and HULC lead on MSD-\(\Delta^3a\) and Bratio. These gains stem from its chunk-structured prediction, overlap-aware blending, and joint regularization of derivatives and seam alignment—enabling smooth, stable, and reward-aligned execution across extended time horizons.
| Method | Success (Avg. Len.) ↑ | MSD-\(\Delta a\) ↓ | MSD-\(\Delta^2 a\) ↓ | MSD-\(\Delta^3 a\) ↓ | Bjump ↓ | Bratio ↓ | HF_ratio ↓ | TV-L1 ↓ |
|---|---|---|---|---|---|---|---|---|
| Classic BC / RL Baselines (Non-VLM) | ||||||||
| HULC [33] | 0.67 | 0.117 | 0.296 | 0.956 | 0.241 | 1.094 | 0.575 | 0.056 |
| SPIL [34] | 1.71 | 0.107 | 0.228 | 0.703 | 0.253 | 2.231 | 1.000 | 0.028 |
| Generative Diffusion / Flow Policies | ||||||||
| 3D Diffuser Actor [36] | 3.27 | 0.259 | 0.574 | 1.790 | 0.212 | 2.676 | 0.455 | 0.013 |
| VPP [39] | 4.29 | 0.096 | 0.181 | 0.535 | 0.237 | 1.646 | 1.000 | 0.035 |
| FLOWER [35] | 4.54 | 0.161 | 0.382 | 1.191 | 0.443 | 2.367 | 0.460 | 0.044 |
| VLA Policies (Autoregressive / Transformer-based) | ||||||||
| GR-1 [37] | 3.06 | 0.082 | 0.165 | 0.496 | 0.969 | 2.224 | 0.999 | 0.006 |
| Seer [38] | 3.50 | 0.091 | 0.186 | 0.556 | 0.297 | 1.957 | 0.442 | 0.007 |
| UniVLA [22] | 3.80 | 0.118 | 0.238 | 0.714 | 0.251 | 4.109 | 0.488 | 0.009 |
| ChunkFlow (Ours) | 4.30 | 0.075 | 0.154 | 0.512 | 0.209 | 1.471 | 0.431 | 0.001 |
Cross-Dataset Evaluation on Long-Horizon Tasks. We evaluate generalization on LIBERO [17], which emphasizes long-horizon task compositionality and layout shifts. As shown in Table 2, ChunkFlow achieves 93.4% success—slightly outperforming PI0.5 [13] (92.6%)—and outperforms OpenVLA (53.7%), VPP (38.9%), and CLIP-RT (83.8%). While PI0.5-RTC [6] applies inference-time chunk blending and reduces boundary artifacts (Bjump: 0.167\(\rightarrow\)0.115, HF_ratio: 0.494\(\rightarrow\)0.342), its success drops sharply to 83.7%. This supports our hypothesis: inference-only smoothing cannot resolve misaligned seam predictions, causing bias accumulation and degraded rollout stability.
By contrast, ChunkFlow enforces continuity during training and directly optimizes boundary alignment across paired chunks. It achieves the lowest motion deviation (MSD-\(\Delta a\) = 0.042, \(\Delta^2 a\) = 0.197, \(\Delta^3 a\) = 0.235), minimal discontinuities (Bjump = 0.082), and the cleanest temporal spectrum (HF_ratio = 0.135, TV-L1 = 0.011). Its average action inference latency is also the lowest (4.43 ms) due to amortized inference over fixed-step overlapping chunks (\(S=L{-}O\)), which reduces sampling redundancy and stabilizes per-action rollout. In contrast, RTC incurs extra planning costs from heuristic smoothing and late-stage proposal reweighting, resulting in a higher ARL (18.47 ms). These results demonstrate that seam-aware training, not inference heuristics, is critical for ensuring temporal smoothness and efficient execution under long-horizon tasks.
| Method | Long SR (%) \(\uparrow\) | MSD-\(\Delta a\) ↓ | MSD-\(\Delta^2 a\) ↓ | MSD-\(\Delta^3 a\) ↓ | Bjump ↓ | Bratio ↓ | HF_ratio ↓ | TV-L1 ↓ | ARL (ms) ↓ |
|---|---|---|---|---|---|---|---|---|---|
| OpenVLA [3] | 53.7 | 0.083 | 0.229 | 0.743 | 0.166 | 1.145 | 0.862 | 0.031 | 219.43 |
| VPP [39] | 38.9 | 0.133 | 0.255 | 0.732 | 0.738 | 5.702 | 0.394 | 0.029 | 13.91 |
| PI0.5 [13] | 92.6 | 0.095 | 0.249 | 0.812 | 0.167 | 1.401 | 0.494 | 0.023 | 9.04 |
| PI0.5-RTC [6] | 83.7 | 0.089 | 0.240 | 0.729 | 0.115 | 0.850 | 0.342 | 0.018 | 18.47 |
| CLIP-RT [40] | 83.8 | 0.135 | 0.302 | 0.916 | 0.179 | 1.350 | 0.999 | 0.026 | 6.86 |
| Seer [38] | 87.7 | 0.141 | 0.279 | 0.639 | 0.195 | 1.602 | 0.337 | 0.022 | 14.25 |
| ChunkFlow (Ours) | 93.4 | 0.042 | 0.197 | 0.235 | 0.082 | 0.082 | 0.135 | 0.011 | 4.43 |
4.3 Ablation Study↩︎
Hyperparameter Sensitivity. We validate our theoretical predictions on continuity-consistent execution by probing architectural and regularization factors. Seam errors grow with stride \((L{-}O)\), and increasing overlap improves pre-blending agreement and suppresses aliasing: \(O{=}0\) yields high-frequency artifacts (HF_ratio = 0.500; Bjump = 0.230), while moderate \(O{=}4\) minimizes the spectrum (HF_ratio = 0.371), and executable \(O{=}8\) balances spectral stability (MSD-\(\Delta^2 a\) = 0.154) with the best seam coherence (Bjump = 0.209). Chunk horizon also matches expectations: too-short \(L{=}8\) removes temporal context, harming acceleration smoothness (MSD-\(\Delta^2 a\) = 0.205), while too-long \(L{=}12\) amplifies extrapolation error, producing bursts (HF_ratio = 0.812). Fig. 3 confirms that only \((L{=}10,O{=}8)\) suppresses energy beyond 3 Hz. Regularizers exhibit predictable failure modes: over-strong curvature (\(\lambda_{D2}{=}0.007\)) induces phase lag and seam drift (MSD-\(\Delta a\) = 0.121; Bjump = 0.214), excessive boundary loss increases curvature (MSD-\(\Delta^2 a\) = 0.209; Bjump = 0.221), and a large sparsity prior (\(3{\times}10^{-4}\)) harms smoothness without spectral gain. Raising TV (\(\lambda_{\text{TV}}\!:\!0.005\!\to\!0.015\)) suppresses natural variation, degrading both \(\Delta a\) (0.075→0.091) and \(\Delta^2 a\) (0.154→0.170). These trends support our core insight: moderate overlap and chunk length reduce stride-induced aliasing, while over-regularization destabilizes dynamics through curvature amplification and delayed transitions.
| Setting (1-factor) | Success \(\uparrow\) | MSD-\(\Delta a\) \(\downarrow\) | MSD-\(\Delta^2 a\) \(\downarrow\) | Bjump \(\downarrow\) | HF_ratio \(\downarrow\) |
|---|---|---|---|---|---|
| First-order regularizer \(\lambda_{\text{TV}}\) (fix \(L,O,\lambda_{D2},\lambda_{B},\lambda_{\text{prior}}\)) | |||||
| \(\lambda_{\text{TV}}{=}0.005\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| \(\lambda_{\text{TV}}{=}0.008\) | 4.29 | 0.083 | 0.162 | 0.214 | 0.433 |
| \(\lambda_{\text{TV}}{=}0.015\) | 4.26 | 0.091 | 0.170 | 0.218 | 0.437 |
| Second-order regularizer \(\lambda_{D2}\) (fix \(L,O,\lambda_B,\lambda_{\text{prior}}\)) | |||||
| \(\lambda_{D2}{=}0.003\) | 4.26 | 0.100 | 0.170 | 0.210 | 0.455 |
| \(\lambda_{D2}{=}0.005\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| \(\lambda_{D2}{=}0.007\) | 4.25 | 0.121 | 0.206 | 0.214 | 0.472 |
| Boundary loss \(\lambda_{B}\) (fix \(L,O,\lambda_{D2},\lambda_{\text{prior}}\)) | |||||
| \(\lambda_{B}{=}0.02\) | 4.27 | 0.096 | 0.165 | 0.222 | 0.437 |
| \(\lambda_{B}{=}0.03\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| \(\lambda_{B}{=}0.04\) | 4.23 | 0.122 | 0.209 | 0.221 | 0.432 |
| Sparsity prior \(\lambda_{\text{prior}}\) (fix \(L,O,\lambda_{D2},\lambda_{B}\)) | |||||
| \(1{\times}10^{-4}\) | 4.26 | 0.097 | 0.168 | 0.217 | 0.437 |
| \(2{\times}10^{-4}\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| \(3{\times}10^{-4}\) | 4.24 | 0.117 | 0.202 | 0.213 | 0.433 |
| Overlap ratio \(O/L\) (retrain; fix \(L,\lambda_{D2},\lambda_{B},\lambda_{\text{prior}}\)) | |||||
| \(O{=}0\) | 4.20 | 0.118 | 0.200 | 0.230 | 0.500 |
| \(O{=}2\) | 4.10 | 0.105 | 0.175 | 0.450 | 0.470 |
| \(O{=}4\) | 4.20 | 0.108 | 0.179 | 0.388 | 0.371 |
| \(O{=}8\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| Chunk length \(L\) (retrain; fix \(O,\lambda_{D2},\lambda_{B},\lambda_{\text{prior}}\)) | |||||
| \(L{=}8\) | 4.30 | 0.120 | 0.205 | 0.205 | 0.450 |
| \(L{=}10\) (default) | 4.30 | 0.075 | 0.154 | 0.209 | 0.431 |
| \(L{=}12\) | 4.20 | 0.102 | 0.192 | 0.240 | 0.812 |
Inference-Time Stability and Smoothness Enforcement. To assess deployment robustness, we examine test-time strategies for enforcing temporal consistency in chunked rollouts. We first evaluate naive overlap execution without retraining (Table 4, A1): small overlap (\(O{=}2\)) slightly reduces curvature (MSD-\(\Delta^2 a\): 0.381 \(\to\) 0.360), but larger values (\(O{=}4/8\)) degrade both smoothness and success due to redundant predictions and conflicts across chunks, confirming that inference-only overlap suffers from gradient ambiguity under perceptual drift. We next study lightweight smoothing heuristics (A2): blending (\(O{=}2\)), EMA filtering, and warm-started chunk latents. Each improves specific metrics (e.g., warm-start lowers MSD-\(\Delta^2 a\) to 0.163), but their combination yields the best stability (HF_ratio = 0.431, Bjump = 0.209, Success = 4.30), even when trained with \(O{=}0\). We further simulate latency via \(\pm\)100 ms control delay (B), observing negligible degradation—indicating strong temporal generalization. Finally, classical filters (Table 5) like Savitzky–Golay and Butterworth reduce high-order jitter (e.g., MSD-\(\Delta^3 a = 0.002\)); however, they fail to suppress seam artifacts (Bjump \(\geq\) 0.228) and spectral aliasing (HF_ratio \(\geq\) 0.69). These results highlight that post-hoc smoothing cannot resolve structural discontinuities. In contrast, ChunkFlow enforces global coherence via derivative-aligned chunk execution learned through training-time regularization.
| Setting | Success \(\uparrow\) | MSD-\(\Delta^2 a\) \(\downarrow\) | HF_ratio \(\downarrow\) | Bjump \(\downarrow\) |
|---|---|---|---|---|
| A1. Naive Chunk Overlap (no retraining) | ||||
| Overlap (\(O{=}0\)) | 4.29 | 0.381 | 1.000 | 0.437 |
| Overlap (\(O{=}2\)) | 4.10 | 0.360 | 0.950 | 0.410 |
| Overlap (\(O{=}4\)) | 3.95 | 0.390 | 0.940 | 0.385 |
| Overlap (\(O{=}8\)) | 3.60 | 0.440 | 0.970 | 0.420 |
| A2. Lightweight Smoothing (no retraining) | ||||
| No smoothing | 4.29 | 0.273 | 0.445 | 0.493 |
| + Blend (\(O{=}2\)) | 4.21 | 0.317 | 0.501 | 0.299 |
| + EMA (\(\alpha{=}0.1\)) | 4.27 | 0.273 | 0.441 | 0.453 |
| + EMA (\(\alpha{=}0.3\)) | 4.27 | 0.283 | 0.438 | 0.376 |
| + Warm start | 4.31 | 0.163 | 0.329 | 0.428 |
| Blend + EMA (\(\alpha{=}0.3\)) + Warm start | 4.30 | 0.154 | 0.431 | 0.209 |
| B. Delay Robustness (jitter \(\pm j\) ms) | ||||
| \(\pm\)0 ms | 4.31 | 0.222 | 0.392 | 0.202 |
| \(\pm\)10 ms | 4.31 | 0.220 | 0.392 | 0.199 |
| \(\pm\)50 ms | 4.30 | 0.222 | 0.390 | 0.203 |
| \(\pm\)100 ms | 4.30 | 0.221 | 0.391 | 0.203 |
| Filter | MSD-\(\Delta^3 a\) \(\downarrow\) | HF_ratio \(\downarrow\) | Bjump \(\downarrow\) | Notes | |
|---|---|---|---|---|---|
| Base (raw) | 0.839 | 1.000 | 0.493 | No smoothing | |
| Savitzky–Golay | 0.045 | 0.78 | 0.256 | Post-hoc | |
| Butterworth (low-pass) | 0.002 | 0.69 | 0.228 | Post-hoc | |
| Cubic spline | 0.839 | 0.97 | 0.493 | Offline fitting | |
| ChunkFlow (ours) | 0.512 | 0.431 | 0.209 | Integrated during training |
History Length Sensitivity. We evaluate how varying temporal context (\(p\)) impacts prediction stability. Without history (\(p{=}0\)), the policy struggles with acceleration smoothness (MSD-\(\Delta^2 a{=}0.223\)), third-order coherence (MSD-\(\Delta^3 a{=}0.582\)), and boundary stability (Bjump\(=0.241\)), due to reliance on instantaneous observations. Short histories (\(p{=}2\)) yield clear improvements (MSD-\(\Delta^2 a{=}0.207\), Bjump\(=0.220\)), while moderate history (\(p{=}4\)) achieves optimal results across all axes (e.g., HF_ratio\(=0.431\), success\(=4.30\)), enabling consistent chunk transitions. However, longer context (\(p{=}8\)) degrades performance (MSD-\(\Delta^2 a{=}0.203\), Bjump\(=0.224\)) as outdated signals introduce error accumulation. These trends confirm that a limited, recent history improves alignment and smoothness, but excessive memory leads to temporal drift.
| \(p\) | Success \(\uparrow\) | MSD-\(\Delta^2 a\) \(\downarrow\) | MSD-\(\Delta^3 a\) \(\downarrow\) | HF_ratio \(\downarrow\) | Bjump \(\downarrow\) |
|---|---|---|---|---|---|
| 0 | 4.29 | 0.223 | 0.582 | 0.462 | 0.241 |
| 2 | 4.27 | 0.207 | 0.545 | 0.431 | 0.220 |
| 4 | 4.30 | 0.154 | 0.512 | 0.431 | 0.209 |
| 8 | 4.13 | 0.203 | 0.538 | 0.450 | 0.224 |
Policy Adaptation with Safety Constraints. To enhance long-horizon performance beyond supervised pretraining, we apply reinforcement fine-tuning using AWAC, with gradient clipping and imitation anchoring. As shown in Table 7, the supervised-only model produces unstable execution with strong high-frequency jitter (HF_ratio = 1.000), sharp curvature (MSD-\(\Delta^3 a\) = 0.535), and seam misalignment (Bjump = 0.237). Adding unconstrained RL (AWAC w/o continuity) reduces spectral noise (↓28%) but fails to correct boundary inconsistencies. In contrast, our Safe RL-FT achieves coherent adaptation: MSD-\(\Delta^3 a\) drops to 0.512, HF_ratio to 0.431, and Bjump to 0.209, recovering full task success (4.30). These results confirm that continuity-aware regularization is critical for reward-driven updates to avoid seam drift and maintain rollout smoothness.
| Method / Variant | Success \(\uparrow\) | MSD-\(\Delta^3 a\) \(\downarrow\) | HF_ratio \(\downarrow\) | Bjump \(\downarrow\) |
|---|---|---|---|---|
| Supervised only (no RL) | 4.10 | 0.535 | 1.000 | 0.237 |
| AWAC (w/o continuity) | 4.17 | 0.530 | 0.720 | 0.225 |
| Safe RL-FT (default) | 4.30 | 0.512 | 0.431 | 0.209 |
Long-Horizon Stability. We assess ChunkFlow’s robustness in long-horizon rollouts, where autoregressive policies often accumulate aliasing and drift. Fig. 4 shows the power spectral density (PSD) of action derivatives, highlighting that ChunkFlow significantly suppresses high-frequency components beyond 2.5 Hz—unlike baselines lacking seam-aware blending or curvature regularization, which exhibit spectral spikes due to discontinuities. This confirms that our structural constraints effectively mitigate jitter over extended horizons. To evaluate the trade-off between smoothness and effectiveness, Fig. 5 plots normalized task Success versus Smoothness (\(1{-}\mathrm{HF\_ratio}\)). ChunkFlow achieves the best balance (0.86, 0.57), outperforming post-hoc filters like BEW (0.82, 0.66) and long-history variants such as Hist-8 (0.83, 0.45). These results show that long-horizon stability cannot be achieved via denoising alone; structural continuity is essential. ChunkFlow’s overlap blending and trajectory-aware training yield executions that remain stable over time.
5 CONCLUSIONS↩︎
We introduced ChunkFlow, a continuity-consistent framework for chunked robotic policy execution. Rather than stacking isolated techniques, ChunkFlow realizes a unified execution model in which overlap-aware blending, seam-regularized learning, and advantage-weighted adaptation are jointly optimized to correct boundary discontinuities in chunked VLA and generative controllers. Experiments on CALVIN, LIBERO, and real-robot benchmarks show improved smoothness, temporal stability, and long-horizon success while preserving the low latency of chunked inference. These results support execution-indexed chunk alignment in simulation and initial hardware tests, while broader real-world robustness remains future work.
ACKNOWLEDGMENT↩︎
This work was supported by the Natural Science Foundation of China under Grant NSFC 62573343 and 62088102, National Basic Strengthen Research Program of ReRAM under Grant2022-00-03, Fundamental Research Funds for the Central Universities xzy012024066,and by the Open-End Fund of Beijing Institute of Control Engineering under GrantOBCandETL-2024-04.