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

Abstract: Most robot policies keep a model in the control loop: a VLA maps observations to actions, and an Agent Harness, such as Agent-as-Policy or Harness VLA queries a VLM for decision making at run time. We propose a different view: the embodied world is an Embodied Turing Machine, whose tape is the robot and environment state and rules are the policy. If this state can be represented accurately, the decision making can be written entirely in code. We therefore propose Code-Only-as-Policy (COAP): code measures and tracks the robot, environment, and task state from camera images and proprioception, and makes every decision from it. The same code applies across episodes, and different tasks share one library without a VLM or VLA in the loop. Compared with VLAs and Agent Harnesses, we analyze three advantages of COAP: (i) Explicit State: the state can be stored in code; (ii) Execution: code makes decision making controllable, recovers from failures flexibly, and runs fast and cheaply online; (iii) Extensibility: new tasks reuse, inherit, or extend the shared library, so capabilities can accumulate over tasks. These advantages make COAP a suitable medium for recursive self-improvement (RSI): coding agents develop the library in a closed loop, and each change is explicit and controllable. On RoboDojo's 42 bimanual tasks, the resulting library reaches a success rate of 70.24% without a model at test time. The upper bound of COAP lies in how accurately the state is represented for decision making and how robust the code logic is. We thus propose COAP as a new paradigm for embodied tasks; since it applies across episodes, it can also serve as an efficient data engine for VLAs and Agent Harnesses.

• The paper introduces Code-Only-as-Policy (COAP), a robot control paradigm that replaces online model inference with fixed, executable code, achieving a 70.24% success rate on complex manipulative tasks.
• COAP employs explicit state representation and structured recovery processes, leading to superior performance in memory, precision, and general tasks, often exceeding the top best results by 30% points.
• The paper demonstrates that COAP can reduce marginal development costs through shared libraries and offline code development, although this incurs substantial upfront engineering effort.

Problem formulation and central thesis

“Embodied Turing Machines: Stateful Code for Robot Recursive Self-Improvement” proposes Code-Only-as-Policy (COAP), a robot-control paradigm in which the runtime policy is an executable program rather than a VLA, VLM agent, or model-generated plan. The paper’s formal abstraction treats the robot and its environment as an embodied Turing machine: the robot and environment constitute a dynamically changing state, while source code supplies the transition rules. At runtime, the code reads RGB observations and proprioception, updates an explicit state representation, and emits motion commands. The program is fixed across episodes; only the measured state changes.

This position differs from prior code-based policies in two respects. First, COAP measures the relevant state using programmable perception code rather than receiving state from a simulator oracle or an external learned perception model. Second, the same task program is reused across episodes, while a shared library is reused across tasks. Thus, the paper makes the strong claim that a sufficiently robust task-specific program can eliminate model inference from the online control loop altogether.

Figure 1: COAP differs from online code generation and oracle- or model-state policies by reusing fixed programs across episodes and measuring state in code.

The proposal is motivated by a distinction among three policy classes. VLAs encode perception, state, and action selection implicitly in model parameters. Agent Harnesses expose some planning or memory through prompts and textual state, but retain a VLM or VLA in the control loop. COAP instead makes both state and transition logic inspectable. This distinction is consequential for debugging: failures can, in principle, be traced to a state variable, measurement procedure, or control rule and corrected through a localized code change.

The paper evaluates the paradigm on RoboDojo’s 42 bimanual manipulation tasks, spanning memory, precision, open instruction following, generalization, and long-horizon manipulation. Its principal result is a 70.24% overall success rate without a model at test time, compared with 31.38% for the strongest listed Agent Harness, 29.64% for the strongest World Action Model, and 27.96% for the strongest VLA. These comparisons are reported against the RoboDojo leaderboard rather than against a newly trained common baseline, so the magnitude of the advantage should be interpreted within that evaluation protocol (2610.12369).

COAP architecture and state representation

