Are We Building Robotics Backwards?

Why I’m starting to think we should build general foundations first—and specialize closer to the customer.

Since I have been in robotics, there have always been two parties. I have talked about these parties in previous blogs, and usually my role has been more of an observer. I understand why both sides exist, and honestly, for a long time I thought they would eventually meet somewhere in the middle anyway. But this time, I find myself tilting toward one side. I hope this is not a hype-based conclusion or an over-generalization, which would be quite ironic considering what this article is about, but some of the recent developments around GPT-6 Astra have made me rethink one of the oldest questions in general-purpose robotics. This might be a spicy take and I expect many people to disagree with me, but hey, if I wanted to write something everybody agrees with, I could just ask an LLM to write it for me :)

Disclaimer: this text was proofread by an LLM :)

The debate is simple to explain, even if the answer is not. In robotics, should we build many specialized robots for specific tasks and, by accumulating enough specialized capabilities, eventually achieve generalization? Or should we spend most of our effort building a sufficiently general system first, and trust that once the general system becomes good enough, specialized applications become much easier? In other words, should we go bottom-up or top-down? Should we go from specialist to generalist, or generalist to specialist? And if we extend this beyond software, should we build task-specific robots first, or should we build general-purpose platforms such as humanoids first?

Bottom-up or top-down?

There is a good argument for the bottom-up approach. In engineering, specialization normally wins. If you know exactly what a machine needs to do, you can optimize everything around that task. You can choose the correct morphology, actuator sizes, workspace, gripper, sensing, controller, safety system and even modify the environment around the machine. This is basically how industrial automation became successful. A welding robot does not need to understand cooking, a palletizing robot does not need fingers, and an autonomous warehouse vehicle does not need legs. If the objective is clearly defined, reducing the problem is normally good engineering. Less complexity means higher reliability, lower cost and an easier path toward deployment.

The generalist argument starts from a very different assumption. Instead of optimizing the machine for one problem, you optimize the system for the ability to learn and solve many problems. You accept some inefficiency at the task level because you believe that generalization itself will eventually create more value than optimization. This is a very expensive bet, especially in hardware, because a general-purpose robot needs more sensing, more degrees of freedom, more computation, more capable manipulation and usually much more complicated control. As I have argued before, complexity needs to earn its keep. A humanoid is a terrible investment if it ends up doing one repetitive task that a four-axis robot could have done faster, cheaper and more reliably.

For most of my career, this is why I have been careful about putting myself fully in either camp. The specialized route has much stronger evidence from industrial robotics. The general-purpose route has a much stronger long-term story, but historically, much less evidence. That balance is starting to change, and strangely, some of the most interesting evidence is not coming from robotics at all.

Then GPT-6 Astra happened

GPT-6 Astra was released by OpenAI on September 3, 2026. It is a general frontier model built around broad capabilities such as reasoning, computer use, browsing, software engineering, science and professional work. It was not introduced as a robotics model. Yet only days after the release, people started connecting Astra to physical robots, and one particular comparison caught my attention.

Robocurve tested GPT-6 Astra against MolmoAct2 on five bimanual robot manipulation tasks, with 20 trials per model on each task, giving 200 physical trials in total. The benchmark involved normal tabletop objects and tasks such as uncapping a marker, transferring a ruler between two cups, manipulating sticky notes, pouring paper clips and opening a box. The reported aggregate task-progress score was 46% for Astra and 12% for MolmoAct2, approximately a 3.9X difference. Astra scored higher on average across all five tasks.

Now, there is a very important clarification here because I have already seen these numbers repeated online as if Astra suddenly achieved a 46% robot-task success rate. That is not what the number means. The benchmark measures progress through the task, not only binary completion. Full completion was still difficult. Astra removed the marker cap in 5 out of 20 attempts, completed the full ruler-transfer task once, and completed the sticky-note task once. On some of the tasks neither system successfully completed the complete sequence. Robocurve also lists limitations in the evaluation, including operator-judged grading and some differences in the physical rigs used between evaluations.

So no, GPT-6 did not solve robotic manipulation. But focusing only on the absolute success rates misses what I think is the more interesting part of the result: who beat whom.

MolmoAct2 is not an outdated classical controller. It is a modern robotics-specific action reasoning model, trained using large amounts of robot manipulation data. Its BimanualYAM dataset alone contains more than 720 hours of real bimanual manipulation demonstrations across many tabletop tasks. Astra, on the other hand, comes from a general frontier-model program. And yet, when both were placed on the same type of physical manipulation problem, the general model performed considerably better on this particular benchmark.

