The Unix Moment for the Humanoid Robot Industry
The Unix moment for the humanoid robot industry is happening

Preface
This week, at China Mobile's first Embodied AI Partner Conference, I gave a 10-minute keynote speech.
It wasn't a particularly long speech, but for BridgeDP it was a weighty moment—the first time we fully and publicly articulated something we have been thinking through for the past three years.
We discussed it internally for a long time and hesitated about whether to bring it up this early. But we ultimately decided to speak—because we increasingly believe that this is not just about BridgeDP; it is the most important structural issue the entire humanoid robot industry is facing.
I want to expand on what I said before and write it down here. If you were in the audience for those 10 minutes, this is the "extended version"; if you weren't, this will be more complete.
Here is the full text.
16 Companies, One Thing
Over the past 18 months, inside our company we have witnessed something that has gone largely unnoticed outside but that we consider significant—
16 humanoid robot companies built their motion control capabilities from zero to one here with us.
16 companies, 16 independent product lines, 16 different teams.
Among them are the humanoid business units of listed companies, star startups that have raised multiple rounds of funding, projects incubated by research institutions, and veteran robot manufacturers that entered bipedal robotics from other form factors. Their resources, starting points, and technical styles are all very different.
But we saw one thing—their algorithm engineers are doing almost exactly the same work.
The problems they bring to our engineering team are the same type of problems. The error logs they paste are very similar in structure. The methods they use to solve problems ultimately converge on a few similar paths.
Specifically, they are all solving these things:
- Hardware abstraction: how to unify different joints, motors, sensors, and control frequencies into a single set of interfaces that the upper-layer algorithms can call
- Motion control: how to deploy policies trained with reinforcement learning onto real robots without issues
- Simulation alignment: how to make models that perform well in simulation transfer to real hardware and still perform well
- Data feedback: how to feed data from robots running in the real world back into the next round of training so that capabilities continue to evolve
These four things are being done by almost every company building humanoid robots.
In each company's engineering team,60% to 70% of the manpower is spent solving problems that are almost identical to those at other companies.
This made us stop and think for a long time internally.
We weren't thinking, "This is a business opportunity"—that kind of thinking is too short-term. We were thinking:
Why is this happening? Why are 16 completely independent companies doing exactly the same thing? Has this happened before in history? If so, how did it end?
Two Echoes from History

This is not unfamiliar to us.
In the computing industry over the past half-century,almost exactly the same story has played out at least twice.
- More than half a century ago: before Unix
In the 1960s and 1970s, the mainframe era. IBM wrote its own operating system, DEC wrote its own, Burroughs wrote its own, Honeywell wrote its own. Every computer company was writing an operating system that could run only on its own hardware,only on its own hardware operating system.
Application programmers who switched to another company's machine had to learn new system calls, new file formats, and new development tools almost from scratch. The capability of the entire computing industry was locked inside each company's "vertical stack."
Until 1969, when two engineers at Bell Labs, Ken Thompson and Dennis Ritchie, started writing something they called Unix. Unix's design philosophy was very simple—to create an operating system that was cross-hardware, portable, modifiable by anyone, and extensible by anyone.
Unix was not a "product" of any single company; it was a redefinition of"what an operating system should be."It turned "fragments" into "infrastructure."
The story after Unix is well known to us today: Linux, BSD, macOS, Android, iOS—almost all operating systems running in the world today are direct or collateral descendants of the Unix philosophy.
The real takeoff of the entire computing industry did not start with transistors; it started with Unix.
- Nearly 20 years ago: before Android
In the early 2000s, on the eve of the smartphone era. Nokia had Symbian, BlackBerry had BlackBerry OS, Motorola had its own firmware—every phone maker was writing firmware that could run only on its own hardware,only on its own hardware firmware.
For app developers, making an app that could run on multiple phone brands was almost impossible—you had to adapt separately to each phone maker's firmware. The entire mobile app ecosystem was locked inside each phone maker's "vertical stack."
In 2008, Android was released. Android was not a phone—Android was an operating system that any phone maker could use, and that required the same set of interfaces to access the app ecosystem.
The story after Android is also well known: the entire mobile app ecosystem took 5 years to cover the distance that the PC app ecosystem took 20 years to cover.
- The same structure twice
These two "operating system moments" have a strikingly consistent structure:
- A new computing paradigm is emerging (mainframe / smartphone)
- Every hardware company is rebuilding the same underlying software
- The real resistance for the industry is not that "algorithms aren't good enough" or "hardware isn't strong enough," but that there is no widely accepted "infrastructure layer" that allows capabilities to be reused across hardware
- The moment that layer appears, the entire industry takes off at a speed far exceeding before
After observing for a long time, our judgment is: today's humanoid robot industry is at exactly the same structural position as those two previous moments.
What's Missing Isn't Smarter Algorithms
What does this mean? Our judgment is this—
What the humanoid robot era lacks is not smarter algorithms; what it lacks is that robot software must become more general-purpose.
I know this statement might sound counterintuitive.
In the past two years, the industry's attention has been almost entirely focused on "algorithms"—stronger reinforcement learning, larger VLA models, smarter end-to-end policies. Every new paper, every new demo, pulls the industry's gaze toward "the smarter the algorithm, the better."
We don't deny the importance of algorithms getting smarter. But what we want to say is—
if the only thing holding back the humanoid robot industry today were "algorithms not smart enough," then this would be naturally solved within 12 to 24 months—because the speed of algorithm progress is among the fastest in the AI industry today.
But if you really look at the engineering manpower these 16 companies spend every day, you will find that the time they spend on "making a smart algorithm run stably, safely, and repeatably on a real robot"far exceeds the time they spend on "making the algorithm smarter."
This is why I say—what's missing is not smarter algorithms; what's missing is that software must become more general-purpose.
A smart algorithm that can only run on one specific robot, in one specific scenario, within one specific time period has limited value for the industry as a whole.
Only when a smart algorithm can be deployed across embodiments, executed with millisecond-level stability, and continuously aligned with the real world, does it truly become an "industry capability."
To achieve this,this industry needs an "operating system."
Today, we believe—
"The Unix moment for the humanoid robot industry is happening."
This is the sentence from the speech, and it is the core of this entire article.
What It Is Not

