
The paper notes that most VLAs use vision-language backbones much smaller than frontier models; its example is the 2B Cosmos-Reason2 in GR00T N1.7. arXiv 2611.21607 (2026-11-16, Tsinghua University, Peking University, Shanghai Jiao Tong University and Galbot) presents ScaleVLA: it freezes DeepSeek-V4.1-Flash-1017, a 552B mixture-of-experts model, as the backbone, reads only features from its first half, and attaches an action DiT trained from scratch. It then compares this backbone with five backbones from 2B to 32B while keeping the action head, initialization, demonstration data and training budget the same. The authors report 45.1% mean success under LIBERO-PRO perturbations, against at most 31.3% for the smaller backbones; 87.8% on LIBERO-Goal with 10 demonstrations per task, above the 85.6% a 2B backbone reaches with 50; 9/10 in-domain successes on a real-robot charger insertion, against 4/10 for the 2B backbone; and a median latency of 215.8 ms per action chunk on RoboCasa (216 ms in the abstract) on 4 H200 GPUs, against 114.7 ms for the 2B backbone on 1 H200. All numbers below are reported by the authors [R]. This site did not run the code or reproduce any result. The paper text read here covers the main body, the conclusion and part of the references, but not Appendices A–C (training recipes, timing method, evaluation settings).
Architecture: the frozen backbone runs only its causal encoder, and the action head is trained from scratch
On the backbone side, a vision encoder turns camera images into visual tokens, and a language backbone organized as a 20-layer causal encoder and a 20-layer decoder processes them with the instruction in the model’s reference chat format. ScaleVLA runs only the causal encoder and reads the features passed to the next layer’s attention, 5120 dimensions per token. Computation stops there: the decoder never runs, and no text is generated. Tokens keep their original order and a modality label, so the action head can attend to image and non-image tokens separately. The language and visual backbones are both frozen and gradients update only the action head, so the authors compute the backbone features once in advance and reuse them during training.
The action head follows the GR00T N1.7 architecture, is initialized randomly and is trained only on robot demonstrations:
- Feature adapter: layer normalization and a two-layer linear projection map each backbone token from 5120 to 2048 dimensions, followed by a 4-layer self-attention transformer.
- Action DiT: 32 layers alternating self-attention and cross-attention. Self-attention runs over robot-state tokens and noisy action tokens; cross-attention reads the adapted backbone features, with successive cross-attention layers attending to non-image and image tokens in turn.
- Training and inference: trained with flow matching. At inference the head starts from Gaussian noise and integrates in 4 steps to produce an action chunk; all 4 steps reuse the same backbone features, so the backbone runs once per chunk. On LIBERO a chunk has 16 steps and 8 commands are executed before replanning; on DexJoCo a chunk has 30 steps, and replacement chunks are generated asynchronously while the controller executes the available actions.
Physical AI Lab 3.1 takes apart GR00T N1’s fast and slow systems and its flow-matching action head; for fine-tuning GR00T N1.7 itself, see Physical AI Lab 3.5. ScaleVLA keeps this kind of action head and replaces the backbone in front of it. The authors start from studies of GPT-6 Astra: such general-purpose models can generate robot actions directly, but in the authors’ view repeated reasoning and action review make each decision slow and costly. In this site’s article on One Policy for 100 Household Tasks, GPT-6 Astra is an agent that gets called; ScaleVLA takes only a frontier model’s internal features and does not let it reason.
What the comparison holds fixed, and what it does not
Table 1 of the paper lists the six backbones: Qwen3-VL-2B, Cosmos-Reason2-2B, Cosmos-Reason2-8B, Qwen3-VL-32B and Cosmos-Reason2-32B are dense models, and DeepSeek-V4.1-Flash-1017 is a 552B mixture-of-experts model; all sizes are total parameters of the source model. The fixed items the authors state: within each benchmark, the action DiT, its initialization and the training data are the same across backbones; the training budget and checkpoint selection rule are the same unless a training variant is marked separately; no pretrained robot-action expert is loaded; only the adapter’s input width follows the backbone.
From the paper’s tables and text, the following are not held fixed and should be kept in mind when reading the results:
- 552B is the total parameter count. A mixture-of-experts model activates only part of it per token, and the text read here does not give the activated count. The 552B backbone is also the only DeepSeek model in the table, so scale and model family change together.
- Inference hardware differs: ScaleVLA uses 4 GPUs with tensor and expert parallelism; every other backbone uses 1.
- Input token counts differ: in the RoboCasa timing, ScaleVLA receives 568 tokens per observation and the other backbones 212. The authors state that they did not isolate how much this contributes to latency.
- Not every table contains every backbone: the RoboCasa and DexJoCo tables have no Cosmos-Reason2-32B; the demonstration-count study compares only the Cosmos-Reason2 2B, 8B and 32B models with 552B; the real-robot test compares three policies.
Simulation results: gains concentrate under perturbation and with few demonstrations, and a few cells are not led
LIBERO (Table 2, each suite trained on its full demonstration set): ScaleVLA averages 96.1% over the four suites, against 94.0% for Cosmos-Reason2-32B, 93.6% for Qwen3-VL-32B, and 90.7% and 91.2% for the two 2B backbones. Spatial and Object are near saturation, and ScaleVLA’s 98.6% on Spatial is below Cosmos-Reason2-8B’s 99.8%; the differences are mainly on Goal (96.8%) and Long (90.2%). The π0, OpenVLA and CoT-VLA rows in the table are published results, not retrained under the same setup.
LIBERO-PRO (Table 3) tests the LIBERO policies above without retraining, under environment (Env.) and object (Obj.) perturbations:
| Backbone | Goal, Env. | Goal, Obj. | Object, Env. | Mean |
|---|---|---|---|---|
| Qwen3-VL-2B | 24.2 | 38.4 | 25.2 | 29.3 |
| Cosmos-Reason2-2B | 20.6 | 37.6 | 11.8 | 23.3 |
| Cosmos-Reason2-8B | 32.6 | 37.6 | 23.6 | 31.3 |
| Qwen3-VL-32B | 11.6 | 44.2 | 12.6 | 22.8 |
| Cosmos-Reason2-32B | 19.2 | 38.8 | 32.4 | 30.1 |
| ScaleVLA (552B) | 47.8 | 56.4 | 31.2 | 45.1 |
Every policy falls well below its Table 2 result. ScaleVLA’s mean of 45.1% is about 14 percentage points above the best dense backbone (Cosmos-Reason2-8B, 31.3%), and it leads in both Goal perturbation columns. Environment perturbation of the Object suite is the exception: the best entry is Cosmos-Reason2-32B at 32.4%, and ScaleVLA has 31.2%. The dense backbones do not rise steadily with size either: Qwen3-VL-32B’s mean of 22.8% is below both 2B backbones. The authors take this as evidence that frontier-model features transfer better beyond the training distribution; that is their interpretation.
RoboCasa (Table 4, out-of-distribution kitchens): with 30 and 100 generated demonstrations per task, the 2B to 32B backbones reach 22–26% and 43–46%, and ScaleVLA 30.7% and 54.9%, so the margin grows from about 5 percentage points to about 9. DexJoCo (Table 5, one policy co-trained on five bimanual dexterous-hand tasks): 42.1% average under object randomization, against at most 38.1% for the smaller backbones; 24.4% under full randomization, against at most 22.1%. Task by task, on Microwave under object randomization ScaleVLA has 73.3%, below Qwen3-VL-32B’s 89.3%; on Assembly under full randomization no backbone exceeds 1.3%.
Demonstration count (Table 7): on the Goal and Long suites, the number of demonstrations per task N is 5, 10, 25 or 50, every backbone uses the same nested subsets, and training is fixed at 5,000 steps. The 2B, 8B and 32B models are all Cosmos-Reason2:
| N | Goal 2B | Goal 8B | Goal 32B | Goal 552B | Long 2B | Long 8B | Long 32B | Long 552B |
|---|---|---|---|---|---|---|---|---|
| 5 | 39.4 | 60.6 | 61.2 | 77.4 | 24.0 | 40.0 | 37.6 | 62.2 |
| 10 | 55.0 | 70.0 | 83.0 | 87.8 | 56.0 | 65.2 | 66.4 | 75.0 |
| 25 | 85.2 | 83.0 | 90.4 | 97.6 | 69.6 | 65.6 | 83.6 | 84.6 |
| 50 | 85.6 | 88.6 | 95.2 | 95.4 | 82.4 | 87.2 | 83.8 | 86.8 |
The gap is largest with few demonstrations: at N = 5, Goal goes from 39.4% to 77.4%. The abstract’s “10 beats 50” means that 552B at N = 10 (87.8%) is above 2B at N = 50 (85.6%). With more demonstrations the gap narrows: at N = 50, 552B’s 95.4% on Goal is only 0.2 percentage points above 32B’s 95.2%, and on Long 8B’s 87.2% is slightly above 552B’s 86.8%. Note also that Table 7 gives 85.6% on Goal for 2B at N = 50, while Table 2 gives 83.2% on Goal for the same backbone trained on all demonstrations. Table 7 fixes 5,000 steps and Table 2 uses the benchmark-specific recipes of Appendix A, so the two tables have different training setups and their numbers should not be mixed.
Latency, hardware and the real robot: slower per chunk, faster at inserting the plug
Table 6 gives the median latency per action chunk on RoboCasa, timed from sending the observation to receiving the action chunk at the client (the method is in Appendix B, which this site has not read). Three of its rows:
| Backbone | GPUs | Tokens | Backbone (ms) | Action head (ms) | Total (ms) |
|---|---|---|---|---|---|
| Cosmos-Reason2-2B | 1 | 212 | 44.7 | 67.1 | 114.7 |
| Cosmos-Reason2-32B | 1 | 212 | 68.4 | 69.0 | 140.7 |
| ScaleVLA (552B) | 4 | 568 | 140.7 | 72.1 | 215.8 |
The authors report that ScaleVLA has 276 times the parameters of Cosmos-Reason2-2B and 1.9 times its median latency. The action head takes about 70 ms with every backbone, more than half of the total for the 2B backbone, and moving from a 2B to a 32B backbone adds only about 26 ms. That 1.9 times compares 4 H200 GPUs with 1, with different input token counts as well. The authors also state that the cost is more hardware than the smaller backbones need. The text read here does not give the control frequency on LIBERO or on the real robot, so the time one action chunk covers cannot be worked out; Physical AI Lab 2.6 works through how to get a control-rate ceiling from latency and chunk length.
The real-robot task is Plug In Charger from RoboDojo: the right arm grasps a phone charger and hands it over, and the left arm aligns the plug with a power-strip socket, inserts it and releases it, observed through a top camera and two wrist cameras. The training data are full teleoperated demonstrations plus segments focused on insertion; most demonstrations start near one reference charger position. The three policies share the same action DiT, training data and training budget and differ only in the backbone: Cosmos-Reason2-2B, π0.5 and ScaleVLA. π0.5’s VLM was trained on large-scale robot data as part of π0.5, and the authors use it to test whether a smaller backbone with robot pretraining can substitute for frontier-scale features. A trial succeeds when the plug is inserted and the left gripper releases it. Each policy runs 10 in-domain trials (starting near the dominant training position) and 15 out-of-distribution trials (the charger shifted or rotated, or the power strip moved beyond most training placements). The results are in Table 8 of the paper:
| Policy | In-domain successes | Out-of-distribution successes | Median insertion time (s) | Median completion time (s) | Median round-trip latency per chunk (ms) |
|---|---|---|---|---|---|
| Cosmos-Reason2-2B + action head | 4/10 | 5/15 | 85.9 | 147.1 | 311 |
| π0.5 + action head | 8/10 | 7/15 | 81.2 | 132.0 | 262 |
| ScaleVLA (552B) | 9/10 | 8/15 | 58.1 | 114.4 | 384 |
The authors report that all in-domain failures occur during insertion, and that in successful trials the three policies take comparable time to grasp and hand over. ScaleVLA has the highest round-trip latency (384 ms) yet the shortest completion time, a median of 114.4 s, 13% less than the 132.0 s of π0.5 + action head, mainly because it inserts the plug 28% faster. The 2B policy triggers multiple safety stops due to insufficient arm clearance, and ScaleVLA has none across all trials; the text read here does not give the number of stops. The time columns count only successful in-domain trials, so the 2B policy’s medians come from just 4 trials and ScaleVLA’s from 9.
The paper gives no intervals. Using the Wilson formula from Physical AI Lab 2.8, this site computes 95% intervals of 59.6%–98.2% for 9/10 and 16.8%–68.7% for 4/10, which overlap between 59.6% and 68.7%. Overlap by itself is not a test, but it shows that 10 trials cannot give a precise estimate of how large the gap is. Between ScaleVLA and π0.5 + action head, 9/10 against 8/10 in-domain and 8/15 against 7/15 out of distribution each differ by a single trial.
Limitations
- This is an arXiv preprint; all numbers are reported by the authors [R], and this site has not reproduced them. This site has not read Appendices A–C, which hold the training recipes, the timing method, the evaluation settings and the validation action errors of two of the real-robot backbones.
- None of the tables read gives a standard deviation, confidence interval or number of training seeds. On the real robot each policy has only 10 in-domain and 15 out-of-distribution trials.
- Going “from 2B to 552B” also changes the model family (there is only one DeepSeek model), dense versus mixture-of-experts structure, the number of inference GPUs (4 against 1) and the input token count (568 against 212). The paper does not separate how much each of these contributes.
- The backbone stays frozen throughout, so the conclusions concern frozen features read from the causal encoder. The text read here does not test fine-tuned backbones.
- The gain does not appear in every cell: on the Object environment perturbation of LIBERO-PRO, on DexJoCo’s Microwave, and on LIBERO-Long at N = 50 demonstrations, a smaller backbone matches or exceeds ScaleVLA.
- 216 ms is the median latency on 4 H200 GPUs in the RoboCasa simulation; the median round-trip latency on the real robot is 384 ms. The paper gives a project page, which this site did not open, so whether code and weights are public, and under which license, is unverified.
Links
- ScaleVLA: Scaling Vision-Language-Action Models to 552 Billion Parameters (arXiv 2611.21607)
- Full paper in HTML
- Physical AI Lab 3.1: Inside VLAs — Encoding One Cup Motion into 256-Bin Tokens, Then Labelling the Scope of Three Models’ Parameter Counts and Rates
- Physical AI Lab 3.5: Fine-Tuning GR00T in Practice — Checking the Fine-Tuning Command and the Modality Wiring Item by Item, Then Using a CPU Stand-In to Separate Open-Loop Error from Closed-Loop Success
- Physical AI Lab 2.6: To the Edge — Working Out the Control-Rate Ceiling from a Latency Log, Telling Whether Quantization Saves Size or Time, Then Sizing an Action Chunk
- Physical AI Lab 2.8: Reproducible Evaluation — Working Out Wald and Wilson Intervals by Hand, Sizing a Run from 1/√n, Then Bounding the Failure Rate after Zero Failures
- Frontier Radar | One Policy for 100 Household Tasks: one π0.5 checkpoint for 100 household tasks, 14 of them handed to a GPT-6 Astra agent that practiced first; authors report Q 0.639 vs 0.108
- Physical AI Lab: a physical AI course where every number can be checked



