Self-Evolving Coding Agents: From Digital Programs to Physical-World Intelligence

AI summary

Overview

Research area: Robotics and embodied AI — specifically vision-language-action (VLA) and world-action (WAM) models, code-as-policy robot agents, and self-evolving agent systems. The paper is published under arXiv category cs.RO (arXiv:2609.35432v1, dated 28 Sep 2026).

Technical level: Advanced. The paper assumes familiarity with robot learning benchmarks, policy architectures, program synthesis, and evaluation protocols, though its central argument — represent task state and procedure as executable code — is stated in accessible terms.

Scope (one sentence): The paper proposes "Physical Coding," an executable world-and-policy-program interface for physical-world agents, and instantiates it in HexaAnything, a coding agent that calls perception, planning, and control tools (including VLA/WAM policies) and is evaluated on long-horizon manipulation, a simulated laboratory benchmark the authors propose (PhyBench), and a real dual-arm AgileX robot.

What This Paper Is About

VLA and WAM models map observations and instructions directly to robot actions, which quietly buries task requirements, progress, and failure recovery inside action sequences, making them hard to inspect or fix. The authors argue the fix is representational rather than another action primitive: the agent should maintain executable code describing both the world state and its own execution procedure, so failures can be localized to a predicate, a tool, or a workflow branch. They build HexaAnything to test this idea across simulation and a real robot, and report preliminary evidence that improvement can happen at the Harness, tool, and data-to-model levels.

Key Contributions

1. A formulation of "Coding Agents for the Physical World" and "Physical Coding." The paper defines an executable interface between physical state, action, evidence, and revision, instantiated as two coupled representations: Code as World (task-relevant objects, relations, observations, constraints, and progress predicates) and Code as Policy (planning, tool calls, execution, verification, and recovery).
2. HexaAnything, a physical coding agent that integrates language models, state observation, independent verifiers, and action tools (including learned VLA/WAM policies) into a single physical execution loop, with tools exposed through a typed Harness.
3. Evidence for Harness, data, model, and tool improvement on long-horizon manipulation, including training a new model (HexaModel) on verified execution traces the Harness returns.
4. PhyBench, a proposed simulated laboratory benchmark, on which the same Harness autonomously completes scientific experiments, motivating a staged path toward broader self-evolution.

Main Findings

• Instruction-conditioned VLAs are barely instruction-conditioned. A QwenGR00T policy (Qwen3-VL-4B backbone, GR00T-style action head) trained in StarVLA on LIBERO with the instruction masked succeeds in 92.3% of trials averaged over three suites, versus 96.2% for its instruction-conditioned counterpart, trailing by at most 6.0 percentage points on any suite. Per-suite numbers in Figure 2 are: Spatial 97.3 vs 91.3 (delta −6.0), Object 99.6 vs 98.5 (delta −1.1), Long 91.6 vs 87.1 (delta −4.5), Average 96.2 vs 92.3 (delta −3.9), with 500 trials per suite. The paper also reports that LangForce's rates are within 1.1 points of these.
• Released VLAs are fragile to small perturbations. The paper reports that they lose more than half their success under small changes in viewpoint or initial robot state and approach zero when object layout or task order is perturbed; increasing data or model capacity does not reliably remove this failure mode.
• Code traces appear to internalize physical execution. On RoboCasa365, HexaAnything improves Composite-Unseen and overall success over the XR-1 VLA, and its Harness-trained HexaModel beats the base model on every split. The specific numerical margins are not reported in the provided text.
• World predicates block premature task completion. In LoadKebabSandwich, where a kebab and a bread must enter an oven before the door closes, the world program records which items are inside and states "both ingredients are inside" as a predicate; the policy program is only permitted to close the door when that predicate holds.
• The same Harness performs scientific experiments. On PhyBench, the Hooke's-law task has the world program record the apparatus, the weights on the tray, and each ruler reading with the load that produced it, while the policy program chooses loads, applies them with the arm, reads the ruler, and fits stiffness from the recorded pairs. Pendulum timing is constrained to complete cycles, in free motion, at an amplitude below 5 degrees.
• Real-robot transfer is reported. On a dual-arm AgileX robot, the agent autonomously completes most tabletop tasks, often faster than published results.
• Verification is independent of the model. The verifier returns typed verdicts — pass, fail, insufficient evidence, blocked, safety stop — and every observation carries provenance, rather than relying on an exit code or a critic produced by the same model.
• Self-evolution is observed at three levels so far. The abstract reports data, model, and tool self-evolution, alongside a Harness-level improvement — described as controlled and partial, not full autonomous co-evolution.

Methodology in Plain English

The authors start from a diagnosis: because action models output motion chunks and a stop signal, nothing durable records what subgoals remain, what conditions hold, or what to do after a failure. Their analogy is digital coding agents, where state is a repository, actions are tool calls that return results, and completion is decided by tests the agent did not write for itself.

Their approach turns physical tasks into two programs. The "world program" is written from what a real robot actually has — images, depth, proprioception, and tool outputs, not privileged simulator state — and holds objects, relations, measurements, constraints, and progress predicates, each tagged with the call and time that produced it. The "policy program" calls typed tools (perception, motion planning, grasping, placement, contact control, plus terminal, file, and Python tools, and learned VLA/WAM policies invoked with a local instruction) and contains branching, looping, verification, and recovery nodes. After each tool call the agent re-observes, updates the world program, and evaluates the predicates the call was meant to change; the episode succeeds only when goal predicates hold on fresh evidence.