So, what exactly is the operating system for the humanoid robot era?
This is a harder question to answer than "what it is not," because there are already several familiar names in the industry that can easily make people think "that thing is the operating system."
So I want to first talk about three things it is not.
- It is not ROS
ROS is an excellent tool. Many of our internal engineers grew up in the ROS world, and we have full respect for it.
But ROS is not the operating system for the humanoid robot era.
ROS is essentially an inter-module communication framework that allows different modules in a robot system—perception, planning, control—to be assembled together. It originated from the research community around 2007, and its core abstraction is the Node/Topic/Service mechanism based on publish-subscribe messaging.
It does this very well. But it was never designed for large-scale production deployment—it does not solve cross-hardware abstraction, it does not solve millisecond-level real-time control, and it does not solve the accumulation of capabilities across embodiments.
The role of ROS in our era is more like the "pipe" in early Unix—a valuable communication mechanism, but not the operating system itself.
- It is not NVIDIA Isaac
Isaac is also an excellent product. It provides very important infrastructure for the industry in simulation, training, and synthetic data.
But Isaac is not the operating system for the humanoid robot era.
Isaac is a training-time platform—it lets a robot learn to do something in a simulated world. Its capability boundary stops at "training" and "simulation."
It does not solve one thing—the operation of a real robot in a real factory, a real home, a real road, every millisecond, every day, every year.
There is a seriously underestimated distinction in the industry—training-time and runtime are two completely different things.
Making a robot "learn" an action and making a robot walk stably, move safely, and perform continuously in the real physical world are two different sets of engineering problems that require two different sets of system capabilities.
Isaac has done the "training-time" side very solidly. But on the "runtime" side, there is no widely accepted answer in the industry today.
- It is not a VLA foundation model
VLA (Vision-Language-Action) foundation models have been one of the most-watched directions in the humanoid robot industry from 2024 to 2026. Physical Intelligence, Google DeepMind, Galaxy General, AGIBOT, and many other excellent teams are working on this.
VLA foundation models are also not the operating system for the humanoid robot era.
VLA foundation models are doing something very important—they solve the problem of "what the robot should do." Given a language instruction and a piece of visual input, the VLA model outputs a high-level action intention.
This is the robot's cognitive brain. This is extremely important. But it does not solve another class of problems—
once that high-level intention is given, how to turn it into millisecond-stable joint torque output? How to ensure it doesn't fall, hurt people, or damage itself during execution? How to maintain stability in 24/7 operation? How to keep working when hardware wears, sensors drift, and the environment changes?
This class of problems is not solved by VLA foundation models, nor do they intend to solve it—because they handle the "what to do" layer.
To turn a brain that "knows what to do" into a robot that can "do it stably, safely, and continuously,"a whole set of system capabilities is needed in between. This set of system capabilities currently has no universally accepted name in the industry.
So What Is It?

