Mitos Robotics
← Writing22 April 2026

Why Scaling Alone Won't Get Us to General Purpose Robots

Robotics has a clear prize: general-purpose robots that do useful work reliably and cheaply enough to deploy in warehouses, hospitals, and homes. The dominant bet for getting there is the VLA scaling hypothesis: train end-to-end transformers on enough demonstrations and let scale do the rest. This piece argues that bet will not pay off over the next 5 to 10 years. The systems that reach general-purpose capability will be hybrid: learned components inside classical structure, not the other way around.

What a VLA actually is

A Vision-Language-Action model, or VLA, is a single neural network that takes in camera images and a natural-language instruction ("put the red block in the bowl") and outputs commands that move a robot's joints and grippers. Pixels and words in; motor commands out. RT-2, OpenVLA, π₀, Figure's Helix, and NVIDIA's GR00T are all variants.

What VLAs are getting right

The VLA bet exists for a reason: classical robotics stacks work, but they are expensive to build, brittle across tasks, and require months of engineering per new deployment. A robot that picks up apples cannot necessarily pick up pens without significant re-engineering. VLAs promise to skip all of that, and the progress is real. π₀.5 cleaned kitchens and bedrooms in homes not in its training data, performing multi-stage tasks lasting 10 to 15 minutes, with performance improving as training scaled from 3 to 104 homes. Even the leading VLA achieves its best results by adding hierarchical structure on top of the learned policy, a pattern that will matter later.

Part I: Practical objections

1. The reliability gap is orders of magnitude

There is a distinction in robotics between safety and reliability that matters here. Safety standards govern things like emergency stops, torque limits, and workspace boundaries: the mechanisms that prevent a robot from hurting someone when something goes wrong. These are well understood, and the standards require them to fail less than once per one to ten million hours. A VLA inside a classical safety envelope can meet this bar, because the safety mechanisms are still classical components. This is not where the problem is.

The problem is behavioral reliability: does the robot actually do its job? Reliably enough that a customer will buy it, an insurer will underwrite it, and an integrator will install it?

Consider what even an optimistic 95 percent task success rate means in deployment. For a robot performing several thousand tasks per shift, that is hundreds of failures per day: dropped items, damaged goods, injured workers. No industrial customer accepts those numbers. No insurer writes policy on them.

Current VLAs are well short of 95 percent. π₀ achieves 20 to 50 percent success zero-shot. π₀.5 "still makes mistakes" by its authors' admission. For comparison, Waymo's modular stack with explicit safety layers achieves 17,000 miles per disengagement and 85 to 88 percent fewer serious crashes than human benchmarks at 56.7 million rider-only miles (Kusano et al. 2025). Tesla FSD, which leans end-to-end, manages a few hundred miles between interventions. The most-deployed autonomous driving system is modular, superhuman in crash rates, and still an open question for regulators.

This is not a gap you close with a bit more training. It is the gap between demo-grade and deployment-grade reliability, and what bridges it for classical systems is explicit characterization of the operational envelope.

2. You can't certify what you can't characterize

To deploy a robot commercially, someone has to answer the question: under what conditions does this system work, and what happens when those conditions aren't met? Safety standards exist specifically for ML-based systems, and they all converge on the same requirement: characterize the system's behavioral envelope. Define where it operates. Enumerate what can go wrong. Provide traceable evidence that failures are bounded and mitigated.

A learned perception module with specified inputs, quantified error rates, and a defined operating range can meet this bar. A monolithic end-to-end model that maps pixels and language directly to motor commands cannot, because its behavioral envelope is effectively the entire input space. This is not unique to VLAs. It is true of any learned system, and the difficulty scales with scope. The narrower and more bounded the component, the easier it is to characterize. The broader it is, the harder. An end-to-end VLA is as broad as it gets.

Formal verification does not help at this scale. Neural network verification is NP-complete in network size, tractable up to low millions of parameters. A 7B VLA is three to four orders of magnitude beyond that. And characterization by exhaustive testing hits the sample complexity wall: the scenarios you need grow with the dimensionality of the input space.

A common response: "wrap it in a safety layer." This is correct, and it is where deployments will converge. But think about what a safety layer does: it holds the guarantees and specifies what the learned model is not allowed to output. The more it constrains, the more the system looks like a classical stack with the VLA as a suggestion engine. The scaling hypothesis says the end-to-end model is the system. A safety layer around it concedes that it is not. The most capable VLAs already show this: π₀.5 predicts semantic subtasks before acting, Helix separates reasoning from reactive control. The frontier is adding structure, not removing it.