That is the part I find important.

I initially wanted to describe this as an AlphaGo moment for robotics. I still think there is something AlphaGo-like about the feeling of watching it, but technically that comparison is too strong. AlphaGo demonstrated decisive superhuman performance in a cleanly defined domain against one of the strongest humans in the world. Here we are looking at five tabletop manipulation tasks, relatively small sample sizes, low completion rates and a system issuing relatively high-level end-effector commands to robot arms. This is very different from controlling contact dynamics at kilohertz rates, maintaining whole-body stability on a humanoid or solving manipulation reliably for hours in an unstructured environment. So I would not call this robotics' AlphaGo moment yet. I would call it one of those results that may look much more important in retrospect than it does today.

Maybe we have been specializing too early

The conclusion I am starting to draw is not that specialization is bad. Clearly it is not. My question is whether we have been specializing too early in the stack.

If you look at the development path of modern frontier models, it is almost the opposite of how robotics has traditionally been developed. Frontier labs spend enormous resources building a generalized foundation through pretraining, reinforcement learning, multimodal learning and broad exposure to different problem domains. Then that general system is adapted toward particular uses. You can fine-tune it, provide tools, add private context, connect external systems, distill it into smaller models or put another control layer around it. The intelligence is general first and specialized later.

Robotics has historically done something closer to the reverse. We start with a particular task, collect data around that task, design the hardware around that task, train the policy around that hardware, optimize the environment and then ask how we can generalize the result. This works extremely well when the task stays fixed. But if the long-term objective is general-purpose robotics, we may be creating thousands of islands and then discovering that connecting the islands is harder than expected. Different robots have different kinematics, different grippers, different action spaces, different sensors, different control frequencies and completely different datasets. A thousand specialists do not automatically become one generalist.

This is why the Astra result interests me beyond Astra itself. LLMs appear increasingly capable of becoming good at specialized tasks because they started from a strong generalized basis, not because somebody originally trained an isolated model specifically for every task they eventually perform. An average frontier model today can explain chess to my grandmother, write code, analyze a legal document, operate software and, when connected through the right interface, generate useful actions for a physical robot. None of these capabilities alone is surprising anymore. What is surprising is that they increasingly live inside the same system.

There is a kind of compounding effect here. Improvements in reasoning can help coding. Improvements in spatial understanding can help computer use. Improvements in multimodality can help robotics. Better planning can help all of them. The research does not remain trapped inside one narrow application. That is a fundamentally different scaling mechanism from building a new intelligent system every time you encounter a new task.

And maybe this is the lesson robotics should pay more attention to.

Does the same argument extend to hardware?

This is where I need to be more careful, because evidence about general models is not automatically evidence for humanoids. GPT-6 Astra performing well with a pair of robot arms does not prove that two legs are better than wheels, or that five-finger hands are better than parallel grippers. Software generalization and hardware generalization are related, but they are not the same problem. Physics does not disappear because the model became intelligent. Mass, friction, backlash, thermal limits, battery density, contact stability and fatigue still exist, and a specialized machine can often exploit physics much more efficiently than a general-purpose one.

But hardware also determines the structure of the learning problem. If every robot has a completely different embodiment, then experience collected on one platform becomes harder to transfer to another. If thousands or eventually millions of robots share reasonably similar morphology, sensors, action spaces and interaction geometry, then knowledge can accumulate around a common physical interface. This is where the argument for a general-purpose platform becomes more interesting to me. The hardware is not only hardware anymore. It becomes part of the data architecture.

This is also one reason I think humanoids remain interesting despite all their obvious engineering disadvantages. The human body is not mechanically optimal for every task, but human environments, tools and demonstrations are structured around roughly human proportions. A humanoid therefore has access to something no highly specialized robot has in the same way: an enormous existing distribution of human interactions with the physical world. Human video, egocentric demonstrations, motion capture, teleoperation and eventually the experience of other humanoid robots can potentially reinforce the same general platform.

That does not mean every general-purpose robot must be humanoid. I do not think we know that. But it does suggest that morphology can have network effects. A common embodiment can make data more valuable, and the more general the intelligence becomes, the more valuable a broadly capable embodiment may become in return. Software and hardware can start reinforcing each other.

Maybe the value of the humanoid is therefore not that it is mechanically optimal.

Maybe the value is that it creates a common physical interface on top of which generalization can compound.

But specialization has one massive advantage: customers

