One-sentence Summary

Researchers from Tsinghua University's Institute for AI Industry Research (AIR) and Z-Trans AI introduce Zetta, a closed-loop embodied harness that evolves code-based runtime critics and recovery skills online through three timescale-separated loops while keeping the base policy frozen, attaining $90.8\%$90.8% on LIBERO-Pro and $93.6\%$93.6% on RoboCasa with an $11.1\times$11.1× inference speedup and zero-shot transfer.

Key Contributions

• Zetta is a closed-loop embodied harness that keeps the base policy frozen while online evolving code-based runtime critics and recovery skills through three timescale-separated loops: action-frequency governance, rollout-level critic-recovery proposal, and validation-gated skill updates.
• Z-Infra is a rollout infrastructure designed for self-evolving embodied agents that decouples agent logic from heterogeneous execution resources and supports continuous batching, resource-sharing environments, and fine-grained processor control.
• Experiments with Zetta and Z-Infra show state-of-the-art success on LIBERO-Pro and RoboCasa under the current rollout budget, reaching 90.8% and 93.6% with an 11.1× inference speedup; success scales with self-exploration experience and learned skills transfer zero-shot.

Introduction

The authors address the challenge of scaling physical intelligence, where end-to-end policy models such as vision-language-action models still face scarce embodied data and brittle real-world deployment, while language-model-based embodied agents orchestrate policies and tools but remain largely open-loop during execution. Existing harnesses reflect mainly after an episode completes, which limits their ability to govern high-frequency robot-environment interaction, assign credit precisely, or turn deployment experience into reusable improvements. The authors’ main contribution is Zetta, a closed-loop embodied harness that evolves code-based runtime critics and recovery skills online while keeping the base policy frozen, using three coordinated loops at action, rollout-batch, and iteration timescales. They also introduce Z-Infra, a rollout infrastructure designed for self-evolving embodied agents that decouples agent logic from heterogeneous execution resources to accelerate learning from self-exploration.

Method

The authors propose a dual-agent governance and evolutionary architecture, termed Zetta, to enable deployment-time evolution of embodied agents without altering the underlying policy parameters. The framework formalizes long-horizon robotic manipulation as an authority-constrained governance process, driven by two core fixed runtime components: the Action Policy and the Orchestrator Agent. The Action Policy generates low-level actions $a_t = \pi(s_t, g; \theta)$at​=π(st​,g;θ) where parameters $\theta$θ satisfy the constraint $\nabla \theta = 0$∇θ=0. The Orchestrator Agent acts as a fixed multimodal reasoning operator responsible for auditing real-time evidence and approving mode transitions. To facilitate closed-loop capability evolution, the system introduces an Evolvable Harness comprising a Runtime Critic for high-frequency monitoring, a Recovery Playbook mapping strategies to causal failure mechanisms, and a Heterogeneous Toolset of executable operators.

During execution, the final operational mode is determined by an online adjudication logic that enforces evidence-driven decision-making. Although the Runtime Critic operates at a high frequency, interventions are only permitted if the auditable evidence of failure is validated and accepted by the Orchestrator Agent. To optimize the Harness offline, the authors introduce Evolutionary Agents that iteratively improve the harness components by analyzing failed rollout data. The optimization objective is defined as $\max_{\mathcal{H}} J(\mathcal{H}) = \mathbb{E}_{g, s_0 \sim \mathcal{D}} [\text{Success}(\tau) \mid \pi, \mathcal{A}_{\text{orch}}, \mathcal{H}]$maxH​J(H)=Eg,s0​∼D​[Success(τ)∣π,Aorch​,H], aiming to maximize the expected task success rate while keeping the base policy and orchestrator invariant.

The evolutionary process operates through a tripartite pipeline. In Phase I, the system conducts large-scale sampling to establish a performance baseline and categorizes trajectories into a Successful Reference Index and a Failed-Seed Manifest. Phase II focuses on mechanism-level failure clustering and top-down hierarchical causal diagnosis. The Diagnosis Agent clusters seeds based on the Earliest Observable Divergence $t_{EOD}$tEOD​, defined as the first time step where the state distribution deviates from the healthy distribution: $t_{EOD} = \min \{t \mid \text{dist}(s_t, s_t^{ref}) > \epsilon, s_t^{ref} \in I_{succ}(\mu_t)\}$tEOD​=min{t∣dist(st​,stref​)>ϵ,stref​∈Isucc​(μt​)}. It then executes a systematic inspection across diagnostic layers, ranging from evaluation and critic layers down to parameter layers. Following diagnosis, the Repair Agent implements minimal harness patches, embedding a strict VLA Re-entry Contract to ensure safe control handover. Phase III consolidates these seed-specific patches into a unified, versioned Harness, which undergoes rigorous historical regression and held-out evaluation to confirm genuine generalization.

