Scaling Laws for Robot Foundation Models

Robot foundation models are large, pre-trained networks that fuse vision, language, and proprioception into a single backbone, meant to replace the old way of building robots one task at a time. For decades, every robotic behavior had to be hand-coded, including a pick-and-place routine for one factory line, a separate control script for a different gripper, and a new set of rules whenever the environment changed even slightly. Intelligence, in that world, got written by a human engineer, not learned from data. Robot foundation models flip that around. A single generalist policy trains across many robots, many tasks, and many environments, then gets adapted or prompted for a new job instead of reprogrammed from scratch.

The taxonomy under this umbrella already has some shape to it. Monolithic vision-language-action (VLA) policies like RT-2, Gato, and RoboCat pack perception, language understanding, and motor control into one network. Modular stacks such as SayCan split the job, using a language model to plan and a separate controller to execute. Multi-agent orchestration systems like InteractGen coordinate several specialized models toward one goal. Different architectures share the same bet: scale and shared representation beat one-off engineering for every new robot.

The growth curve behind this bet explains the urgency on its own. The field grew from a handful of publications on robot foundation models in 2021 to thousands by 2024, with the vast majority published in 2024 alone, a handful of research groups poking at an idea turning into a full-scale, multi-institution race in the space of three years. That is not slow academic interest building over years. That is a handful of research groups poking at an idea turning into a full-scale, multi-institution race, in the space of three years.

Scaling laws in language models and requirements for transferring them

The scaling laws everyone in AI now takes for granted showed that loss in language models follows a power-law relationship with dataset size, parameter count, and compute. Feeding the model more data, more parameters, and more compute causes loss to drop in a predictable, measurable way. That wasn't a lucky pattern specific to text, either. Later work found the same power-law behavior in discriminative image modeling, generative image modeling, and video modeling, which is what turned "scaling laws" from a language-model curiosity into something that looked like a general property of large neural networks trained on large datasets.

Transferring that finding to robotics takes more than building bigger robot models and hoping for the best. It needs data at a scale comparable to what the internet hands text models for free, a wide enough spread of tasks that improvement isn't just memorization in disguise, and a loss metric that actually predicts how the model performs once it's deployed on a real machine. Robotics spent years borrowing only one piece of this playbook, vision-language pretraining, without direct evidence that the whole scaling framework applies to physical tasks. What was missing until recently was direct evidence that scaling laws hold within robotics itself: that more robot-specific data and compute produce consistent, predictable gains on physical tasks, not just on proxy benchmarks borrowed from vision and language.

The first systematic evidence: power laws appear in robotics, and they are steep

That evidence now exists. Sartor et al. ran the first comprehensive meta-analysis quantifying neural scaling laws for robot foundation models, drawing on 327 research papers spanning data size, model size, and compute across a wide range of robotic tasks. The headline finding: robotic task performance improves with more data, more parameters, and more compute, following a power-law relationship, and the rate of improvement runs steeper than what shows up in language tasks. Not an analogous curve borrowed from a different domain and roughly holding. A faster one.

Robotic policies today are often in the moderate-to-poor range on many benchmark tasks, and it would be easy to read that as some kind of ceiling, a fundamental limit on what learned policies can do in the physical world. Sartor et al.'s finding argues against that reading directly. Moderate performance looks like a position partway up a steep curve, not a wall, which lines up with what scaling law research found in other domains: capabilities that look absent at small scale can appear abruptly once data and compute cross some threshold.

The empirical weight behind this trend sits concentrated in a few places. Google DeepMind contributes to 19% of all publications in this field, the single most prolific institution in the meta-analysis. That concentration matters for how you read the evidence, since a meaningful share of the field's data pipelines, infrastructure, and compute budgets sit inside one organization rather than spread evenly across a hundred labs.

The three axes where robot scaling diverges from language scaling: data, model size, and inference

Data

Language models scale on text scraped from the internet, effectively a free byproduct of decades of human writing nobody had to go collect. Robotics has no equivalent lying around. There's no internet-scale archive of paired sensor observations and motor commands sitting somewhere waiting to be scraped. Useful robot data only exists once someone builds the collection pipeline, runs the robot, and logs what happened, and that single fact is where robotics diverges from language most sharply.

The field's biggest cross-institutional answer to that problem is the RT-X / Open X-Embodiment dataset, assembled from 22 different robots across 21 academic and industrial institutions, spanning 527 skills over 160,266 tasks. It's the clearest evidence yet that closing the data gap in robotics takes coordination at an institutional scale language modeling never needed, since no single lab owns 22 different robot platforms.

