Action Chunking Transformer on ALOHA: Bimanual Imitation Learning vs Diffusion Policy (2026)

A robot that picks up a cube is a solved problem. A robot that threads a zip tie, slots a battery into a tight holder, or pops the lid off a cup using two hands is not, and for years the reason was less about hardware than about how policies were trained. Standard behavior cloning predicts one action per timestep. Tiny errors compound, the robot drifts off the demonstration distribution, and fine-grained tasks collapse. The action chunking transformer (ACT) attacked this problem with a deceptively simple idea: predict a whole block of future actions at once, and run the policy far less often than the robot moves.

Paired with the low-cost ALOHA teleoperation rig, ACT reached 80 to 90 percent success on tasks that earlier baselines almost never completed, using about ten minutes of demonstrations per task. This article explains exactly how it works, which design choices carry the weight, how it differs from Diffusion Policy, and how to decide between them in 2026.

What this covers: the ALOHA hardware, the ACT architecture and its conditional VAE, temporal ensembling, the verified numbers from the paper, a head-to-head comparison with Diffusion Policy and flow-based successors, running ACT in LeRobot, failure modes, and a practical checklist.

Context and Background

Imitation learning, also called learning from demonstration, trains a policy to reproduce what a human did. The simplest form is behavior cloning (BC): collect observation and action pairs, then fit a network with supervised learning. It is attractive because it needs no reward function and no simulator. For industrial and IoT-connected robotics, where a technician can demonstrate a task in minutes, that is a large practical advantage.

The weakness is compounding error. A BC policy sees only states from human demonstrations, yet at test time its own small mistakes push it into states the demonstrator never visited. In fine-grained manipulation, a 5 mm error at the wrong moment means a missed insertion. The classic remedies, such as DAgger-style interactive correction, need a human in the loop during training. Another remedy is to cut the effective horizon of the problem, and that is where action chunking enters.

The second obstacle was hardware cost. High-quality bimanual manipulation traditionally required expensive arms and calibrated force sensing. The ALOHA system, short for A Low-cost Open-source Hardware System for Bimanual Teleoperation, changed the economics. According to the original paper, it uses two ViperX 6-DoF follower arms at roughly $5,600 each and two WidowX leader arms at roughly $3,300 each, for a total of about $18,000 (about $20,000 with add-ons). Both ACT and ALOHA were introduced together in “Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware” by Tony Zhao and colleagues, presented at Robotics: Science and Systems 2023 (arXiv 2304.13705).

Since then the field has moved quickly. Diffusion Policy (Chi et al., arXiv 2303.04137) modeled action distributions with denoising diffusion and reported an average 46.9 percent improvement over prior methods across 12 tasks from four benchmarks. Large vision-language-action models such as pi0 adopted flow matching with chunked outputs. And the open-source LeRobot library made ACT a few-line command for anyone with a dataset. If you are tracking that ecosystem, our guide to Diffusion Policy for robot manipulation covers the denoising side in depth, and the LeRobot v0.6 vs v0.5 migration guide covers the tooling changes you will hit when running ACT today.

The thesis of this article is narrower than “ACT versus diffusion, pick a winner.” ACT’s real contribution is not the transformer; it is a control-frequency decoupling trick. Once you understand that, you can reason about every successor, including diffusion and flow policies, as variations on the same chunking theme with different answers to a single question: how do you represent a distribution over chunks?

How the Action Chunking Transformer Works

An action chunking transformer is an imitation learning policy that predicts k future joint-position targets in one forward pass, instead of one action per step. Trained as a conditional variational autoencoder on teleoperated demonstrations, it executes the chunk open-loop and blends overlapping predictions with temporal ensembling, cutting the effective task horizon by a factor of k.

Figure 1: ACT architecture. The CVAE encoder exists only at training time; at test time the style variable z is set to zero and the transformer decoder maps images and joint state to a chunk of 100 actions.

