Embodied Turing Machines: Stateful Code for Robot Recursive Self-Improvement

TL;DR

COAP (Code-Only-as-Policy) argues that if a robot’s observable state (robot, environment, task) can be tracked accurately from camera + proprioception, decision-making can be written entirely in code with neither a VLA nor a VLM-in-the-loop. The authors frame the embodied world as an Embodied Turing Machine — tape is state, rules are the policy — and derive three advantages over VLA / Agent-Harness patterns: Explicit State (state lives in code variables), Execution (code is controllable, cheap, fast, failure-recovery-flexible), and Extensibility (new tasks reuse/extend one shared library). On RoboDojo’s 42 bimanual tasks the resulting library reaches 70.24% success without any model at test time, and the authors position COAP as a substrate for coding-agent-driven recursive self-improvement, with the generated library also usable as a data engine for downstream VLAs or Agent Harnesses. [Abstract]

Key claims

The embodied world admits a Turing-machine framing where state is the tape and policy is the transition function, so if state can be represented accurately from sensors, every decision is decidable in code without a learned model in the control loop. [Abstract]
Explicit State: the robot/environment/task state is stored in code variables (not weights, not VLM context), making it inspectable and auditable at every step. [Abstract]
Execution: code is controllable, deterministic, fast and cheap online, and gives flexible failure recovery compared to a VLA emitting actions from a stateless chunk or an Agent Harness querying a VLM each decision. [Abstract]
Extensibility: new tasks reuse, inherit, or extend one shared library, so capabilities accumulate across tasks rather than being re-learned per task. [Abstract]
These three properties make COAP a suitable substrate for recursive self-improvement: coding agents develop the library in a closed loop and each change is explicit and controllable (vs. a VLA update that silently reshapes a weight manifold). [Abstract]
On RoboDojo’s 42 bimanual simulation tasks the COAP library reaches 70.24% success with no model at test time. [Abstract]
The upper bound of COAP is set by (a) how accurately state can be represented for decision-making and (b) the robustness of the code logic — not by model capacity. [Abstract]
Because COAP applies across episodes rather than per-episode, the same library can serve as an efficient data engine for downstream VLAs or Agent Harnesses. [Abstract]

Method

The core move is a reframing: a VLA keeps a model in the control loop mapping observations to actions, and an Agent Harness (Agent-as-Policy, Harness VLA) queries a VLM at every decision point. COAP replaces both with code. One module measures and tracks robot pose, environment state, and task progress from camera images + proprioception into typed variables; a second module makes every decision from those variables using ordinary program control flow. The same codebase applies across episodes of the same task, and different tasks share one library so a new task extends existing modules rather than re-authoring from scratch. For development, the authors position coding agents as the authors of the library in a closed loop — each library change is a code diff and each outcome is a graded rollout, so every improvement is explicit and version-controlled rather than absorbed into opaque weights.

RoboDojo’s 42 bimanual tasks are the evaluation surface, and the headline 70.24% is reported for the resulting shared library against those tasks with no model at test time. (The arxiv landing page provides abstract and framing only; architectural details of the state-tracking perception module, the specific code-authoring loop, and per-task breakdowns live in the PDF, which was not fetched at filing.)

Results

70.24% success rate on RoboDojo’s 42 bimanual tasks with no model at test time. [Abstract]
Positioned as both a standalone policy and a data engine — the same shared library can mass-produce successful rollouts that downstream VLAs or Agent Harnesses can be trained on, because the library is episode-general rather than per-instance. [Abstract]
Positioning as a new paradigm for embodied tasks; headline comparison is against VLAs and Agent Harnesses at the design-space level rather than against a specific checkpoint on this benchmark. [Abstract]

Quantitative comparisons against specific VLA baselines on the same RoboDojo-42 split, per-task numbers, and the data-engine downstream-training numbers are in the PDF and not available at filing time.

Why it’s interesting

COAP sharpens three debates the wiki is currently tracking. First, it stakes out a sharp no-model-at-test-time cell on the recipe-lever board of VLA Models, where it sits closest to OpenRUA: Robot-Use Agents Are Zero-Shot Visuomotor Policies OpenRUA’s “no bespoke harness, just terminal access to the robot’s native API” position but goes further — OpenRUA keeps Claude Opus 5 in the inference loop writing programs, COAP removes the LLM at inference entirely and shifts all the intelligence into a pre-authored shared library. The RoboDojo-42 70.24% number is directly comparable to the RoboDojo: A Unified Sim-and-Real Benchmark for Comprehensive Evaluation of Generalist Robot Manipulation Policies baseline sweep and to InternW0-Δ: A World Action Model Bridging Predictive Dynamics and Actions with 20K+ Hours of Open Data‘s 23.9% on the same bench, giving the first cell on this concept’s grid for “code library, zero model at inference” on this exact benchmark.

Second, it extends the Tool-Use Agents design space. Harness-level work there (Harness VLA, Pigey, RoboHarness, HomeBody, 2AM) has pushed toward “wrap frozen VLA/skills in an orchestrator with typed primitives”; COAP’s position is that if state tracking is accurate enough, the orchestrator is also unnecessary — the Turing-machine framing says a sufficiently expressive type for state collapses the whole control problem into ordinary code. Sibling framing to ASPIRE: Agentic /Skills Discovery for Robotics ASPIRE and Playful Agentic Robot Learning RATs on the “distill a frozen reusable program vocabulary” axis, but with the vocabulary graduating from “primitives the agent calls” to “the policy itself.”

Third, COAP’s “code as the substrate for RSI” framing fits directly into AI-for-AI Research‘s physical-RSI subthread alongside RoboRSI: Stable, Efficient, and Reusable Robot Self-Evolution in Complex Real-World Environments RoboRSI (four-agent harness over a four-level skill tree) and ENPIRE / GaP / ASPIRE / GRID Auto-Engineering. The explicit load-bearing claim — that every change is a code diff and therefore auditable — is the operational version of the two-round frozen-knowledge discipline Toward Recursive Self-Improvement in Physical AI argues the field is missing. Whether COAP’s library actually realizes compounding improvement across tasks (vs each task’s extension being orthogonal) is the open empirical question the paper opens for this concept.