Researchers Plug GPT-6 Astra Directly Into a Robot to Tidy an Unfamiliar Kitchen

A Humanoid Cleans an Unfamiliar Kitchen With GPT-6 Astra at the Controls

Researchers from Stanford and Caltech have built a system called HomeBody that lets a Unitree G1 humanoid robot walk into a kitchen it has never seen, tidy the space, and pull items out of drawers without a person steering its movements. The robot runs on GPT-6 Astra, and the demonstration adds to a widening body of evidence that the model carries over usefully from text and images into machines that physically move through the world.

What stands out is not that a robot can grasp objects — factory arms have done that for decades. It is that this machine worked out what to do in a room whose layout it had never encountered, using a general-purpose model rather than a pipeline engineered specifically for that one kitchen.

How HomeBody Is Assembled

GPT-6 Astra Calls Directly Into a Skill Library

Most robot-learning stacks insert a trained control layer between the language model and the hardware. That layer — often a policy network or motion planner refined on task-specific data — converts high-level intent into joint-level commands. HomeBody removes it. A swappable vision-language model, in this case GPT Astra, issues calls straight into an extensible library of skills covering grasping, navigation, and opening drawers. Because the library is modular, individual abilities can be added or replaced without retraining the entire system, and the underlying VLM itself can be exchanged for another model.

Explore First, Remember Afterwards

Before handling anything, the robot surveys the room. It constructs a digital twin of the kitchen inside Nvidia's Isaac Sim, then logs objects and their positions in a spatial memory. That memory is what lets the machine locate an item after it has passed out of the robot's field of view — routine for a person, but genuinely difficult for systems that reason only about whatever the camera currently captures.

Planning, Acting, Self-Correcting

Given a loose instruction such as "clean up the kitchen," the language model decomposes the job into steps, carries them out through the skill library, and self-corrects when something goes wrong. The plan is not a fixed script. It adapts to what the robot discovers and to failures as they happen, which is the difference between automation and something closer to general-purpose behavior.

Why Dropping the Control Layer Matters

Removing the trained intermediary changes the economics and the flexibility of the whole system in several ways.

• Generalization: the robot is not locked to a single kitchen layout or a narrow task list, because the reasoning comes from the model rather than from data collected for one environment.
• Modularity: skills can be extended independently, and the vision-language model can be swapped out as better ones appear.
• Interpretability of intent: instructions can be given in ordinary language instead of being compiled into bespoke controllers.

The trade-off is that a frontier model now sits inside the control loop, which is precisely where the system's weaknesses become most visible.

Where the System Still Struggles

The team's account is candid about the shortcomings, and they cluster around the cost of leaning on a large model in real time.

• Latency: GPT-6 Astra's response times are a limiting factor when the robot has to react to a changing physical scene.
• Hardware strain: the finger servos overheat during extended manipulation, a mechanical constraint that no amount of model quality can paper over.
• Compute expense: keeping a frontier model in the loop is costly, which matters for anyone imagining this running in a home rather than a lab.

None of these are trivial. Latency and overheating are the kinds of problems that surface after the demo videos end, when a system has to run for hours rather than minutes. Compute cost determines whether an approach like HomeBody ever leaves the research setting.

Safety Questions and the Benchmark Record

HomeBody arrives against a mixed backdrop. Earlier benchmarks showed that Astra's spatial reasoning had improved substantially — a prerequisite for a model that has to reason about where things are and how to reach them. At the same time, separate work flagged safety issues when Astra is given control of a robot. Those two findings sit uncomfortably together: the same capability that makes the model useful for manipulation also raises the stakes when its judgment is wrong.

A language model issuing direct commands into a skill library compresses the distance between a bad decision and a physical consequence. The absence of a trained control layer removes a filter that might previously have constrained implausible or unsafe actions. That does not make the approach unworkable, but it does mean safety evaluation has to move alongside capability evaluation rather than trailing behind it.

The Wider Push Toward Embodied AI

HomeBody lands in the middle of a broader shift. OpenAI has already announced plans to return to robotics, including machines intended for personal use. That ambition gives demonstrations like this one a commercial context beyond the academic: if a general model can operate a humanoid in an unfamiliar room, the argument for building hardware around a single powerful model becomes much stronger.

The Stanford and Caltech work is best read as a test of that premise. It does not claim to solve household robotics. It shows that the layer most researchers assumed was necessary — a trained controller bridging language and motion — can, at least in this configuration, be replaced by direct calls into a library of reusable skills.

The Code Is Public, and the Questions Are Open

The HomeBody code is available on GitHub, which means other groups can probe the same architecture on different robots and different rooms. The interesting questions are now empirical. How much does performance degrade when the kitchen is messier, the objects are unfamiliar, or the task stretches over hours? How much of the success comes from the skill library and how much from the model's own reasoning? And what happens when latency, heat, and compute budgets are treated as first-class constraints rather than footnotes?

For now, the demonstration stands as another data point that GPT-6 Astra works well with robots — and as a reminder that the gap between a compelling kitchen demo and a dependable household machine is still measured in servos, seconds, and dollars.

This article is based on reporting by The Decoder. Read the original article.