Figure 1 shows the data flow. Four RGB cameras and 14 joint positions (seven per arm, including the gripper) enter the policy. A ResNet18 processes each 480 by 640 image into a 15 by 20 feature map with 512 channels, which is flattened to 300 tokens and given 2D sinusoidal position embeddings. Image tokens, the joint-state token, and a latent token feed a transformer encoder. A transformer decoder then uses a fixed set of learned query positions, one per future timestep, to cross-attend to that encoding and emit the actions. In the original configuration the encoder has four layers and the decoder seven, with a hidden dimension of 512, feedforward dimension of 3200, and eight attention heads. The authors report roughly 80 million parameters, training from scratch per task in about five hours on a single 11 GB RTX 2080 Ti, and an inference time of about 0.01 seconds.

Why predict chunks: the horizon argument

The core argument is arithmetic. ALOHA records at 50 Hz, so a task lasting 20 seconds has 1,000 steps. A one-step policy must make 1,000 correct decisions in sequence, and every error feeds the next observation. If the policy predicts chunks of k = 100 and executes them open-loop, it makes only 10 decisions. Errors still occur inside a chunk, but they do not compound through observation feedback until the next replanning point.

There is a second benefit that is easy to miss. Human demonstrators pause, hesitate, and move in non-Markovian ways: the same visual state may lead to “wait” or “go” depending on what happened a second ago. A single-step policy that sees only the current frame cannot tell these apart, and it averages the behaviors or oscillates. A chunk-predicting policy commits to a whole trajectory segment, which resolves much of that ambiguity without needing a long observation history.

The ablation in the paper quantifies this. Averaged over four settings with no temporal ensembling, success rises from 1 percent at k = 1 to 44 percent at k = 100, then tapers, with dips at k = 200 and k = 400. Chunking also helped the BC-ConvMLP and VINN baselines, which suggests the gain comes from chunking itself rather than from the transformer. That point matters later, because it explains why diffusion and flow policies adopted the same trick.

Why a CVAE: modeling the demonstrator’s style

Human data is noisy and multimodal. Two operators, or one operator on two attempts, may reach the same object along different paths and at different speeds. If you regress an action chunk with a plain L1 or L2 loss, the model learns something close to the average or the median of those modes, which can be a motion nobody performed.

ACT trains as a conditional variational autoencoder. A BERT-style transformer encoder reads the joint positions and the target action sequence plus a learned [CLS] token, and predicts the mean and variance of a latent “style” variable z. The paper’s figure shows a 32-dimensional diagonal Gaussian. The decoder policy conditions on z, the images, and the joint state to reconstruct the action chunk. The loss is L1 reconstruction plus a KL term weighted by beta = 10. At test time, the encoder is discarded and z is set to the zero vector, the mean of the prior, so inference is deterministic.

Is this component essential? The authors’ ablation says it depends on the data. On scripted demonstrations, which are perfectly consistent, removing the CVAE costs only about 1 percentage point. On human demonstrations, success drops from 35.3 percent to 2 percent, a loss of 33.3 points. The CVAE lets the model absorb variability in the data into z instead of corrupting its deterministic output. For anyone collecting real teleoperated data, treat it as required.

Why L1 and absolute joint targets

Two smaller choices are worth noting. The paper reports that an L1 loss produced more precise action modeling than L2, which is consistent with L1’s lower sensitivity to outliers in noisy human data. And actions are absolute target joint positions for both arms (14 dimensions), not end-effector deltas. Joint-space targets map directly onto the leader-arm readings, so there is no inverse kinematics step and no singularity handling. The cost is portability: a policy trained on one arm geometry does not transfer to another without retraining.

ALOHA Hardware and the Teleoperation Pipeline

ACT is only as good as its demonstrations, and ALOHA’s design is built around producing high-quality ones cheaply.

Figure 2: ALOHA data pipeline. Leader arms drive follower arms in joint space; images and joints are recorded together, used to train ACT, and the trained policy later takes the place of the human at the leader arms.