For self-evolution, the paper organizes updates into four coupled targets — the Harness, the model, data and environments, and the embodiment and compute substrate — connected by a typed execution trace, with representation and interface evolution cutting across all four. Each round is described as a generate–evaluate–select cycle over a versioned artifact bundle a_v = (W_v, P_v, H_v, D_v, M_v, E_v) — world representation, policy, Harness, admitted data, memory, and evaluator configuration — with independent evaluation gating whether a change is admitted or rolled back. The paper describes seven explicit operations for each round; in the provided content only the first, "Specify" (freeze the task distribution, environment version, random seeds, budgets, and evaluation protocol), is shown before the text is truncated.

The overall program is staged: Stage 1 bootstraps the coding–action–state–feedback loop; Stage 2 closes the data–model–Harness loop; Stage 3 transfers it to constrained physical workflows with real sensors, users, engineers, and safety gates. The reported experiments cover the Harness, tool revision, and a first data-to-model update; the four-target co-evolution remains future work.

Why This Matters

Impact on research. The paper reframes a common benchmark result — near-saturated success on tasks like LIBERO — as potentially uninformative, showing that a policy trained with the instruction masked still reaches 92.3% versus 96.2% for the instruction-conditioned version. It also draws a sharp methodological line between systems that store what they learn outside the model (memory, skill libraries, critics, operating ranges) and a Harness that produces training data an independent evaluator has already admitted. If that line holds, it changes how embodied agent improvements should be measured and attributed.

Real-world applications:

• Manufacturing and factory workflows, where the authors explicitly target deployment and where tasks involve real sensors, users, engineers, and safety gates.
• Scientific laboratory automation — PhyBench is designed around the loop of deciding what to measure, operating instruments, and checking whether data support a conclusion.
• Tabletop manipulation on real dual-arm hardware, demonstrated on an AgileX robot where the agent completed most tasks, often faster than published results.
• Operator-facing robotics tooling: on the real robot, tools are exposed through URAI and shared by both humans and agents.

Industry relevance. The four-target taxonomy (Harness, model, data and environments, embodiment and compute substrate) maps onto practical engineering concerns: what you can change without retraining, what requires new demonstrations, and what requires different hardware. Tracking provenance and permitting rollback for each versioned artifact bundle is a deployment-oriented property, not only a research one.

Future Directions

• Weight internalization. The paper's stated future work targets internalizing into model weights what the world and policy programs currently supply, extending the first data-to-model update reported here.
• Autonomous redesign of higher-level artifacts. The authors list autonomous redesign of architectures, languages, representations, and tasks as a goal beyond the current tool and Harness evolution.
• Coordinated evolution of all four targets. The present report covers Harness and tool evolution plus a first data-to-model update; joint evolution of the Harness, model, data and environments, and embodiment and compute substrate remains a longer-term program, as do Stages 2 and 3.
• Independent validation at scale. The paper identifies as an open gap that few systems sustain updates with independent validation, regression control, provenance, and rollback, and warns that a training reward is not an independent verifier and that a persistent artifact is not a model update.

Target Audience

Robotics and embodied-AI researchers working on long-horizon manipulation, VLA/WAM policy design, and agent harnesses; engineers building or evaluating robot-agent stacks in manufacturing, laboratory automation, and dual-arm manipulation; and researchers in self-evolving and code-as-policy agent systems who need a concrete, hardware-grounded formulation of what "self-evolution" should mean when the environment returns delayed, noisy, or irreversible feedback. Readers looking for settled, quantified benchmark dominance should note that the reported self-evolution results are described as preliminary and partial, and that specific improvement margins for RoboCasa365 are not given in the paper content available here.

Authors’ abstract

Vision-language-action (VLA) and world-action (WAM) models map observations and instructions directly to robot actions. This directness ties a policy to training: minor layout or viewpoint changes cause failure, and instructions generalize poorly. The root cause lies in representation: task requirements, conditions, progress, and failure recovery are implicitly encoded in action sequences, making them difficult to inspect or revise. Digital coding agents offer a precedent: LLMs call tools, verify results, and revise from feedback as executable code. The same working pattern of explicit state, manageable execution, and revisable procedures underlies generalization and long-horizon execution in the physical world, letting physical experience return as reusable programs, memory, or evidence. We propose Physical Coding, representing task state and execution as code. Code as World records objects, relations, constraints, and progress; Code as Policy organizes planning, verification, recovery, and execution. We build HexaAnything, which calls perception, planning, and control tools, including VLA/WAM policies, and makes in-the-loop decisions from external feedback. Verified traces become data and memory, enabling evolution from tools and Harness to model weights, architectures, and ultimately hardware and task design. On RoboCasa365, HexaAnything improves Composite-Unseen and overall success over XR-1 VLA, and its Harness-trained HexaModel beats the base on every split, indicating code traces internalize physical execution. On PhyBench and a dual-arm AgileX robot, the agent autonomously completes physics experiments and most tabletop tasks, often faster than published results. We observe data, model, and tool self-evolution; future work targets weight internalization, autonomous redesign of architectures, languages, representations, and tasks, and deployment in manufacturing and science.