NVIDIA Lets Robots Self-Learn Overnight to Install GPUs, ENPIRE to Be Open-Sourced Soon

On June 17, Jim Fan, co-head of NVIDIA’s GEAR Lab, posted a video on X: eight Codex agents were thrown into a real robot workshop, equipped with a set of robotic arms, a batch of GPUs, and a generous token budget, and were given a single instruction — “Finish the job as quickly as possible, keep the robots busy, but don’t cause accidents or waste money.”

Then the people left. The next morning, researchers returned to look at a training report, not an experiment log.

This is ENPIRE, short for “Agentic Robot Policy Self-Improvement in the Real World,” developed by NVIDIA GEAR in collaboration with CMU and UC Berkeley. Jim Fan calls this direction AutoResearch — letting AI conduct scientific research by itself. In the past, this had only been done in a purely digital world, such as letting agents automatically run experiments, run benchmarks, and write reports. ENPIRE is the first time this loop has been moved into the physical world, onto real hardware.

Not Remote Control, But True Free-Roaming

To understand ENPIRE’s significance, you first have to differentiate it from past “AI + robotics” demos.

Most robotics learning projects, whether using reinforcement learning or imitation learning, require a human somewhere in the core loop. A human may design the reward function, label data, or reset the scene — when the robotic arm pushes a block off the table, a grad student has to run over and pick it up. The human’s presence in the loop limits the learning speed to the grad student’s endurance.

ENPIRE’s goal is to completely remove this human from the loop. It provides programming agents like Codex with an API into the physical world, and lets the agents handle the rest:

• Experiment design: Define the training process, sampling strategy, and hyperparameters for the current task
• Execute training: Schedule GPU resources and let the robots try
• Judge success or failure: Use visual cues to tell if the task is done or if the robot got stuck
• Reset the scene: Have the robot arm return objects to their starting positions, eliminating manual intervention
• Analyze failures: Check logs, review videos, and analyze code for issues
• Consult literature: Go online to read research papers on how others solved similar problems
• Revise code and retry: Iterate on the control stack and run again

The key points in this loop are “resetting the scene” and “judging success or failure” — traditionally human tasks, now taken over by agents using computer vision plus code generation. Once these two steps are closed, the entire robotics lab can run 24/7, with researchers only needing to review summaries each morning.

It Really Inserted a GPU Into a Motherboard

Just talking about loops is boring — we need to see how hard the tasks are. ENPIRE tested several challenging manipulation skills:

• Precisely inserting fine pins into holes on a box
• Threading a cable tie
• Cutting the cable tie with scissors
• Inserting a GPU into a motherboard’s PCIe slot
• Organizing a pile of nails

The last one is particularly amusing — NVIDIA’s robot installing a NVIDIA GPU into a NVIDIA motherboard. From a hardware perspective, the PCIe slot’s alignment tolerance is only at the millimeter level, requiring high precision in force feedback and visual alignment. The agent’s self-trained policy ultimately achieved a 99% success rate under the pass@8 standard.

What does this mean? It means that if you give ENPIRE a brand-new dexterous manipulation task it has never seen, and let it run overnight, you’ll likely have a working policy by the next morning. This equals roughly three months of work for a PhD researcher in a traditional robotics lab.

Three Programming Agents Competing Side-by-Side

An interesting detail in the paper: ENPIRE didn’t just test OpenAI’s Codex; it also included two other systems for comparison:

• OpenAI Codex (paired with GPT-5.5)
• Anthropic Claude Code (paired with Opus 4.7)
• Moonshot AI Kimi Code (paired with Kimi K2.6)

All three could complete the entire AutoResearch process, but their research speed differed across tasks. The paper doesn’t declare a clear winner, but this kind of head-to-head is revealing — it shows that the agentic coding race has escalated to “who can better drive robots to do research.” A year ago we were still comparing HumanEval scores; now we’re comparing who can teach a robotic arm to install a GPU fastest.

All three models are available through the OpenAI Hub, where developers can try replicating results or tweak prompts, switching between Codex, Claude, and Kimi with the same key — no need to apply for quotas from each provider.

“Physical Scaling Law”: How Much Faster Are 8 Robots Compared to 1

ENPIRE also observed a phenomenon they call the “physical scaling law.”

The name sounds grand, but the core observation is intuitive: running AutoResearch in parallel on 8 robots advances research much faster than on just 1 or 4. Two reasons:

1. Parallel experiments are inherently faster: 8 robots can test 8 different strategies at once, similar to increasing a researcher’s batch size from 1 to 8.
2. Agents learn from each other: If one robot discovers an effective trick, other agents can reference its successful code — like multiple PhDs peer-reviewing each other’s work on the same project.