3. Deployment demands properties end-to-end models struggle to provide

Beyond certification, customers, insurers, and operators demand properties that end-to-end models make hard. Two are binding.

Debuggability. When a deployed system fails, engineers diagnose why. Modular stacks localize: perception missed the object, planner produced a bad path, controller overshot. Interpretability research is advancing, but at production speed, "the network output the wrong action, here are some attention visualizations" is not "the planner chose path X because cost function Y weighted collision avoidance below throughput." Debugging end-to-end models is much more expensive per incident.

Updatability. Real deployments evolve: new SKU, new gripper, new safety rule. Modular stacks update the affected module and run its regression suite. End-to-end models update with LoRA, which beats retraining, but after any update you revalidate the whole model because you cannot prove it did not change elsewhere. Tractable for a narrow deployment; not for a general-purpose home robot.

These are not impossibilities; they are costs, and the costs scale with the breadth of the operating envelope. Pure end-to-end is the hardest path through every gate. The winners over the next 5 to 10 years will be architectures the scaling-hypothesis proponents of 2023 would not recognize as their own.

Part II: Theoretical objections

Part I assumed VLAs will keep improving and asked whether that is enough to actually ship. The arguments in Part II are different: they are reasons to think that simply adding more data and bigger models will not produce the reliability improvements the scaling hypothesis predicts.

4. Training data can't explore enough of the action space

To learn a good policy, a model needs more than examples of what an expert did. It needs to have seen enough different ways of doing things that it can generalize to new situations. Call this the coverage problem: how much of the space of possible actions has the training data actually explored?

