Robot Foundation Models in 2026: What VLAs Can Actually Do

You can spend all day talking to a generative model. Code gets written, images get made, drafts appear. And the tools scattered across your desk are still exactly where you left them. You put them back yourself.

Robot foundation models are the attempt to close that gap. A language model generates text, an image model generates pictures, and a robot foundation model generates motion. The output is joint angles instead of tokens — which sounds like a small substitution, and is not.

What matters in 2026 is that this stopped being a laboratory story. There is an arm whose structural parts you print yourself, published under an open license. There are small models that run on it, with weights you can download. And there is an official memory table telling you whether your GPU can train them. For the first time, all three conditions are met at once for an individual.

One disclaimer before the numbers. This site does not own the hardware and has not run these procedures. So you will not find claims here that something worked or did not. What you will find is the conditions stated in official documentation and repositories, organised so you can decide. Every figure carries its source, and all of it was checked on 2 September 2026.

The output is joint angles, not tokens

These systems are generally called VLAs — vision-language-action models. They take camera images and a natural language instruction, and output how the joints should move.

The difference from a language model is in the nature of the output. Text generation is a repeated discrete choice: pick the next token. Joint angles are continuous, and they have to be smooth over time or the machine damages itself. Approximately right is not an acceptable output.

The second difference is the cost of failure. A bad paragraph can be reread. A bad arm motion drops the object. That asymmetry explains most of the design decisions the labs have made.

The third is that there is no undo. Regenerate the text and you are back to the initial state; the knocked-over cup stays knocked over. From the model perspective, its own output changes its next input. Drift slightly at one moment and the next frame shows a scene that was not in the training data, and the error compounds from there.

This is also why the official guidance on training looks unfamiliar. Imitation learning is expected to converge in five to ten epochs over the dataset, not hundreds of thousands of raw steps. It is a kind of learning where what is in the data decides the result far more than how much of it there is.

Four families, four design philosophies

As of September 2026 there are four main lineages worth knowing. They differ less in benchmark scores than in how they split the problem up.

GR00T puts a diffusion head behind a vision-language model, so understanding the situation and generating smooth motion live in separate layers. Pi 0.5 implements the same split as two internal pathways, discrete above and continuous below. Gemini Robotics splits at a coarser grain still, moving spatial reasoning and planning out into ER 2 as its own model.

The point worth taking from this is not that diffusion is the winning technique. It is that everyone independently concluded the same thing: the part that understands what to do and the part that produces smooth continuous motion want different machinery.

Whether you can get the weights decides more than benchmarks

If you intend to actually build something, there is a question that comes before performance. Can you obtain the weights at all?

GR00T, the pi family and SmolVLA publish theirs. Gemini Robotics 2 does not. ER 2 is usable through Google AI Studio, but the acting VLA and the on-device models are limited to early-access partners, and the public route is a signup form for the Trusted Tester Program. The number of testers is not published. Whatever its capabilities, that alone removes it from the options an individual has.

This axis carries more weight here than it does with language models. If a text model keeps its weights private you can still call the API. A robot cannot work that way. Command intervals are short and network latency turns directly into broken motion, so running inference locally is a practical precondition in most setups. Querying a distant data centre every frame is possible in principle and wrong for an arm on your desk.

Open code does not mean open weights

There is a second trap in the word open. The code and the weights are licensed separately, and they are not the same conditions.

The GR00T model card states plainly that the model is ready for commercial and non-commercial use. The Gemma terms that apply to the pi weights also permit commercial use, but they attach a use-restrictions policy and an obligation to pass the restrictions down to anyone you redistribute to.

Then there is SmolVLA. Neither the model card, nor the API metadata, nor the file listing in the repository carries a license (checked 2 September 2026). Do not call that open. It does not mean the terms are permissive; it means the terms are not stated. LeRobot publishes the code, and a code license does not reach the weights.

The habit worth building is opening the actual clauses rather than a summary of them. Model licenses have already caught this site out once, on the image generation side, and robotics is no different.

The memory table decides who can try

Whether you can try any of this comes down to whether it fits on the GPU you own. The official LeRobot compute guide groups the policies by memory. The figures assume batch size 8 with the AdamW optimiser.

The reading is blunt. Large VLAs and the multimodal group only just reach the top of the consumer range, and the guide itself says 24GB is tight at batch size 1. Small VLAs come into range at the 16GB class. That is the whole reason the entry point for an individual is effectively SmolVLA and nothing above it.

The guide also flags that these are order-of-magnitude figures rather than predictions, and that real usage swings roughly fifty per cent either way depending on image resolution and data loading. Take the numbers with that caveat attached. If you have sized models by memory before, the arithmetic is the same one used in estimating what fits in your VRAM.

What actually changed in 2026

Put the pieces together and the shift is easy to state. An arm you can build costs tens of thousands of yen. Weights that run on it are downloadable. The memory needed to train them is written down in an official document. None of those three was reliably true two years ago.

That price band is what makes the difference, because it means you are allowed to fail. Nobody experiments freely with an industrial arm worth millions. At tens of thousands of yen, breaking something is part of learning. The bill of materials for that arm is covered in the SO-101 build, and if you have a 3D printer the structural parts become a consumable rather than a purchase.

None of this means the models are good. Published hardware comparisons put average success rates around a third to a half, with individual tasks landing anywhere between zero and ninety-five per cent. That spread, and how to read it, is the subject of the failure modes article.

What to take away

• A VLA outputs continuous joint angles, so errors compound instead of resetting. That single property explains most of the design decisions
• Check weight availability before benchmarks. Local inference is a practical requirement, so a closed model is not an option for an individual
• Code license and weights license are different. GR00T weights are under NVIDIA terms, pi weights under Gemma terms, and SmolVLA states no weights license at all
• The 16GB class reaches SmolVLA and stops there. Large VLAs need 24-40GB and the official guide calls 24GB tight
• Imitation learning converges in five to ten epochs. Data quality, not data volume, is the lever

Where to go next depends on what you have. If you own a printer, the parts list is the practical starting point. If you would rather size the compute first, the SmolVLA fine-tuning estimate does that. And the reverse guide sorts the entry paths by budget.

Sources

• NVIDIA, GR00T-N1.7-3B model card
• Physical Intelligence, openpi
• Hugging Face, lerobot/smolvla_base
• Google DeepMind, Gemini Robotics 2 brings whole body intelligence to robots
• Hugging Face, Compute HW Guide for LeRobot Training
• The Robot Studio, SO-ARM100 repository

ブラウザだけでできる本格的なAI画像生成【ConoHa AI Canvas】

swiftwand

X

AIを使って、毎日の生活をもっと快適にするアイデアや将来像を発信しています。 初心者にもわかりやすく、すぐに取り入れられる実践的な情報をお届けします。 Sharing ideas and visions for a better daily life with AI. Practical tips that anyone can start using right away.