HoloBoxing teaches a humanoid to box in 7 minutes on a single GPU

The HoloBoxing team has proposed a simple recipe for training a humanoid robot to box: take a whole-body controller that is already trained, freeze it, and train a small planner on top that decides where and how to punch. The additional training takes about seven minutes on a single GPU. The work is published on arXiv as 2610.32909 and was featured in Hugging Face Daily Papers.

Motor skills in one place, tactics in another

Anyone who has tried to train a humanoid with reinforcement learning knows the problem: a single policy has to keep its balance, coordinate dozens of joints, and win the task at the same time. The reward for a punch gets smeared across that whole tangle, so training is slow and unstable.

HoloBoxing cuts the task along the seam. The ability to move the body lives in a frozen, pretrained controller that handles execution at the joint level. Everything related to fighting falls to a compact high-level policy. It does not command the motors directly. Instead, it predicts target points for the body: where the hands, torso, and other parts should end up.

There is one more layer between the planner and the controller. A trained mapping turns the planner's 32-dimensional action into structured target windows, meaning a set of points over a short horizon that the controller can work with. The action space stays small, and the controller receives input it already knows how to handle.

Start with imitation, finish with reward

The downside of pure RL is that exploration begins almost blind. The authors address this with imitation initialization: the planner first acquires basic boxing behavior, and only then does reinforcement learning refine the interaction with the opponent. The reward polishes behavior that already resembles a fight rather than searching for a fight from scratch.

As a result, the optimization problem shrinks to a small high-level policy. Full-body control is never relearned at any step.

What the seven minutes include and what they don't

The authors are careful about the limits of this figure. Here is how it breaks down:

• Frozen whole-body controller: pretrained in advance, not part of the budget.
• Compact planner: predicts target body points for the boxing task.
• Planner action: 32 dimensions.
• Trained mapping: converts 32-dimensional actions into structured target windows.
• Imitation initialization: provides starting behavior before RL begins.
• Reinforcement learning: refines behavior in combat, reusing the representation and the controller.
• Budget: about seven minutes, including fitting the reusable representation and one task run on a single GPU.
• Not counted: controller pretraining, data preparation, evaluation, and hyperparameter search.

The last item matters. The seven minutes describe the cost of a new task given a ready base, not the cost of the entire pipeline from scratch. That is an honest metric for a scenario where the controller already exists and only needs to learn a new activity.

The evaluation was done in simulation: the authors ran boxing experiments and per-component ablation runs to understand the role of imitation initialization and the other parts of the recipe. The paper includes no real robot in a ring, and transfer from simulator to hardware remains a separate question.

Where this is useful

The main value of the work lies in the architectural technique. If a team has a good general-purpose body controller, every new task, whether boxing, wrestling, or team interactions, becomes a short experiment on a single GPU. This shifts the center of gravity: the expensive part is done once, while the cheap part can be iterated dozens of times a day.

For labs without clusters, it is also a matter of accessibility. Many labs can train the top layer on a single GPU, but not pretrain a controller from scratch. A division of labor between those who build base controllers and those who write tasks on top of them looks like a natural ecosystem for humanoid robotics.

The practical takeaway for engineers is this: before adding complexity to an end-to-end policy, check whether you can freeze the low level and optimize only a compact high-level one. If the starting behavior can be obtained through imitation, RL in the second stage is needed only for fine-tuning, and training time is measured in minutes.