Action tokenizers let robot policies treat control as autoregressive next-token prediction. As these policies are trained on larger and more diverse datasets, they will need a universal tokenizer that can encode actions from many embodiments and data sources, including ones it has not seen. We study action tokenization at scale, training on 49k hours of action data from real-world robots, handheld grippers, simulation, and humans. We introduce Neural Action Tokenizer (NAT), a causal tokenizer whose decoder lets actions be executed as their tokens are generated.
Across four simulation benchmarks, NAT outperforms FAST and prior neural action tokenizers when tokenizing unseen robot embodiments, and in vision-language-action models it outperforms FAST+ across four benchmarks and on a real robot when acting through its tokens. NAT tokens also close the performance gap to a flow-matching action head on some benchmarks while lowering the inference latency for first actions. Our experiments also find that robot data may not be necessary to learn an effective action space: a NAT trained only on human hand motion performs close to tokenizers trained on robot data.
Contributions
- State-of-the-art neural action tokenization. NAT outperforms FAST and prior neural action tokenizers (OAT, ActionCodec, and NAC) in mean success on unseen robot embodiments.
- A universal streaming action tokenizer. We train NAT on 49k hours of actions from real-world robots, handheld grippers, simulation, and humans, yielding a tokenizer for diverse action data. Its causal decoder supports immediate execution, and its time-ordered tokens let a policy condition its next chunk on the actions still executing without retraining.
- Human data for action tokenizers. Our experiments suggest that robot data may not be necessary to train an action tokenizer: a NAT trained only on human hand motion is nearly as effective as one trained on all sources.
- Pretraining vision-language-action models with NAT tokens. We show that NAT tokens can help pretrain vision-language-action models: further training a pretrained vision-language model on 1.8k hours of robot data through NAT tokens, before fine-tuning, raises mean success on four simulation benchmarks over fine-tuning the vision-language model directly.
- Flow action heads and action tokens. Acting through NAT tokens produces first actions sooner than acting through a flow-matching action head, and on some benchmarks matches its success: on LIBERO, the two are within the 95% intervals.
Method
NAT flattens an action chunk into a one-dimensional signal, encodes it with a causal convolutional encoder, and quantizes the latents with multi-scale FSQ into coarse-to-fine tokens. Tokens are emitted in time order, so the causal decoder can turn the first group of tokens into the first actions while the policy is still generating the rest of the chunk.

Varying action dimensions. Robots differ in their number of action dimensions, while NAT encodes chunks of a fixed width. Each action vector is split into groups of at most 7 dimensions, one per arm where the dataset defines arms and consecutive dimensions otherwise, and each group is tokenized as its own chunk.

Streaming and real-time chunking. As soon as the tokens of a latent are generated, NAT decodes that latent's actions and the robot executes them, while the policy continues generating the rest. While the policy predicts the next chunk, the robot keeps executing the current one, so the next chunk must continue from the actions that run in the meantime. Because the tokens are ordered in time and the decoder is causal, this works through the tokens alone: NAT encodes the actions still executing as the start of a new chunk, their first tokens form a fixed prefix, and the policy generates only the remaining tokens from the new observation. The robot then switches to the new chunk with less of a jump (Table 8), without any change to training or sampling.

Data
The corpus has 49k hours (5.5B action frames) from 156 datasets: real-robot teleoperation, simulation, handheld grippers (UMI), and human hands. Each dataset is normalized per dimension to [−1, 1]. The corpus excludes the evaluation robots (Franka Panda and Sawyer), so the tokenizers are not trained on them.