COAP maintains three major forms of state. Environment state contains object categories, poses, dimensions, spatial relations, confidence, measurement source, and measurement time. Robot state contains joint configurations, end-effector poses, gripper openings, and reachability information. Task state contains stage, object-to-arm assignments, retry counts, subgoal status, and persistent task memory. The paper also organizes these variables into five practical categories: robot, object, environment, relation, and task state.

At each control step, the policy implements a transition of the form $x_{t+1},a_t=F_\theta(x_t,o_t)$, where $x_t$ is the explicit state, $o_t$ is the current observation, and $a_t$ is a trajectory segment. Proprioceptive state is refreshed directly; environment state is inferred from RGB images; task state is updated by the task program. Occluded objects retain their last measured pose in an episode-level world state, while high-precision operations trigger wrist-camera remeasurement.

The perception stack is deliberately conventional rather than foundation-model-based. It uses NumPy and OpenCV, robot-mesh projection, robot masking, connected-component analysis, table-plane geometry, and template fitting against known object shapes. RGB boundaries are projected into the table plane, candidate object regions are matched against geometric models, and the resulting records supply positions, orientations, sizes, and confidence values. This design supports inspection and modification of the measurement process, but it also makes the approach dependent on known camera calibration, robot geometry, object models, and simulated scene assets.

Figure 2: COAP separates offline code development, shared library reuse, and fixed-program execution without an online agent or VLA.

The paper illustrates the distinction between environmental and task state with a covering-and-uncovering task. The program measures cubes and cups, associates them by spatial order, stores the color beneath each cup, and later retrieves that memory after the cubes have become occluded. The relevant information is therefore not expected to remain visible in recent frames or implicit in a model’s hidden state; it is stored explicitly in program variables.

This explicit representation directly explains the strong performance on memory and precision tasks. COAP reaches 89.9% on Memory and 75.1% on Precision, versus 50.3% and 33.5% for the strongest corresponding alternatives in the reported comparison. The implication is not merely that explicit memory helps: it suggests that persistent symbolic state and metric geometric state are particularly advantageous when the correct next action depends on information that is no longer visible or requires accurate spatial measurement.

Shared libraries and code-level extensibility

COAP uses a layered library whose dependencies run from task programs through object-family abstractions, manipulation primitives, perception, and motion planning. Task programs specify ordering, task-specific conditions, and special cases. Lower-level modules implement grasping, picking, carrying, placing, pushing, pouring, inverse kinematics, collision checking, remeasurement, verification, and recovery.

The central engineering principle is abstraction by manipulation method rather than by individual object. For example, top, side, handle, rim, edge, and cloth-pinching grasps are reusable across object categories. A new task can therefore compose existing functions, inherit an existing task and override one decision, or introduce a default-off parameter into a shared function. Default-off extensions preserve the behavior of callers that do not activate them, providing a practical compatibility mechanism.

Figure 3: COAP’s layered library separates task-specific decisions from reusable object, manipulation, perception, and motion code.

The reported reuse is substantial: 83% of the code executed by a new task comes from the shared library. Four tasks developed from scratch reached an average validation success of 47% within 15 hours, without new demonstrations or policy training. The task-specific timelines show first successful programs between approximately four and six hours for several tasks, although some tasks remained weak or unsuccessful. These results support the claim that library reuse can reduce marginal development cost, but they do not establish that code development is universally faster than model adaptation: the relevant baseline curves for VLA and Agent Harness development are explicitly described as schematic.

The paper also evaluates regression control. Tasks whose code was not changed retained 78.4% success before library evolution and 79.9% afterward, with no statistically significant task-level change under the reported test. The authors therefore argue that default-off parameters, inheritance, and isolated task additions permit cumulative improvement without catastrophic interference. This is a meaningful contrast with continual VLA fine-tuning, but the compatibility guarantee is conditional on the implementation discipline and test fixtures used. It protects tested execution paths, not arbitrary unseen states.

