betaFeedback

WorksComputer Science

CoEvolve: Self-Evolving Code Policies from Skills to Strategies for Humanoid Robots

Abstract

Recent advances in Vision-Language-Action (VLA) models and World Action Models (WAMs) have expanded the manipulation and whole body capabilities of individual robots. Yet a single robot remains limited by its embodiment, and many real world tasks require capabilities that can only emerge through cooperation. Existing multi robot frameworks largely emphasize task decomposition, allocation, and replanning, while providing limited support for adapting executable coordination when physical execution deviates from the intended behavior. We present CoEvolve, a framework that represents team coordination as executable code over fixed robot motor skills. CoEvolve introduces Verifier Guided Coordination Evolution, where a multimodal foundation model instantiates coordination strategies through motion primitives, semantic objectives, temporary robot roles, and bounded execution parameters. Physical verification evaluates each executed transition, rejected behaviors trigger structured coordination revision from an accepted checkpoint, and verified experience is retained to guide subsequent decisions. We evaluate CoEvolve with two simulated Unitree G1 humanoids transporting a freely supported rigid payload through constrained corridors. Across 15 base task runs with three multimodal backbone families, CoEvolve completes 8 tasks, with every backbone achieving end to end success. Additional evaluations yield verified placement on two additional corridor layouts and after both same-backbone and cross-backbone experience initialization, while exposing persistent limitations in motion precision and contact stability. These results support executable coordination as a practical interface for adapting long horizon multi robot collaboration under shared physical constraints.

Introduction

Recent advances in robot foundation models have equipped individual robots with increasingly general visuomotor capabilities, enabling them to follow language instructions and perform diverse manipulation tasks [2, 3, 11, 1]. Yet some physical tasks require capabilities that cannot be provided by one robot alone. Transporting an extended object through a constrained environment, for example, requires coordinated support, relative motion, corner negotiation, and placement [5, 19]. Collaboration is therefore not simply the aggregation of individual skills. Robots that can independently walk, turn, and move laterally must still determine how to combine these capabilities while carrying a shared object. We view this formation of team behavior as a form of co-becoming: effective cooperation is realized through the changing relationship between individual capabilities and the shared physical state.

This motivates our central question: given fixed individual motor skills, how can an agent instantiate and revise executable team coordination as a shared physical task unfolds? Multi-robot planning methods address task decomposition, allocation, and collaboration through structured and language-model planning [4, 18, 9, 14, 27], while learned coordination methods optimize joint or decentralized policies through training [29, 6]. In parallel, agents improve textual skills, memory systems, and executable implementations through feedback and experience sharing [26, 28, 24]. Code as Policies and subsequent robot programming systems also generate and revise executable behaviors through interaction [13, 7, 16, 25]. We study a complementary challenge: revising coordination when robots are physically coupled through a shared payload. In this setting, an individual action can alter both a teammate’s support conditions and the feasibility of subsequent joint motion. As a result, a valid task plan does not guarantee that the current coordination pattern remains executable. The key challenge is therefore to instantiate joint behavior from fixed motor skills and revise the relevant coordination relation when physical execution deviates, for example when unequal displacement disrupts formation or a constrained turn requires temporary support and mover roles.

We introduce CoEvolve, a framework for adapting executable team coordination during shared physical tasks. Figure 1 summarizes the motivation and overall interaction loop. CoEvolve separates fixed individual motor capabilities from the coordination strategy that composes them for the current task phase. Rather than selecting from a library of complete strategies, the agent instantiates coordination through motion primitives, semantic objectives, temporary roles, coordination modes, and bounded execution parameters. The evaluated setting provides simulator measurements and route references, while the model determines how these capabilities should be combined within the resulting physical constraints.

Figure 1. Motivation and overview of CoEvolve. The schematic contrasts individual manipulation with coordinated transport of a shared payload. CoEvolve combines executable team policies, physical verification, and reusable experience to revise coordination during execution.

Our Verifier Guided Coordination Evolution mechanism uses physical execution evidence to determine which aspects of coordination should change. A rejected transition triggers a revision to the maneuver, the relationship between robot roles, or the execution parameters. Revised policies are evaluated after restoration of the latest accepted simulator checkpoint. Verified outcomes also contribute complementary forms of experience: abstract coordination records guide subsequent decisions, while accepted executable examples inform code generation. Foundation model and motor policy weights remain fixed. The adaptation concerns the task plan, instantiated coordination strategies, and stored experience rather than the acquisition of new motor skills.

We evaluate CoEvolve with two simulated Unitree G1 humanoids carrying a freely supported rigid payload through constrained corridors. The base evaluation contains eight complete tasks across fifteen runs and three foundation model families. We further compare against four adapted external baselines and two component variants, evaluate additional corridor layouts, and study reuse of verified cooperative experience across foundation model backbones. These experiments distinguish demonstrated execution capability from causal component effects: some comparison, scene, and transfer records differ in runtime configuration, interaction budget, or continuation conditions. Our contributions are:

Figure 2. Framework of CoEvolve. The Task Orchestrator commits a team subtask, which the Policy Coder grounds into executable robot policies. Physical verification accepts or rejects the resulting transition; rejected executions trigger structured coordination revision, while verified outcomes update cooperative experience. Motor-policy weights remain frozen.

  • We introduce an executable representation of team coordination that separates fixed individual motor capabilities from the cooperative strategy instantiated for the current physical situation.

  • We propose Verifier Guided Coordination Evolution, which combines physical verification, structured strategy revision, and reusable cooperative experience to adapt coordination during execution.

  • We provide an extensive evaluation across three foundation model families, adapted multi-robot and code policy baselines, additional corridor layouts, and cross-model experience reuse, while analyzing the execution and contact limitations that remain.

Related Work

Self-Evolving Agents. Self-evolving agents adapt multiple components of an agent system. Building on feedback accumulation and skill reuse in Reflexion and Voyager [21, 23], SkillOpt optimizes textual skills for frozen agents, while MemEvolve evolves the memory architecture itself [26, 28]. Continual Harness adapts prompts, sub-agents, skills, and memory within an ongoing episode, and Hyperagents additionally makes the improvement procedure editable [10, 31]. Related systems automate the design or modification of the agent itself, including Automated Design of Agentic Systems and the Darwin Gödel Machine [8, 30]. Group-Evolving Agents (GEA) enables experience sharing among evolving coding agents, whereas CORAL supports autonomous multi-agent search through shared persistent memory [24] (Qu et al. 2026). These approaches concern agent implementations, knowledge, or search processes. CoEvolve instead studies online revision of executable inter-robot coordination during a shared physical task, with motor skills and runtime contracts fixed.

Robot Policy Refinement from Execution Feedback. REMAC revises multi-robot task plans through reflection, while HyCodePolicy and Act-Observe-Rewrite revise executable robot programs from execution feedback [27, 15, 12]. ASPIRE combines multimodal failure diagnosis, program repair, and reusable skill discovery, including bimanual manipulation; ENPIRE automates policy improvement through real-robot experimentation and reset [16, 25]. These works already connect program revision with physical experience. CoEvolve focuses on physically coupled humanoid transport, where failures can require changes to the selected maneuver or temporary support roles. It combines structured coor-

