Nvidia’s ENPIRE Hands AI Coding Agents a Robot Fleet to Train Themselves

Nvidia, Carnegie Mellon University and the University of California, Berkeley have built a framework that moves AI coding agents from writing software on screens to teaching physical robots new skills on live hardware. Named ENPIRE, the system automates the end-to-end loop of generating training code, running experiments on robot fleets, and iterating until tasks are mastered—all without a human operator. The approach is the first to combine large language model coding agents with real robotics hardware at scale, effectively handing an entire fleet of eight robot arms to agents like Codex, Claude Code and Kimi Code so they can learn, reset and improve entirely on their own.

What ENPIRE demonstrates is not just another simulation-based training run, but a practical pathway to autonomous skill acquisition in robot fleets. By letting coding agents control physical reset routines, data collection and policy refinement, the system removes the traditional bottleneck of human oversight. The results show that when eight robots collaborate, they can reach over 99% task success on tasks such as pin insertion, GPU seating and zip-tie cutting—while also cutting the time to master a new task by more than half compared to a single robot, even though the total compute cost grows faster than the time saved.

From Code on Screen to Code on Hardware

Historically, AI agents that write and test code have operated in isolated software environments where failure is cheap and reset is instant. ENPIRE extends that loop into the physical world by giving agents direct control over robot hardware and workspace resets. The framework splits training into two phases. In the first phase, a human guides the agent in building two permanent tools: a reset routine that returns the workspace to a known safe state, and a data logger that records sensor streams and outcomes after every trial. Once these tools are in place, the agent takes full control, repeatedly generating new policies, executing them on the robots, analyzing failures, and rewriting its own code—without any human intervention. This shift from supervised to fully autonomous experimentation marks a fundamental change in how robots can learn.

The practical implication is that teams no longer need to babysit every training run. Instead, they can set up a robot fleet, define the task in natural language, and let the agents iterate until the robots consistently succeed. The system is designed to handle the messiness of real hardware: dropped objects, misaligned parts, sensor noise—all become inputs to the agent’s self-correction loop. For robotics labs and manufacturers, this reduces the need for custom simulation environments and manual data collection, replacing them with a general-purpose framework that adapts to new tasks through code.

Agents That Code, Test and Improve on Real Arms

ENPIRE uses state-of-the-art coding agents—including variants of Codex, Claude Code and Kimi Code—to write Python-based training loops that call robot APIs, capture sensor feedback, and adjust control policies. Each agent generates candidate solutions in code, runs them on one or more robot arms, logs metrics, and uses the outcomes to refine its next attempt. Because the agents operate in a closed loop with physical hardware, they experience the full cost of failure: a dropped pin or mis-seated GPU must be reset before the next attempt, and each reset consumes real time and energy. This creates a strong incentive for the agent to converge quickly on reliable policies.

The framework’s design deliberately mirrors how human engineers debug code, but at robot speed. When a policy fails, the agent doesn’t just see a binary success or failure—it receives detailed logs of joint trajectories, force readings, and visual detections. The agent can then edit its code to adjust tolerances, retry strategies, or even switch to a different grasping approach. Over time, this leads to policies that are robust to real-world variability. The paper reports that an eight-robot fleet reached 99% success across multiple tasks, suggesting that parallelization and shared learning accelerate both performance and reliability.

Scaling from One Arm to Eight Arms

One of the most striking findings is how performance scales with fleet size. Training a single robot to insert a pin can take hours, with many failed attempts along the way. With eight arms working in parallel, ENPIRE cut the wall-clock time to mastery by more than half, even though the total compute token usage grew faster than the time saved. This indicates that parallelization provides diminishing returns in compute efficiency but clear gains in real-world throughput. For manufacturers, this means that deploying multiple robots under ENPIRE can significantly shorten the time needed to bring a new skill online.

The scaling behavior also reveals practical trade-offs. While more robots accelerate data collection, each additional arm increases the complexity of workspace management and the risk of collisions or interference. ENPIRE addresses this by enforcing strict reset protocols and data logging, ensuring that every robot operates within a controlled state space. The framework’s ability to generalize across different tasks—from delicate pin insertion to forceful zip-tie cutting—suggests it can adapt to a wide range of industrial operations without redesigning the training loop for each new skill.

Token Costs and Compute Efficiency

Despite the time savings, the total token cost of training grows faster than the reduction in wall-clock time. Every iteration, whether successful or not, consumes tokens as the agent reads logs, writes new code, and calls APIs. In large fleets, this can lead to substantial compute bills, especially when agents explore many dead-end strategies before converging. The paper does not provide exact dollar figures, but the trend is clear: autonomous robot training is compute-intensive, and cost management will be a key factor in real deployments.

For teams considering ENPIRE, the cost equation depends on task complexity and fleet size. Simple tasks with clear success criteria may converge quickly, keeping token usage low. Complex tasks with ambiguous feedback—such as fine assembly with tight tolerances—may require many iterations, driving up costs. The framework’s reliance on proprietary coding agents also introduces licensing and rate-limit considerations. Teams will need to budget for compute and agent access, and may explore open-source alternatives or local fine-tuning to reduce dependency on third-party services.

What This Means for Robotics Teams and Factories

ENPIRE signals a shift from manually programmed robots to self-programming ones. For research labs, it offers a way to rapidly prototype new skills without building custom simulators or collecting large datasets. For factories, it could shorten deployment cycles for new product lines, especially in electronics assembly where tasks like GPU seating and connector insertion are common. The ability to define tasks in natural language and let agents iterate until success is achieved reduces the need for specialized robotics engineers, lowering the barrier to automation.

However, the framework is not a plug-and-play solution for every use case. Tasks requiring high precision, safety-critical operations, or compliance with regulations will still need human oversight and validation. ENPIRE’s output must be audited before deployment in real production lines. Additionally, the framework’s reliance on coding agents introduces variability in policy quality—some agents may generate brittle or unsafe code if not properly constrained. Teams will need to implement guardrails, such as policy validation layers or fallback human operators, to ensure reliability.

The Road Ahead: From Research to Real-World Use

The next phase for ENPIRE is likely to focus on generalization and safety. The current system excels at specific, well-defined tasks but may struggle with open-ended or highly variable environments. Future work could integrate vision-language models to interpret unstructured scenes, or add human-in-the-loop validation for high-stakes tasks. Another priority is reducing token costs through more efficient agent architectures or local fine-tuning of open-source models.

For hardware vendors, ENPIRE highlights the growing importance of software-defined robotics. Companies that provide robot arms, grippers, and sensors will need to expose clean APIs and robust reset mechanisms to support autonomous training. For AI platform providers, the framework underscores the value of coding agents that can operate beyond the screen, interfacing directly with physical systems. This could drive demand for agent platforms that support hardware integration, logging, and safety checks out of the box.

Practical Takeaways for Teams Evaluating ENPIRE

• Start with well-defined, repetitive tasks that have clear success criteria, such as insertion or cutting operations.
• Budget for compute costs, especially when using proprietary coding agents, and consider open-source alternatives for cost-sensitive projects.
• Implement safety checks and human review before deploying learned policies in production environments.
• Use parallel fleets to accelerate training, but monitor for interference and manage workspace reset protocols carefully.
• Plan for integration with existing robot APIs and data logging systems to minimize setup time.

ENPIRE represents a meaningful step toward autonomous robotics, where machines teach themselves new skills with minimal human input. While not a universal solution, it demonstrates that coding agents can extend their reach from software development to physical action—ushering in an era where robot fleets become self-improving systems. The challenge ahead is to make this capability reliable, affordable, and safe enough for real-world deployment.