Figure 4: New tasks predominantly execute shared library code and can be added without data collection or model retraining.

Execution control, recovery, and computational cost

COAP’s execution strategy is based on explicit checks, state updates, and structured recovery. Manipulation primitives return evidence about their outcome, such as whether an object was grasped, held during lifting, placed, or verified at the target. When a step fails, the program can remeasure the scene, backtrack to a known task stage, and retry with a different grasp or motion strategy.

Among episodes in which something went wrong, the program noticed and reported the problem in 76% and attempted a new method in 34%. The paper reports that 12% of all such episodes were reattempted successfully, while 42% were detected and terminated with an explanation. These results show that explicit recovery is operationally useful, but they also expose a limitation: detection does not imply successful recovery, and a substantial fraction of failures remained unreported or unrepaired.

Figure 5: Explicit checkpoints and backtracking limit failure propagation, while fixed code substantially reduces online computation.

The online computational profile is one of COAP’s clearest advantages. A control call has a median latency of 0.3 ms on a CPU, with a median of 352 decisions per episode. Perception and planning account for most of the decision time, while many intermediate calls simply advance an already planned action segment. The reported episode compute is 0.8–2.4% of that estimated for a VLA and less than 0.1% of that estimated for an Agent Harness.

These comparisons require qualification. The VLA and Agent Harness costs are estimates derived from reported model sizes and assumed inference schedules, rather than direct measurements under a common hardware configuration. Nevertheless, the architectural distinction is robust: COAP moves model computation offline into code development, whereas VLA and Agent Harness methods pay inference costs during every episode.

Recursive self-improvement through code search

The paper frames recursive self-improvement as an iterative software-engineering process. A coding agent observes failed development episodes, identifies a faulty state variable or transition rule, proposes a code diff, executes the resulting program, and merges the change only if it improves validation performance by a prescribed margin. Each candidate is a complete runnable branch, allowing multiple alternatives to be evaluated concurrently.

This process resembles a constrained search over program variants. CPU-level checks reject branches with invalid task transitions, infeasible inverse-kinematics solutions, or collisions. Simulation evaluation then applies a non-regression-oriented acceptance rule. The current implementation uses Claude Opus 5.5 coding agents without human intervention in the development loop, although the task definition, evaluation protocol, safety constraints, and acceptance thresholds are externally specified.

Figure 6: Parallel branching evaluates multiple alternatives to a decision and selects changes using validation performance.

Parallel branching is important because code changes are cheap to instantiate relative to retraining a VLA. The paper reports that decisions with two or more variants produced an accepted change in four of five cases. In the busiest development interval, 12 task evaluations ran concurrently and completed in 17% of the serial execution time. These measurements support the narrower claim that code provides a convenient search medium for offline policy improvement. They do not demonstrate unrestricted self-modification: candidate generation remains dependent on the coding model, and selection is based on finite validation layouts.

The paper identifies six properties that make a medium suitable for this process: diagnosable failures, targeted changes, cross-task reuse, parallel trials, persistence of gains, and cheap improvement rounds. COAP satisfies these properties because state is explicit, modifications are diffs, branches are executable programs, and accepted changes can be integrated into a shared library.

Benchmark results

COAP’s overall success rate is 70.24%, with a benchmark progress score of 75.45. It leads the reported alternatives across all five task dimensions.

RoboDojo dimension	COAP success	Best listed baseline	COAP margin
Memory	89.9%	50.3%	+39.6 points
Precision	75.1%	33.5%	+41.6 points
Open instruction	64.1%	31.0%	+33.1 points
Generalization	65.7%	30.5%	+35.2 points
Long horizon	56.4%	43.4%	+13.0 points
Overall success	70.24%	31.38%	+38.86 points

The largest advantages occur on Memory and Precision, precisely the dimensions most directly aligned with COAP’s explicit state and geometric measurement. The smallest advantage occurs on Long-Horizon tasks, where accumulated contact failures, incomplete recovery logic, and compounding execution errors remain difficult even with explicit state.

