01. What Large Models Are Doing to Robot Architecture
Take a humanoid robot apart and it was never one technical problem. It’s a stack of systems, each layer constraining the ones above and below it.
The body. This is the robot’s physical hardware — motors, reducers, sensors, batteries.
The cerebellum. Motion control. Standing, walking, grasping. This layer doesn’t care about why an action happens, only how to execute it. In China’s robotics industry — Unitree, Black Sesame Technologies, Horizon Robotics — people routinely call this layer the “cerebellum.”
The brain. This is where the biggest changes have happened over the past two years. It handles scene understanding, instruction comprehension, task decomposition, decision-making, and dialogue with humans. Figure AI’s System 2, Tesla Optimus’s FSD neural network, and the embodied foundation models from Unitree and AGIBOT all play the role of “brain.”
There are now two main technical paths for the brain. One is VLA (Vision-Language-Action), which pushes for end-to-end processing — visual and text inputs go in, action outputs come out, with no hand-designed submodules or discrete intermediate representations in between. Representative models include RT-2, GR00T N1, and π0.5. The other path is the world model approach, which doesn’t let the network output actions directly. Instead, it learns an internal model of the physical world, simulates outcomes “in its head,” then decides what to do. NVIDIA Cosmos and Yann LeCun’s former team at Meta are key examples of this approach. VLA attracted the most attention from 2024 to 2025, but by 2026 the world model route has been catching up fast. Unitree’s IPO prospectus already lists WAM, VLA, and dual-system architecture (a complex model for the brain, a simpler one for the cerebellum) as the three main technical directions. It’s too early to call a winner, but that doesn’t change the core observation: whichever path wins, it’s replacing the brain, not the cerebellum.
A quick note: the “brain plus cerebellum” split is an industry shorthand, not a strict academic taxonomy. Figure AI actually deploys a two-layer architecture (System 2 / System 1), while the classic academic framework uses three layers — perception, planning, action.
For a long time, progress in humanoid robots was almost entirely concentrated in those bottom two layers.
From the late 1990s through the mid-2010s, humanoid projects in Japan, Korea, and the US — ASIMO, HRP, HUBO, and later Atlas — all circled around one question: how to make the body more human. Better bipedal gait, lighter structures, higher power density in actuators. None of that was fake progress. Those were real, hard engineering problems. But look upward and you’d find a nearly frozen zone: the planning and decision-making layers were stuck in another era.
Before large models, a humanoid robot’s “decision-making” was fundamentally a crude piece of engineering. Even in the most advanced systems of that time, “decision” usually meant state machines, task trees, and rule engines. What a robot could do depended entirely on how many branches an engineer had pre-written. Its “understanding” of the world came from human-defined labels, thresholds, and conditional statements. That approach works in a lab or a heavily structured environment. Push it into the real world and the complexity spirals out of control.
Google was among the first institutions to recognize this. In the mid-2010s, teams at Google X, Google Brain, and later DeepMind kept circling a deceptively simple but fundamental question: if every action a robot takes has to be chained together by hand-coded rules, it will never adapt to the real world.
So a different technical route began to emerge — instead of separating perception, decision, and action into independent modules, why not let them all happen together inside one learning system?
After 2016, Google ran a series of manipulation experiments: deep learning for end-to-end grasping, reinforcement learning that let robotic arms learn through trial and error in cluttered environments, systems that adjusted their strategies through repeated failures. Those efforts eventually converged into a clear direction: a robot doesn’t need to “fully understand the world” before acting. It can refine its understanding while acting.
But that route still had hard boundaries at the time. These systems weren’t large language models. They were task-centric control models. They solved “how to convert visual signals into motion given a specific goal,” not “understanding the goal itself.” The models were small, highly task-specific, and had almost no language comprehension. You could teach one to “pick up the red cube,” but you couldn’t tell it to “tidy up the desk.” It could move, but it didn’t know what it was doing.
The policy generation layer was equally limited.
Google’s RT-1 (Robotics Transformer 1), introduced in 2022, is a good snapshot of that era. RT-1 wasn’t a large language model. It was a policy model that predicted actions directly from vision. Input: images and task labels. Output: sequences of arm movements. The architecture worked like this: when a user said something like “grab the water bottle on the table,” EfficientNet processed the image, a FiLM layer fused the language instruction with visual features, tokens went into a TokenLearner that extracted the important ones, and a Transformer output the action sequence — joint rotations, motor commands, and so on.
RT-1 could already handle hundreds of manipulation tasks in real environments. It was trained on 130,000 demonstration trajectories covering more than 700 tasks. But there was a catch: every task had been explicitly labeled and repeatedly demonstrated. The model didn’t understand “purpose.” It had learned, statistically, “what the most likely next action is given this visual scene.”
Put bluntly: before large models, humanoid robots had made some progress on “can it move?” but made very little progress on “does it know what it’s doing?”
The real inflection point came after 2022. For the first time, the decision-making layer had a model architecture that could actually carry “task understanding.” ChatGPT marked the maturation of a new technical form: large language models built on the Transformer architecture, which demonstrated increasingly generalizable capabilities in language understanding and reasoning. It wasn’t built for robots. But it gave robots, for the first time, a practical tool for understanding human intent.
For humanoid robots, this meant the “brain” could finally escape hand-written rules and become a generalizable, transferable system. The robot no longer needed an engineer to script every task. It could understand “what do you want me to do” through language.
Google was among the first to bring this shift into robotics systematically. In 2023, Google introduced PaLM-E. To be clear: PaLM-E is fundamentally a multimodal large language model. It doesn’t output motor control signals. It wasn’t built to walk. Its role sits squarely in the decision layer. PaLM-E embeds language, visual input, and robot state into the same semantic space, and answers one question: “What should I do right now, given the environment and the instruction?”
In the demo videos, the robot could understand instructions like “bring me the thing that’s better for breakfast” — something almost unimaginable under the old paradigm. The breakthrough wasn’t about precision of movement. It was that the robot could reason at a semantic level: what is “breakfast,” what does “better for” mean, what does “bring me” imply.
That was a qualitative shift in the decision layer. And around the same time, the policy generation layer started changing too.
Google released RT-2 in 2023. Unlike RT-1, RT-2 wasn’t purely a vision-to-action model. It injected the representational power of large language models into action generation. RT-2 still handled “how to move,” but it was now drawing abstract concepts from language and transferring them into action decisions. For example, a robot that had never been explicitly taught to “pick up trash” could complete that action in a new setting after understanding “throw away the thing nobody needs.”
This marks a role change for the policy generation layer. It’s no longer just a “scene-to-motion mapper.” It’s becoming a bridge from semantics to action: the language model above understands intent, and the policy model below converts that intent into executable movement sequences.
For humanoid robots, this is especially critical. Humanoid robots aren’t designed for factory assembly lines. They’re designed for the human world. And instructions in the human world are inherently vague, incomplete, and context-dependent. Only when the policy layer can parse the intent behind language does action become truly generalizable.
That’s why, between 2022 and 2024, more and more humanoid robot companies started talking openly about “large models.” Figure explicitly made general-purpose models the centerpiece of its robot intelligence. 1X, Agility Robotics, and others also folded language understanding and visual decision-making into their system designs to varying degrees. What they were all talking about wasn’t “letting the model control joints directly.” It was “letting the model handle decision and intent understanding.”
And here’s the thing: this change didn’t overturn the existing structure. The body still matters. The cerebellum still matters. The behavioral organization layer still exists. Large language models didn’t teach robots to walk or grasp. They redefined why those actions happen in the first place.
In other words, large models didn’t make humanoid robots stronger. They made them, for the first time, appear to be thinking. And that’s why the impact of large models isn’t evenly distributed across all layers — it’s heavily concentrated in the decision and policy generation layers. Those two layers are where previously fragmented capabilities got organized into something coherent and transferable for the first time.
Before this, a humanoid robot was a collection of abilities. After this, it began to have something like task awareness.
Look back at the decades of humanoid robot history and there’s a bitter irony: what really kept these machines out of the real world was never unsteady legs. It was underpowered brains. Large models are the first thing that turned this problem into something engineers can actually work on.
02. The New Wave Takes Shape
If large models gave humanoid robots the ability to “understand tasks,” the next question became brutally concrete: who actually handles “figuring out what to do” and “converting that into a sequence of executable actions”?
By 2024, this question had surfaced at both the industry and capital levels. Morgan Stanley’s early 2026 report, “2026 Outlook — Humanoids,” put it with restrained but telling precision: the industry’s focus is shifting from the “prototype wars” of 2024 to a concentrated bet on the “robot brain” in 2025. Once the milestone of “it can stand, walk, and demo movements” was achieved, what actually started dividing the field was the intelligence structure inside the machine.
This wasn’t an abstract conversation. Reality pushed it forward. On Tesla’s Q4 2025 earnings call, Musk laid out Optimus’s difficulties with unusual candor: first, building a robotic hand with the dexterity and degrees of freedom of a human hand; second, “real-world AI”; third, mass production. He even used a near-brutal metaphor for a humanoid robot without AI: “An Optimus without an AI chip is a prop, like the Tin Man from The Wizard of Oz — actually, worse. The Tin Man could at least walk. Without an AI chip, Optimus can’t even sit there.”
The quote circulated widely in the industry, not because it was dramatic, but because it put a finger on an emerging consensus: the physical bottlenecks are now well understood. What actually limits the ceiling is the brain.
That’s when “embodied model” started turning from an academic term into a repeated industry keyword.
“Embodied model” here doesn’t refer to a single standardized answer. It’s a category of technical bets: attempts to use learnable models to replace the intelligence structures that were previously piled up from rules, scripts, and engineering heuristics. These bets fall roughly into two interlocking layers — brain models at the decision level, and Vision-Language-Action (VLA) models connecting language, vision, and action at the policy level.
In the US, one of the most representative companies on this route is Skild AI. Founded in 2023, Skild AI’s founding team includes engineers from autonomous driving and robotics backgrounds as well as researchers who spent years working on foundation models. Unlike traditional robot companies, Skild AI didn’t rush to demo a complete humanoid body. Instead, they repeatedly emphasized one goal: build a “general-purpose intelligence core that can transfer across different robot bodies.” In their framing, the body is replaceable. The intelligence should be reusable. That’s essentially ripping the “brain” out of the “body” and turning it into an object that can evolve on its own.
Pi (Physical Intelligence) has been telling a similar story. Their founding team includes researchers from OpenAI’s early robotics efforts and engineers with experience building large-scale systems at Google and Tesla. Their recurring theme: real-world intelligence doesn’t come from stacking up more tasks. It requires a decision structure that can transfer across tasks and settings. That’s why so much of their work goes into long-horizon decision-making, error recovery, task interruption, and re-planning — all of them fundamentally brain-level problems, not control-layer techniques.
Meanwhile, in China, parallel explorations were unfolding at roughly the same pace.
The technical route for China’s robot brain is moving from VLA-only models toward a fusion of VLA and world models. VLA handles the connection between vision, language, and action. The world model handles understanding how the physical world changes. Together they form the critical chain from “thinking clearly” to “doing it.”
At BAAI’s 2026 conference, the Beijing Academy of Artificial Intelligence unveiled its in-development Wujie · RoboBrain Orca. The core idea: build an embodied brain around “predicting the next physical state.” It fuses large volumes of ego-centric interaction data to strengthen the world model’s embodied representations, which in turn improves few-shot learning and cross-scenario generalization downstream.
Galbot’s path is particularly representative in this direction. At the core of Galbot’s technology stack is AstraBrain, its fully self-developed embodied foundation model. It integrates brain, cerebellum, and neural control into an end-to-end framework, creating a tight loop between perception, decision, and execution. In 2026, Galbot released AstraBrain WAM 0.5 (World-Action Model), unifying VLA and world model under one architecture — the robot understands physical world rules while simultaneously generating executable action strategies. Alongside it came AstraBrain-WBC 0.5, aimed at real-time whole-body motion control for humanoid robots. Trained on large-scale human motion data, it demonstrated scaling behavior in robot motion control similar to GPT-style scaling laws, with zero-shot generalization to unseen actions.
Robot Era took a different route, one more focused on system architecture. Their ERA-42 model adopted a dual-system structure from day one: “slow thinking, fast execution.” A high-level model handles reasoning and task decomposition. A low-level model handles high-frequency execution and closed-loop control. The split tries to fit “thinking like a human” and “reacting like a machine” into one unified framework. They’ve since brought world models into the mix, so the model can not only act but also predict future states — a move clearly aimed at longer-term generalization.
Galaxea and Spirit AI have been pushing further on a different architectural question: how do reasoning and action coexist inside the same model? Spirit AI’s self-developed Spirit v1.6 uses a deeply integrated architecture that fuses VLA with a world model, connecting environment perception, action decision-making, and temporal world-state inference in one technical chain. The integration answers a specific challenge: intelligence isn’t just about independent reasoning ability. It’s about making thinking and acting work together efficiently. Galaxea’s next-generation embodied foundation model G0.5 is built on a VLA architecture where the same model, with the same weights, handles both reasoning and action simultaneously — giving the robot what they call “thinking in action.”
What’s notable is that this wave isn’t limited to companies that “make models.” Hardware-native companies like Unitree are being reshaped by it too. According to multiple industry sources, Unitree has set up a dedicated internal team to push model-level R&D systematically, while actively seeking partners who can fit deeply into their intelligence stack. That pivot is itself the clearest signal of the wave: when hardware capabilities start to converge, what separates one company from another is the brain and the strategy.
Step back and the pattern is clear. The wave isn’t “humanoid robots.” It’s “the intelligence layer inside humanoid robots.” The industry is becoming less focused on which prototype looks more human and more focused on who can build an embodied model that transfers, scales, and keeps learning.
If the last wave was about “can it stand up,” this one is about something harder: “does the robot actually know what it’s doing.” And that’s precisely the dividing line between a robot that lives on a demo stage and one that works in the real world.