After discussing three things it is not, let's talk about what it is.
We call it—Runtime Robot OS, a runtime operating system for robots.
There is a key word in this name: "Runtime."
It is the counterpart to "training-time."Training-time is about "whether the robot can learn"; runtime is about "whether the robot can run in the real world."These two things are equally important, but they are two different sets of problems that require two different systems.
A Runtime Robot OS must have three things simultaneously:
- Multi-Embodiment Abstraction
It must allow upper-layer policies, models, and applications to be unaware of the differences in underlying hardware—whether bipedal, quadrupedal, wheel-legged, whether joints are direct-drive or gear-driven, whatever the sensor configuration, the upper layers can access them in a unified way.
This has been done twice in the history of operating systems:
- PC operating systems let applications be unaware of whether the CPU is Intel or AMD, or which graphics card is installed
- Phone operating systems let apps be unaware of whose hardware it is
A Runtime Robot OS must do it a third time—making robot applications unaware of which robot embodiment they are running on.
- Real-time Safe Execution
It must, at the scale of every millisecond—not every second, not every 100 milliseconds—ensure that the robot's joint torque output, force-control constraints, and safety boundaries are stable, predictable, and never out of control.
This is the biggest difference between robots and ordinary software—if an ordinary software stutters, the user just restarts; if a robot stutters, it may hurt people, hurt itself, or hurt the environment.
Millisecond-level real-time safety is the hard baseline of a Runtime Robot OS.
- Continual Real-world Alignment
A robot is not a device that is burned once and never changes. It runs in the real world; sensors drift, hardware wears, environments change, tasks evolve.
A Runtime Robot OS must have the ability—to take the real-world operating experience of every robot, accumulate it, feed it back, train the next generation of capabilities, and safely push it back to all robots.
This is the true "data flywheel" of the robot era. It is not the same as the "user feedback reinforcement learning" in today's large model industry—the latter is text, the former is physics.
No existing system has achieved all three of these things simultaneously.
ROS does part of the communication abstraction, but it has no cross-embodiment capability, no real-time safety, and no learning loop.
Isaac does part of the training-time capability, but it is not in the runtime.
VLA does part of the cognitive abstraction, but it does not solve execution and continual learning.
Only when a system simultaneously achieves these three things does it qualify as the "operating system of the robot era."
Why We Believe This Is Feasible
At this point, some people may ask—
"What you're describing sounds important, but can it really be built? Or is this just a PowerPoint concept?"
That is a very reasonable question. I want to answer it seriously.
Three years ago, when BridgeDP was founded, we made a decision that holds deep meaning for us today—not to build complete robots, not to build foundation models, not to build applications, but to focus specifically on the "motion control" layer.
This decision didn't look smart in 2023—back then, building complete robots was sexy, building foundation models was hot, and building applications had customers. Specializing in a "middle layer" was hard to explain externally and put a lot of pressure internally.
But we made this decision based on a judgment:
the robot industry will eventually stratify. Whoever can turn motion capabilities from "project delivery" into "infrastructure" will hold one of the key entry points to the AI-ification of the physical world.
Three years later, we can present some verifiable facts today:
- 26 humanoid robot companies are using our motion control capabilities
- 50+ legged robots with significantly different structures—bipedal, quadrupedal, wheel-legged, different joint layouts, different drive methods—run on the same motion learning and control system
- the engineering cycle to bring a new robot from hardware integration to the first usable gait has been compressed from the original "project-level person-months" to "week-level"
- The essence of this is—building a separate system for each new embodiment has been replaced at our company by "one system + a toolchain for automated adaptation to a new embodiment"
I mention these numbers not to talk about BridgeDP, but to say one thing—
we are not describing a story about the future. We are using engineering facts to provide an existence proof for this category.
This layer is feasible. It can be abstracted. It can be reused across embodiments. It is already being voted for with the feet of 26 companies.
At this point, this matter is no longer a PowerPoint concept; it is a fact repeatedly verified by engineering practice—though today it is still concentrated on the single pillar of "motion capability."
The complete form of a Runtime Robot OS is far more than the single pillar of motion capability. But one pillar being proven feasible by engineering means that the overall feasibility of this system has its first cornerstone.
Device, Edge, Cloud—Three Layers of the Complete Form