The follower arms are two ViperX 6-DoF arms with a 750 g payload, about 1.5 m span, and 5 to 8 mm accuracy, fitted with parallel-jaw grippers whose 3D-printed “see-through” fingers wear grip tape. The leader arms are two smaller WidowX arms. The operator moves the leaders, and the system maps leader joints directly to follower joints. A 3D-printed handle with a scissor mechanism operates the gripper, and rubber bands provide gravity compensation so the operator does not tire. Four Logitech C922x webcams record 480 by 640 RGB: two wrist-mounted, one front, one top. Teleoperation and recording run at 50 Hz, while the cameras stream at 30 fps.

Two properties make this setup good for learning. First, joint-space mapping means the recorded action is exactly the command the follower received, so there is no mismatch between what the human did and what the policy must output. Second, because the human sees the real arms through their own eyes while the policy sees only the four cameras, the demonstrations carry the dexterity of a human with immediate physical feedback, yet the data contains no force sensing. ACT learns to act from vision and proprioception alone.

The paper used 50 demonstrations per real task (100 for Thread Velcro), amounting to about 10 to 20 minutes of data per task. Simulated tasks used 50 scripted and 50 human demonstrations. That data efficiency is the headline for practitioners.

ALOHA 2 and Mobile ALOHA

The hardware did not stand still. ALOHA 2 (arXiv 2405.02292) improved ergonomics and robustness. The leader gripper moved from a scissor design to a low-friction linear rail, dropping the opening force from 14.68 N to 0.84 N, about a tenfold reduction. Follower closing force at the fingertip rose from 12.8 N to 27.9 N. Rubber-band gravity compensation gave way to adjustable passive retractors; in a six-user study, operators averaged 1.38 shapes per minute with passive compensation versus 0.97 with an active software approach. The frame was rebuilt from 20 by 20 mm aluminum extrusions, and the webcams were replaced with four Intel RealSense D405 cameras recording 848 by 480 RGB. The authors also released a MuJoCo Menagerie model of the workcell, with system identification from 11 real trajectories. The ALOHA 2 paper gives no dollar total, so we make no cost claim for it.

Mobile ALOHA (arXiv 2401.02117) placed the bimanual rig on a wheeled base for whole-body teleoperation, and showed that co-training behavior cloning on new mobile data together with existing static ALOHA datasets raised success rates by up to 90 percent, using 50 demonstrations per task on tasks such as sautéing shrimp, storing cookware in a cabinet, and calling and entering an elevator. That co-training result is a useful reminder: ACT-style policies benefit from pooled data across related tasks, a pattern that later became standard.

Temporal Ensembling and Execution

Chunking introduces a cost. If the policy plans 100 steps and executes all 100 without looking again, it cannot react to a slip in step 5. The opposite extreme, replanning every step and executing only the first action, restores reactivity but produces jerky motion because consecutive chunks may disagree about the plan.

Figure 3: Temporal ensembling. The policy is queried at every timestep, so several overlapping chunks each hold a prediction for the current step; they are blended with exponentially decaying weights.

ACT’s answer is temporal ensembling. The policy is queried every timestep, so at time t there are several chunks that each include a prediction for time t, made at different earlier steps. The executed action is a weighted average of those predictions, with weights w_i = exp(-m * i), where i is the age of the prediction. If m is small the average favors the oldest prediction equally, giving very smooth motion; a larger m favors the freshest prediction and restores responsiveness. The paper defines the weighting but, in the text we reviewed, gives no numeric value for m, so tune it yourself.

The benefit of the blending is smoothness, and it is modest in measured terms. In the paper’s ablation, temporal ensembling improved ACT by 3.3 percentage points and BC-ConvMLP by 4, but hurt VINN by 20. Ensembling assumes the chunks are similar enough to average; for a nearest-neighbor method like VINN, averaging across different retrieved trajectories blends incompatible plans.

Chunk size versus reactivity