Algorithm 1 CoEvolve: Verifier Guided Coordination Evolution
Require: Task $g$, capability interface $\mathcal{K}$, initial experience $\mathcal{M}_0$, budget $B$
1: $P \leftarrow \operatorname{INITIALIZEPLAN}(g); \mathcal{M} \leftarrow \mathcal{M}_0; \bar{s} \leftarrow s_0; \xi \leftarrow \varnothing$
2: $C \leftarrow \operatorname{SAVECHECKPOINT}(\bar{s})$
3: for $t = 0, \ldots, B - 1$ do
4: $o_t \leftarrow \operatorname{OBSERVE}(\bar{s}); q_t \leftarrow \operatorname{ACTIVEPHASE}(P)$
5: $r_t^D \leftarrow \operatorname{RETRIEVESTRATEGY}(\mathcal{M}^D, q_t, \xi); z_t \leftarrow \operatorname{ORCHESTRATE}(g, o_t, P, r_t^D)$
6: $r_t^A \leftarrow \operatorname{RETRIEVEEXEMPLAR}(\mathcal{M}^A, z_t); (\chi_t, \Pi_t) \leftarrow \operatorname{GENERATEPOLICY}(z_t, o_t, r_t^A, \mathcal{K})$
7: $s_t^+ \leftarrow \operatorname{EXECUTE}(\bar{s}, \Pi_t); E_t \leftarrow \operatorname{VERIFY}(\bar{s}, \Pi_t, s_t^+)$
8: $\mathcal{M} \leftarrow \operatorname{UPDATEEXPERIENCE}(\mathcal{M}, \chi_t, \Pi_t, E_t)$
9: if $E_t^{\mathrm{acc}}$ then
10: $\bar{s} \leftarrow s_t^+; C \leftarrow \operatorname{SAVECHECKPOINT}(\bar{s}); P \leftarrow \operatorname{ADVANCEIFCOMPLETE}(P, E_t); \xi \leftarrow \varnothing$
11: if $S(\bar{s}, g)$ then
12: return success
13: end if
14: else
15: $\operatorname{RESTORE}(C); \xi \leftarrow \operatorname{FAILURECONTEXT}(E_t, \chi_t)$
16: $\ell_t \leftarrow \operatorname{SELECTREVISIONSCOPE}(E_t, \chi_t); \chi'_t \leftarrow \operatorname{REVISECOORDINATION}(\chi_t, \ell_t, E_t)$
17: $\operatorname{COMMITREVISION}(\chi'_t)$ ▷ constrains next orchestration and policy generation
18: end if
19: end for
20: return failure

dination revision with physical transition checks, checkpoint recovery, and sequential retrieval of strategy records and accepted code exemplars.

Method

Figure 2 illustrates the overall architecture of CoEvolve, from semantic coordination decisions to executable policies, physical verification, and experience-driven revision.

Overview and Coordination Representation

Task formulation. CoEvolve separates fixed individual motor skills from mutable team coordination. For NN robots manipulating a shared payload, a persistent semantic plan Pt=[(qk,γk,σk,t)]k=1KP_t = [(q_k, \gamma_k, \sigma_{k,t})]_{k=1}^{K} records task phases, completion criteria, and status. The host provides route-segment geometry and progress constraints, while the model determines how the robots coordinate within those constraints. State, observation, and route interfaces are detailed in Appendix § 10.§ 1.

Executable coordination. We use executable code as the coordination interface, following the Code as Policies paradigm [13], but generate paired robot policies under a shared coordination decision. Above the fixed motor interface, CoEvolve exposes coordinated linear transport, pivot, and alignment. The Task Orchestrator commits zt=(κt,dt,mt,ρt1:N)z_t = (\kappa_t, d_t, m_t, \rho_t^{1:N}), where κt\kappa_t is the coordination primitive, dtd_t the semantic objective, mt∈{sync,asym}m_t \in\{\mathrm{sync}, \mathrm{asym}\} the coordination mode, and ρt1:N\rho_t^{1:N} the temporary robot roles. These variables denote the coordination fields of the committed subtask; its structured representation also carries formation intent, completion evidence, and execution constraints.

The Policy Coder supplies bounded execution parameters θt1:N\theta_t^{1:N}, yielding χt=(zt,θt1:N)\chi_t = (z_t, \theta_t^{1:N}) and executable team policy Πt=(πt1,…,πtN)\Pi_t = (\pi_t^1, \ldots, \pi_t^N). Each robot receives a separate policy containing the allowed action call followed by an explicit stop. The host validates the paired policies as one logical team transaction and dispatches them to separate motor deployments. Logical grouping does not imply identical physical response. The motor interface and execution constraints are given in Appendix § 10.§ 2.

Verifier Guided Coordination Evolution

Executing Πt\Pi_t from the latest accepted state sts_t produces candidate state st+s_t^{+}. The verifier returns Et=Verify⁡(st,Πt,st+)E_t = \operatorname{Verify}(s_t, \Pi_t, s_t^{+}) and determines acceptance from measured task progress, payload support and stability, robot configuration, and environmental contacts. A multimodal evaluator assists scene interpretation and failure diagnosis, while measured physical quantities determine transition acceptance. An accepted transition becomes the next trusted checkpoint; the semantic plan advances only when the active phase satisfies its completion criterion.

A rejected transition triggers typed revision rather than unrestricted policy regeneration. Given failed strategy χt\chi_t and verifier evidence EtE_t, the revision scope ℓt∈{STRATEGY,COORDINATION,PARAMETER}\ell_t \in\{\text{STRATEGY}, \text{COORDINATION}, \text{PARAMETER}\} changes (κt,dt)(\kappa_t, d_t), (mt,ρ1:Nt)(m_t, \rho_{1:N}^{t}), or θt1:N\theta_t^{1:N}, respectively. Fields outside the selected scope remain fixed. The approved child strategy constrains the next policy-generation step rather than being replaced by an unrelated coordination decision, and the resulting policy is evaluated again from the latest accepted checkpoint. Verification, revision validation, and recovery rules are detailed in Appendix § 10.§ 3.

Verified Cooperative Experience

CoEvolve maintains two dynamic stores, Mt=(MtD,MtA)\mathcal{M}_t = (\mathcal{M}_t^D,\mathcal{M}_t^A). Strategy memory MtD\mathcal{M}_t^D stores abstract coordination knowledge, while action exemplar memory MtA\mathcal{M}_t^A stores accepted executable implementations. Strategy records capture applicability conditions, observed failure patterns, and repair directions, whereas action exemplars retain executable code and effective parameters.

Before orchestration, strategy records are retrieved using the active phase qtq_t and recent failure context ξt\xi_t as rtD=RetrieveStrategy⁡(MtD;qt,ξt)r_t^D = \operatorname{RetrieveStrategy}(\mathcal{M}_t^D; q_t, \xi_t). After the Orchestrator commits (κt,dt,mt)(\kappa_t, d_t, m_t), compatible action exemplars are retrieved as rtA=RetrieveExemplar⁡(MtA;κt,dt,mt)r_t^A = \operatorname{RetrieveExemplar}(\mathcal{M}_t^A; \kappa_t, d_t, m_t). Thus, strategy retrieval informs what coordination to attempt, while exemplar retrieval informs how to implement the selected coordination.

Experience is updated only after physical execution:

Mt+1=UpdateExperience⁡(Mt,χt,Πt,Et).\mathcal{M}_{t+1} = \operatorname{UpdateExperience}(\mathcal{M}_t, \chi_t, \Pi_t, E_t).

Accepted transitions may provide reusable strategy records and executable exemplars, while rejected transitions may provide verified counterexamples. Unexecuted repair proposals are not promoted as successful experience. Record schemas, retrieval, and promotion rules are given in Appendix § 10.§ 4.

Experiments

Experimental Setting

Task and observations. We evaluate CoEvolve on cooperative payload transport in MuJoCo [22]. Two Unitree G1 humanoids jointly carry a freely supported 0.5 kg rigid payload through constrained corridors. The task requires coordinated transport, corner negotiation, target placement, and release. The base task additionally requires both robots to retreat while remaining upright.

The model receives simulator measurements, global and payload-centered observations, the active task phase, and retrieved experience when enabled. The host provides route-segment geometry and progress constraints. The model selects the coordination primitive, temporary roles, coordination mode, and bounded execution parameters within these constraints.

Execution and models. Each robot uses an independent SONIC deployment with frozen policy weights [17], together with task-specific skill wrappers and support posture control. The host validates paired robot policies as one team transaction and dispatches their planner commands. The controllers retain independent observation histories and execution threads, so joint dispatch does not imply identical physical responses.

We evaluate GPT-5.4-mini, Gemini-3.5-Flash, and Claude-Sonnet-4.6. One backbone performs all semantic roles within a run. Except for experience reuse experiments, dynamic memory starts empty and updates remain local to that run.

Evaluation Protocol and Metrics

A physical transaction is one joint robot command dispatched for physical execution. Accepted and rejected executions consume the physical budget, while outputs rejected before dispatch consume model calls but no physical transactions. The base task uses an 80-transaction budget and requires placement, release, and robot retreat. Layout and experience-reuse evaluations use verified placement and release as their endpoint.

We report success rate (SR), verified progress (VP), execution acceptance (EA), and Progress AUC (PAUC). SR measures completion of the relevant endpoint. VP is VP=100n−1∑r=1nqr/Kr\mathrm{VP} = 100n^{-1} \sum_{r=1}^{n} q_r/K_r, where qrq_r of the KrK_r scene-defined milestones are certified at the final trusted checkpoint. EA is EA=100n−1∑r=1nAr/Tr\mathrm{EA} = 100n^{-1} \sum_{r=1}^{n} A_r/T_r, the mean per-run fraction of dispatched transactions accepted by the verifier. Unresolved charged outcomes remain in the denominator and produce the confirmed lower bounds marked by ≥\ge. EA does not include failures that occur before physical dispatch.

PAUC measures when verified milestones are first acquired. Let τrk\tau_{rk} denote the first cumulative physical transaction at which milestone kk is certified, with τrk=∞\tau_{rk} = \infty if it is never certified. For reporting horizon BB,

PAUC@B=100n∑r=1n1KrB∑k=1Kr[B−min⁡(τrk,B)].\mathrm{PAUC}@B = \frac{100}{n} \sum_{r=1}^{n} \frac{1}{K_r B} \sum_{k=1}^{K_r} [B - \min(\tau_{rk}, B)] .

Rejected transactions remain charged, rollback does not refund interaction, and each milestone contributes once. After termination, certified progress is held constant until BB. PAUC therefore measures progress attainment and its timing, not terminal stability or inference efficiency. VP measures progress retained at the final trusted checkpoint, whereas PAUC measures when verified milestones are first attained.

We use B=80B = 80 for base comparisons, a retrospective horizon of B=160B = 160 for additional layouts, and the first 80 cumulative transactions for transfer PAUC. Other transfer metrics describe the complete selected execution. Physical transactions, foundation-model calls, terminal categories, and run-time accounting are reported in Appendices § 12.§ 3 and § 12.§ 4. The full comparison condition reuses the GPT backbone runs, and differences in runtime and continuation settings make the aggregate comparisons descriptive rather than matched causal estimates.

Cross-Backbone Evaluation

We first test whether the same coordination interface supports different foundation model backbones. Each backbone is evaluated on five base-task runs under the same task definition and endpoint.

Local acceptance does not guarantee sustained task advancement. Table 1 shows successful full-task execution under all three backbones. Claude achieves the highest EA (86.5%) and PAUC@80 (64.5%) but fewer completions than GPT and Gemini, separating local execution validity from terminal success. The same distinction appears within one GPT run: after reaching the fourth milestone at transaction 47, 31 of the remaining 33 transactions are accepted, including 27 setup actions, yet no further milestone is certified. Claude’s failed runs instead terminate during generation or repair, which EA does not measure because no physical transaction is dispatched.

BackboneFull-task SR@80 ↑\uparrowVP (%) ↑\uparrowEA (%) ↑\uparrowPAUC@80 (%) ↑\uparrow
GPT-5.4-mini3/5 (60.0%)86.785.461.9
Gemini-3.5-Flash3/5 (60.0%)76.766.760.2
Claude-Sonnet-4.62/5 (40.0%)76.786.564.5

Table 1. Base-task results across foundation model backbones (n=5n = 5 per backbone). Success requires placement, release, and robot retreat. VP, EA, and PAUC are per-run means.

Long-horizon performance therefore depends on revisions that continue phase advancement, not only on verifier-accepted execution.

Method Comparisons and Component Analysis

We next test whether physical feedback alone is sufficient for long-horizon repair, and whether structured revision and verified experience address different failure modes. We compare CoEvolve with REMAC [27], COHERENT [14], CaP-Agent0 [7], and ASPIRE [16], adapted to the same cooperative transport task and robot interface. We also evaluate Flat Reflective Repair and CoEvolve without Dynamic Experience. Implementation details are given in Appendix § 11.§ 2.

Structured revision and verified experience target different repair failures. Table 2 shows full-task completion only for CoEvolve, although all alternatives reach partial progress. A CaP-Agent0 trace illustrates why feedback alone can be insufficient: after receiving a requirement for different yaw corrections, the repair changes both values from 2.5 to 2.0 and preserves the rejected relation. Typed revision instead separates changes to the maneuver, role relation, and execution parameters. The component variants expose a second distinction. Removing Dynamic Experience still reaches 60.0% VP but yields no completion, with EA at 63.8% and PAUC@80 at 46.4%. Flat Reflective Repair terminates at the payload-drop limit in four runs, whereas the no-memory variant

MethodFull-task SR@80 ↑VP (%) ↑EA (%) ↑PAUC@80 (%) ↑
External baselines
REMAC [27]0/5 (0.0%)26.757.123.3
COHERENT [14]0/5 (0.0%)56.7≥ 83.649.1
CaP-Agent0 [7]0/5 (0.0%)33.366.729.5
ASPIRE (Online) [16]0/5 (0.0%)40.074.935.6
Component variants
Flat Reflective Repair0/5 (0.0%)43.373.236.3
CoEvolve w/o Dynamic Experience0/5 (0.0%)60.063.846.4
CoEvolve3/5 (60.0%)86.785.461.9

Table 2. Base-task comparison using GPT-5.4-mini (n=5n = 5 per condition). The full method reuses the GPT runs in Table 1. ≥ denotes a confirmed EA lower bound.

LayoutVerified placement ↑\uparrowVP (%) ↑\uparrowEA (%) ↑\uparrowPAUC@160 (%) ↑\uparrow
Layout 21/3 (33.3%)41.771.430.3
Layout 30/3 (0.0%)58.346.153.6
Layout 41/3 (33.3%)50.064.137.1

caption: tbl:3: Additional-layout results (n=3n = 3 per layout). PAUC@160 uses a common retrospective reporting horizon.

ends in four generation/repair stalls and one budget exhaustion. These failure profiles are consistent with structured revision localizing what should change and verified experience supplying evidence for what to try next, without isolating either effect causally.

Figure 3 provides a concrete execution-level view of the contrast observed in Table 2. Both methods reach a nontrivial turning stage, but their subsequent executions diverge. CoEvolve continues through the corner and eventually completes the task, whereas REMAC first produces a rejected pivot, then executes a smaller accepted pivot, but later terminates at the payload-drop limit. The comparison shows that local executability and verifier acceptance are not sufficient for sustained task progress: an accepted correction may still leave the team in a configuration that does not support the remaining transport sequence. This trace is consistent with the role of structured revision in changing the coordination relation after failure, rather than only producing another locally executable motion.

Representative CoEvolve and REMAC executions on the base task

Figure 3. Representative CoEvolve and REMAC executions on the base task. CoEvolve reaches task completion, whereas REMAC terminates at the cumulative payload-drop limit after successive pivot attempts. Attempt labels denote internal execution indices rather than cumulative physical transactions.

Evaluation Across Layouts

We then test whether successful coordination on the base task remains executable under different corridor geometries. Three additional layouts are evaluated with GPT-5.4-mini using three runs per layout. The endpoint is verified placement and release without the final robot retreat. Scene geometry is shown in Appendix § 11.§ 1.

Local progress does not guarantee future physical feasibility. Table 3 records verified placement in Layouts 2 and 4, while Layout 3 reaches no placement despite the highest VP (58.3%) and PAUC@160 (53.6%). The execution traces in Figure 4 illustrate this discrepancy: Layout 3 advances through several certified milestones before payload support degrades. Because the payload is supported through finite contact rather than rigid attachment, an accepted transition can reduce the support margin required by later maneuvers. Checkpoint acceptance therefore certifies the executed transition, not the feasibility of the remaining task. The result identifies future support and clearance as constraints that local transition verification does not explicitly optimize.

Representative execution traces across additional layouts

Figure 4. Representative execution traces across additional layouts. Layout 3 accumulates intermediate progress before payload support degrades, illustrating why certified local progress need not preserve feasibility for later maneuvers. Layouts 2 and 4 show successful placement under different coordination sequences. Attempt labels denote internal execution indices rather than cumulative physical transactions.

The successful Layout 4 continuation uses the refined corridor-verification condition described in Appendix § 11.§ 5; it is not treated as a matched geometry-only replicate.

Cross-Model Experience Reuse

Finally, we test whether verified experience can be reused outside the backbone that produced it. GPT-5.4-mini is initialized with experience banks collected from successful GPT, Gemini, or Claude executions. No simulator state, checkpoint, controller history, or trajectory is transferred.

Bank size alone does not explain cross-model reuse. Table 4 records two placements with Gemini-derived experience, one with GPT-derived experience, and none with the Claude bank. The target selects, instantiates, and verifies policies, so the experiment transfers coordination evidence rather than a solved trajectory. GPT and Gemini provide 17 and 16 strategy records, compared with only four from Claude, which may reduce the decision coverage available to the target. Record count is not sufficient, however: GPT has more action exemplars than Gemini but no pivot exemplar, while both Gemini and Claude include pivot examples. The observed differences are therefore more consistent with coverage and state-specific applicability than with bank size alone. Unequal source banks and the absence of a matched empty-memory condition prevent a causal transfer claim.

Source →\to TargetStrategy records / action exemplarsVerified placement ↑\uparrowVP (%) ↑\uparrowEA (%) ↑\uparrowPAUC@80 (%) ↑\uparrow
GPT →\to GPT17 / 141/5 (20.0%)50.075.438.0
Gemini →\to GPT16 / 82/5 (40.0%)76.780.355.8
Claude →\to GPT4 / 80/5 (0.0%)56.7≥61.6\ge61.645.0

Table 4. Experience reuse with GPT-5.4-mini as the target (n=5n = 5 per source bank). PAUC uses the first 80 cumulative physical transactions. ≥\ge denotes the confirmed EA lower bound.

Conclusion

We propose CoEvolve, a framework for adapting executable multi-robot coordination over fixed motor skills through physical verification, structured revision, and verified experience. Across three foundation model families, CoEvolve achieves end-to-end cooperative transport, while additional evaluations show successful execution under new layouts and same-model and cross-model experience reuse. The experiments also separate local execution validity from sustained task advancement: accepted actions can fail to resolve the current coordination bottleneck, and verified progress can precede later loss of physical support. These findings identify structured coordination revision as a useful interface for long-horizon cooperation while leaving motion precision, contact stability, and physical recovery as open limitations.

Limitations

CoEvolve has limitations. First, end-to-end execution incurs substantial wall-clock cost because model inference, physical execution, verification, and recovery recur throughout a run (Appendix § 12.§ 4). Second, rejected executions are recovered by restoring an accepted simulator state rather than a physically executable recovery policy, which limits direct transfer to real robots. Third, the frozen motor interface provides bounded motion intentions rather than precise endpoints: unequal robot responses, residual motion after stopping, and accumulated formation drift can reduce clearance and destabilize the shared payload. Payload stability also depends on finite contact regions, friction, and simulator contact dynamics, which we do not systematically randomize in the study. Finally, all experiments use simulation, privileged physical state information, and supplied route references. Real-world deployment will require perception from onboard sensing, more accurate motion and contact models, safe physical recovery, and evaluation under broader environments and hardware conditions. The relatively small and heterogeneous evaluation cohorts also limit strong causal claims about individual components, scene generalization, and experience transfer.

AI Use Statement

Generative AI tools were used to assist with literature search and summarization, research ideation and experimental design, software development and debugging, interpretation of experimental results, and drafting and refinement of the manuscript. All AI-assisted suggestions, code changes, experimental configurations, quantitative results, citations, and scientific claims were independently reviewed and verified by the authors. Generative AI was not used to generate synthetic datasets or to prove mathematical claims. The authors take full responsibility for the methodology, implementation, experiments, analysis, and final content of this work.

Ethics Statement

This work studies multi-robot coordination entirely in simulation and does not involve human participants, personal data, or deployment on physical robots. The proposed framework is intended for research on cooperative robot reasoning and execution. Although physical verification and recovery are used within the simulator, they should not be interpreted as safety guarantees for real-world deployment. Applying the system to physical robots would require additional safeguards, state and contact estimation, calibrated motion control, and hardware-specific safety validation.

Reproducibility Statement

Section 3 specifies the coordination framework. Appendix § 10 describes the role interfaces, motor capabilities, verification, and experience mechanisms; Appendix § 11 documents execution settings, baseline adaptations, endpoints, and selected runs. Appendix § 12 defines metric reconstruction, uncertainty from unresolved transactions, resource statistics, and run-time accounting. These descriptions distinguish recorded execution conditions from the retrospective reporting horizons used in the aggregate results.

Additional Method Details

State, Plan, and Role Interfaces

The state st=(xt1:N,xto,ct,G)s_t = (x_t^{1:N}, x_t^o, c_t, \mathcal{G}) contains robot states, payload state, contact and support measurements, and scene geometry. Observations combine serialized measurements, global and payload-centered views, and geometric references for the active route segment. These references may include world directions, local progress targets, corridor boundaries, and completion gates. They are distinct from the semantic plan Pt=[(qk,γk,σk,t)]k=1KP_t = [(q_k, \gamma_k, \sigma_{k,t})]_{k=1}^{K}, which records task phases, completion evidence, and status rather than an executable waypoint sequence.

The tuple zt=(κt,dt,mt,ρt1:N)z_t = (\kappa_t, d_t, m_t, \rho_t^{1:N}) denotes the coordination fields of the committed subtask. Its structured representation additionally contains formation intent, completion evidence, and execution constraints. The Coder supplies bounded numerical parameters θt1:N\theta_t^{1:N}, giving χt=(zt,θt1:N)\chi_t = (z_t, \theta_t^{1:N}) and the executable team policy Πt=(πt1,…,πtN)\Pi_t = (\pi_t^1, \ldots, \pi_t^N). Thus, the Orchestrator determines the coordination decision, while the Coder determines its numerical and programmatic implementation.

The roles in Table 5 use the selected backbone through different prompts and output schemas, not independently trained models. Their structured proposals remain subject to host validation.

RoleResponsibility
Task OrchestratorMaintain the semantic plan and commit the current team subtask.
Policy CoderGenerate bounded parameters and executable policies for the robots.
EvaluatorInterpret observations and execution evidence for failure analysis.
Evolution ManagerSelect a revision scope and objective from verifier evidence.
Mutation OperatorPropose a child strategy within the approved scope.
Code RepairerRepair invalid or inconsistent policy drafts.
Memory WriterPropose experience records consistent with executed outcomes.

Table 5. Structured model roles. Physical acceptance, execution checks, checkpoint management, and experience promotion remain host operations.

Motor Capabilities and Team Execution

The motor interface wraps separate SONIC deployments with frozen policy weights [17]. Available skills are summarized in Table 6. The transport primitives are coordinated_linear_transport, coordinated_pivot, and coordinated_alignment.

CapabilityMotor skillsArguments
Longitudinal motioncarry_forward, carry_backwardDistance, speed, ramp duration
Turningturn_clockwise, turn_counterclockwiseYaw, yaw rate, turn segment
Lateral motioncarry_lateral_left, carry_lateral_rightDistance, speed, ramp duration
Height controlplace_crouch, recover_standHeight, ramp, hold duration
Payload recoveryrecover_payload_inwardRamp and hold duration

Table 6. Motor capabilities available through the execution interface.

Linear transport uses a common translation objective; pivoting assigns temporary inner-support and outer-mover roles; alignment uses a reference robot while the other makes a bounded correction. Initialization, placement, release, and retreat are lifecycle operations rather than additional transport primitives.

Synchronous coordination uses compatible commands for a shared objective; asymmetric coordination permits different temporary roles or parameters. Neither guarantees identical robot displacement. Each robot policy contains one allowed action call followed by an explicit stop. The host checks output structure, allowed methods, numerical bounds, syntax, and consistency of the paired policies before dispatch. Generated policies cannot change the verifier, invoke simulator restoration, or access low-level controller handles. Joint dispatch is a logical transaction, not a hard real-time synchronization barrier.

Verification, Revision, and Recovery

Acceptance depends on measured payload support and stability, robot state, environmental contacts, phase validity, and progress relative to the committed objective. Visual interpretation assists diagnosis but cannot override contradictory physical measurements. An accepted setup or corrective action can establish a checkpoint without completing a task phase; phase advancement requires separate completion evidence.

Revision acts on the failed strategy χt=(κt,dt,mt,ρ1:Nt,θ1:Nt)\chi_t = (\kappa_t, d_t, m_t, \rho_{1:N}^{t}, \theta_{1:N}^{t}). Strategy revision concerns the maneuver and objective, coordination revision concerns mode and temporary roles, and parameter revision concerns bounded numerical arguments. The host checks the child against its failed parent and the selected mutable fields. Once approved, that revision constrains the next orchestration and code-generation step rather than being discarded by an unrelated decision.

After rejection, the host restores the latest accepted simulator state, clears transient execution state, resynchronizes the controllers, and verifies the restoration. A fingerprint of the checkpoint, normalized policy, and effective arguments blocks identical rejected transactions at that checkpoint. Recovery neither physically reverses the motion nor automatically searches earlier checkpoints. Separately selected diagnostic restart points are evaluation conditions, not autonomous recovery actions.

Algorithm 1 summarizes this loop. Its model procedures include bounded validation and repair; an inability to produce a valid next transaction can terminate execution before the physical budget is exhausted. Only dispatched physical transactions consume that budget. Execution attempt identifiers can therefore differ from cumulative transaction counts.

Experience Contents and Retrieval

The two dynamic stores are written as Mt=(MtD,MtA)M_t = (M_t^D, M_t^A). The static skill catalog belongs to the capability interface and does not evolve. Strategy records store applicability conditions, coordination principles, observed failure patterns, and repair directions. The active phase filters applicable records, while recent failure type and level contribute to ranking. The next primitive, objective, and mode are not query conditions because they have not yet been selected.

After the coordination decision is committed, action exemplars are matched by primitive, semantic objective, and coordination mode. Phase only ranks otherwise compatible exemplars. These entries retain accepted code and effective parameters but remain subject to the current subtask and execution constraints. Strategy retrieval therefore informs the coordination decision; exemplar retrieval informs its implementation.

Promotion requires agreement between a record’s claim, the executed behavior, and the verifier outcome. Eligible accepted executions can yield positive strategy records and executable exemplars; rejected executions can yield counterexamples. Unexecuted repairs are not successful experience. Strategy records omit scene coordinates, checkpoint poses, and numerical action magnitudes, whereas exemplars retain concrete implementations. Standard fresh runs start with empty dynamic memory; transfer runs preload a fixed source bank and update only their own subsequent experience.

Representative Coordination Revision

Figure 5 illustrates a rejection, restoration, and subsequent coordination revision within an episode. It complements the cross-layout visualization in Figure 4; neither figure adds independent runs to the quantitative evaluation.

Coordination revision during execution

Figure 5. Coordination revision during execution. Selected snapshots show transport, target alignment, rejection and checkpoint restoration, followed by revised behavior and the illustrated completion. Attempt labels identify positions in the episode, not cumulative physical-transaction counts.

Execution and Evaluation Details

Environment Layouts and Endpoints

The base environment and three additional corridor layouts are shown in Figure 6. All use two humanoids supporting a free rigid payload. The images describe scene geometry, not a prescribed executable trajectory. Route references, native milestones, and verification predicates are associated with the evaluated scene configuration.

Environment layouts

Figure 6. Environment layouts. Layout 1 is the base environment; Layouts 2–4 provide additional corridor configurations.

The base task requires stable placement, release, and robot retreat. The scene and experience evaluations omit retreat from their placement endpoint. Placement requires target support and release over a 3 s stability window. The reported base tolerances include a target support radius of 0.30 m, payload-center vertical tolerance of 0.08 m, and terminal tilt tolerance of 20∘^\circ. The full-task endpoint additionally requires upright robots and the specified robot–target clearance.

Comparison Configurations

All comparison conditions use GPT-5.4-mini. REMAC [27], COHERENT [14], CaP-Agent0 [7], and ASPIRE [16] are adapted to the cooperative transport task rather than reproduced in their original environments. Table 7 describes the evaluated mechanisms. A shared task interface does not imply identical runtime or recovery implementations.

The full reference in Table 2 reuses the GPT runs in Table 1. Differences in execution configuration and repair continuations prevent interpreting this comparison as an isolated causal estimate of a component’s effect.

Controller and Contact Configuration

The execution chain consists of skill wrappers, batched planner intents, two independent SONIC processes, separate robot command streams, and the dual-robot MuJoCo bridge. The inspected deployment uses nominal input, planner, policy/control, and command-writer rates of 100, 10, 50, and 500 Hz, respectively. These are scheduling settings, not guarantees of simultaneous command

ConditionEvaluated mechanism
REMACReflective multi-robot planning through the task and capability interface.
COHERENTMulti-agent coordination using the robot observations and bounded skills.
CaP-Agent0Executable robot-code generation for cooperative payload transport.
ASPIRE (Online)Online adaptation with the reported setting K=8K = 8 and verification local to the current checkpoint.
Flat Reflective RepairDirect policy rewriting without selecting a typed revision scope; physical feedback, recovery, and dynamic memory remain available.
w/o Dynamic ExperienceStructured revision with strategy and exemplar retrieval, writing, and promotion disabled.

caption: tbl:7: Comparison mechanisms. External methods are task-specific adaptations; the component conditions alter the stated parts of CoEvolve.

:::

consumption. The inspected manifest records MuJoCo 3.8.1; the separate stopping diagnostic uses a 0.005 s integration step.

Each deployed policy uses ten-frame local histories containing joint states, base angular velocity, gravity direction, and previous actions, together with motion references. The robots maintain independent histories and reference states. The inspected support adapter regulates 14 arm joints per robot using torque-limited PD control with kp=24k_p = 24, kd=1.5k_d = 1.5, a 6 s ramp, and palms tilted by 60°; the waist is excluded. This posture regulation is not a rigid grasp or a constraint on the payload center of mass.

The palm proxy has half extents of 0.06 m, 0.035 m, and 0.006 m; the corresponding forearm values are 0.11 m, 0.032 m, and 0.006 m. Contact parameters from the inspected generator are listed in Table 8. They are simulation parameters rather than measured material coefficients; effective contact also depends on geometry, mixing rules, and the solver. They are not a claim that every historical instantiated scene was identical.

GeometrySlidingTorsionalRolling
Palm/forearm proxies3.00.050.002
Payload2.00.050.002
Target1.40.030.001
Ground default1.00.020.001

Table 8. Configured contact parameters in the inspected scene generator.

For payload orientation RR, center height zoz_o, and half extents hih_i, its lowest point is zmin⁡=zo−∑i=13∣R3i∣hiz_{\min} = z_o - \sum_{i=1}^{3} \lvert R_{3i}\rvert h_i. This calculation addresses payload clearance only; it does not certify robot clearance or the full swept trajectory. No contact-parameter sensitivity or randomization study is included in the reported evaluation.

Local Execution Diagnostics

Stopping response. A local test without foundation-model calls requests a 0.25 m translation using the native 0.5 m/s speed and 1.5 s ramp. Displacements are projected onto the fixed initial world direction, with an endpoint tolerance of ±0.05\pm0.05 m. Table 9 reports this single trace.

QuantityObserved value
Requested displacement0.250 m
Payload displacement at stop trigger0.192672 m
Final payload displacement0.663442 m
Maximum sampled payload displacement0.689713 m
Payload displacement after stop trigger0.470769 m
Front robot displacement after stop trigger0.476529 m
Back robot displacement after stop trigger0.483128 m
Endpoint error+0.413442 m

Table 9. Single-trace stopping diagnostic, not a repeated-trial accuracy estimate.

Bilateral IDLE sending completes approximately 0.742 ms after the trigger, with an observed consumption bound of approximately 13.7 ms after sending. Commands remain IDLE while references and both robots continue forward. The trace documents residual motion after stop consumption without uniquely identifying its lower-level cause. Successful return from a skill call therefore does not establish endpoint accuracy or continuous-time safety.

Release feedback. An earlier execution fails a pre-release vertical condition at a logged 0.459 m against a 0.45 m limit. Support withdrawal does not occur. The feedback is subsequently made more specific about the stage, predicate, measurement, and withdrawal status without relaxing the gate.

The missing historical gate snapshot is not replaced with a later measurement. This is a feedback correction, not evidence of a post-release drop or repaired release dynamics.

Scene Records and Execution Conditions

Execution changes address approved child strategies, release feedback, route boundaries, accepted setup history, and restored observations. These do not replace the conceptual method, but can affect the subsequent execution. The successful Layout 4 continuation additionally uses adjusted corridor verification. Normal rollback still restores the latest accepted checkpoint; separately authorized earlier restart points are not automatic ancestor search. Original budgets and drop rules remain part of the corresponding records.

LayoutRun 1Run 2Run 3
Layout 2D, 19/80S, 88/160D, 30/80
Layout 3B, 160/160D, 118/160D, 94/160†
Layout 4D, 57/80D, 29/80S, 120/160∗

Table 10. Scene outcomes and cumulative transactions/original limit. S denotes placement, D a drop-limit terminal, and B budget exhaustion. ∗ Placement follows adjusted corridor verification. † The effective limit is 160; an older embedded field retains 80.

Layout 2 and Layout 4 reach placement at 88 and 120 transactions. Neither is a placement within 80 transactions. The common PAUC horizon of 160 is a retrospective accounting window; it does not recast originally shorter executions as fresh trials with identical budgets.

Source Banks and Transfer Records

The GPT, Gemini, and Claude banks contain 17/14, 16/8, and 4/8 strategy-record/action-exemplar entries, respectively. Each fixed bank initializes five target executions. A successful source can contribute both positive strategy records and counterexamples; its action exemplars are accepted implementations. No source physical state or complete trajectory is transferred. Unequal bank sizes and absent matched empty initialization limit conclusions about transfer benefits.

The records in Table 11 include repair continuations and an authorized restart in the Claude condition. Read-only validation confirms the retained records without replacing the original finalization status or creating new physical trials. The Gemini conditional stop at 82/100 is not reclassified as generation failure or budget exhaustion. For the fourth Claude execution, original metrics record 31 transactions before a camera exception; independent reconciliation confirms 32 transactions and the sixth drop. The original exception remains recorded. Two charged outcomes in the second Claude execution remain unresolved.

SourceRun 1Run 2Run 3Run 4Run 5
GPTD, 25/80S†, 56/80D, 46/80G, 25/80D, 37/80
GeminiD, 40/80S†, 58/80C, 92/100S, 41/80G, 46/80
ClaudeD, 56/80B{sup}‡`, 80/80D{sup}†`, 53/80D{sup}‡`, 32/80D, 78/80

Table 11. Transfer outcomes and cumulative transactions/original limit. G denotes generation/repair stall; C denotes conditional diagnostic stop. † Original finalization gaps are retained alongside later read-only validation. ‡ The terminal outcome is independently reconciled.

Checkpoint consistency of decision context. A Claude-to-GPT transfer execution illustrates a distinction between restoring physical state and restoring a valid decision context. After simulator recovery, the Manager continued using a decision associated with a retired checkpoint. Correcting the context binding allowed execution to resume, but the run ultimately reached the payload-drop limit. This separates two requirements: plans and retrieved evidence must apply to the state from which a policy is executed, and the resulting motion must preserve physical support. Repairing the former does not establish the latter. The case motivates checking checkpoint consistency when reusing decisions after recovery rather than treating simulator restoration alone as sufficient synchronization.

Metric Computation and Supplementary Results

Outcomes, Progress, and Acceptance

All group metrics weight runs equally. Success is SR=100n−1∑rSr\mathrm{SR}=100n^{-1}\sum_r S_r, using full-task completion within 80 transactions for the base tables and placement/release for the scene and transfer tables. Verified progress is VP=100n−1∑rqr/Kr\mathrm{VP}=100n^{-1}\sum_r q_r/K_r, with qrq_r certified milestones in the terminal trusted-state record and KrK_r native scene milestones. The base task has four route gates, a target-region milestone, and a protocol-specific terminal milestone. Milestone fractions are not fractions of distance, time, or skill difficulty.

For executions with Tr>0T_r>0 charged physical transactions and ArA_r confirmed acceptances, EA=100n−1∑rAr/Tr\mathrm{EA}=100n^{-1}\sum_r A_r/T_r. This is the mean of per-run ratios, not 100∑rAr/∑rTr100\sum_r A_r/\sum_r T_r. If UrU_r charged outcomes are unresolved, the accounting bounds are

EAlo=100n∑rArTr,EAhi=100n∑rAr+UrTr.\mathrm{EA}_{\mathrm{lo}}=\frac{100}{n}\sum_r\frac{A_r}{T_r},\qquad\mathrm{EA}_{\mathrm{hi}}=\frac{100}{n}\sum_r\frac{A_r+U_r}{T_r}.

The main tables report only the confirmed lower endpoint with ≥\ge. Unresolved outcomes are not relabeled as rejections. This yields the reported lower bounds of 83.6% for COHERENT and 61.6% for the Claude source condition. These are bookkeeping bounds rather than confidence intervals. Setup and corrective actions may be accepted without completing a milestone, so EA describes local execution validity, not global success.

Reconstructing Progress AUC

PAUC is computed retrospectively from saved accepted checkpoints. For each run, records are ordered by cumulative charged physical transactions, including inherited continuation costs. The first saved checkpoint that certifies a prefix containing milestone kk determines τrk\tau_{rk}; τrk=∞\tau_{rk}=\infty when no certificate is recorded. We use pr(t)=Kr−1∑k1[τrk≤t]p_r(t)=K_r^{-1}\sum_k 1[\tau_{rk}\le t] with pr(0)=0p_r(0)=0. For an integer reporting horizon BB,

PAUC@B=100nB∑r∫0Bpr(t) dt=100nB∑r∑t=0B−1pr(t)=100n∑r1KrB∑k=1Kr[B−min⁡(τrk,B)].\begin{aligned} \mathrm{PAUC}@B&=\frac{100}{nB}\sum_r\int_0^B p_r(t)\,\mathrm{d}t\\ &=\frac{100}{nB}\sum_r\sum_{t=0}^{B-1}p_r(t)\\ &=\frac{100}{n}\sum_r\frac{1}{K_rB}\sum_{k=1}^{K_r}[B-\min(\tau_{rk},B)]. \end{aligned}

The integral and integer sum use the same step-function convention. Attainment exactly at BB contributes zero area, although it can still establish endpoint success. A run with no certified milestones scores zero.

Each milestone earns credit once. Rejected transactions and unresolved charged outcomes remain in the chronology but receive no unverified progress credit. Setup-only acceptance and repeated attainment introduce no additional milestone credit. Rollback does not refund transactions; a certified prefix later retired by a documented rewind retains its historical first-attainment credit. Unverified fragments from different branches are not combined into a certificate. After termination, recorded attainment is held constant to BB.

PAUC consequently measures historical attainment and its timing, while VP measures terminal retained progress. Neither substitutes for success or continuous physical stability. For example, attaining half the milestones at transaction 20 under B=80B = 80, with no further progress, gives 100(1/2)(80−20)/80=37.5%100(1/2)(80 - 20)/80 = 37.5\%; attaining the same milestones at transaction 60 gives 12.5%12.5\%. These are illustrative scores, not additional experiment results or percentages of resource savings.

EvaluationPAUC horizonOutcome scope
Base task80Placement, release, and retreat within 80 transactions.
Additional layouts160Placement/release in the selected execution; original limits differ.
Experience reuse80PAUC uses the first 80 transactions; other metrics use the complete selected execution.

Table 12. Reporting horizons and task endpoints. A common retrospective horizon does not establish a matched experimental protocol.

The score retains the native verification semantics of the saved records. It is not obtained by replaying all runs under one common verifier. Different milestone definitions or execution configurations limit direct causal comparisons even when all scores are expressed as percentages.

Resource Use and Termination Categories

Table 13 reports actual physical interaction and recorded foundation-model calls, including continuation costs once. Pre-dispatch failures consume model calls but no physical transactions. Early unsuccessful termination can reduce both counts, so neither has an unconditional better-direction arrow. Incomplete call totals remain lower bounds and are not converted into monetary cost without billing evidence.

ConditionPhysical transactionsFM callsTerminal counts D/G/B/CUnresolved transactions
Base-task backbones (five runs each)
GPT-5.4-mini52.4460.40/1/1/00
Gemini-3.5-Flash27.0148.60/2/0/00
Claude-Sonnet-4.624.2182.00/3/0/00
Comparison conditions (five runs each)
REMAC20.4122.84/1/0/00
COHERENT43.8873.41/4/0/01
CaP-Agent017.4≥355.0\ge355.01/4/0/00
ASPIRE (Online)19.2≥175.2\ge175.21/4/0/00
Flat Reflective Repair29.6176.64/1/0/00
w/o Dynamic Experience62.2490.60/4/1/00
Additional layouts (three runs each)
Layout 245.7301.72/0/0/00
Layout 3124.0≥1394.7\ge1394.72/0/1/00
Layout 468.7650.72/0/0/00
Source experience → GPT (five runs each)
GPT → GPT37.8282.83/1/0/00
Gemini → GPT53.4348.61/1/0/10
Claude → GPT59.8≥576.2\ge576.24‡/0/1/02

Table 13. Resource and termination diagnostics. Physical transactions and FM calls are per-run means; terminal and unresolved counts are group totals. ≥\ge denotes a confirmed call-count lower bound. ‡ One drop terminal is independently reconciled with its original infrastructure exception retained. The full comparison row reuses the GPT backbone results and is not duplicated here.

Termination labels describe the final stopping condition, not intermediate error counts or unique causes. D is the applicable payload-drop limit; later placement records use six cumulative drops, while older records retain their configured stopping rule. G is generation/repair stall, covering the failure to produce an executable next candidate through invalid, contradictory, or repeatedly rejected proposals. It does not distinguish model errors from interface or recovery-rule effects. B is exhaustion of the physical budget and C is a conditional diagnostic stop.

The selected archive contains 69 logical executions after deduplication: 15 backbone runs, 30 comparison runs, nine scene runs, and 15 transfer runs. Reused reference rows and continuation prefixes are not additional independent trials. Different endpoints, limits, and execution conditions preclude combining this archive into one aggregate success rate.

Run-Time Accounting

Run time is measured as elapsed wall-clock time within recorded execution segments, summed once across all segments belonging to each logical execution. It includes model and API waiting, physical execution, verification, recovery, and finalization. Manual pauses, code modification, and queue waiting between segments are excluded, and concurrent subprocess durations within a segment are not summed separately.

The selected archive contains 69 deduplicated logical executions. Timing is complete for 65 executions; the remaining four retain confirmed lower bounds from available continuous event spans. The resulting cumulative run time is at least 112.8 hours, with a mean of at least 98.1 minutes per execution. The Full condition in Table 2 reuses the five GPT executions in Table 1 and is not counted again. The incomplete timing records are COHERENT run 203, Layout 3 runs 200 and 201, and Claude-to-GPT run 203. Missing intervals are not imputed as zero.

Run time describes end-to-end execution-process duration rather than robot motion time, GPU-hours, or the calendar duration of the evaluation campaign. It covers only the selected evaluation archive, not development experiments, manual code changes, or diagnostic work outside these records. Shorter run time does not necessarily indicate greater efficiency because unsuccessful runs may terminate early, while repeated verification and recovery can extend a run substantially.

Mean run time over all executions should also be distinguished from run time conditioned on success. The five GPT base-task executions average 254.7 minutes, whereas the three successful GPT executions average 142.4 minutes. One budget-exhausted GPT run lasts approximately 11.65 hours and substantially increases the all-run mean. We therefore report all-run mean time as an end-to-end execution statistic rather than as a better-is-lower efficiency metric.

ConditionnnComplete timingMean run time (min)
Base-task backbones
GPT-5.4-mini55/5254.7
Gemini-3.5-Flash55/574.9
Claude-Sonnet-4.655/587.8
Comparison conditions
REMAC55/529.0
COHERENT54/5≥99.3\ge99.3
CaP-Agent055/529.6
ASPIRE (Online)55/555.6
Flat Reflective Repair55/538.7
w/o Dynamic Experience55/5158.6
Additional layouts
Layout 233/374.5
Layout 331/3≥253.0\ge253.0
Layout 433/3138.3
Source experience →\to GPT
GPT →\to GPT55/557.2
Gemini →\to GPT55/581.2
Claude →\to GPT54/5≥108.3\ge108.3
All selected executions6965/69≥98.1\ge98.1

Table 14. Run-time statistics for the selected execution archive. Means include successful and unsuccessful outcomes. Complete timing counts executions with complete recorded timing; ≥\ge denotes a confirmed lower bound caused by missing historical timing intervals. The reused Full condition from Table 2 is not counted separately.

References

  1. [1]Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, et al. π₀: A vision-language-action flow model for general robot control. arXiv preprint arXiv:2410.24164, 2024.
  2. [2]Anthony Brohan, Noah Brown, Justice Carbajal, Yevgen Chebotar, Joseph Dabis, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, Jasmine Hsu, et al. Rt-1: Robotics transformer for real-world control at scale. arXiv preprint arXiv:2212.06817, 2022.arxiv.org/abs/2212.06817
  3. [3]Anthony Brohan, Noah Brown, Justice Carbajal, Yevgen Chebotar, Xi Chen, Krzysztof Choromanski, Tianli Ding, Danny Driess, Avinava Dubey, Chelsea Finn, et al. Rt-2: Vision-language-action models transfer web knowledge to robotic control. arXiv preprint arXiv:2307.15818, 2023.arxiv.org/abs/2307.15818
  4. [4]Yishuai Cai, Xinglin Chen, Zhongxuan Cai, Yunxin Mao, Minglong Li, Wenjing Yang, and Ji Wang. Mrbtp: Efficient multi-robot behavior tree planning and collaboration. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, pp. 14548–14557, 2025.
  5. [5]Flavio De Vincenti and Stelian Coros. Centralized model predictive control for collaborative loco-manipulation. In Robotics: Science and Systems, volume 2023, 2023.
  6. [6]Ria Doshi, Tian Gao, Annie Chen, Chelsea Finn, and Jeannette Bohg. Chorus: Decentralized multi-embodiment collaboration with one vla policy. arXiv preprint arXiv:2606.12352, 2026.arxiv.org/abs/2606.12352
  7. [7]Letian Fu, Justin Yu, Karim El-Refai, Ethan Kou, Haoru Xue, Huang Huang, Wenli Xiao, Guanzhi Wang, Dantong Niu, Fei-Fei Li, et al. Cap-x: A framework for benchmarking and improving coding agents for robot manipulation. arXiv preprint arXiv:2603.22435, 2026.arxiv.org/abs/2603.22435
  8. [8]Shengran Hu, Cong Lu, and Jeff Clune. Automated design of agentic systems. In International Conference on Learning Representations, volume 2025, pp. 21344–21377, 2025.arxiv.org/abs/2408.08435
  9. [9]Shyam Sundar Kannan, Vishnunandan LN Venkatesh, and Byung-Cheol Min. Smart-llm: Smart multi-agent robot task planning using large language models. In 2024 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pp. 12140–12147. IEEE, 2024.arxiv.org/abs/2309.10062
  10. [10]Seth Karten, Joel Zhang, Tersoo Upaa Jr, Ruirong Feng, Wenzhe Li, Chengshuai Shi, Chi Jin, and Kiran Vodrahalli. Continual harness: Online adaptation for self-improving foundation agents. arXiv preprint arXiv:2605.09998, 2026.arxiv.org/abs/2605.09998
  11. [11]Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Ted Xiao, Ashwin Balakrishna, Suraj Nair, Rafael Rafailov, Ethan Foster, Grace Lam, Pannag Sanketi, et al. Openvla: An open-source vision-language-action model. arXiv preprint arXiv:2406.09246, 2024.arxiv.org/abs/2406.09246
  12. [12]Vaishak Kumar. Act-observe-rewrite: Multimodal coding agents as in-context policy learners for robot manipulation. arXiv preprint arXiv:2603.04466, 2026.arxiv.org/abs/2603.04466
  13. [13]Jacky Liang, Wenlong Huang, Fei Xia, Peng Xu, Karol Hausman, Brian Ichter, Pete Florence, and Andy Zeng. Code as policies: Language model programs for embodied control. In 2023 IEEE International conference on robotics and automation (ICRA), pp. 9493–9500. IEEE, 2023.arxiv.org/abs/2209.07753
  14. [14]Kehui Liu, Zixin Tang, Dong Wang, Zhigang Wang, Xuelong Li, and Bin Zhao. Coherent: Collaboration of heterogeneous multi-robot system with large language models. In 2025 IEEE International Conference on Robotics and Automation (ICRA), pp. 10208–10214. IEEE, 2025a.arxiv.org/abs/2409.15146
  15. [15]Yibin Liu, Zhixuan Liang, Zanxin Chen, Tianxing Chen, Mengkang Hu, Wanxi Dong, Congsheng Xu, Zhaoming Han, Yusen Qin, and Yao Mu. Hydecodepolicy: Hybrid language controllers for multimodal monitoring and decision in embodied agents. arXiv preprint arXiv:2508.02629, 2025b.arxiv.org/abs/2508.02629
  16. [16]Runyu Lu, Yubo Wu, Ethan Kou, Letian Fu, Wenli Xiao, Ajay Mandlekar, Yinzhen Xu, Guanya Shi, Ken Goldberg, Ang Chen, et al. Aspire: Agentic/skills discovery for robotics. arXiv preprint arXiv:2607.00272, 2026.arxiv.org/abs/2607.00272
  17. [17]Zhengyi Luo, Ye Yuan, Tingwu Wang, Chenran Li, Fernando Castañeda, Sirui Chen, Zi-Ang Cao, Jiefeng Li, David Minor, Qingwei Ben, et al. Sonic: Supersizing motion tracking for natural humanoid whole-body control. Science Robotics, 11(117):ead4592, 2026.DOI
  18. [18]Zhao Mandi, Shreeya Jain, and Shuran Song. Roco: Dialectic multi-robot collaboration with large language models. In 2024 IEEE International Conference on Robotics and Automation (ICRA), pp. 286–299. IEEE, 2024.
  19. [19]Bikram Pandit, Ashutosh Gupta, Mohitvishnu S Gadde, Addison Johnson, Aayam Kumar Shrestha, Helei Duan, Jeremy Dao, and Alan Fern. Learning decentralized multi-biped control for payload transport. In Conference on Robot Learning, pp. 1021–1034. PMLR, 2025.arxiv.org/abs/2406.17279
  20. [21]Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflexion: Language agents with verbal reinforcement learning. In Advances in neural information processing systems, volume 36, pp. 8634–8652, 2023.arxiv.org/abs/2303.11366
  21. [22]Emanuel Todorov, Tom Erez, and Yuval Tassa. Mujoco: A physics engine for model-based control. In 2012 IEEE/RSJ international conference on intelligent robots and systems, pp. 5026–5033. IEEE, 2012.DOI
  22. [23]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16291, 2023.arxiv.org/abs/2305.16291
  23. [24]Zhaotian Weng, Antonis Antoniades, Deepak Nathani, Zhen Zhang, Xiao Pu, and Xin Eric Wang. Group-evolving agents: Open-ended self-improvement via experience sharing. arXiv preprint arXiv:2602.04837, 2026.arxiv.org/abs/2602.04837
  24. [25]Wenli Xiao, Jia Xie, Tonghe Zhang, Haotian Lin, Letian Fu, Haoru Xue, Jalen Lu, Yi Yang, Cunxi Dai, Zi Wang, et al. Enpire: Agentic robot policy self-improvement in the real world. arXiv preprint arXiv:2606.19980, 2026.arxiv.org/abs/2606.19980
  25. [26]Yifan Yang, Ziyang Gong, Weiquan Huang, Qihao Yang, Ziwei Zhou, Zisu Huang, Yan Li, Xuemei Gao, Qi Dai, Bei Liu, et al. Skillopt: Executive strategy for self-evolving agent skills. arXiv preprint arXiv:2605.23904, 2026.arxiv.org/abs/2605.23904
  26. [27]Puzhen Yuan, Angyuan Ma, Yunchao Yao, Huaxiu Yao, Masayoshi Tomizuka, and Mingyu Ding. Remac: Self-reflective and self-evolving multi-agent collaboration for long-horizon robot manipulation. Pattern Recognition, pp. 114831, 2026.arxiv.org/abs/2503.22122
  27. [28]Guibin Zhang, Haotian Ren, Chong Zhan, Zhenhong Zhou, Junhao Wang, He Zhu, Wangchunshu Zhou, and Shuicheng Yan. Memevolve: Meta-evolution of agent memory systems. arXiv preprint arXiv:2512.18746, 2025.arxiv.org/abs/2512.18746
  28. [29]Hao Zhang, Yaru Niu, Yikai Wang, Ding Zhao, and H Eric Tseng. Halo: Learning human-robot collaboration via heterogeneous-agent lyapunov policy optimization. arXiv preprint arXiv:2603.03741, 2026a.arxiv.org/abs/2603.03741
  29. [30]Jenny Zhang, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. Darwin gödel machine: open-ended evolution of self-improving agents. In International Conference on Learning Representations, volume 2026, pp. 104223–104294, 2026b.arxiv.org/abs/2505.22954
  30. [31]Jenny Zhang, Bingchen Zhao, Wannan Yang, Jakob Foerster, Jeff Clune, Minqi Jiang, Sam Devlin, and Tatiana Shavrina. Hyperagents. arXiv preprint arXiv:2603.19461, 2026c.arxiv.org/abs/2603.19461

Paper details

vlnc:W_guxgsq4r
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Generative AI tools

View statement
Looking for related papers…
Contents