At this point, I want to push one step further and paint a bigger picture.
We have built the on-device OS kernel. But the complete form of a Runtime Robot OS is far more than on-device.
It will have three layers—
- On-device
The millisecond-level real-time control layer. It lets every robot walk safely and move stably in the physical world.
This is the minimum threshold for a robot to "stay alive." It is also the core of what BridgeDP is doing today. This layer must be completed on the robot itself and cannot rely on the network—because network latency directly translates into the robot falling.
- Edge
The scenario-level skill orchestration layer. It lets multiple robots in a campus, a production line, or a home work collaboratively.
This layer does not require millisecond-level real-time, but it requires second-level coordination. Task allocation, space sharing, and capability complementarity among multiple robots—this is not done on the device (the device has no global view), nor in the cloud (cloud latency is too high). It is done at the edge.
- Cloud
The cross-embodiment capability accumulation and continual learning layer. It turns the experience of every robot into the capability of all robots.
This is the true "data flywheel"—a robot learns to open a refrigerator in a certain home, and this capability can—under the premise of ensuring safety, privacy, and ownership—become a shared capability for all robots of the same model.
None of these three layers can be missing. Without the device layer, robots cannot survive in the physical world; without the edge layer, robots cannot coordinate in group scenarios; without the cloud layer, robots have no true evolutionary capability.
Building these three layers completely is the complete form of the Runtime Robot OS. This is not a matter of one or two years; it is a decade-scale engineering effort.
New Infrastructure—OS + Computing Power Network
This matter has several corresponding shadows in history.
In the PC era,the new infrastructure was called "operating system + internet backbone"—Windows / Linux paired with TCP/IP and fiber-optic networks, allowing applications to circulate globally.
In the mobile era,the new infrastructure was called "Android + 4G/5G"—a unified app stack paired with a wireless network covering billions of people, enabling the entire mobile internet.
In the robot era, it will be called—
"Runtime Robot OS + computing power network."
This is the new infrastructure of the robot era.
Its two components cannot be missing either:
- Runtime Robot OS solves "how a robot runs stably, safely, and continuously"
- Computing power network solves "how the device, edge, and cloud computing power of millions or tens of millions of robots can be uniformly scheduled, orchestrated, and served"
Neither of these two things can be accomplished independently by any single company. An OS company cannot build a nationwide computing power network on its own; a network and computing infrastructure provider cannot build a runtime operating system for the robot era from scratch.
It requires—deep collaboration between the OS provider and the network and computing infrastructure providers.
This is already happening. We stood on that stage because we believe—this matter is no longer a vision; it is a real, ongoing industrial process being pushed by multiple parties.
Final Words: This Is an Invitation
I want to end this article with the same passage I used to close the speech.
Every paradigm shift in computing leaves a Unix moment in history—someone always steps up to turn fragments into infrastructure.
In the mainframe era, someone said this, and Unix came to be. In the smartphone era, someone said this, and Android came to be. Today, in the humanoid robot era,it is our generation's turn to say this sentence.
This is not a matter for one company. Not for one robot manufacturer. Not for one operator. Not for one chipmaker. Not for any single company alone.
This is the beginning of an era.
In the coming months, we will present our thinking, our products, and our engineering practices to the industry one by one. We will invite industry peers to discuss, debate, and refine it together.
But more important than all of that—
everything we write today is not a conclusion; it is an invitation.
We look forward to working with every engineer, researcher, entrepreneur, investor, and policy maker who cares about the robot industry—to define together what the operating system of this era should look like.
If you also believe that "fragments should become infrastructure"—
this is the invitation.
Shang Yangxing
Founder & CEO, BridgeDP
May 17, 2026 · Shenzhen





界面新闻
深视新闻
深圳特区报
财新
36氪
钛媒体
中国新闻周刊
蓝鲸新闻
Z Finance
投资家网
雷峰网
亿欧
环球网
南方日报
极客公园