In language, you get dense coverage almost for free. At any point in a sentence, there are only a few dozen plausible next words (Zipf's law concentrates language heavily), and the internet supplies billions of authors who made different choices from similar starting points. For "The best way to cook rice is to...", some wrote "boil it," some "steam it," some "use a rice cooker." The space of plausible alternatives is small, and the data covering it is vast.

Physical action is a completely different story. A robot arm with 7 joints has a 7-dimensional continuous action space. The number of meaningfully different things it could do from any given state is enormous: at even coarse resolution, roughly 10 million distinct regions per state. Fifty teleoperators picking up the same mug give you fifty trajectories through this space, which is part of why VLAs are improving. But fifty trajectories in a 7-dimensional continuous space covers a vanishing fraction of what the model would need to generalize reliably.

The strongest objection: physical trajectories may lie on low-dimensional manifolds that are dense with respect to the tasks that actually matter. If task-relevant action really occupies a 2-3 dimensional subspace, the coverage math gets much more favorable, and simulation bridges the rest. This is the live question in robot learning.

5. The scaling laws depend on properties language has and physical action does not

Kaplan et al. (2020) showed that language model error decreases as a smooth power law in both model size and training data: double the parameters and the error drops by a predictable percentage, double the data and the same thing happens. The exponents are small (roughly 0.07 to 0.10) but the relationship holds across seven or more orders of magnitude. That predictability is what lets labs plan billion-dollar training runs. Scaling laws have also been observed in images, video, code, and protein structure (Henighan et al. 2020), but the exponents vary, cleanness varies, and transfer to downstream task performance varies.

Two properties do most of the work in language and are absent in physical action.

Self-similarity. Natural language has approximately the same statistical structure at every scale: Zipf for words, similar patterns for phrases and topics. Patterns learned at one level transfer to higher levels. Physical dynamics are not self-similar. Picking up a mug (rigid contact), folding cloth (deformable), and pouring liquid (fluid) are qualitatively different regimes. There is no Zipf for actions.

Compositionality of learning. Language has finite vocabulary and grammar; new sentences teach novel combinations of familiar parts with predictable meanings, so learning composes naturally. Physical skills compose too. Humans do it constantly, combining grasping, pulling, and reaching into novel sequences. But they compose through understanding: internal models of how objects behave, planning, and reasoning about sub-tasks. Behavior cloning on flat action data does not learn this way. It learns by copying demonstrations: for this input, produce this output. There is no explicit representation of "grasping" as a reusable primitive, no physics reasoning that transfers to a novel object, no planner that decomposes "get the mug from the drawer" into "open drawer, then reach, then grasp." The compositional structure is in the world, but flat behavior cloning does not extract it. Recent attempts to get compositional generalization achieve it by adding exactly the hierarchical structure this piece argues for.

No VLA paper has shown clean power-law scaling across multiple orders of magnitude. π₀.5's performance improved from 3 to 104 training homes. That is data-scaling, not a scaling law. A scaling law would predict performance at 10,000 homes from performance at 100 with a clean exponent. Nobody has shown that.

The test: a VLA demonstrating clean power-law scaling across multiple orders in the next few years. Without it, the scaling claim is a bet, not a fact.

6. The curse of horizon and credit assignment

Granting both prior arguments, physical tasks still have long horizons and sparse feedback. A language model training on next-token prediction has effective horizon 1. A manipulation task at 100 Hz over ten seconds has horizon 1000, with a success signal that may arrive only at the end.

Reinforcement learning has a known problem here: when the reward signal is sparse (arriving only at the end of a long episode), variance in the learning signal grows with the square of the horizon length. For imitation learning (the approach VLAs use), the shape is the same. Ross and Bagnell (2010) proved that when a model is trained to copy expert demonstrations, errors compound quadratically: small mistakes push it into states the expert never visited, where it makes larger mistakes, which push it further off-distribution. Double the task length and the expected error roughly quadruples. DAgger reduces this to linear error growth, but only by having an expert correct the model continuously during training, which is not scalable. Standard VLA training is behavior cloning, so the quadratic problem applies.

The bound is not tight in practice. With diverse training data and careful per-step accuracy, real models beat the worst-case theorem. But the shape of the difficulty is what matters: the scaling required to overcome it grows faster than in language.

Objection: π₀.5 performs kitchen tasks lasting 10 to 15 minutes, which looks like long-horizon success. Look at how. π₀.5 does not try to learn the whole task end-to-end. It breaks "clean the kitchen" into shorter subtasks ("pick up plate," "place plate in sink") and connects them with a learned planner. Each subtask is a shorter imitation problem, and the planner stitches them together. This is hierarchical decomposition: exactly the kind of structure that makes long horizons tractable. The most successful VLA achieves its best results by adding structure that makes it less end-to-end. That supports the hybrid thesis, not the scaling one.

The architecture question is open; the structural one is not

The history of deep learning is a history of architectures matched to domains. Generic deep neural networks did not solve computer vision; convolutional neural networks did, because they encode the spatial structure of images. Generic deep networks did not solve language; transformers did, because self-attention encodes long-range dependencies and parallel structure. In each case the breakthrough was not just "more data and more parameters" but the right structural prior for the domain.

VLAs bet that the transformer, the architecture that solved language, is also the right architecture for physical control. There is no strong reason to believe this. Transformers work across domains when the domain can be preprocessed into something that looks like a sequence: Vision Transformers chop images into patches, protein transformers tokenize amino acids, VLAs discretize continuous actions into bins. Whether this preserves enough of what matters for physical dynamics (continuity, smoothness, contact discontinuities, embodiment constraints) or discards it is an open question.

And here is the strongest counterargument to everything in Part II: maybe the transformer is not the right architecture, but some future one is. Pre-transformer attempts at language were genuinely poor. RNNs and LSTMs did not scale. Then transformers arrived and scale ate every objection. Just as CNNs encoded what images need and transformers encoded what language needs, some future architecture could encode what physical dynamics need: continuity, contact, embodiment, long task horizons. It could do for robotics what transformers did for language.

This is the possibility most likely to undermine Part II. It does not touch Part I. Even if a breakthrough architecture arrives next year, a monolithic model of any kind still cannot specify its operational domain when trained on "everything," still cannot produce a traceable safety case, still cannot be debugged at production speed. Those constraints are about structure, not which network powers the learned components.

The empirical evidence is already pointing this way. The best place to watch is what Physical Intelligence, the most-watched VLA lab, has shipped in the last six months.

π*₀.₆ (November 2025) introduced RECAP: offline RL pre-training followed by on-robot data collection that incorporates demonstrations, on-policy data, and expert teleoperated interventions during autonomous execution. On the hardest tasks, throughput more than doubles and failure rate is roughly halved versus the base VLA. The defining feature is expert interventions during deployment, which is DAgger under another name. The π team has effectively conceded that the behavior cloning bound in Section 6 is real and that closing it requires ongoing human correction.

π₀.₇ (April 2026) goes further. It claims "initial signs" of compositional generalization, the thing Section 5 argues behavior cloning cannot deliver. The air fryer example is the centerpiece: no task data, model performs the task with step-by-step language coaching from a human. What generates the coaching at inference time is a separately trained high-level policy that produces language subtasks. A lightweight world model generates visual subgoals. The action expert takes both as conditioning and produces the motor commands. The inference-time diagram in the blog post shows it plainly: high-level policy, world model, action expert, each a distinct component with specified interfaces between them. Task prompts now carry metadata about desired speed and quality, control modality labels for joint versus end-effector control, and visual subgoal images. Each added channel specifies something the model would otherwise have to infer from ambiguous demonstrations. Each is structure. Physical Intelligence is describing a modular system with learned components and calling it a VLA.

The compositional generalization evidence is genuine but narrow. The air fryer task fails on a zero-shot prompt and succeeds only with human coaching. A separate policy is then trained to generate the coaching autonomously. None of Part I's reliability, certifiability, debuggability, or updatability arguments are touched by it.

The through-line from π₀.₅ to π*₀.₆ to π₀.₇ is not more parameters and more data producing emergent capabilities. It is the steady addition of structure: hierarchical decomposition, expert interventions, RL fine-tuning, world models, metadata conditioning, high-level policies. Each addition is a concession that flat end-to-end learning on teleoperation data does not close the gap. The direction of travel is exactly the hybrid thesis.

Whatever learned architecture wins in robotics, it will be a component inside a hybrid system, not the system itself.

The goal is to solve the problem

The goal is not the most elegant architecture, not impressive demos. The goal is robots that do useful work reliably enough to trust and cheaply enough to buy.

Neither pure approach gets there alone. Classical stacks are verifiable, debuggable, and certifiable, but they are brittle, expensive to engineer, and do not generalize across tasks. End-to-end learned systems generalize better but resist characterization, certification, and field-level maintenance. The hybrid thesis is not "go back to classical." It is: combine the strengths. Classical structure gives you the safety envelope, the planning layer, the interfaces that let you certify, debug, and update. Learning gives you the parts you cannot hand-engineer: perception, grasp prediction, dynamics, locomotion.

Concretely, the system that wins has a classical planner with specified cost functions, explicit state, and verifiable termination conditions; a classical safety envelope with collision avoidance, torque limits, workspace bounds, and watchdog timers; and learned modules for what learning does best. The safety case argues about each component. Updates are local. Failures trace. A field technician can swap a model without retraining the stack.

The real world is indifferent to elegance. It asks one question: does the robot work? Everything else is aesthetics.

Appendix: Key concepts

End-to-end learning vs modular systems. An end-to-end model maps raw inputs (pixels, words) directly to final outputs (motor commands) through a single trained network, with no human-specified intermediate representations. A modular system decomposes the problem into explicit components (perception, planning, control, safety) with specified interfaces. The VLA scaling hypothesis is the claim that end-to-end is sufficient; this piece argues winning systems will be predominantly modular with learned components.

Scaling laws and power laws. In language AI, model performance improves in a remarkably predictable way as model size and training data increase. The error follows a power law: double the data and the error drops by a fixed percentage, with this pattern holding across many orders of magnitude. The predictability is what gives labs confidence to spend billions on training runs.

Zipf's law and self-similarity. Zipf's law is the observation that in natural language, a few words ("the," "of," "and") are extremely common and most words are rare, following a precise mathematical pattern. This extends to phrases, sentences, and topics: language has similar statistical structure at every scale. This property, called self-similarity, is believed to be one reason scaling laws work for language.

Degrees of freedom and action space. A robot arm with seven joints has seven degrees of freedom: seven independent numbers describing its configuration. Its action space is the set of all possible commands you could send at any moment. For a 7-joint arm, this is a 7-dimensional continuous space; the volume grows exponentially with dimensionality.

Distribution shift. A model trained on one set of situations may perform poorly in new situations that differ from what it saw during training. This gap is distribution shift, the central practical problem in deploying any learned system.

Imitation learning and behavior cloning. Imitation learning is the general family of techniques where a model learns to reproduce expert behavior. Behavior cloning is the simplest version: treat each state-action pair from expert demonstrations as a supervised learning example. VLAs are typically trained by behavior cloning on teleoperation data. DAgger is an interactive variant that also queries the expert on states the learned policy visits, which avoids the distribution shift problem but requires continued expert availability.

Horizon. The number of sequential decisions a policy makes to complete a task. A language model predicting one token has horizon 1. A robot arm performing a ten-second task at 100 decisions per second has horizon 1000. Longer horizons make learning harder because small errors accumulate.

Functional safety and PFHd / PLd. Functional safety is the branch of engineering concerned with systems behaving safely under failure. ISO 10218 (industrial robots), ISO 13482 (personal care robots), IEC 61508 (general safety-related systems), and ISO 26262 (automotive) govern safety-function reliability. Performance Level (PL, ranging PLa through PLe) and Probability of Failure per Hour for dangerous failures (PFHd) are the quantitative requirements. PLd corresponds to PFHd between 10⁻⁷ and 10⁻⁶: fewer than one dangerous failure per one to ten million hours of operation.

ML-specific safety standards. ISO 21448 / SOTIF (automotive "Safety of the Intended Functionality"), UL 4600 (autonomous products including ML), and ISO/IEC TR 5469 (AI functional safety) govern behavioral reliability for systems that include learned components. They require Operational Design Domain specification, hazard analysis, and structured safety cases.

Operational Design Domain (ODD). The explicit specification of conditions under which a system is designed to operate safely, including environment, traffic or workflow conditions, time of day, weather, and other bounds. Required by SOTIF and UL 4600 as a prerequisite for safety case construction.

Safety case. A structured argument (claims supported by evidence supported by inference) that a system is acceptably safe for a given ODD. The core deliverable of UL 4600 and implicit in SOTIF. Unlike formal verification, a safety case is a credible argument rather than a mathematical proof.

LoRA and parameter-efficient fine-tuning. Techniques for updating large neural networks without retraining from scratch. LoRA (Low-Rank Adaptation) trains small additional weight matrices while keeping the base model frozen, making updates cheaper but still requiring regression testing against a fixed benchmark.

References

Practical deployment: safety, verification, and ML-specific standards

  • ISO 10218-1:2025, ISO 10218-2:2025. Robotics. Safety requirements. iso.org/standard/73933.html. The 2025 revision incorporating the previous ISO/TS 15066 on collaborative robots.
  • ISO 21448:2022. Road vehicles. Safety of the intended functionality (SOTIF). iso.org/standard/77490.html. The ML-specific automotive safety standard.
  • NHTSA (ongoing). Standing General Order on Crash Reporting for Levels 2-5 ADS and ADAS. nhtsa.gov/laws-regulations/standing-general-order-crash-reporting. Source for the repeated agency observation that learned driving systems produce confident actions in situations they have no business acting in.

Theoretical: imitation learning and distribution shift

  • Ross, S., Bagnell, D. (2010). Efficient Reductions for Imitation Learning. AISTATS. proceedings.mlr.press/v9/ross10a.html. The quadratic O(T²ε) error bound for naive behavior cloning.
  • Ross, S., Gordon, G., Bagnell, D. (2011). A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning (DAgger). arxiv.org/abs/1011.0686. The linear O(Tε) bound achievable with on-policy correction.

Theoretical: scaling laws and their prerequisites

  • Kaplan, J. et al. (2020). Scaling Laws for Neural Language Models. arxiv.org/abs/2001.08361. Source for the α ≈ 0.076 and β ≈ 0.095 exponents.
  • Henighan, T. et al. (2020). Scaling Laws for Autoregressive Generative Modeling. arxiv.org/abs/2010.14701. Scaling laws observed across images, video, math, and other domains.

VLA models discussed

Independent evaluations and datasets

  • Wang, J. et al. (2025). Evaluating π₀ in the Wild: Strengths, Problems, and the Future of Generalist Robot Policies. GRASP Lab, University of Pennsylvania. penn-pal-lab.github.io/Pi0-Experiment-in-the-Wild. Source for the 20–50% zero-shot success numbers.
  • Open X-Embodiment Collaboration (2023). Open X-Embodiment: Robotic Learning Datasets and RT-X Models. arxiv.org/abs/2310.08864. The largest cross-embodiment robot learning dataset.
  • Khazatsky, A. et al. (2024). DROID: A Large-Scale In-the-Wild Robot Manipulation Dataset. arxiv.org/abs/2403.12945.