Generalization is more mixed than the aggregate score suggests. COAP reaches 77.3% on standard layouts but only 54.1% on randomized layouts containing new object instances, room and table appearances, and distractors. On the 40 tasks with programs, validation and test success are relatively close on standard layouts—76.7% versus 74.9%—but the randomized setting exposes dependence on scene structure and perception assumptions. Thus, the result supports task-level program reuse within a structured environment more strongly than broad open-world generalization.

Failure modes and empirical boundary

The paper divides failures into perception error, contact error, incomplete logic, and poor code design. Perception and contact errors account for 62% of failures, while incomplete logic and poor code design account for 37%. This decomposition leads to the paper’s central boundary condition: COAP’s upper bound is determined by the fidelity of state representation and the robustness of the transition logic.

Perception failures include object misclassification, incorrect segmentation-like region extraction, and faulty final verification. Contact failures are more fundamental: the current state representation does not fully capture grasp contact, deformable-object configuration, or the mechanical conditions governing slip. Code failures include missing retries, insufficiently general conditions, and hard-coded thresholds that fail on new object sizes.

Figure 7: COAP failures arise from both imperfect state measurement and incomplete or poorly generalized code logic.

This analysis qualifies the paper’s strongest conceptual claim. Code is inspectable, but inspectability does not guarantee correct state estimation. A white-box controller can make systematic errors when its state variables omit relevant physical information. The reported oracle-state comparison makes this explicit: the same program succeeds in 83% of episodes with oracle state but only 63% with measured state. The 20-point gap is evidence that perception and state abstraction, rather than high-level task logic alone, are a major performance bottleneck.

Limitations and open questions

The evaluation is entirely in simulation, and the perception system uses public benchmark assets, calibrated camera models, robot meshes, object dimensions, and known scene structure. Transfer to physical robots would require recalibration, object and contact-parameter estimation, and retuning of grasp widths, speeds, and tolerances. Consequently, the 70.24% result should not be interpreted as evidence of equivalent real-world performance.

The approach also incurs substantial offline development cost. Every new task requires coding-agent iterations, execution, debugging, and validation. Although online execution is inexpensive, this cost is shifted rather than eliminated. The paper does not provide a controlled accounting of total engineering effort against VLA data collection, fine-tuning, or Agent Harness prompt development.

Generalization remains incomplete. Two tasks have no successful program, several task success rates are low, and one task reaches only 0.7%. Randomized-layout performance is substantially below standard-layout performance. Moreover, the acceptance rule evaluates finite validation fixtures, and the reported compatibility mechanism protects existing code paths only under the assumptions encoded in tests and default-off interfaces.

Several questions remain open within the paper’s own framework. How should COAP represent deformable-object contact, uncertainty, and unobserved dynamics? Can learned perception modules be integrated without forfeiting state inspectability and controllability? What validation protocol can prevent overfitting when branching over many code variants? And can the proposed library abstraction transfer to real hardware without requiring object- and robot-specific redesign?

Conclusion

The paper presents COAP as a programmatic alternative to model-in-the-loop robot control. Its technical contribution is the integration of explicit state estimation, fixed code policies, shared manipulation libraries, structured recovery, and offline coding-agent improvement. On RoboDojo, this design achieves 70.24% success and substantially exceeds the listed VLA, World Action Model, and Agent Harness baselines, with particularly large gains on memory and precision tasks.

The results support the narrower thesis that explicit, persistent state and executable transition logic are highly effective for structured bimanual manipulation. They also establish the method’s principal constraint: performance depends on whether the code can measure the physically relevant state and encode sufficiently robust recovery logic. The paper’s most consequential open problem is therefore not whether code can replace online model inference in a benchmark, but whether the same state-and-library methodology can retain its advantages under unstructured perception, complex contact, and real-world dynamics.