Lin et al. ran the most detailed real-world data-scaling study to date, collecting 40,000 demonstrations and executing 15,000 real-world robot rollouts under a controlled evaluation protocol. The finding cuts against the naive "more data is always better" assumption: generalization follows a power-law relationship with the number of distinct environments and objects a policy sees, but once demonstrations per environment cross a certain threshold, adding more barely moves the needle. Diversity beats volume, flatly. The payoff is almost startling given how modest the input was: four data collectors working a single afternoon gathered enough for two task policies to hit roughly 90% success rates on environments and objects the policies had never seen before.

Physical Intelligence took this to industry scale with its π₀ base model, pre-trained on more than 10,000 hours of robot data, followed by π₀.5 with improved open-world generalization. Robot data doesn't pile up passively the way text does on the web. It only shows up after someone pairs careful engineering with a learning method built to actually use it.

Model size

The compute-optimal formulation from LLM scaling carries over conceptually: under a fixed budget, loss follows a power law in both parameter count and dataset size. But acquiring robot-scale data runs into physical constraints token datasets never face, since collecting one demonstration takes a robot, a workspace, and real elapsed time, not a web crawler running overnight.

Generalist AI's GEN-0 model tests whether the LLM pattern holds at industry scale. Trained on 270,000 hours of real-world manipulation trajectories collected across homes, warehouses, and workplaces, with data operations adding 10,000 new hours per week, GEN-0 gave the field its first industry-scale confirmation that more pretraining data and compute produce consistent, predictable gains in downstream post-training performance. That alone would be notable. But GEN-0 also turned up something sharper: a phase transition in performance once models crossed a substantial parameter threshold, following the same pattern that defined large language models, described by Generalist AI as a first for robot foundation models.

Model ossification is the second big finding out of that work. Below a certain size, models stop being able to absorb further pretraining at all, hitting a hard ceiling on what they can learn no matter how much more data gets thrown at them. Models below the 7B threshold showed clear, early ossification. Models at and above the 7B threshold absorbed pretraining substantially better. In LLM literature, this kind of ossification appeared in models with tens of millions of parameters, not billions. This means robot foundation models need to get roughly a hundred times larger before hitting the same wall. Generalist AI attributes the gap to Moravec's Paradox: tasks that look effortless to a human, like grasping an unfamiliar object or recovering from a slipped grip, demand far more computational complexity than abstract language reasoning does.

One caveat tempers all of this. Research in the field has noted that a bigger foundation model backbone does not automatically hand you a better robot policy, and that robotics-specific training matters alongside raw model scale.

Inference-time scaling

A third axis runs independently of data and parameter count: how much compute gets spent at the moment of deployment, not during training. RoboMonkey demonstrated inference-time scaling laws for VLAs, showing that action error drops as the number of sampled actions increases, following an exponentiated power law across CogACT, Octo, OpenVLA, and SpatialVLA.

At deployment, RoboMonkey samples a small set of candidate actions, applies Gaussian perturbation and majority voting to build a distribution of proposals, then uses a VLM-based verifier to pick the best. At deployment, RoboMonkey samples a small set of candidate actions, applies Gaussian perturbation and majority voting to build a distribution of proposals, then uses a VLM-based verifier to pick the best one. Training that verifier on synthetic data sharpens its accuracy consistently. The payoff is concrete: pairing existing VLAs with RoboMonkey produces a 25% absolute improvement on out-of-distribution tasks and an 8% higher average success rate on in-distribution tasks, and fine-tuning the VLA and verifier together adds another 7% gain over fine-tuning the VLA alone.

This axis matters because it's a lever that doesn't need new data or a bigger model. An existing policy can squeeze out more performance just by spending more compute at the moment it acts, which offsets, at least partially, how expensive and slow data collection remains.

The GEN-1 results as a milestone and a measuring stick for scaling meeting mastery

If GEN-0 established that the scaling laws hold, GEN-1 shows what those laws look like once they compound. Built on the GEN-0 foundation through further scaling combined with algorithmic advances, GEN-1 pushed average success rates on multiple dexterous tasks to 99%, up from 64% for GEN-0, while completing box assembly roughly three times faster than the prior state of the art. Each of those results needed only one hour of robot data for post-training, a figure easy to skim past but hard to overstate given how expensive robot data collection has been historically.

The task-level demonstrations back up the headline numbers. GEN-1 folded T-shirts 86 consecutive times without any human stepping in. It serviced robot vacuums more than 200 consecutive times. It assembled boxes at roughly three times the speed of the previous state of the art. Generalist AI describes this as crossing a "mastery threshold," not incremental improvement on a benchmark but a qualitative shift in reliability, speed, and the ability to improvise a recovery when something goes slightly wrong. A model that succeeds nearly every time is something you can deploy. A model that succeeds only sometimes is a research result, and the distance between those two things is the whole ballgame.

The embodiment gap: what scaling cannot yet cross on its own