The right k is task-dependent. Larger chunks reduce compounding error and decision frequency but increase open-loop exposure. In LeRobot, the ACT default sets chunk_size = 100 and n_action_steps = 100, with temporal ensembling disabled (temporal_ensemble_coeff is None). This default executes the whole chunk and then re-queries, which is the simplest scheme and works well when the scene is static. If you enable temporal ensembling, LeRobot requires n_action_steps = 1, because the policy must be queried every step, and your inference loop must run fast enough to do so.

A related lesson applies to all chunked policies: the replanning boundary is where failures concentrate. Newer work targets exactly this. Bidirectional Decoding (arXiv 2408.17355) samples many candidate chunks at each step and selects one that is backward-coherent with the previous chunk and forward-contrastive against a weaker checkpoint. The authors report about a 32 percent relative improvement over the vanilla baseline in simulation, and about 46 percent when combined with exponential moving average smoothing. Real-Time Chunking (arXiv 2506.07339) addresses inference latency in diffusion and flow policies by generating the next chunk while the current one runs, freezing the actions guaranteed to execute and inpainting the rest. Both are inference-time fixes that leave the trained policy unchanged.

What the Numbers Show

All figures in this section come from the ACT paper unless stated otherwise. Each cell is a success rate in percent, and tasks are staged, so later columns measure deeper progress.

Task (stage)	BC-ConvMLP	BeT	RT-1	VINN	ACT
Sim cube transfer, scripted (transfer)	1	27	2	3	86
Sim cube transfer, human (transfer)	0	1	0	0	50
Sim bimanual insertion, scripted (insert)	1	3	1	1	32
Sim bimanual insertion, human (insert)	0	0	0	0	20
Real slide Ziploc (open)	0	0	0	0	88
Real slot battery (insert)	0	0	0	0	96

Real-world results in the second table compare ACT to BeT only. ACT reached 84 percent on Open Cup (open lid), 20 percent on Thread Velcro (insert), 64 percent on Prep Tape (hang), and 92 percent on Put On Shoe (secure), versus 0 percent for BeT at the final stage on all four.

Three points deserve emphasis. First, the baselines nearly always scored zero on real tasks, so the comparison measures a gap between “can attempt” and “can finish.” Second, the hardest tasks remain hard: Thread Velcro tops out at 20 percent and simulated bimanual insertion at 32 and 20 percent. ACT is strong, not magic. Third, a control-frequency user study with six participants found that dropping teleoperation from 50 Hz to 5 Hz increased task time by 62 percent, which supports the choice of high-rate control and, by extension, the chunking trick, since a chunked policy can output high-rate actions while querying at a lower rate.

A caution about methodology. The baselines in this paper were implemented by the authors under their own tuning budget, the sample counts are small (success rates in multiples of the trial count), and later papers have reported ACT results on different task suites with different protocols. Do not compare numbers across papers without checking trial counts, demonstration quality, and whether the policy was trained per task or multitask.

Action Chunking Transformer vs Diffusion Policy

ACT and Diffusion Policy are often presented as rivals. They are better understood as siblings: both predict action chunks and use receding-horizon execution. They differ in how they model the distribution over those chunks.

ACT uses a CVAE with a single latent z set to zero at inference. The decoder is deterministic, so ACT models one mode per z. Diffusion Policy trains a denoiser, and at inference it starts from Gaussian noise and iteratively refines it into an action sequence conditioned on observations. Sampling different noise gives different modes, so it represents multimodality natively and can produce distinct but valid solutions.

Horizons, steps, and latency

Diffusion Policy’s reported settings are shorter in horizon. For the CNN variant, the prediction horizon is Tp = 16, the action horizon Ta = 8, and the observation horizon To = 2 for most simulated tasks; the authors state that an action horizon of 8 was optimal for most tasks they tested. ACT’s chunk of 100 is far longer. On the denoising side, the paper trains with 100 diffusion iterations, and uses DDIM to reduce inference to about 10 iterations, giving roughly 0.1 s latency on an Nvidia 3080 in Section 3.4 (the appendix lists 16 iterations for real-world runs, so the paper is not fully consistent on this point). ACT’s roughly 0.01 s forward pass is about an order of magnitude cheaper, though the two numbers come from different hardware and different model sizes, so treat the comparison as indicative.

