acceptodds
Withdrawn from ICLR 2027

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

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

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.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Robot Learning, Embodied AI, Multi-Robot Systems, Multi-Agent Coordination, Foundation Models

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_ccgHOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CoEvolve studies adaptation of executable coordination for robots manipulating a shared payload while keeping foundation-model and motor-policy weights fixed. The framework represents a team decision through a maneuver and semantic objective, a coordination mode and temporary robot roles, and bounded execution parameters. A Task Orchestrator selects the coordination decision, and a Policy Coder produces paired executable robot policies. Measured physical execution determines transition acceptance. Rejected transitions trigger restoration of the latest accepted simulator checkpoint and a typed revision restricted to strategy, coordination, or numerical parameters. The system also maintains abstract strategy records and accepted executable examples, retrieved before and after the coordination decision, respectively.

Critical strengths

1. The paper proposes a meaningful representation for adaptation under shared physical constraints.

The separation between fixed individual motor capabilities and mutable team coordination is well motivated. For robots supporting the same payload, an action can be individually executable while producing an unsuitable relationship with the other robot. Explicitly representing the maneuver, temporary roles, coordination mode, and numerical parameters makes this relationship accessible to revision. The host-enforced revision scopes provide a concrete implementation of this idea. Successful base-task executions across all three backbones support the practical feasibility of the interface. It offers a way to study cooperation without requiring the acquisition of a new joint motor policy for every task.

2. The failure analysis usefully distinguishes local validity, task advancement, and future physical feasibility.

The paper documents an execution with many accepted setup actions but no further milestone progress, and additional-layout executions in which progress precedes degradation of payload support. These observations identify limitations that would be obscured by reporting acceptance rate or progress alone. The paper also handles these findings candidly, acknowledging that local transition verification does not establish feasibility of the remaining task. This diagnostic framing is useful beyond the particular foundation-model backbones evaluated.

Critical weaknesses

1. Limited Novel Insight Beyond Existing Agentic Repair Frameworks

Many central concepts, such as executable robot policies, multimodal execution-guided repair, and reusable validated experience are established in closely related work. ASPIRE [1] also explicitly addresses local repair loops by exploring alternative task strategies. Consequently, the strongest distinctive contribution here is the proposed factorization of coordination repair and its enforcement during subsequent generation.

However, given current experiments, the submission does not show what new coordination knowledge this factorization enables the agent to infer. The provided interface already includes reasonable design choices, but they make it important to separate model-inferred coordination from coordination structure authored into the interface. The current submission establishes an interesting system more clearly than a reusable insight about coordination.

2. Insufficient Causal Evidence for the Proposed Coordination Mechanism

Table 2 reports three successes for the full GPT condition and none for the alternatives, but Section 4.2 and Appendix B.2 explicitly state that execution and continuation differences prevent isolated causal interpretation. This is consequential for Flat Reflective Repair, which is intended to retain feedback, recovery, and dynamic memory while removing typed revision. A comparison under shared conditions could directly test the paper’s most important hypothesis; the reported aggregate comparison cannot do so.

The observed failure cases also make the mechanism ambiguous. The w/o dynamic experience fails mainly in generation/repair stalls, but that ablation alos removes both abstract strategy records and executable examples. Thus, memory may improve valid command generation or interface adherence. But does not indicates transferable physical coordination knowledge.

These concerns matter because they leave open whether the method addresses the coordination bottleneck or repairs limitations of the current model and execution ability. The authors’ descriptive framing is appropriately cautious, but the resulting evidence is insufficient to establish the stronger insight that would make the contribution compelling.

References:

[1] Lu, R., Wu, Y., Kou, E., Fu, L., Xiao, W., Mandlekar, A., ... & Wang, G. (2026). ASPIRE: Agentic/Skills Discovery for Robotics. arXiv preprint arXiv:2607.00272.