Results
Comparison with prior action tokenizers
With one cross-embodiment policy per tokenizer, NAT has the highest mean success (47.0%), ahead of FAST (43.4%), the other neural tokenizers (29.0–40.9%), and the diffusion policy (35.9%). NAT is best on LIBERO-Long and RoboCasa, FAST on Meta-World, and OAT on RoboMimic. OAT and NAC solve under 10% of Meta-World, whose actions fill a small part of the normalized range and so magnify reconstruction error. With a LIBERO-only policy (Table 2), NAT reaches 77.9% (FAST: 66.2%).
| Method | LIBERO-Long | Meta-World | RoboMimic | RoboCasa | Mean |
|---|---|---|---|---|---|
| NAT (ours) | 74.4 ± 3.8 | 38.2 ± 6.6 | 38.6 ± 2.5 | 36.8 ± 3.3 | 47.0 ± 1.5 |
| FAST | 68.6 ± 0.7 | 39.4 ± 1.4 | 35.1 ± 3.4 | 30.8 ± 7.9 | 43.4 ± 1.7 |
| OAT | 70.3 ± 2.9 | 9.2 ± 3.1 | 40.0 ± 3.7 | 26.8 ± 4.7 | 36.6 ± 2.3 |
| ActionCodec | 61.8 ± 3.8 | 32.2 ± 2.3 | 39.1 ± 1.6 | 30.5 ± 4.5 | 40.9 ± 1.6 |
| NAC | 57.2 ± 1.3 | 7.9 ± 2.5 | 26.1 ± 4.2 | 25.0 ± 2.3 | 29.0 ± 1.2 |
| Diffusion Policy | 57.5 ± 4.6 | 31.8 ± 4.3 | 29.2 ± 3.5 | 25.2 ± 5.0 | 35.9 ± 2.6 |
Tokens and generation rate. On LIBERO, which runs at 20 Hz, one second of action takes 9 tokens with the universal NAT, 24 with FAST+ (2.8× more), and 140 with per-dimension binning (16× more).
What data does an action tokenizer need?
These studies train tokenizers on subsets of the corpus and evaluate them on LIBERO-Long with a fixed LIBERO-only policy.
Human data alone. Trained on human hands only, NAT keeps 74.4% and FAST, whose DCT basis is not learned, is unchanged, while OAT, ActionCodec, and NAC lose 18–33 points. NAT's reconstruction error on LIBERO grows by 22%, versus 27% for OAT and 40% for ActionCodec. A human-only NAT is also close to the all-data NAT with a cross-embodiment policy (38.0% vs. 38.5% mean success).
| Method | Recon. error | Success (%) | ||
|---|---|---|---|---|
| All | Human | All | Human | |
| NAT (ours) | 1.44 | 1.76 | 77.9 ± 1.8 | 74.4 ± 2.2 |
| FAST | 0.95 | 0.95 | 66.2 ± 2.1 | 67.0 ± 3.5 |
| OAT | 3.10 | 3.93 | 61.5 ± 1.8 | 38.6 ± 1.3 |
| ActionCodec | 2.47 | 3.45 | 58.4 ± 1.2 | 40.9 ± 2.8 |
| NAC | 2.56 | 4.04 | 57.8 ± 2.8 | 25.1 ± 1.9 |
Data mix. Every subset of source types stays within 4.1 points of the full mix and above FAST. Removing human-hand data causes the largest single-source drop (3.1 points).
| Source type | Only this type | This type removed |
|---|---|---|
| Real robot | 77.8 ± 4.0 | 75.9 ± 3.2 |
| Sim robot | – | 77.0 ± 5.1 |
| UMI | 76.0 ± 2.4 | 77.2 ± 3.6 |
| Human hands | 74.4 ± 2.2 | 74.8 ± 2.5 |
| UMI and human hands | – | 73.8 ± 2.7 |
Data amount. With the policy fixed, training NAT on 0.1% to 100% of the corpus (50 to 49k hours, same number of updates) keeps success between 74.3% and 76.4%.