Figure 4: A practical decision flow. Start from how multimodal your demonstrations are and how much inference latency you can afford.

Where each wins

Diffusion Policy reported 95 percent on real-world Push-T, against 0 percent for IBC and 20 percent for LSTM-GMM, and its simulated Push-T state-based score of 0.95 beat BeT at 0.79. Those are strong results on tasks with clear multimodality, such as pushing an object around an obstacle from either side. The ACT paper did not benchmark against Diffusion Policy, and the Diffusion Policy paper does not mention ACT or ALOHA, so no head-to-head number exists in these two primary sources. Any claim that one beats the other in general should be treated as unverified; later independent comparisons exist but vary by task suite and tuning effort.

Criterion	ACT	Diffusion Policy	Flow-based VLA with chunking
Chunk length (reported)	100	8 executed of 16 predicted (CNN variant)	Task dependent, not verified here
Multimodality	Via CVAE latent, zero at test time	Native, through sampling	Native, through sampling
Inference cost	Single forward pass	Iterative, about 10 to 16 steps	Iterative, fewer steps typical
Data needed	About 50 demos per task in the paper	Task dependent	Large pretraining plus fine-tuning
Hyperparameter sensitivity	Moderate	CNN robust, transformer sensitive	Higher
Typical choice when	Fast, per-task bimanual with clean data	Strongly multimodal behavior	Language-conditioned generalist

The honest summary: use ACT when you want a small, fast, stable baseline with a modest dataset, and consider diffusion or flow policies when your demonstrations are strongly multimodal or when you plan to scale to many tasks and language conditioning. The authors of Diffusion Policy recommend beginning with their CNN variant and note that the transformer variant can perform better on tasks with sharp or high-rate action changes but is more sensitive to hyperparameters.

Running ACT in LeRobot

LeRobot (Hugging Face) provides a reference ACT implementation and pretrained checkpoints. Its default configuration mirrors the paper: resnet18 backbone, dim_model 512, 8 heads, feedforward 3200, four encoder layers, latent_dim 32, a four-layer VAE encoder, kl_weight 10.0, learning rate 1e-5 for both the policy and the backbone, and dropout 0.1. One detail will surprise readers of the paper: the default n_decoder_layers is 1, not 7. The LeRobot source explains that the original code has a bug in which only the first decoder layer is used, so one layer matches the original’s effective behavior. If you compare parameter counts, note that the LeRobot model card for the simulated insertion checkpoint lists 51.7M parameters, not the 80M cited in the paper, which is consistent with a lighter decoder.

The official model card for lerobot/act_aloha_sim_insertion_human gives the following commands. The checkpoint was trained for 100k steps in about 1 hour 50 minutes on an NVIDIA A100, and the card reports a 20.6 percent success rate over 500 evaluation episodes, close to the 20 percent in the paper.

python lerobot/scripts/train.py \
    --output_dir=outputs/train/act_aloha_insertion \
    --policy.type=act \
    --dataset.repo_id=lerobot/aloha_sim_insertion_human \
    --env.type=aloha \
    --env.task=AlohaInsertion-v0 \
    --wandb.enable=true

python lerobot/scripts/eval.py \
    --policy.path=outputs/train/act_aloha_insertion/checkpoints/last/pretrained_model \
    --output_dir=outputs/eval/act_aloha_insertion/last \
    --env.type=aloha \
    --env.task=AlohaInsertion-v0 \
    --eval.n_episodes=500 \
    --eval.batch_size=50 \
    --device=cuda \
    --use_amp=false

Script paths and flag names change between LeRobot releases, which is why the migration guide linked above is worth reading before you copy commands into a pipeline. Your own data should be stored in the LeRobot dataset format; the LeRobot dataset v3 chunked Parquet streaming article explains how episodes, video, and metadata are laid out, which directly affects dataloader throughput for ACT’s four-camera input.