To support the massive parallel rollouts required by this self-evolving agent, the authors design Z-Infra, a specialized rollout infrastructure that decouples agent logic from hardware resource management. The infrastructure addresses resource heterogeneity and execution dynamism through a decoupled abstraction layer.

As shown in the figure below:

The Z-Infra architecture is organized into three distinct layers. The Control Plane serves as the single entry point, exposing a unified API that abstracts backend heterogeneity, handles request routing, and manages fault tolerance via a global session registry. The Environment Worker Layer manages the lifecycle of simulation environments across diverse families, utilizing a session-based lifecycle management system and resource-sharing groups to amortize model compilation and rendering context setup. The Rollout Worker Layer provides GPU-resident model serving for VLA and perception models. It implements a scheduler that classifies inference requests into compatibility groups and dispatches them in a first-come-first-served manner. To maximize throughput, the Rollout Worker leverages model partitioning, deploying the Vision-Language Model and Action Expert as separate processes with independent scheduling policies, alongside an optional quantization runtime to balance inference efficiency and policy success rates. Communication across these layers is structured around bounded asynchronous channels, enabling transparent scaling across multi-node GPU clusters.

Experiment

The framework is evaluated on LIBERO-Pro and RoboCasa using frozen pretrained VLA policies and strict held-out seed generalization. It first profiles empirical failure patterns under deterministic execution, then evolves critic and recovery mechanisms that target physical bottlenecks without fine-tuning the policy. The experiments show that identifying root physical state variables leads to discontinuous "Aha" gains, and that accumulated mechanisms scale intra-task performance and transfer zero-shot across related tasks. Additional infrastructure evaluation shows that Z-Infra sustains controlled latency and higher throughput under concurrency compared with baselines.

The core agent API is organized into five categories: session management, observation and state, low-level control, policy execution, and perception and planning. All primitives support transparent batching across sessions, while policy execution supports both atomic observe-infer-step operations and autonomous episode runs. Performance context shows Z-Infra scales throughput under concurrency with controlled latency growth, outperforming baselines that lack its persistent worker and asynchronous batching design. The API groups primitives into five categories covering session lifecycle, environment introspection, motor control, policy execution, and perception and planning. Session management primitives create, renew, and close long-lived sessions, with episodes running within sessions from reset to termination. All primitives support transparent batching across multiple sessions. Policy execution includes policy_step for atomic observe-infer-step calls and run_episode for autonomous execution. Z-Infra achieves higher throughput and more controlled latency growth under concurrency than baselines, attributed to persistent workers, dynamic batching, and asynchronous scheduling.

On the 18 RoboCasa Atomic-Seen tasks, Zetta outperforms the pure VLA baseline on every task and raises the macro-average success rate by 20 percentage points. The largest absolute gains occur on tasks where the baseline success was lowest, while already strong tasks improve by smaller margins. Across the wider evaluation, Zetta is reported to improve 32 task-setting pairs and match the baseline on the remaining eight. Zetta raises the macro-average success rate from 73.56% to 93.56% and outperforms the baseline on all 18 listed RoboCasa tasks. The largest gains are on weaker baseline tasks such as T5 and T15; broader reported results also show Zetta improving 32 task-setting pairs while matching the remaining eight.

Zetta substantially improves average success over the frozen pi0.5 baseline on LIBERO-Pro, with the overall macro-average rising from about 32 percent to about 71 percent. Gains are largest on Goal variants, where average success reaches roughly 89 to 93 percent after starting from 31 to 38 percent. On LIBERO-10 settings, improvements are more modest but still clear, especially in the S condition where the baseline is very weak. Average success in Goal (T) and Goal (S) improves from 31.0 and 38.0 to 92.5 and 89.0, respectively. Zetta raises LIBERO-10 (S) average success from single digits to 40 percent, while the baseline remains near zero on most tasks. Across individual tasks, Zetta generally matches or exceeds the frozen pi0.5 baseline, with especially consistent gains on Goal tasks.

The evaluation covers the agent API design, downstream policy performance, and generalization across benchmarks. The API organizes session management, observation, low-level control, policy execution, and perception and planning into five primitive categories, with transparent batching and asynchronous scheduling that improve throughput under concurrency. On RoboCasa Atomic-Seen tasks, Zetta outperforms the pure VLA baseline on every listed task, with the largest gains on tasks where the baseline is weakest. On LIBERO-Pro, Zetta substantially improves over the frozen pi0.5 baseline, especially on Goal variants, while gains on LIBERO-10 are more modest but consistent.