There is still a very strong argument against everything I just wrote, and it is called the market.

Customers do not buy generalization. They buy solutions. A warehouse manager does not care that your robot can theoretically make coffee, fold clothes and operate a dishwasher. They care whether it can unload boxes for an entire shift without stopping production. A factory does not want to participate in an embodied intelligence research experiment. It wants uptime, predictable ROI, safety and serviceability. This is why specialized robots have such a strong go-to-market advantage. You can define a narrow problem, engineer around it and demonstrate economic value much earlier.

But perhaps we are mixing two different types of specialization: product specialization and foundational specialization.

A general-purpose platform does not require a general-purpose product. ChatGPT may be based on a broad foundation model, but companies build extremely specialized products on top of frontier models every day. A legal AI product does not need to tell its customer that underneath the interface there is a model capable of writing Python or discussing biology. The user sees a specialized workflow, while the underlying intelligence remains general.

Why could robotics not develop the same way?

A humanoid working in a warehouse might spend five years doing almost nothing except moving containers between two workstations. Commercially, that is a specialized product. But the underlying model and perhaps much of the underlying hardware could still belong to a general-purpose platform. When a better manipulation capability is learned elsewhere, that warehouse robot may benefit. When a better perception model is developed, thousands of applications may inherit it. The specialization happens near the customer, while generalization remains underneath.

That seems increasingly different from building the entire technical stack around one use case from the beginning.

Where should specialization happen?

I also do not think the future robot will be controlled entirely by one gigantic foundation model. Robotics operates at very different timescales. A model can spend hundreds of milliseconds or even seconds deciding how to approach a task. A balancing controller cannot. Contact response, motor control and manipulation can require updates hundreds or thousands of times per second, with predictable timing and stability guarantees. There are good reasons why classical control, trajectory optimization and small task-specific policies exist.

The architecture I increasingly expect is hierarchical. A generalized model handles semantic understanding, planning, reasoning, adaptation and perhaps medium-horizon action generation. More specialized models handle locomotion, manipulation and other high-frequency skills. Traditional control closes the fastest physical loops. The interesting question is therefore probably not whether the future is general or specialized. It is where specialization enters the stack.

My current bias is that it should enter later than we have traditionally assumed.

Generalize the representation. Generalize the learning system. Generalize the ability to reason about different tasks. Where economically possible, create common physical platforms that allow data and capabilities to transfer. Then specialize close to the application, where the actual physics, safety constraints and business case demand it.

This is quite different from designing an entirely new robot and learning system every time a new use case appears.

So which side am I on?

For years, I assumed both sides would eventually converge. The specialized robotics world would gradually make its machines more capable, while humanoid and general-purpose robotics companies would gradually make their systems more reliable and economically useful. Somewhere in the middle, we would end up with general-purpose robotics.

I still think both paths will continue, and industrial automation is certainly not going away. There will always be applications where the optimal robot is a highly specialized machine, just as there are still ASICs despite the existence of general-purpose computers. If you need to weld the same seam two million times, please do not send a humanoid with a frontier model to do it just because it is fashionable.

But if I had to place a bet today on which direction is more likely to create genuinely general-purpose robotics, I am increasingly betting on generalist first and specialist second.

Not because Astra solved robotics. It did not.

Not because humanoids have suddenly proven themselves economically. They have not.

What changed for me is something more fundamental. Frontier models are giving us evidence that generality itself can become an advantage in specialized problems. The traditional intuition is that the specialized model should dominate the general one inside the specialist's own territory. When a general model walks into that territory and starts winning, even imperfectly, that assumption deserves to be questioned.

If this continues, then the research strategy changes. Perhaps we should not expect general-purpose robotics to emerge because we successfully connect hundreds of isolated specialized robots. Perhaps we should build sufficiently general intelligence and sufficiently general physical platforms, then let specialization happen on top of them.

In logical terms, we have spent much of robotics trying to move inductively from many specific solutions toward general capability. Maybe the better path is closer to the opposite direction: establish a strong general foundation, then derive the specialized systems we need from it.

Or, using a simpler picture, instead of growing many roots and hoping they somehow become one tree, perhaps we should grow the trunk first and let it branch.

I am not ready to claim that this is proven. There is far too little evidence for that, and robotics has a wonderful habit of punishing people who extrapolate too quickly from clean demonstrations.

But I am no longer standing exactly in the middle either.

Specialization may win the first deployment.

Generality may win the learning curve.

And for general-purpose robotics, the learning curve might eventually matter more.