A minimal inference loop with temporal ensembling

The sketch below is illustrative, not copied from a library. It shows how a policy queried every step maintains a buffer of overlapping predictions and blends them with the exponential weights from the paper. The value of m is a placeholder to tune.

import numpy as np

class TemporalEnsembler:
    def __init__(self, chunk_size=100, action_dim=14, m=0.01):
        self.k, self.m = chunk_size, m
        self.buf = np.zeros((10_000, chunk_size, action_dim))
        self.valid = np.zeros(10_000, dtype=bool)

    def step(self, t, chunk):
        # chunk: (k, action_dim), prediction made at time t
        self.buf[t] = chunk
        self.valid[t] = True
        ages = np.arange(0, self.k)             # age of each prediction
        idx = t - ages                           # chunks that cover time t
        keep = (idx >= 0) & self.valid[np.clip(idx, 0, None)]
        w = np.exp(-self.m * ages[keep])
        preds = np.stack([self.buf[i][a] for i, a in zip(idx[keep], ages[keep])])
        return (w[:, None] * preds).sum(0) / w.sum()

In practice, you query the network once per control tick, pass its output to step, and send the blended 14-D vector to the arms. Note the cost: with k = 100 you run the full network every 20 ms at 50 Hz. The reported 0.01 s inference time on a 2080 Ti makes that feasible, but your camera pipeline and image preprocessing must fit in the remaining budget.

Trade-offs, Gotchas, and What Goes Wrong

Open-loop blindness. A 100-step chunk is two seconds at 50 Hz. If an object slips or a person moves a part during that window, the policy will not know until the next query. Tasks with disturbances need shorter n_action_steps, temporal ensembling, or inference-time methods such as Bidirectional Decoding or Real-Time Chunking.

Smoothness versus reactivity. Ensembling smooths motion but delays response to new information, since stale predictions retain weight. Setting m too low makes the robot sluggish after a grasp failure; too high brings back the jitter. There is no universal value, and the paper does not give one in the text we reviewed.

Deterministic output on multimodal data. With z fixed at zero, ACT commits to one behavior. If your demonstrations split into two equally valid strategies and the CVAE does not cleanly separate them, the policy can pick a mode inconsistently across chunk boundaries, producing hesitation. Diffusion-style sampling handles this more gracefully, though it brings its own boundary-consistency issues.

Data quality dominates. The CVAE ablation shows human data is where the architecture earns its keep, and the same sensitivity applies to everything else: operator fatigue, inconsistent speed, and failed demonstrations kept in the dataset all degrade results. The ALOHA 2 authors recommend a break of at least two minutes about every ten minutes of teleoperation, a detail that sounds trivial and is not. Filter episodes aggressively.

Per-task training. The paper trains from scratch per task. Co-training results from Mobile ALOHA show pooling data helps, but a single ACT checkpoint is not a generalist. Language conditioning and cross-embodiment transfer are the territory of larger VLA models, and the 80 million parameter ACT is not designed for it.

Hardware coupling. Absolute joint targets bind the policy to one kinematic structure. Changing arms, camera placement, or even gripper fingers invalidates the visual and action mappings. Camera calibration drift is a common silent failure: a wrist camera knocked by a collision shifts every feature map the ResNet produces.

No force feedback. The system learns from vision and joint position only. Tasks that depend on contact forces, such as tight insertions, succeed through visual cues and compliance in the hardware. This explains the lower insertion numbers (20 to 32 percent in simulation, 20 percent on Thread Velcro) and why a vision-only policy plateaus there.

Benchmark portability. Success rates measured on a specific rig, lighting, and object set rarely carry over. The paper’s own variance across stages shows how quickly success decays: Prep Tape falls from 96 percent at grasp to 64 percent at hang. Plan for staged evaluation on your own setup rather than quoting a single headline figure.

Practical Recommendations