None of this settles the hardest problem in the field. Domae et al.'s 2026 survey names it directly: robot foundation models, VLA policies included, get discussed almost entirely through a scaling lens, yet a model can generalize beautifully in one sense and still be unable to run on a robot with a different body. The survey calls this the embodiment gap, and it sits at the center of what scaling laws haven't resolved yet.

Some of that gap will shrink through more data and bigger models. Some of it will stay engineering work specific to a given robot's joints, sensors, and actuators, and no clear account of where that line falls exists yet. Some early empirical work has started probing it in simulation: the first empirical validation of embodiment scaling laws focused on proprioceptive locomotion, chosen specifically because it has a small sim-to-real gap and depends mostly on morphology and dynamics rather than perception. That work used a procedurally generated set of robot descriptions spanning humanoids, quadrupeds, and hexapods to test how well learned locomotion transfers across body types.

On the data side, Some work in the field has pursued a strategy of treating embodiment itself as something to scale across, training on multi-embodiment datasets built around the idea that human motion can serve as a kind of universal reference transferring across robot platforms. Whether that approach scales as cleanly as data or parameters do is still an open question, and treating it as settled would be premature.

The practical challenges that still bend the scaling curve in robotics

Cost is the most obvious constraint, and it doesn't move the way compute costs have moved for language models. High-quality robot data takes real robots, real time, and real human supervision to collect. Lin et al.'s finding, that environment diversity outweighs raw volume, only sharpens the problem: getting that diversity at scale takes the kind of institutional coordination RT-X pulled off across 22 robots and 21 institutions, a far heavier lift than scraping more web pages ever was.

Latency creates a second bottleneck, and it sits in direct tension with inference-time scaling. Transformer self-attention scales quadratically with input sequence length, which makes pure transformer architectures a poor fit for real-time control loops that need to respond in milliseconds. RoboMonkey improves accuracy by sampling more actions at inference time, which is exactly the opposite of what a latency-constrained control loop wants. Reconciling more sampling for accuracy against tighter timing for control remains unresolved, and no architecture on the table today solves both at once.

Safety compounds both problems. Autoregressive VLAs carry limited memory and no strong internal verification step, so they can hallucinate an action or fail to replan when the environment shifts mid-task. RoboMonkey's verifier addresses part of this by checking candidate actions before execution, but a partial fix isn't a solved problem. Deploying these systems in spaces with people in them raises the stakes on getting it right, and that stakes-raising is not a footnote.

One emerging approach sidesteps the high cost of collecting robot data differently: in-context learning, where a model adapts to a new task from a single example at deployment without updating any weights. Skild AI's S1 model, pre-trained on 100,000 hours, conditions on one video demonstration and reports 66% cumulative per-step success versus 9% for its language-conditioned VLA baseline. One in-context demonstration performed comparably to roughly 380 post-training episodes. Call it the robotics version of the GPT-3 prompting moment, where teaching a model a new behavior shifted from a retraining run to handing it a single recorded example.

The scaling trajectory as evidence accumulates

The trajectory is no longer a hypothesis borrowed from language modeling. Power-law relationships between data, compute, model size, and robotic task performance have now shown up in meta-analysis, in controlled real-world data-scaling studies, in industry-scale pretraining runs, and in inference-time experiments. Four independent lines of evidence, converging on the same shape of curve, is a stronger position than the field held even two years ago.

The steeper exponents in robotic scaling matter for how fast the gap between benchmark performance and deployable reliability might close. If robotic performance climbs faster with added compute and data than language performance does, the distance between today's moderate benchmark scores and reliable, deployable performance could close faster than intuition built on LLM timelines would suggest. That optimism has to sit next to the physical cost of collecting robot data, a cost that hasn't fallen the way compute costs have, and that remains the binding constraint on how fast any of this actually scales.

Three things deserve tracking as more evidence comes in. The embodiment gap might narrow through cross-embodiment datasets like UniHand-2.0, or it might remain stubbornly dependent on per-robot engineering. Whether inference-time verification, in the style of RoboMonkey, becomes a standard part of production robot stacks rather than a research technique confined to papers. Whether in-context learning approaches like S1 cut the per-task data requirement enough to change the actual economics of deploying a robot on a genuinely new job.

The ossification finding carries a planning implication that's easy to miss. Organizations building robot foundation models need to budget for parameter counts well beyond what earlier LLM-era intuition would suggest, because the data and compute investment required to dodge early ossification runs far larger than intuition tuned to ossification thresholds in the tens of millions of parameters would predict. Scaling in robotics costs more, in data and in compute, than the version of this story that played out in language. That's the trade, and it isn't up for negotiation: steeper curves buy faster gains, but only for those willing to pay the steeper price of admission.