Stanford's HomeBody connects GPT-6 Astra to the Unitree G1 to tidy up the kitchen

The robot's GPT moment really does depend on GPT (doge)!

Just now, GPT-6 Astra was connected to Unitree G1, and it went into the kitchen to work~

In the Stanford team's latest project HomeBody, Unitree G1 first explores a kitchen it has never seen before, and then, following language instructions, it can tidy up objects, throw away cardboard boxes, and even find medicine that is not in front of it and hand it to a person.

For example, tell it to gather the coffee bags in the middle, and then throw away the specified milk and orange juice cartons.

G1 will move back and forth in the kitchen, gather the coffee bags onto the island counter, and then deal with the cartons to be discarded.

For another example, a single sentence: "Bring me the medicine."

Even if the medicine is not in its current field of view, it can find clues from previously saved images, walk to the corresponding drawer, open the drawer, take out the medicine, and then hand it to the person, while also completing the task of throwing away cartons along the way.

It can be said that from Robocurve previously letting GPT and Claude control a robotic arm to complete tabletop pick-and-place tests, to this time G1 entering the kitchen, the scope of tasks in which large models control robots has expanded another circle.

This time, the robot not only has to decide what to grasp in front of it, but also remember where things are, and then string walking, grasping, and placing together into a sequence.

More notably, the team says that when deployed to this new kitchen, the system does not need to collect additional training data, nor does it need to train another dedicated motion policy. Its generalization is quite good.

Seeing this, some people could not help but start calculating:

If I had the money to buy a G1 and then connect it to GPT, could I also...?

Let's first look at how HomeBody actually gets the work done.

Simply put, the core idea of HomeBody can be summed up in one sentence: Let GPT treat robot skills as tools to call.

Astra is responsible for understanding goals and arranging steps, then calling skills such as navigation, grasping, and opening drawers to complete the task step by step.

However, to let a robot go to the kitchen to fetch things, it first has to know what the kitchen looks like and where things are placed.

The whole process can be divided into three steps.

In HomeBody, the first instruction the robot receives is very simple: "You are a kitchen robot. Please explore this space."

Then, Astra selects positions worth observing and guides G1 to move. As the robot walks, it records camera images, lidar scans, and its own joint postures and the positions it passes through.

The camera is responsible for seeing what is in the room, while sensors such as lidar provide measured spatial structure; SLAM, that is, simultaneous localization and mapping, helps the robot build a map while determining where it is.

These observations do not disappear when the robot turns around; instead, they are saved and become spatial memory that can be called upon for subsequent tasks.

Touring is not enough. Astra next also acts as a Real2Sim agent, building a digital kitchen in the Isaac Sim simulation platform.

This digital twin is equivalent to a three-dimensional room model, helping the system determine the locations of various places and the spatial relationship between the robot and the target.

To make the digital kitchen not only look similar, HomeBody also gives the model the geometric information measured by SLAM, using real measurements to constrain the reconstruction result.

After all, the position of the countertop and the width of the passage will affect whether the robot can walk through and whether its hand can reach the position.

Then, the system aligns the real-world localization map with the digital kitchen in the same coordinate system, and associates the captured images, content descriptions, and corresponding locations.

In this way, the previously saved image is not just "I have seen this drawer," but also corresponds to a location to which the robot can return.

When looking for things later, the robot can first check clues from memory and then walk back to the corresponding location.

After preparation is complete, the user can say "tidy up the kitchen," and then add where the coffee bags should go and which cartons should be thrown away.

Astra will combine the current image, map, spatial memory, whether it is holding something in its hand, and the execution result of the previous step to choose which skill to call next and which target to operate on.

The medicine-fetching demo shown earlier used this capability. Although the user did not say where the medicine was, the system can find the drawer from the saved key images and then connect skills such as navigation, opening the drawer, and taking out the medicine.

Previously, when Robocurve let GPT and Claude control a robotic arm, the model used tool calls to specify the gripper's position, orientation, and open-close state based on camera images and robot state, and then the low-level module converted them into specific actions.

HomeBody also uses tool calls, but what it hands to GPT are more complete skills: navigation, grasping, placing, opening drawers, and picking objects from drawers.