If you are starting a bimanual project in 2026, begin with the simplest credible baseline and invest in data before architecture. ACT is that baseline: small enough to train on a single consumer GPU, fast enough for 50 Hz control, and supported by an open reference implementation. Reserve diffusion or flow policies for the moment ACT’s failures are demonstrably about multimodality rather than data quality.

Collect demonstrations deliberately. Use a consistent operator workflow, vary object placement systematically across the workspace, and discard failures. Fifty well-chosen episodes beat two hundred sloppy ones, a pattern consistent with the 50-demo regime in both the ACT and Mobile ALOHA papers. Use the same camera mounts across sessions and record calibration notes.

For deployment, treat chunk size and execution mode as tunable hyperparameters, not constants. Start from the paper and LeRobot defaults, measure on your task, and change one thing at a time. Log every replanning boundary during evaluation, because that is where most failures cluster. If latency becomes the bottleneck, look at asynchronous execution and inference-time chunk stitching before replacing the model.

Finally, keep the safety envelope outside the learned policy. A transformer that outputs joint targets has no notion of workspace limits, so clamp velocities and joint ranges in the controller, and make the emergency stop independent of the model.

Checklist before you train and deploy:

Confirm 50 Hz recording with timestamps aligned across cameras and joints.
Collect at least 50 clean demonstrations per task and review them for consistency.
Keep the CVAE enabled for human-collected data.
Start with chunk_size 100 and tune n_action_steps and temporal ensembling on your task.
Evaluate with staged success metrics, not a single pass or fail.
Add controller-level joint and velocity limits independent of the policy.
Record camera calibration and lock mounts.
Benchmark against a diffusion or flow baseline only after fixing data issues.

Frequently Asked Questions

What is an action chunking transformer?

An action chunking transformer, or ACT, is an imitation learning policy that predicts a block of future robot actions in a single forward pass rather than one action at a time. It uses a transformer decoder inside a conditional VAE and was introduced alongside the ALOHA hardware. Predicting chunks of 100 steps shortens the effective task horizon, which reduces the compounding errors that plague single-step behavior cloning.

What does ALOHA stand for, and how much does it cost?

ALOHA stands for A Low-cost Open-source Hardware System for Bimanual Teleoperation. According to the original paper, two ViperX follower arms cost about $5,600 each and two WidowX leader arms about $3,300 each, giving a total near $18,000, or about $20,000 with add-ons. The ALOHA 2 paper gives no total price, so current costs should be checked with vendors.

Is ACT better than Diffusion Policy?

Neither primary paper compares against the other, so no verified head-to-head number exists. ACT is smaller and faster, with a single forward pass reported at about 0.01 seconds, while Diffusion Policy models multimodal action distributions natively through iterative denoising. Choose ACT for a fast, stable per-task baseline and diffusion when demonstrations split into distinct valid strategies or when you need the added expressiveness.

What is temporal ensembling in ACT?

Temporal ensembling queries the policy at every timestep so that several overlapping chunks each predict the current action. The executed action is their weighted average, with weights exp(-m times age). It smooths motion and, in the paper’s ablation, improved ACT by 3.3 percentage points. It requires running inference at control rate, and the value of m trades smoothness against responsiveness.

How many demonstrations does ACT need?

The original paper used 50 demonstrations per real task, or 100 for Thread Velcro, equal to roughly 10 to 20 minutes of data, and the same number of scripted and human demonstrations in simulation. Mobile ALOHA also used 50 demonstrations per task. These numbers assume consistent, clean teleoperation; noisy data or higher task variability will require more.

Can ACT run in real time on modest hardware?

The paper reports about 0.01 seconds inference on an 11 GB RTX 2080 Ti, with training around five hours on that card for a roughly 80 million parameter model. That supports running at 50 Hz if image preprocessing and camera I/O are efficient. In LeRobot, the default executes a full chunk before re-querying, which lowers the compute demand further.

ACT Action Chunking Transformers and ALOHA: Bimanual Imitation Learning vs Diffusion Policy (2026)