Which architectural choices matter?
These ablations, unlike the other tokenizer studies, train on a 1% subset of an earlier corpus that includes the evaluation robots. Success rises from 12.9% with one FSQ scale to 75.8% with four, with no gain from eight. Replacing FSQ with NAC's residual vector quantization costs 8.8 points. We suspect two causes, not isolated here: RVQ's learned codebooks are prone to collapse, leaving codes unused, and FSQ's fixed grid makes codes that share most channel levels decode to similar latents, so a policy's confusions between them cost less, while RVQ's codes have no such structure. The ISTFT and linear output heads perform similarly (75.6% vs. 75.8%), so NAT uses the linear head, and a non-causal NAT scores 1.7 points higher, within the 95% intervals.
| Component | NAT | Success | Alternative | Success |
|---|---|---|---|---|
| Quantizer | MS-FSQ | 69.3 ± 2.2 | MS-RVQ | 60.5 ± 1.2 |
| Output head | Linear | 75.8 ± 3.6 | ISTFT | 75.6 ± 0.5 |
| Causality | Causal | 75.8 ± 3.6 | Non-causal | 77.5 ± 3.1 |
| Scales (tokens) | 1 (8) | 2 (12) | 4 (28) | 8 (60) |
|---|---|---|---|---|
| Success | 12.9 ± 0.8 | 56.3 ± 4.3 | 75.8 ± 3.6 | 74.9 ± 1.6 |
NAT VLA
Two LFM2-VL-450M VLAs are pretrained on 4.8B tokens of MolmoAct2's seven-robot data mixture (1.8k hours), which includes DROID, BC-Z, RT-1, and BridgeData V2: one with a universal NAT (4 latents, 14 tokens per chunk, 6,400 codes per scale, trained for one pass over the full zero-shot corpus) and one with FAST+, otherwise identical. On held-out data, NAT's action error under greedy decoding is 16% lower. Each is then fine-tuned jointly on four simulation benchmarks and on a real robot. Acting through tokens, NAT leads on all four benchmarks and raises mean success from 37.4% to 61.4%; on LIBERO it reaches 90.8% against 62.0% for FAST+, while on Meta-World the intervals overlap. Without robot pretraining, the NAT VLA reaches 54.9%, still above the pretrained FAST+ VLA; robot pretraining through NAT tokens adds 6.5 points (4.8 on LIBERO), with non-overlapping intervals on Meta-World and RoboMimic.
| Tokenizer | Acts via | LIBERO | Meta-World | RoboMimic | RoboCasa | Mean |
|---|---|---|---|---|---|---|
| NAT (ours) | Tokens | 90.8 ± 2.6 | 22.8 ± 2.2 | 81.2 ± 2.4 | 50.9 ± 3.3 | 61.4 |
| FAST+ | Tokens | 62.0 ± 4.2 | 20.9 ± 2.4 | 29.1 ± 2.8 | 37.6 ± 3.2 | 37.4 |
| NAT, no robot pretraining | Tokens | 86.0 ± 2.8 | 15.6 ± 1.6 | 72.5 ± 2.6 | 45.4 ± 3.1 | 54.9 |
| NAT (ours) | Flow expert | 89.2 ± 2.8 | 45.7 ± 2.5 | 89.8 ± 2.0 | 69.5 ± 3.0 | 73.6 |
| FAST+ | Flow expert | 89.0 ± 2.5 | 43.9 ± 2.5 | 84.7 ± 2.3 | 67.9 ± 3.0 | 71.4 |
Flow action head. Through a flow-matching expert trained with knowledge insulation, NAT VLA reaches 73.6% mean success and FAST+ VLA 71.4%; the intervals overlap except on RoboMimic. These runs add a mid-training stage and use MolmoAct2's post-training learning rates, so they differ from the token runs in more than the action head. The expert raises NAT's mean by 12.2 points, mostly on Meta-World and RoboCasa, and FAST+'s by 34.0. On LIBERO, NAT tokens and the expert are within the 95% intervals (90.8% vs. 89.2%). The expert adds 77.7M parameters, a mid-training stage, and a denoising process at inference, while NAT's first actions arrive sooner than a chunk from our flow head (19.0 vs. 42.0 ms) and, in our latency analysis, than the heads of GR00T N1.7 and MolmoAct2, and its tokens keep streaming and real-time chunking.
Real robot and latency