Questions for authors
  1. Did REMAC, COHERENT, CaP-Agent0 and ASPIRE have access to the same checkpoint restoration and physical verifier as CoEvolve? If not, the 0/5 results are confounded by reset access rather than by coordination reasoning.
  2. Please run (or report, if it exists) a non-LLM revision control: identical verifier, rollback, budget and skill API, with revision implemented as random/structured perturbation over θ and over (mode, roles). How many completions does it reach? This is the single experiment that would establish whether typed LLM revision is the insight.
  3. Were all runs in Tables 1 and 2 executed on a frozen codebase? Please list the execution changes referenced in B.5 and which runs they precede.
  4. Across all 69 executions, what fraction of rejections are attributable to actuation error (overshoot, residual motion, drift) versus a wrong coordination decision? A rejection-cause taxonomy would be more informative than any of the current tables and would directly address "why do current tools fail."
  5. Why does Claude terminate in generation/repair stalls (3/5)? Is this a host schema/validation interaction? This matters for whether the scaffold is backbone-robust or tuned to GPT.
Reviewer_9DsJOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CoEvolve is a simulation framework for two humanoid robots that must carry one shared rigid payload through a tight corridor. Individual walking skills stay fixed. What changes online is the team’s coordination, written as executable code and revised when physical execution fails.

Critical strengths

Carrying a freely supported rigid payload couples the robots: one robot’s motion changes the other’s support and can make the next joint maneuver infeasible. CoEvolve keeps the motor policies frozen and treats coordination as code over a small decision: primitive, objective, sync versus asymmetric mode, temporary roles, and bounded parameters. Prior multi-robot planners and code-policy repair loops do not represent that coupling, so they can keep producing locally valid motions that preserve the failed relation. The GPT comparison gives that distinction.

Critical weaknesses

The main result is that CoEvolve succeeds on 3 of 5 runs, while the comparison methods and both ablations succeed on 0 of 5. The authors say these runs differ in how they execute, how they recover from failure, and how many attempts they get, so they might not be a fair comparison? The extra corridors and the experience-reuse tests have the same problem, and every group has only 3 to 5 runs. What this shows is that one fully configured system sometimes finishes the carry. It does not show that the proposed revision rules or the experience memory caused that success.

The robots do not detect failure themselves. The simulator tells them whether the box is still supported, whether anything made contact, and where the corridor boundaries are. After a failure, they do not walk back. The simulator reloads the last successful state. The low-level controller is also inaccurate: a requested move of 0.25 m ends with the payload about 0.66 m away. So the paper shows that a language model can rewrite code when an all-knowing judge reports an error and the world can be rewound. It does not test what happens without that judge or that rewind.

Questions for authors

In Table 2, did the other conditions run under the same setup as the GPT CoEvolve runs, including how failures were judged and how the simulator was restored? If something important differed, which condition was it?

Did the eight full-task successes in Table 1 stay within Algorithm 1 and only reload the latest accepted checkpoint? For the Layout 4 placement, I am also unsure what the adjusted corridor check changed, and whether that placement would still count under the original rule.

Reviewer_NiRhOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

CoEvolve combines code-based robot coordination with physical verification, checkpoint rollback, structured revision, and experience retrieval over frozen motor skills. The framework is evaluated on two simulated humanoids transporting a shared payload through corridors, using three model backbones, adapted baselines, and several component and transfer experiments.

Critical strengths

The shared-payload setting presents meaningful physical coordination challenges. The paper also candidly documents execution failures and the limitations of simulator-based recovery.

Critical weaknesses
  1. The paper does not establish a substantial methodological advance. Code generation, execution feedback, policy repair, and experience retrieval are familiar components, and their combination here offers limited new insight into robot coordination.

  2. The experiments are too narrow and small to support a significant empirical contribution. A few runs on one simulated task family, even with three backbones, do not establish robust coordination or reveal a convincing generalizable finding.

  3. The comparisons do not convincingly establish effectiveness. Differences in execution conditions weaken the baseline and ablation results, while the transfer experiments lack a matched control demonstrating that reused experience actually helps.

Questions for authors
  1. What specific capability or finding does CoEvolve establish beyond existing feedback-driven robot programming frameworks?

  2. Do the reported gains persist when baselines and component variants use identical execution and recovery settings?

  3. What evidence shows that stored experience improves performance over an otherwise identical empty-memory condition?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.