To understand the difference between the two, let's first look at a common division of labor in robot systems:

Simply put, it is "arrange the task—generate actions—control the body."

What HomeBody adjusts is exactly the middle link: letting System 2 directly call the skill library, with skill modules planning specific actions and then handing them to the low-level control system for execution, without going through a learned VLA.

Specifically, these skill libraries contain already-written, reusable motor skills (Navigate, Pick, Place, Open drawer, Pick from drawer, etc.).

These skills have a unified interface: the large model only needs to tell it "where to go, what to grasp, and where to put it," and the skill executes on its own, then feeds the result back to the large model after execution.

For example, for grasping, Astra only needs to point out the target object in the image and specify whether to use the left or right hand.

Next, the perception module inside the grasping skill will outline the object, estimate depth, determine the target's 3D position in combination with camera calibration, and calculate the grasp pose. The motion planner then plans how the robotic arm should reach over and how to avoid obstacles, and finally hands it to the control module for execution.

In other words, GPT decides which one to grasp and which hand to use, while the skill module handles how the hand reaches over and how to grasp it.

Other skills follow a similar division of labor. Navigation receives the target position and orientation; placing receives the drop point for the item; opening a drawer encapsulates aligning with the handle, hooking the handle, and pulling back to open it into one complete skill.

After each skill is executed, the result is fed back to Astra, which then decides the next step. When deviations occur, the skill module will first adjust and retry on its own, and if it cannot resolve the issue, it hands it back to the large model for re-planning.

Through this decision—execution—feedback loop, "walk to the drawer—open the drawer—take out the medicine" can be chained into one task, without requiring the large model to handle every step of the motion details.

As for how to maintain balance while walking and reaching, that belongs to the work of System 0 mentioned earlier. HomeBody uses a pretrained AMO control policy, allowing lower-body movement to simultaneously consider the upper body's action goals, coordinating walking and manipulation.

This also explains why not needing additional training does not mean the entire system has never been trained. HomeBody does not need to retrain a dedicated motion policy for a new kitchen, but the existing perception models, motion planning, and pretrained controllers are still the foundation that enables the robot to get work done.

However, saving on training for new environments does not mean there is no cost to deployment and operation.

Currently, HomeBody's perception, planning, and skill execution run on a laptop equipped with an RTX 4090, while Astra is responsible for decision-making remotely.

Rebuilding the digital kitchen in the early stage requires preparation time and API costs; during actual task execution, model inference also causes waits between actions.

Even if the software pipeline runs smoothly, long-duration work still has to pass the hardware hurdle—for example, overheating of the finger servos is one of the limitations the system currently faces.

So, connecting GPT to the Unitree robot can indeed let the robot work in the kitchen, but behind it there still has to be a complete set of perception, planning, and control systems working together.

As for buying a G1 now, connecting it to GPT's API, and waiting for it to do your chores—it is not that simple yet.

Since the root of all evil, Robocurve, began using GPT-6 Astra to control robots, the robotics/embodied AI circle entered the "large model era" almost overnight.

Overall, there are currently several main routes:

The first is the approach Robocurve adopted earliest: the large model directly receives camera images and robot state, outputs the gripper's target position, orientation, and opening/closing degree, and then the low-level inverse kinematics module converts them into joint actions for execution; after completion, it observes again, forming a closed loop.

The second route is to let the large model act as System 2 (slow thinking), paired with a VLA responsible for generating actions. Anthropic has tested letting a language model receive, modify, or even replace the actions proposed by MolmoAct.

This time, HomeBody chooses to let System 2 directly schedule the skill library, and then the low-level system, including the pretrained AMO, handles execution and body coordination.

It is not simply "adding another layer of System 0," but rather changing the way decisions and actions are connected, and combining it with spatial memory to extend tasks from the desktop to the entire room.

Currently, Robocurve's latest status is: the latest GPT-6 Sol has an average score 1.6 times that of GPT-5.6 Sol, while costing about 47% less.

Opus 5.5's average score is about 1.8 times that of Opus 5, close to GPT-6 Astra, with a single-run cost about 21% lower than Astra.