Both VLAs are fine-tuned on 481 teleoperated demonstrations; the universal NAT's corpus includes our own Trossen AI recordings. Each policy runs 10 trials per task from the demonstrations' median start pose, each scored by an operator. NAT succeeds in 55% of trials and FAST+ in 35%, leading on three of the four tasks. FAST+ is better at placing grapes (70% vs. 20%), although NAT's reconstruction error on the grape demonstrations is small (MSE 0.0005) and its policy's greedily sampled actions have lower reconstruction error than FAST+'s (MSE 0.021 vs. 0.038). In failed trials NAT VLA did not appear to lower the gripper far enough and closed above the grapes; because each chunk's 16 actions execute open loop, such an offset may go uncorrected.
| Tokenizer | Fold towel | Turn on scale | Marker in bin | Grapes on plate | Mean |
|---|---|---|---|---|---|
| NAT (ours) | 90 | 70 | 40 | 20 | 55 |
| FAST+ | 50 | 20 | 0 | 70 | 35 |
FAST+ uses 6 to 73 tokens per chunk (38.8 on average) and decodes only after the whole chunk. NAT uses 14, and its first 4 decode to 8 actions, which take 267 ms to execute at 30 Hz; the rest of the chunk, and the next one, are generated while the robot moves. NAT VLA has its first actions after 19.0 ms, 5.1× sooner than FAST+ VLA and 2.2× sooner than its own flow expert. On 3–5B models, generating NAT's first 4 tokens would take 45–101 ms, comparable to or faster than their action heads, and a full chunk 85–226 ms, under the 267 ms the first actions take to execute.
| Model | Tokenizer | Size | Per token | First actions | Full chunk (tokens) | Full chunk (flow head) |
|---|---|---|---|---|---|---|
| NAT VLA (ours) | NAT | 0.45B | 2.0 ± 0.0 | 19.0 ± 0.5* | 39.5 ± 0.6* | 42.0 ± 0.9 |
| FAST+ VLA | FAST+ | 0.45B | 2.2 ± 0.0 | 97.5 ± 37.6 | 97.5 ± 37.6 | 46.5 ± 12.6 |
| GR00T N1.7 | NAT† | 3B | 4.1 ± 0.0 | 44.7 ± 1.0 | 85.2 ± 1.0 | 56.6 ± 1.2 |
| π0.5 | NAT† | 3B | 6.5 ± 0.0 | 69.0 ± 1.7 | 134.5 ± 1.7 | 72.6 ± 0.2 |
| MolmoAct2 | NAT† | 5B | 12.6 ± 0.0 | 100.8 ± 0.3 | 226.4 ± 0.4 | 132.4 ± 1.3 |
Real-time chunking
With real-time chunking, the NAT VLAs' switches from one chunk to the next come with smaller jumps. The difference between the last executed action of a chunk and the first action of the next falls from 0.126 to 0.065 for the VLA fine-tuned on the four benchmarks and from 0.046 to 0.0096 for the robot-pretrained VLA on held-out data. A switch is still larger than the change between two actions of the same chunk.
| NAT VLA | Across a chunk switch | Within one chunk | |
|---|---|---|---|
| With RTC | Without RTC | ||
| Fine-tuned | 0.065 ± 0.007 | 0.126 ± 0.010 | 0.031 ± 0.003 |
| Pretrained | 0.0096 ± 0.0007 | 0.046 ± 0.009 | 0.0024 ± 0.0002 |
Takeaways
- A single action tokenizer can serve robots it has never seen, outperforming FAST and prior neural tokenizers without training on the evaluation robots.
- An action tokenizer may not need robot data: human hand motion alone yields a tokenizer close to one trained on all sources, so large-scale human data could be used to train action tokenizers.
- NAT tokens are an effective action representation for vision-language-action models, both for robot pretraining and for acting, where they outperform FAST+.
- Action tokens can be faster than flow action heads, and on some domains acting through tokens alone closes the performance gap to a flow head, though a gap remains on others.
Limitations and future work
Acting through NAT tokens still trails a flow-matching head on some benchmarks; further tuning and design choices, such as the token budget, decoding, and fine-tuning recipe, may close this gap fully. NAT encodes every chunk in a fixed number of tokens; a future study could set the number of tokens per chunk dynamically. NAT is also trained on a single chunk length, so tokenizing chunks of varying length remains to be explored. Our data-scaling experiment scales the tokenizer's training data while keeping the policy's LIBERO data fixed; a future study could explore the benefits of scaling the tokenizer corpus together with the policy's training corpus.
Quickstart
pip install nat-tokenizerfrom nat_tokenizer import NATActionTokenizer
tokenizer = NATActionTokenizer.from_pretrained()Resources
- Paper: ahadjawaid.com/nat-paper.
- Code: github.com/ahadjawaid/nat (MIT).
- Python package: nat-tokenizer on PyPI (MIT).
- Tokenizer weights: ahad-j/nat-tokenizer-h32-l4-c6400 on Hugging Face (MIT).
- NAT VLA: ahad-j/nat-vla-450m, robot-pretrained LFM2-VL-450M (LFM Open License v1.0), fine-tuned with the LeRobot integration (pull request, policy type nat_vla).
- Collection: all NAT models on Hugging Face.
BibTeX
@misc{jawaid2026nat,
title={NAT: Scaling Causal Neural Action Tokenizers Across Embodiments},
author={Ahad Jawaid and Alexander Swerdlow and Yu Xiang},
year={2026}
}