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

Self-Evolving Coding Agents. From Digital Programs to Physical-World Intelligence. By Hongcheng Gao and twelve others, from HexaFuture. Published on the twenty-eighth of September. Its code repository is a placeholder: a readme, and nothing to run yet.

Vision-language-action models and world-action models map observations and instructions straight to robot actions. That directness ties a policy to its training. Minor changes in layout or viewpoint cause failure, and instructions generalize poorly. The authors locate the root cause in representation. Task requirements, conditions, progress and failure recovery are all encoded implicitly in action sequences, where they are difficult to inspect or revise. When a policy fails, there is no written-down notion of what the task required or how far it had got, only a sequence of actions, and nothing explicit that could be corrected directly.

Digital coding agents offer a precedent. Language models call tools, verify the results, and revise from feedback, all as executable code. The authors argue that the same working pattern, explicit state, manageable execution and revisable procedures, underlies generalization and long-horizon execution in the physical world as well, and lets physical experience come back as reusable programs, memory or evidence. The claim is that flexibility comes from that working loop: state you can see, steps you can check, and procedures you can rewrite when a check fails.

Their proposal is 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. What a direct policy hides inside its actions is written out where it can be read and changed.

The system built on this is HexaAnything. It calls perception, planning and control tools, including VLA and WAM policies themselves, and makes in-the-loop decisions from external feedback. Verified traces become data and memory. The authors describe that as the route to evolution, starting from tools and the Harness, and extending to model weights, architectures, and ultimately hardware and task design.

On RoboCasa365, HexaAnything improves success on the Composite-Unseen split and overall, compared with the XR-1 VLA. HexaModel, trained with the Harness, beats its base on every split, which the authors read as code traces internalizing physical execution.

On PhyBench and on a dual-arm AgileX robot, the agent autonomously completes physics experiments and most tabletop tasks, often faster than published results. The authors also report observing data, model and tool self-evolution. Across the three settings, the pattern is that an agent reasoning in code can sit on top of existing robot policies, use them as tools, and wrap a layer of verification and recovery around them.

Much of the ambition is stated as future work: weight internalization, autonomous redesign of architectures, languages, representations and tasks, and deployment in manufacturing and science. The bet underneath is easier to state. A robot's grasp of a task should live in something it can read and rewrite, the way a coding agent's does, rather than inside a sequence of actions it cannot inspect.