Accelerating Robot Motion Without Losing Success Rate: Three Walls We Hit in Fast Action-Chunk Playback and How We Solved Them
How we accelerated a bimanual towel-folding VLA policy to 1.5–2.0x speed without re-collecting demonstrations or redoing pretraining—overcoming gripper dynamics and jitter-induced pseudo-curvature, servo tracking-lag shifts (+3 mm air grasps), and 2x horizon exhaustion and cloth inertia across 100-episode real-robot evaluations.
Contents
In automating towel folding at linen supply plants, robot motion speed translates directly into unit economics. As we detailed in Part 1 of this series[9], the hourly profit generated by a single robot is governed by two numbers: success rate and cycle time. Moving faster does more than shorten the duration of each successful fold and raise hourly throughput—within a fixed 120-second episode cap, it also buys extra time to recover from missed corner grasps, directly reducing timeout failures themselves.
The most straightforward way to speed up an already-trained robot policy is to take the sequence of future target actions emitted in a single model inference—an action chunk—and compress its time axis at execution time to play it back at 1.5x or 2.0x speed. Doing so requires neither collecting expensive new robot demonstrations nor retraining a large model from scratch. Recent work in imitation learning and vision-language-action (VLA) models has likewise begun exploring test-time acceleration of action chunks beyond demonstration speed via temporal rescaling and time-optimal path parameterization (TOPP)[4][5][6].
When we brought this idea directly onto physical dual-arm robots folding real towels, however, one physical and control breakdown followed another. A trajectory planner intended to make motion fast and smooth paradoxically slowed the robot down to 0.8x; once 1.5x motion worked, the arms began missing hanging towel corners and success rate dropped by 10 percentage points; and pushing the cap to 2.0x flung the leading edge of the cloth by inertia, ruining the fold.
In this post, we walk through the three walls we hit on the path to making fast action-chunk playback practical for real-world bimanual towel folding, how we diagnosed each root cause, and how we solved them. In the latter half (§4), we also compare our approach against recent prior methods, clarifying where our design differs technically and why those differences matter on deformable cloth manipulation.
Setup: Robot Platform and Base Policy
Our experimental platform is a bimanual system equipped with two 6-DoF arms (Dobot Nova 5) and two current-controlled parallel-jaw grippers (ROBOTIS RH-P12-RN-A). Taking 224×224 px images from three cameras—one overhead camera and left/right wrist cameras—together with a 14-dimensional joint and gripper state, the controller sends target joint positions and gripper commands at 50 Hz (20 ms control period).
Our base policy is a vision-language-action model [1][2] pretrained and fine-tuned on our in-house linen manipulation datasets. Conditioned on shared image-language representations, a flow-matching Action Expert generates a 50-step action chunk (1.0 second at 50 Hz) per inference. To keep the arms moving smoothly without pausing during GPU inference (~120 ms, or ~6 control steps), we train and deploy with Training-Time RTC (Real-Time Chunking)[3]: the committed actions that the robot continues executing during inference (the prefix) are fed into the next inference as conditioning so that each new chunk seamlessly continues the previous trajectory.
Every main evaluation reported below runs 100 episodes per condition (120-second time limit) and is scored uniformly—both for pass/fail quality and completion timestamp—by a fixed automated visual quality judge to eliminate operator-to-operator grading variance.
1. Wall 1: Mechanics and Generated Trajectories — Gripper Closing Lag and Reverse Slowdown from Pseudo-Curvature
Phase-Based Variable-Rate Playback and RTC Alignment
When playing back an action chunk at rate , shrinking the 20 ms control period itself would violate the timing assumptions of low-level servo loops and communication threads. Instead, we keep the control loop fixed at 50 Hz, treat each chunk as a continuous function over phase , and advance the phase by on each control tick: plays at normal speed and at 1.5x speed. The policy itself is never told ; it always receives observations and action histories on its native 1x grid.
The first subtlety is maintaining consistency with Training-Time RTC. Because wall-clock GPU inference time (~120 ms = 6 control steps) stays constant regardless of playback speed, the chunk phase consumed during inference grows by factor (up to chunk steps at 1.5x). Moreover, under variable-rate playback, the consumed phase at an inference trigger is generally non-integer. We therefore scale the RTC prefix length to (where is the 1x inference delay in steps) and resample the committed trajectory from the non-integer phase at unit 1.0-step intervals before passing it to the model.
To build this fast-playback foundation, we immediately had to confront two mechanical and trajectory hurdles: physical gripper speed and high-frequency noise in generated chunks.
Challenge 1: Speeding Up the Arms Does Not Speed Up Current-Controlled Grippers
While slowing down around gripper actuations has been noted in prior work[4], profiling our hardware logs showed that our current-controlled grippers physically require ~0.9 s to travel from fully open to fully closed (~0.38 s to open). Compressing command playback to 1.5x cannot shorten physical jaw travel time; uniform fast playback would lift the arm before the fingers finished closing, resulting in an air grasp.
At the same time, those same logs revealed that active gripper opening and closing accounts for only ~8% of total episode duration. From the outset, we therefore imposed a continuous local rate cap based on the gripper command gradient so as never to exceed the physical jaw speed limit (configured separately for opening and closing):
Immediately after a close command finishes, we also hold unit rate () for 0.1–0.2 s so the physical fingers can finish settling, and we propagate a backward deceleration ramp from the end of each chunk so the arm smoothly decelerates ahead of upcoming gripper closures rather than braking abruptly.
Challenge 2: Smooth Speed Planning Slowed a 1.5x Target Down to 0.8x
To push straight free-space segments to 1.5–2.0x without seam jerks, we parameterized discrete chunk waypoints as natural cubic splines and implemented a closed-form forward-backward velocity planner (~3 ms per chunk) that solves for the maximum velocity curve (MVC) under per-joint velocity and acceleration bounds and (with ):
To eliminate acceleration spikes at chunk transitions, we also blended the first 10 steps of each incoming chunk with the outgoing trajectory using a quintic smoothstep weight for C2 continuity (continuous position, velocity, and acceleration), while correcting the next inference's prefix by the exact blended execution residual.
Yet when we deployed this smoothing pipeline on the robot with a 1.5x target cap, motion became silky smooth—but the effective playback rate averaged just 0.81x (minimum 0.55x), slower than standard 1.0x execution.
The culprit was invisible high-frequency micro-jitter inside the action chunks produced by flow matching. Discrete waypoints emitted by the model carry step-to-step fluctuations of a few milliradians. Negligible in position, passing them directly through an interpolating cubic spline explodes the second derivative into massive pseudo-curvature—reaching a 99th-percentile 1x-equivalent acceleration of . Interpreting this micro-jitter as a series of hairline sharp turns, the MVC planner stayed on the brakes across most of the chunk to respect the acceleration limit.
The fix was remarkably simple: before fitting the cubic spline, we pass the 12 arm-joint trajectories through a 9-point Savitzky-Golay filter. Without distorting the global path shape (maximum position deviation ≤ 0.002 rad), 99th-percentile 1x-equivalent acceleration dropped by more than two-thirds from , allowing offline replanning to hit the rate cap and enabling smooth physical 2.0x runs averaging ~1.7x effective speed with zero protective stops.
2. Wall 2: Closed-Loop Control — A +3 mm Air-Grasp Shift from Expanded Servo Lag, and State-Lag Compensation
1.5x Cut Completion Time by 25%, but Dropped Success Rate by 10 Points
To isolate the impact of fast playback on task success rate from spline planning changes, we first fixed the simplest linear-interpolation + gripper-speed-guard pipeline and ran 100 real-robot episodes on pile towel folding—picking one face towel from a stacked pile on a conveyor, unfolding it in mid-air, folding it twice, and stacking it.
Compared against the 1.0x baseline, running with a 1.5x cap (1.34x effective mean speed) shortened mean completion time on successful episodes by 24.6%, from 78.3 s to 59.0 s. At the same time, however, success rate fell by 10.0 percentage points from 58.0% to 48.0%, and episodes failing to finish within 120 seconds rose from 33 to 41. Roughly 20 seconds of speed headroom was being wiped out by mid-task grasp failures.
To pinpoint what broke, we audited all 3,428 grasp attempts across the 200 combined episodes using 3D forward-kinematics (FK) trajectory comparisons and counterfactual offline re-inferences.
The dominant regression appeared during aerial unfold grasping—where one arm suspends the towel by a corner in mid-air while the other arm descends to pinch the hanging bottom corner. The miss rate at this stage jumped from 33.6% at 1.0x to 47.7% at 1.5x (+14.1 points). (In addition, during initial descent onto the towel pile, stretching the RTC prefix from 6 to 9 steps carried downward motion 1–4 mm deeper into the stack, increasing two-towel double-grasps on ~2 mm-thick cloth from 0 to 5 episodes.)
Why Does Running at 1.5x Make the Gripper Close 3 mm Too High in Mid-Air?
Comparing arm heights on missed aerial-unfold attempts revealed that at 1.5x, the flange height at gripper closure shifted upward by a median of +2.9 mm (+3.0 mm at the fingertips, and +3.2 mm in measured arm height at the chunk generation trigger) relative to 1.0x. Against a thin hanging towel corner, closing 3 mm higher causes the fingertips to graze just above the tip of the cloth and close on empty air.
We initially suspected chunk-transition artifacts or gripper-guard side effects, but re-running the model on identical recorded observations shifted predicted close height by less than 0.1 mm, ruling out every playback-side artifact. Counterfactual offline inference isolated the primary mechanism—directly accounting for ~1.5–2 mm of the ~3 mm shift, with the remainder along the 2D wrist camera's unobservable optical depth axis—as an interaction between policy state anchoring and position-servo tracking lag:
- 1. The policy anchors its planned close height strongly to measured joint positions : Holding camera images fixed while perturbing only the input arm joint state up or down by a few millimeters shifts the model's planned closure height in the same direction (with a slope of ~0.9 without prefix, and ~0.28–0.35 even with the real action prefix). Rather than relying solely on visual corner coordinates, the policy plans relative to where it believes the arm currently sits ()—effectively deciding "descend Δz millimeters from here and close."
- 2. Fast playback stretches servo tracking lag in chunk coordinates by factor : On our position-controlled arms, measured joint positions trail commanded positions by a steady real-time lag of roughly 4 control steps (80 ms). That 80 ms wall-clock lag does not change between 1.0x and 1.5x. During a 1.5x descent, however, the arm descends 1.5x faster and advances ~1.5 chunk steps per control tick, so in chunk coordinates the tracking gap stretches from 4.0 steps to ~6.0 steps—widening the vertical gap at the pre-closure inference trigger from 2.5 mm to 4.4 mm.
As a result, throughout descent at 1.5x, every inference receives a state input telling the policy that the arm is still higher up than it would be at the corresponding phase at 1.0x, systematically pulling the planned closure height upward.
The Trap of "Zeroing Out Lag" and Closed-Form State-Lag Compensation
Once servo tracking lag is identified as the cause, the most tempting fix is to ask: "Why not feed the lag-free command directly as the policy's state input instead of measured ?"
Here lies a deeper trap: the 1.0x training demonstrations themselves were recorded on the exact same robot—meaning every training state already contains 4 steps (80 ms) of steady-state servo lag. Substituting at test time erases all lag and pushes the policy out of its training state distribution. When descending toward the tabletop, feeding —which sits several millimeters below the physical arm —causes the policy to plan subsequent downward chunks from a falsely low height, creating a severe hazard of driving the end-effector forcefully into the table.
The right target is therefore not zero lag, but canceling only the extra lag introduced by playback rate while preserving the exact 4-step lag (a fraction of total lag) present in 1.0x data. Requiring neither policy retraining nor controller gain tuning, this reduces to a single closed-form interpolation for the 12 arm-joint state inputs at each inference trigger (keeping the 2 gripper dimensions at their measured values):
At unit speed (, including during gripper slowdowns), the second term vanishes and exactly as before; at , adding of the tracking error restores chunk-coordinate lag back to its 1.0x-equivalent 4 steps.
To test this prediction cleanly, we evaluated three 1.5x conditions—(1) uncompensated (), (2) zero-lag (cmd: ), and (3) rate-proportional state-lag compensation (rate: formula above)—for 100 real-robot trials each using the exact same checkpoint and linear + gripper-guard playback pipeline.
| Condition | Trajectory Interpolation | State Input Handling | Success Rate | Pass Completion Time (Mean / Median) | Unfinished at 120 s | Unrecoverable Failures (Table Presses)* |
|---|---|---|---|---|---|---|
| 1.0x Baseline | Standard (1.0x) | Measured (natural 1x lag) | 58.0% | 78.3 s / 77.1 s | 33 | 1 (0) |
| 1.5x Uncompensated | Linear + Gripper Guard | Measured (expanded lag) | 48.0% | 59.0 s / 52.6 s | 41 | 11 (0) |
| 1.5x Zero-Lag (cmd) | Linear + Gripper Guard | Command (all lag erased) | 57.0% | 60.9 s / 53.5 s | 26 | 16 (7) |
| 1.5x State-Lag (rate) | Linear + Gripper Guard | Interpolation keeping lag | 53.0% | 57.4 s / 51.1 s | 28 | 5 (0) |
| (Ref.) 2.0x on 1-Second Chunk | C2 Spline + Speed Planner | Measured (uncompensated) | 46.0% | 58.8 s / 49.1 s | 29 | 9 (4) |
* Unrecoverable failure counts and tabletop-pressing incidents are tallied from operator failure logs recorded during evaluation.
The outcome was unambiguous. Relative to uncompensated 1.5x (48.0% success, 41 unfinished), both lag-aware modes—rate (53.0%, 28 unfinished) and cmd (57.0%, 26 unfinished)—substantially cut unfinished episodes and recovered success rate within 100-trial sampling noise.
What decisively separated the two was how they failed. Erasing lag completely with cmd produced the highest count of unrecoverable failures across all runs—16 episodes, including 7 hazardous incidents where an arm pressed forcefully into the tabletop. Preserving the 1x steady lag with rate held tabletop presses to 0 while delivering the fastest mean completion time among all 1.5x runs at 57.4 s (−26.8% vs. 1.0x; median 77.1 s → 51.1 s, −33.8%).
3. Wall 3: Scaling to 2.0x — 1-Second Chunk Exhaustion and Cloth Inertia
Why Pushing a 1-Second Chunk Model to 2.0x Breaks Down
As shown in the bottom reference row of the table above, keeping the 1-second chunk () model and enabling the C2 spline speed planner from §1 at a 2.0x cap yielded only 46.0% success, with frequent large fold/stacking misalignments (20 episodes). At 2.0x and beyond, two fundamental barriers emerge that test-time post-processing alone cannot cross.
The first is exhaustion of the RTC delay-conditioning range and chunk horizon. While the relationship bounding maximum speedup from inference latency and chunk length has been noted before[4], combining Training-Time RTC with inter-chunk blending tightens the constraint considerably. On our hardware, inference latency is typically 6 control steps, but tail load reaches up to steps (200 ms). At x, the robot consumes up to 20 chunk steps during a single inference. On a 1-second chunk model trained with a maximum simulated delay of 9 steps (even when clamped to 12 steps at test time), 98.5–100% of chunk switches above 1.5x landed outside the pinned prefix in unanchored free-generation territory, producing pre-blend position jumps of 3.4 mm median (and 9.3–9.5 mm under 10-step tail latency) at 2.0x.
More generally, for an inference period of control steps and a seam-blend window of chunk steps, avoiding horizon exhaustion before the next chunk arrives and finishes blending requires:
With , max delay , and blend width , already requires —right at the ceiling of a 1-second chunk—while demands steps, physically exhausting a 1-second horizon.
Solution 1: 2-Second Chunks () with Mixed-Delay Fine-Tuning
Keeping the 50 Hz temporal resolution unchanged, we doubled the model's output horizon to steps (2.0 seconds) and expanded the training-time simulated delay range up to 46 (supporting prefixes up to 45 steps, or up to x) during task fine-tuning.
This architecture carries two practical advantages. First, because vision and language tokens dominate compute inside a VLA model, doubling Action Expert tokens from 50 to 100 increases inference time by only ~10 ms (from 117 ms to 127–128 ms, or half a control step). Second, because weight matrix shapes do not depend on chunk length , we do not need to re-run costly 100k-step pretraining—a standard 20k-step task fine-tune on 250 demonstrations suffices to turn a 1-second policy into a 2-second policy.
One training detail proved essential: sampling simulated delays uniformly from dilutes training density on short prefixes ( steps)—used during 1.0x execution and gripper slowdowns—to roughly one-fifth of standard training. To avoid degrading 1.0x behavior, we trained with a 50/50 mixture distribution: 50% and 50% . Setting runtime inference delay to a conservative 11 steps above the 10-step empirical tail (giving prefix length steps at 2.0x) achieved 0% out-of-prefix switches and 0 mm pre-blend position jumps all the way up to 4.0x across 400 offline chunk transitions, matching 1-second chunk smoothness.
Solution 2: Taming Cloth Inertia at 2.0x — Capping Only the First Fold via Dual-Arm FK Lookahead
Because the conveyor unit was occupied by another experiment, we validated the 2-second chunk model on round-table towel folding—picking a face towel from a side round table, unfolding it onto the main table, and folding it twice. Enabling both the smooth speed planner from §1 (SG filter + MVC + C2 blend) and state-lag compensation (rate) from §2, we ran initial 2.0x commissioning trials on the robot.
Robot motion itself was completely smooth, with zero protective stops or vibration. Yet the very first 2.0x commissioning run ended in three consecutive failures.
The culprit was no longer robot control, but deformable cloth dynamics under inertia. Analyzing the first half-fold—where both arms lift the two near corners of the spread towel and carry them forward over the far half—showed that the model generated a ~1.8x longer back-and-forth path at 2x, which when played at ~1.9x pushed peak forward flange speed to 2.7x of 1x execution (0.10 → 0.26 m/s) and peak lay-down descent speed to 3.2x (0.14 → 0.44 m/s). Carrying a thin face towel at that speed flung the upper edge violently onto the lower half by inertia, stamping a stiff, skewed crease along the fold line that caused the subsequent second fold (quarter-fold) to collapse. No matter how cleanly we compress the time axis of an action chunk, gravity and cloth settling do not speed up.
Crucially, every other stage of the episode—reaching to the round table, grasping, aerial re-grasping and unfolding, and even the second fold where the doubled towel is thicker and stiffer—succeeded cleanly at 2.0x. We only needed to cap playback speed to 1.0x during the few seconds of the first half-fold.
Detecting this phase requires neither collecting labels nor training an external visual classifier: the first half-fold has an unmistakable geometric signature identifiable purely from commanded actions and dual-arm forward kinematics (FK). Scanning the active chunk and a 25-step lookahead window (taking just 0.3 ms per 100-step chunk), we implemented a lightweight causal state machine:
- 1. Dual grasp: Both left and right gripper commands are closed ().
- 2. Lift: Mean flange height across both arms (in arm-base frame) rises above 850 mm, suspending the towel.
- 3. Pull-back (hang): After the lift peak, both arms pull back toward the near side () by more than 200 mm, resting the lower edge of the towel on the table.
- 4. Forward carry onset (cap ON): As soon as mean flange rises more than 40 mm forward () within the 25-step lookahead window, the playback rate cap smoothly ramps to 1.0x and holds until a gripper opens to release the fold. (Because the second quarter-fold lifts no higher than 790 mm, it never triggers the detector and runs at full 2.0x speed.)
Replayed across labeled real-robot episodes, this kinematic rule alone covered over 96% of every first half-fold, triggered a median of 0.1–0.65 s ahead of fold onset for smooth deceleration, and fired outside true folds for just 1.2% of total 1x episode time. Slowing only the first fold to 1.0x adds roughly 3 seconds on 1x reference trajectories (4–13 seconds on longer 2x trial folds). Re-running commissioning on the robot with this cap enabled immediately turned 0/3 into 2/3 successes.
100-Episode Real-Robot Evaluation
We evaluated this 2-second chunk policy across two main conditions—(1) a 1.0x control and (2) up to 2.0x playback combining the smooth speed planner, state-lag compensation (rate), and the 1.0x first-fold cap—over 50 episodes on each of two robots (100 episodes per condition). For reference, we also list the conventional 1-second chunk () 1.0x baseline trained on the same dataset.
| Condition | Chunk Horizon / Playback Speed | Success Rate | Pass Completion Time (Mean / Median) | Unfinished at 120 s |
|---|---|---|---|---|
| (Ref.) Conventional 1-Second Chunk at 1.0x | (1.0 s) / 1.0x | 74.0% | 76.6 s / 73.8 s | 19 |
| 2-Second Chunk at 1.0x (Control) | (2.0 s) / 1.0x | 58.0% | 80.9 s / 80.7 s | 32 |
| 2-Second Chunk at 2.0x + 1st-Fold 1.0x Cap | (2.0 s) / up to 2.0x | 70.0% | 63.8 s / 57.9 s | 21 |
Two key takeaways stand out from this evaluation.
First, in a head-to-head comparison on the exact same 2-second chunk checkpoint (bottom two rows), 2.0x playback not only cut completion time from 80.9 s → 63.8 s mean (−21.1%, and 80.7 s → 57.9 s median, −28.3%), but also raised success rate from 58.0% → 70.0% (+12.0 points). Accelerating reach, grasp, and aerial-unfold cycles allowed episodes that suffered one or two early corner misses to finish recovering well inside the 120-second limit, cutting unfinished episodes by roughly one-third from 32 down to 21.
Second, compared against the conventional 1-second chunk 1.0x baseline (74.0% / 76.6 s mean, 73.8 s median): while widening the output horizon to 2 seconds lowers standalone 1.0x performance to 58.0%, deploying it at its intended operating point—2.0x playback + state-lag compensation + 1.0x first-fold cap—preserves a 70.0% success rate statistically indistinguishable from the 1-second baseline while shortening completion time by 12.8 s on average (−16.7%) and 15.9 s in median (−21.5%).
4. How Our Approach Differs from Prior Work
Recent efforts to execute imitation-learning and VLA policies faster than human demonstrations fall broadly into two families: training-side acceleration and test-time action-chunk retiming.
Training-side methods include DemoSpeedup[7], which temporally compresses low-entropy free-space demonstration segments before retraining, and SpeedAug[8], which combines multi-tempo resampled demonstrations with reinforcement-learning fine-tuning. Rebuilding multi-thousand-episode pretraining datasets and retraining foundation VLA policies from scratch is costly, however, making test-time playback approaches—where existing checkpoints work directly, and even 2x+ horizon extension requires only lightweight task fine-tuning—far more practical in production.
Among test-time methods that accelerate action chunks beyond demonstration speed, representative prior works include SAIL[4], which switches between two discrete speed levels, and RACE[5] and RoboPace[6], which fit cubic splines to chunks and solve time-optimal path parameterization (TOPP-RA) under joint velocity and acceleration bounds. Comparing these systems against ours in the context of physical bimanual deformable-object manipulation ( + Training-Time RTC + position-controlled arms) highlights clear architectural differences.
| Dimension | SAIL[4] | RACE[5] | RoboPace[6] | Ours |
|---|---|---|---|---|
| Handling Servo Tracking Lag at High Speed | Relabels actions to achieved positions & retrains policy + swaps in high-gain controller | Relabels actions to reached states & retrains policy | None (unaddressed) | No retraining or controller changes. Closed-form state-lag compensation preserving 1x steady lag () |
| Async Inference Latency & Chunk Seams | Inference-time guidance + max-speed bound from latency | Parallel multi-chunk sampling & reachability selection (Test-Time Search) | Open-loop inference + linear position blending | Training-Time RTC integration (effective delay scaling, non-integer phase 1x resampling, C2 smoothstep blend + prefix residual correction, mixed-delay FT) |
| Generative Micro-Jitter Curvature | Offline Bézier demo smoothing before training only (no test-time fix) | None | None | Test-time 9-point Savitzky-Golay pre-filter (prevents 2nd-derivative pseudo-curvature from causing 0.8x reverse slowdown) |
| Slowdown Triggers & Deformable Cloth | Binary fast/slow switch from motion complexity flag or gripper action | Joint velocity/acceleration bounds only (ignores grippers, contact, cloth) | Hand-to-table / hand-to-hand mesh proximity + separately trained visual contact predictor (4.69M CNN+GRU) | Zero auxiliary networks. Continuous current-gripper gradient cap + settle hold, plus dual-arm FK lookahead 1st-fold 1.0x cap |
Our technical differences distill into three core points:
- 1. Restoring the 1x steady-state lag distribution rather than zeroing out lag: Both SAIL and RACE address high-speed tracking lag by relabeling training actions from commands to achieved states and retraining the policy (alongside higher-gain low-level control in SAIL), while RoboPace leaves state-input lag unaddressed. Keeping our command-trained policy and position controller untouched, we showed that because 1.0x demonstrations themselves embed steady servo lag, erasing lag (cmd) pushes the policy out of distribution whereas preserving of the lag restores it—validating the distinction in 100-trial robot ablations (7 tabletop presses under cmd vs. 0 under rate) with a one-line closed-form interpolation.
- 2. Training-Time RTC integration and removal of flow-matching micro-jitter: Rather than sampling multiple candidate chunks in parallel per inference as in RACE, we extended single-chunk Training-Time RTC to variable-rate playback via non-integer phase resampling onto the 1x grid, post-C2-blend prefix alignment, and mixed-delay fine-tuning. We also identified why applying spline + TOPP planning directly to discrete flow-matching chunks induces severe reverse slowdown via second-derivative pseudo-curvature , resolving it with a lightweight Savitzky-Golay pre-filter.
- 3. Physics- and kinematics-driven slowdowns with zero auxiliary neural networks: RoboPace also evaluates bimanual towel folding (~1.5–1.65x), triggering slowdowns from hand-to-table / hand-to-hand proximity and a separately trained wrist-camera contact-step predictor. Yet the failure mode that broke 2.0x towel folding occurs while both hands already hold the towel high in mid-air—far from both the table and each other—when swing inertia flings the free cloth edge forward, which proximity-to-contact triggers cannot detect. Without training any auxiliary networks, our continuous gripper-gradient model and 0.3 ms dual-arm FK lookahead state machine handle both actuator limits and cloth dynamics.
5. Conclusion: The Boundary of Time-Axis Compression and What Comes Next
In this post, we walked through the three walls we encountered when accelerating action-chunk playback to 1.5–2.0x on physical bimanual towel folding, along with each solution:
- Wall 1 (Gripper closing lag and jitter-induced pseudo-curvature): Combining a continuous current-gripper gradient cap, post-close settle hold, and backward lookahead ramp with a 9-point Savitzky-Golay pre-filter + C2-blended MVC speed planner established smooth, on-target fast playback.
- Wall 2 (~3 mm upward air-grasp shift from expanded servo lag): Closed-form state-lag compensation—preserving the 1x steady-state lag fraction () rather than erasing lag—cut pile towel folding completion time by 26.8% (78.3 s → 57.4 s) with zero tabletop presses and zero retraining or controller changes.
- Wall 3 (1-second chunk exhaustion and cloth inertia at 2.0x): Fine-tuning a 2-second chunk horizon () under a mixed delay distribution and capping only the first half-fold to 1.0x via dual-arm FK lookahead raised round-table towel folding success rate from 58.0% → 70.0% (+12.0 points) over its 1.0x control while cutting completion time by 21.1% (80.9 s → 63.8 s mean; 80.7 s → 57.9 s median).
Just as importantly, these experiments drew a crisp empirical boundary between what test-time time-axis compression can accelerate and what it cannot. Unloaded reaching, approaching and grasping corners, aerial re-grasping and unfolding, and even the stiffer doubled second fold can all be pushed up to 2.0x simply by re-timing 1.0x trajectories. Carrying a thin, wide sheet of cloth across a large arc in the first half-fold cannot: compressing time alone flings the cloth by inertia and ruins the fold line.
Speeding up even that final phase requires going beyond playing 1x demonstrations faster—it requires the policy itself to discover, through physical trial and error such as reinforcement learning, trajectory shapes that move fast without whipping the cloth. Cleanly separating the seconds we can wring out via test-time control from the physical motions that only learning can reshape gives us a solid foundation for our next stage of research.
Working right alongside operating linen-supply production lines, our team tackles problems sitting at the intersection of physical dynamics, control engineering, and machine learning with data and first-principles math. If you enjoy digging past off-the-shelf recipes to ask "why did the gripper close 3 mm high on the real robot?" and "why does zeroing out lag make the arm press the table?"—and turning those answers directly into factory-floor hourly profit—please reach out through our careers page. Come fold towels with us.
References
- [1]Kevin Black, Noah Brown, Danny Driess, et al. (Physical Intelligence). : A Vision-Language-Action Flow Model for General Robot Control. arXiv:2410.24164, 2024.
- [2]Physical Intelligence, Kevin Black, Noah Brown, et al. : a Vision-Language-Action Model with Open-World Generalization. arXiv:2504.16054, 2025.
- [3]Kevin Black, Allen Z. Ren, Michael Equi, and Sergey Levine. Training-Time Action Conditioning for Efficient Real-Time Chunking. arXiv:2512.05964, 2025.
- [4]Nadun Ranawaka Arachchige, Zhenyang Chen, Wonsuhk Jung, et al. SAIL: Faster-than-Demonstration Execution of Imitation Learning Policies. arXiv:2506.11948, CoRL 2025.
- [5]Sunwoo Kim, Jeongjun Kim, and Joseph J. Lim. RACE: Time Optimal Execution of Action Chunk Policies Beyond Demonstration Speed. ICLR 2026 (OpenReview: INsLvSCJ4z).
- [6]Mimo Shirasaka, Takehiko Ohkawa, Takuya Okubo, Nicola Scianca, Tatsuya Matsushima, and Kei Ota. RoboPace: Contact-Aware Time-Optimal Retiming for Action-Chunk Policies. arXiv:2610.09696, 2026.
- [7]Lingxiao Guo, Zhengrong Xue, Zijing Xu, and Huazhe Xu. DemoSpeedup: Accelerating Visuomotor Policies via Entropy-Guided Demonstration Acceleration. arXiv:2506.05064, CoRL 2025.
- [8]Taewook Nam, Junmo Cho, Youngsoo Jang, and Sung Ju Hwang. SpeedAug: Policy Acceleration via Tempo-Enriched Policy and RL Fine-Tuning. arXiv:2512.00062, 2025.
- [9]Omotenashi Robotics (Kanta Sugiyama). Folding Towels, Measured in Yen per Hour. Omotenashi Robotics Research, 2026.

We are hiring ML engineers
We judge research not by novelty, but only by whether it moved the goal that matters. If that sounds like your research culture, a conversation is enough to start. We also take enquiries about joint research and technical partnerships here.
Cite this article
BibTeX. Paste it straight into your reference manager.
@misc{omotenashi-action-chunk-fast-playback-2026,
author = {Kanta Sugiyama},
title = {Accelerating Robot Motion Without Losing Success Rate: Three Walls We Hit in Fast Action-Chunk Playback and How We Solved Them},
year = {2026},
url = {https://omotenashi-robotics.com/en/research/action-chunk-fast-playback},
note = {Omotenashi Robotics Research}
}