Modern coding agents succeed at managing an environment end to end at
scale [1, 2, 43]. Their shared design has been systematized as a
harness [7]: a reactive loop that re-decides from the latest observed
state [44], a tool registry the model selects from at
runtime [45], recovery that reads a failure trace and
retries [46], managed context [47], and memory that persists
across sessions [48]. We transplant these patterns into the physical
world, adapting each component along the way
(§3). Two properties of the software
environment have no physical counterpart. A code repository is readable, and
its tests are verifiable by construction. The physical world provides
neither, so we build both (§4).
Embodied foundation models supply atomic capability in the physical world
along two complementary lines. Vision-Language-Action (VLA) models map
observation and instruction end to end to actions, from the RT
series [49] through open generalist policies [50] to
flow-matching architectures [10, 31]. World Action Models (WAMs) grow
out of world models, predictors of how the world evolves, and fold action
emission into the prediction network. DreamZero, a recent instance, drives a
robot in closed loop from a single image-to-video diffusion
model [51]. Both lines are the tools our harness calls, not the layer
it replaces. A recent evaluation across control interfaces finds that
frontier models mostly fail when driving joints directly but act capably when
supervising pretrained policies, with the interface mattering as much as the
model itself [12]. Today's best policies succeed on a single step
with probability p of roughly 0.8 to 0.9 [10, 50], so an
n-step task succeeds with only pn
(§2), which collapses even for modest
n; recovery and evaluation at the harness level close this gap
without waiting for single-step perfection. This is why our design separates
atomic capability from orchestration explicitly.
Language-model orchestration over robot skills begins open-loop. SayCan
selects affordance-grounded skills step by step but nothing judges the skill
just executed [41], and Code as Policies emits a one-shot
program [52]. Inner Monologue comes closest to closing the loop,
threading environment feedback back through the language model, but the
feedback channel is hand-picked and there is no general mechanism to decide
whether a step has actually succeeded [53]. Later work supplies
individual pieces of the loop, a scene graph the planner reads [23]
and a failure judge that rules on outcomes [54]. Dual-system VLAs
take a different route and pair a slow vision-language reasoner with a fast
low-level controller [55, 56, 57, 58]. Most recently, concurrent systems
bring coding agents to robotics: RoboClaw automates data collection through
self-resetting action pairs [59], CaP-X benchmarks coding agents on
manipulation and improves them by scaling test-time
interaction [32], Guava searches the harness design space for
manipulation and distills the result into a compact model for
deployment [60], ENPIRE has coding agents self-improve policies on
real robots through automated reset, rollout, and
verification [61], and ASPIRE discovers reusable skills by writing
and repairing control code [62]. Our work carries the paradigm of
coding agents over as a whole. The harness is itself the deployed system,
closing the loop from instruction to completion in the physical world.