ENPIRE: Agentic Robot Policy Self-Improvement in the Real World

TL;DR

ENPIRE is a harness framework that lets frontier coding agents (Codex / GPT-5.5, Claude Code / Opus 4.7, Kimi Code / K2.6) autonomously improve real-robot manipulation policies inside a closed physical feedback loop. Four modules — Environment (auto-reset + auto-verify), Policy Improvement (heuristics, tool calls, BC, offline / online RL), Rollout (single or fleet), Evolution (the coding agent analyzes logs, consults literature, edits training code) — turn real-world robot learning into a controllable optimization that the agents themselves manage. The headline result: coding agents reach 99% pass@8 on dexterous tasks (Push-T, pin insertion, GPU insertion, cutting a zip tie, tying a zip tie) without human supervision, and the project introduces two efficiency metrics, Mean Robot Utilization (MRU) and Mean Token Utilization (MTU), for measuring multi-agent physical autoresearch.

Key claims

A repeatable real-world feedback loop (reset → execute → verify → refine) is the missing abstraction that lets coding agents automate robotics research, in contrast to prior coding-agent successes confined to digital environments [§Abstract].
The auto-evaluation stack combines a bounding-box detector, a segmentation model, and a per-camera binary verdict (e.g. for zip-tie insertion: tail covered by head?), fused across cameras into the final reward — no human in the verification loop [§Auto Evaluation].
Auto-reset returns each task to a randomized initial state without manual intervention and records whether each reset succeeded with representative frames for inspection [§Auto Reset].
ENPIRE supports multiple Policy Improvement (PI) regimes inside the same loop: heuristic learning, tool calling, behavior cloning, offline RL, online RL — the same harness instruments all of them [§Abstract, §Agents Improve Policies From Physical Feedback].
On Push-T, Pin Insertion, GPU Insertion, Tie Zip-tie, and Cut Zip-tie, agent-driven policies reach a 99% pass@8 success rate after autonomous search [§Learned Manipulation Policy].
AutoEnvBench tracks agent-driven research progress over wall-clock time across Push-T (heuristic learning) and Pin Insertion (gradient-based learning) for three coding agents — Codex / GPT-5.5, Claude Code / Opus 4.7, Kimi Code / K2.6 — instead of only the final-policy success rate [§Evaluate Coding Agent].
Scaling the robot fleet (1 → 4 → 8 agents) trades wall-clock-to-success for resource utilization: MRU decreases as agent teams spend more time summarizing peer branches and less time operating the robot, while GPU active utilization rises, and total token consumption grows superlinearly with fleet size [§Scaling Autoresearch on Robot Fleets, §Limitations].
Simulation evaluation in RoboCasa lets agents run denser ablations and test whether recipes discovered in the physical loop transfer to broader manipulation settings [§Evaluation in Simulation].

Method

ENPIRE is a four-module harness wrapped around a fleet of real robots. The Environment (EN) module exposes each manipulation task as self-resetting and self-verifying — a randomized initial state is sampled, the reset behavior is executed, then a fused multi-camera verifier scores the trial as a binary reward. The Policy Improvement (PI) module is the regime-agnostic learner: at each iteration a coding agent picks an improvement strategy (heuristic, tool-use, behavior cloning, offline / online RL) and edits the training code accordingly. The Rollout (R) module evaluates the candidate policy on one or more physical robots in parallel. The Evolution (E) module is the autoresearch brain — a coding agent (Codex / GPT-5.5, Claude Code / Opus 4.7, or Kimi Code / K2.6) reads logs and prior branches, consults literature, proposes the next algorithmic hypothesis, and writes the next code edit; per-agent branches are visualized as a hypothesis git-tree against the wall-clock success-rate curve so the contribution of individual ideas is auditable. The page reports both real-robot results across five tasks and a simulation suite in RoboCasa for denser ablation.

Results

99% pass@8 success rate across Push-T, Pin Insertion, GPU Insertion, Tie Zip-tie, and Cut Zip-tie under fully autonomous agent-driven search [§Learned Manipulation Policy].
Scaling-law plots on Push-T and Pin Insertion across 1- / 4- / 8-agent teams: larger fleets reach success sooner but at higher total token consumption and lower per-agent Mean Robot Utilization [§Scaling Autoresearch on Robot Fleets].
AutoEnvBench reports per-agent research-progress curves over wall-clock time for Codex / GPT-5.5, Claude Code / Opus 4.7, Kimi Code / K2.6 on both a heuristic-learning task (Push-T) and a gradient-based-learning task (Pin Insertion) [§Evaluate Coding Agent].
Two new metrics introduced for multi-agent physical autoresearch: MRU (Mean Robot Utilization, the fraction of wall-clock time the robot is actively running trials rather than waiting on agent log-reading / debugging / LLM-backbone latency) and MTU (Mean Token Utilization) [§Abstract, §Limitations].
Acknowledged limitations: robot and compute are under-utilized while agents read logs / write code / wait on the LLM backbone, and scaling the fleet drives token consumption up because more agents must summarize each other’s branches [§Limitations].

Why it’s interesting

ENPIRE is the first filed AI-for-AI-research instance whose closed loop closes through physical hardware, not a Kubernetes training run or a Lean compiler. The four AI-for-AI Research systems already on the wiki — Scaling Karpathy's Autoresearch: What Happens When the Agent Gets a GPU Cluster (single-knob val_bpb search), AlphaGo Moment for Model Architecture Discovery (architecture-scale linear-attention search), FARS: Fully Automated Research System (paper-scale autonomous research), and Kosmos: An AI Scientist for Autonomous Discovery (cross-domain scientific discovery) — all converge on the same scaffold pattern, but each runs on cheap digital experiments. ENPIRE pays the action cost in real-robot wall-clock time, which is why the project foregrounds MRU / MTU as new headline metrics; the question “how much does parallel scaling actually buy you” inverts when each rollout costs minutes of physical robot time. It also extends the RL Environment Platforms env-as-package pattern (Docker backend + automated verifier, e.g. Toolathlon-GYM: Large-Scale Long-Horizon Environments for Tool-Use Agents, SETA: Scaling Environments for Terminal Agents (env repo)) into manipulation by treating the auto-reset + multi-camera verifier as the same role the Docker sandbox plays for terminal agents, and complements Genesis World — Simulation platform for general-purpose robotics & embodied AI learning / RoboCasa365 — Large-Scale Simulation of Everyday Tasks for Generalist Robots on the simulation side. Finally, the coding-agent lineup (Codex / GPT-5.5, Claude Code / Opus 4.7, Kimi Code / K2.6) makes this the first wiki-filed head-to-head Agentic Software Engineering evaluation where the deliverable is a working dexterous manipulation policy rather than a SWE-Bench score.