But this scaling isn’t linear. With more robots:

• Token consumption rises sharply: Each robot must be monitored, summarized, and scheduled by the agent
• Coordination overhead grows: Agents spend more time reading “teammates’ progress”
• Per-unit utilization drops: Sometimes robots wait for each other’s results

This is strikingly similar to the scalability curve of human research teams — a 10-person lab is faster than a single person, but not 10x faster. ENPIRE’s novelty is that it quantified this “organizational behavior” effect for the first time in an AI agent + physical robot setup.

Why NVIDIA, Why Now

GEAR Lab was founded late last year by Jim Fan and Professor Zhu Yuke — its name stands for Generalist Embodied Agent Research. Its mission is clear: build foundation models for embodied intelligence, not just for virtual worlds (games, simulators) but also the physical world (robots).

They’ve built a series of components:

• Cosmos: A world foundation model that can generate physically realistic videos and scenes
• GR00T: A general-purpose humanoid robot foundation model
• DreamDojo: A policy learning environment based on world models
• Isaac Sim/Lab: Simulators and synthetic data pipelines

ENPIRE is the “last mile” in this system — the previous models, simulators, and world models feed data and perform pretraining, but deploying robots in the real world still requires fine-tuning and adaptation on the actual hardware. This step used to heavily depend on humans, and ENPIRE automates it.

From a product standpoint, NVIDIA sells GPUs, robotics development kits (Jetson, Thor), and software stacks. If it can ensure that “customers who buy our hardware don’t have to babysit experiments overnight and can have ready-to-use strategies in the morning,” it will greatly boost the hardware’s appeal. This is a classic NVIDIA play — lower the developer threshold to the floor so the ecosystem grows by itself.

What Open-Sourcing Means

Jim Fan made it clear that ENPIRE will be open-sourced. The impact of this has two layers:

For leading robotics labs: It cuts costs. Instead of paying a group of PhDs to watch over experiments, you can wrap this agent framework around your setup and turn researchers from “operators” into “product managers” — defining tasks, reading reports, and deciding the next research direction. A lab’s output could multiply.

For individual developers and hobbyists: In theory, you could set up a “self-running robotics lab” at home. In practice, the bar is still high — you need at least:

• A set of robotic arms (at least 1, ideally 4–8 for scaling effects)
• A batch of GPUs (for training policies, not just inference)
• A token budget for programming agents (Codex, Claude Code, etc. aren’t cheap)

So realistically, “hosting an automated robotics lab at home” is more likely to become standard for small-to-medium robotics companies and university labs, rather than garage hobbyists. Then again, in 2017 you wouldn’t have expected to run a GPT-3-scale LLM on your own GPU just a few years later. Open-source compounding effects are always underestimated.

Some Unresolved Issues

After watching the demo video and reading the paper abstract, I have several reservations:

1. Safety: Letting an agent fully control robotic arms means its code directly drives heavy machinery. The paper highlights “safety” as a constraint, but the fail-safes, past accidents, and measures to prevent dangerous moves in pursuit of success rates are details worth examining.
2. Task generalization: Current tests involve “repeating a specific action in a fixed setting.” Real robotics applications often require performing long-sequence tasks in changing environments. Whether the ENPIRE loop can extend to such contexts is key for the future.
3. Cost: How many tokens do 8 agents burn overnight? If training a policy costs thousands of dollars in API calls, is it really cheaper than hiring a PhD? The paper doesn’t provide this calculation.
4. Reliability of ‘agents learning from each other’: In multi-agent collaboration, if one agent goes astray, could it mislead the entire group? This is an old problem in multi-agent systems, and mistakes in the physical world have higher costs.

Final Thoughts

ENPIRE is one of the most “futuristic” robotics learning projects I’ve seen in the past six months. Not because it made a groundbreaking algorithmic advance — taken individually, components like agents, code generation, self-improvement, and multi-robot setups aren’t new. Its power lies in engineering integration: stitching these mature components into a closed loop that can operate autonomously 24/7 in the physical world for the first time.

Such “engineering tipping points” often change the industry more than algorithmic breakthroughs. When a robotics lab’s capacity is no longer limited by human working hours, the iteration speed of the entire embodied intelligence field will be redefined.

As for what happens after open-sourcing, we’ll just have to wait and see.

References

• ITHome: NVIDIA’s robots self-learn “GPU installation,” bringing AI into the real world with full autonomy — First Chinese media coverage with Jim Fan’s video and task demo
• Zhihu Column: An in-depth conversation with GEAR on world models, self-evolution loops, and DreamDojo — Background interview on GEAR Lab’s world model and self-evolution loop