I spent most of the last decade building systems where the worst-case failure was a bad dashboard number or a stale table. Then I sat through a robotics demo where the failure mode was a robot arm putting a wine glass through a countertop, and it recalibrated something for me: this is the same discipline — pretraining, fine-tuning, evaluation harnesses — wearing a much less forgiving deployment target. The industry now calls this Physical AI, and it's worth understanding on its own terms before you go looking at any single model or company, because it explains why robotics spent so long looking like the ugly stepchild of the deep learning boom and why that changed only very recently.
Physical AI is the application of foundation-model techniques — large-scale pretraining, transformer architectures, learning from internet-scale and simulated data — to systems that have to perceive and act in the physical world: robots, autonomous vehicles, industrial manipulators, drones. NVIDIA popularized the term hard, starting with Jensen Huang's GTC keynotes in 2024 and leaning on it even harder through 2025 and into 2026, but the term itself is just useful shorthand for a real distinction. Contrast it with what you'd call digital AI — chatbots, code assistants, image generators — systems that take tokens in and put tokens out, with no physical consequence if they're wrong. A hallucinated paragraph gets edited. A hallucinated grasp trajectory drops a $40,000 payload.
Why did robotics miss the first foundation-model wave?
Robotics missed it because the thing that made foundation models work for text and images — scraping the internet — has no equivalent for robot actions. GPT-family models trained on a meaningful fraction of all written human language, sitting there for free, already labeled by the act of being written. Image models trained on billions of captioned photos. There is no "internet of robot joint-torque sequences." Nobody was uploading their robot's proprioceptive state and motor commands to a public forum for a decade before someone thought to scrape it.
What you get instead is expensive to collect at the source: a person in a teleoperation rig, physically guiding a robot arm through a task, one demonstration at a time, in real time, one robot, one environment. Compare that to the marginal cost of one more scraped web page. A research lab running teleoperation might collect a few thousand demonstrations in a good month. A large language model's pretraining corpus is measured in trillions of tokens. That gap — call it six or seven orders of magnitude of effective data availability — is the actual reason "robot GPT" didn't show up in 2019 alongside the first wave of scaled transformers. It wasn't that nobody wanted it. There was nothing to scale into.
There's a second, quieter reason: the action space itself is continuous, high-dimensional, and physically constrained in ways text isn't. A language model's output space is a fixed, finite vocabulary of tokens. A robot's output space is a continuous vector of joint torques or end-effector positions, subject to physics — inertia, contact forces, friction — that doesn't forgive an off-distribution guess the way autocomplete does. Predicting the next token wrong costs you a weird sentence. Predicting the next motor command wrong costs you a collision.
What actually changed — the three ingredients
Three things converged over roughly 2023 to 2026 to break the data bottleneck, and none of them alone would have been enough.
1. Simulation at a scale that manufactures data
GPU-accelerated physics simulation stopped being a nice-to-have for validating a control policy and became the primary way to generate training data. Modern simulators run thousands of parallelized physics instances on a single GPU cluster, faster than real time, producing synthetic (state, action, next-state) trajectories the way a factory produces parts. NVIDIA's own numbers from the GR00T program are the clean illustration of the order of magnitude here: they've reported generating on the order of hundreds of thousands of synthetic manipulation trajectories — equivalent to thousands of hours of human demonstration — in a matter of hours of simulated compute, and blending that synthetic data with real teleoperation data measurably improved downstream policy performance over real data alone. I go deep on exactly how that pipeline works, and why it isn't free, in the sim-to-real piece in this set — the short version is that simulation turned "data collection" from a bottleneck resource into something closer to a compute problem, which is a problem this industry already knows how to throw GPUs at.
2. Vision-language-action models: borrowing priors instead of learning from scratch
The second unlock was architectural. Instead of training a robot control policy from zero on the (still comparatively small) pool of real demonstration data, researchers found they could bolt an action-output head onto a model already pretrained on internet-scale vision and language data, and get a policy that generalizes to novel objects and instructions it never saw a robot perform. That's the vision-language-action (VLA) model — the model takes a camera frame and a language instruction and outputs a robot action, reusing visual and semantic understanding that came from a wildly larger, cheaper-to-collect pretraining corpus. Google DeepMind's RT-2 and the open-source OpenVLA model (trained on the multi-institution Open X-Embodiment dataset) are the reference points here, and I cover the actual mechanics — action tokenization, chunking, the autoregressive-vs-diffusion split — in the companion deep-dive. The headline idea worth holding onto for now: a VLA model doesn't need to relearn what a coffee mug looks like. It already knows. It only needs to learn what to do with one.
3. Cheaper, better teleoperation hardware
The third ingredient is less glamorous and easy to undercount: the actual cost of collecting a real robot demonstration dropped. Teleoperation rigs, VR-based control interfaces, and more capable, more available robot hardware made it economically feasible for a company to collect tens of thousands of real demonstrations rather than a few hundred. That real data still matters — it's what closes the sim-to-real gap that pure simulation can't fully solve on its own — and it got cheaper and faster to collect at the same time simulation got dramatically cheaper to generate synthetically. Both curves moved in the right direction at once, which is unusual and is a big part of why this looks like an inflection point rather than a slow grind.
graph TD
A["Internet-scale vision + language
pretraining (borrowed prior)"] --> D["VLA model
backbone + action head"]
B["GPU-parallel simulation
synthetic trajectories at scale"] --> D
C["Teleoperation + real robots
real demonstration data"] --> D
D --> E["Perception
what is in front of me"]
E --> F["World model / simulation
what happens if I act"]
F --> G["Policy
which action to take"]
G --> H["Action
motor command to the robot"]
H -.->|"outcome feeds back"| E
The shape of a Physical AI stack. Three distinct data sources feed the model that used to be starved for exactly one of them (real robot data). Once trained, the runtime loop is perception, an internal world model or simulation the policy can reason against, a policy that picks an action, and the action itself — with the real outcome closing the loop back into perception.
What is a "world model," and why does it belong in this stack?
A world model, in the Physical AI sense, is a learned internal representation of how the environment behaves and changes in response to actions — the model equivalent of "if I push this cup, it will slide, and if I push it too hard, it will tip." NVIDIA's Cosmos family of world foundation models is the current reference example: instead of (or in addition to) predicting an action directly, a world model can predict future video frames or future scene states conditioned on a proposed action, which a planner can then use to evaluate "what happens if I do this" before committing to it on real hardware. This matters because it's a second, complementary route to the same goal as simulation — generating and evaluating plausible futures cheaply — except the world model is learned from data rather than hand-coded physics, which makes it faster to adapt to a new environment but harder to trust blindly.
The landscape as of mid-2026
A few names now anchor almost every conversation about Physical AI, and it's worth being precise about what each one actually is, since the marketing blurs together fast.
| Layer | What it is | Reference example |
|---|---|---|
| Simulation platform | The 3D physics environment where synthetic data is generated and policies are validated before touching real hardware | NVIDIA Omniverse (built on the PhysX physics engine), Isaac Sim |
| Robot foundation model | A pretrained, generalist model that maps perception + instruction to action across many tasks and, ideally, many robot bodies | NVIDIA Isaac GR00T (an open, customizable humanoid foundation model NVIDIA began releasing in 2025); Physical Intelligence's π0 |
| World model | A learned model of environment dynamics used to simulate or predict outcomes of candidate actions | NVIDIA Cosmos world foundation models |
| Humanoid hardware | The physical robot body the models actually run on and were partly trained against | Figure's humanoid line, Tesla Optimus, Boston Dynamics' electric Atlas, 1X's humanoid platform |
The honest caveat: this landscape moves fast enough that specific version numbers and unit-production claims age within months, and some of the more triumphant deployment figures circulating in 2026 (tens of thousands of humanoid units "deployed") mix pilot programs, internal factory use, and genuine commercial contracts pretty loosely. Treat any specific number you read — including some of the ones in this article — as a snapshot, not a settled fact, and go check the primary source before you repeat it in a room that matters.
The gap between a GTC keynote demo and a robot that ships is still wide. A humanoid folding one shirt on stage, or a manipulation policy nailing a curated pick-and-place task, tells you almost nothing about how that same policy handles an unfamiliar object, a cluttered bin, or a lighting condition the training data didn't cover. Physical AI has a much higher variance between "works in the demo" and "works in a customer's actual warehouse" than digital AI does, because the physical world doesn't grade on a curve the way a chatbot's users implicitly do. If someone shows you a Physical AI demo, the first question worth asking is what percentage of attempts off-camera failed.
Why is 2026 the inflection point, and not five years ago or five years from now?
Because all three ingredients — cheap synthetic data at scale, a proven architectural pattern (VLA) for transferring internet-scale priors into action, and real teleoperation data that's finally affordable to collect in volume — became available in roughly the same window, and each one alone would have stalled. Simulation without a way to transfer the resulting policy to a real robot is a research toy. A VLA architecture with nothing but a few hundred real demonstrations to fine-tune on is data-starved regardless of how clever the backbone is. Cheap teleoperation without simulation or transfer learning just gets you back to the old, slow, linear cost of collecting demonstrations one at a time. It's the combination, not any single piece, that makes 2026 look different from 2019 — and it's exactly the reason NVIDIA built an entire platform strategy (Omniverse for simulation, Cosmos for world models, GR00T for the policy, Jetson Thor for the onboard compute) around owning every layer of that stack at once rather than betting on one layer alone.
What to carry away
Physical AI names something real: foundation-model techniques finally reaching embodied systems, after a decade where the internet-scale-data trick that worked for text and images had no equivalent for robot actions. The unlock wasn't one breakthrough — it was GPU-scale simulation manufacturing synthetic trajectories, vision-language-action architectures that transfer internet-pretrained priors into motor policies instead of learning from scratch, and teleoperation hardware finally cheap enough to collect real data at volume, all landing in the same few years. NVIDIA's Isaac/GR00T and Omniverse stack, and humanoid platforms from Figure, Tesla, Boston Dynamics, and 1X, are the visible tip of that convergence in mid-2026 — genuinely further along than five years ago, and genuinely earlier-stage than the demo reels suggest. If you're evaluating this space for real, the two follow-on questions are how the actual VLA mechanism works and why simulation had to become a data pipeline to make any of this affordable — which is exactly where the next two pieces in this set pick up. Once you're past the model and simulation questions, the practitioner question is where all this data actually lives and how it gets off a real fleet — I cover the reference architecture for that on AWS and on GCP in two follow-on pieces.