# Why language models scaled first — and robotics foundation models are likely next *2026-08-15* — Transformers reshaped machine learning where static data and batch parallelism align. Robotics lagged on physics-bound RL until GPU-native sim stacks like Isaac Lab made transformer-scale training plausible. URL: https://dylanengelbrecht.dev/insights/transformers-robotics-foundation-models.html The transformer did not replace every machine learning technique — gradient boosting still wins tabular leaderboards, model predictive control still runs factories — but it became the default backbone for representation learning wherever large datasets and parallel compute align. Vision, language, code, and multimodal models now share one architectural family: self-attention over sequences, pretrained at scale, then fine-tuned. That consolidation is why it feels like transformers "ate" machine learning even though classical pipelines never vanished. ### Why LLMs adopted transformers almost immediately Language was the perfect first customer. The training corpus already existed — web text, books, code — with no environment required. The objective is simple: predict the next token. Each training step is embarrassingly parallel over sequences; there is no physics engine blocking the backward pass. Scaling laws from Kaplan et al. and later Chinchilla made compute spend predictable: more parameters and more tokens, in balance, reliably improve loss. LLM training is offline batch learning on frozen corpora. That data economics made the transformer revolution visible to everyone first. ### Why robotics lagged: physics and parallel training Robotics reinforcement learning is a different problem. Policies learn from interaction, not from a pre-collected corpus. Each environment step depends on physics, contact, actuator limits, and sensor noise. Sample efficiency is brutal: classic algorithms such as PPO need millions of transitions. Real robots cannot supply that throughput; teleoperation is slow and expensive. For years the bottleneck was infrastructure, not model architecture. The traditional loop — CPU physics simulator, copy observations to GPU, train a small MLP policy, copy actions back — caps how much experience you can generate. Isaac Gym (2021) showed what changes when the full loop stays on the GPU: physics buffers feed PyTorch tensors directly, enabling tens of thousands of parallel environments and roughly two to three orders of magnitude faster training on continuous-control tasks. Robotics did not lack interest in deep learning; it lacked the parallel data factory LLMs enjoyed by default. ### Simulation loops practitioners already know The conceptual loop is familiar to anyone who has trained agents inside a simulator. Dylan Engelbrecht wrote Introduction to Unity ML-Agents around Unity ML-Agents — a toolkit for reinforcement learning inside Unity simulations, not a games-only novelty. Manufacturing layouts, warehouse digital twins, procedural environments, and research scenes all share the same training contract: episode reset, observation tensors, reward signals, policy update. ML-Agents teaches engineers to think in loops — simulation ticks and training episodes — instead of one-off scripts. The gap for robotics at transformer scale was throughput: game and research sims on CPU physics rarely reach the parallel environment counts that make large policy networks practical. ### Isaac Lab closes the throughput gap Isaac Lab is the open modular stack NVIDIA positions as the successor to Isaac Gym — GPU-accelerated robot learning on Isaac Sim with parallel rigid-body and deformable physics (PhysX), tiled rendering, domain randomization, and ready-to-train environments for manipulation and locomotion. The design goal is datacenter-scale RL and imitation learning: thousands of environments per GPU, cloud deployment, and a path toward integration with the differentiable Newton physics engine for gradient-based approaches. This is the missing layer between "we have transformer architectures" and "we can afford to train them on robot data." Be precise about determinism. Isaac Gym's authors note that fully deterministic rollouts can break under some runtime randomization and GPU scheduling order — floating-point ordering across thousands of parallel envs can diverge. High-throughput, GPU-resident simulation is the win; bit-exact reproducibility across every contact-rich scenario is still hard. Sim-to-real transfer, safety certification, and hardware variance remain downstream problems. Fast sim does not erase them, but it changes what is economically trainable. ### Transformers are already entering robotics Robotics did not ignore transformers — it adopted them later and on smaller data budgets. RT-1 scaled a transformer policy on large real-world demonstration datasets. RT-2 co-fine-tuned vision-language models on robot trajectories, treating actions as tokens so web-scale visual priors transfer to control. Diffusion and flow policies add another path: generate action chunks with high-capacity sequence models. The lag is pace and scale relative to language, not absence of the architecture. ### Robotics foundation models are likely next The convergence is straightforward. Transformers supply capacity and transfer; GPU sim supplies experience throughput; demonstration datasets and teleoperation supply grounding in physical tasks. Together they mirror the LLM recipe — pretrain broadly, specialize per embodiment or task — applied to closed-loop control instead of next-token prediction. Robotics foundation models are likely next: general-purpose vision-language-action policies and sim-pretrained controllers that fine-tune on real robot logs, analogous to how chat models fine-tune from a text foundation. A "massive boom" is not guaranteed on a calendar — hardware cost, safety, and sim-to-real gaps still gate deployment — but the training bottleneck is shifting from "can we run enough RL?" to "can we curate diverse, high-quality interaction data?" When parallel sim is cheap, transformer policies become rational rather than exotic. For builders crossing games, simulation, and physical AI: the mental model you already use in ML-Agents or Isaac Lab — loops, rewards, parallel rollouts — is the same mental model foundation robot policies will need. The difference is scale. Language models won first because the data was already on disk. Robotics is building the data factory now.