A Morphology-Invariant Symbolic Interface Enables Multi-Step Policy Transfer Across Robot Bodies

1. Introduction

Reusing behavior across robots with different bodies is a central ambition of generalist robot learning [1,2,3,4], and it faces a structural obstacle. A policy entangles the morphology-invariant structure of a task, what to do and in what order, with the morphology-specific control that executes it, and transferring the policy transfers both at once. Companion work measures how little ports under controlled evaluation; a morphology-distance predictor of transfer gain fails to beat a prior that never sees the source robot (Spearman $\rho =0.283$ versus $0.579$ over 42 independent pairs), a full-feature transferability oracle fails to beat a one-bit arm/not-arm indicator ($0.762$ versus $0.834$), and the apparent benefit of pretraining diversity dissolves once total data volume is held fixed [5]. A companion theory paper closes the continuous route as well; any continuous task representation informative enough to support control retains body-identifying structure under a strong probe, so an interface that supports cross-body reuse must be coarse, a discrete or symbolic code being one realization [6].

This paper builds and evaluates that coarse interface. The construction factors a multi-step task into a morphology-invariant symbolic plan, the ordered subgoal sequence, and a per-subgoal grounded reach skill; the plan carries no morphological information, so it transfers across bodies at no cost, while the skill is short-horizon and cheap to ground on a new body. The interface between the two is a single symbolic progress variable, the identity of the active subgoal, and the experiments isolate exactly what that variable is worth. Three agents are trained by behavior cloning from the same demonstrations under the same budget and differ only in how the observation is factored. A reactive agent sees its configuration and all K targets and must infer which subgoal is active; an oracle-flat agent is additionally hand-fed the active subgoal, an information-matched upper bound on what a monolithic policy could do; the deliberative agent obtains the same variable from its own plan. The deliberative agent ties the oracle-flat agent at every depth, so deliberation is not superior to a flat policy given the same information, and both exceed the reactive agent by more than fifty points of success at every depth beyond one, so the progress state is the entire effect. Deliberation matters because it is a cheap, transferable source of that state, which no oracle announces on a new robot.

The paper makes five contributions.

1.

We isolate the morphology-invariant symbolic progress state as the transferable object in multi-step cross-embodiment transfer, with a three-agent design in which an information-matched monolith ties deliberation while the realistic reactive baseline collapses at depths 2 to 4, within morphology and under cross-morphology transfer (Section 4.1 and Section 4.2); the cross-morphology contrast, 0.590 versus 0.018 pooled over depths 2 to 4 with a depth-1 control gap of $-0.002$, is certified by the program’s acceptance gate.

2.

We close the memory loophole with two recurrent controls, a GRU trained under the matched budget and a per-morphology-tuned GRU trained to depth-1 parity, both of which collapse at every depth beyond one under behavior cloning (Section 4.3).

3.

We quantify the factorization’s data efficiency; at depth 3 the deliberative agent reaches the oracle-fed monolith’s best success with 2.5 to 3 times fewer demonstrations and nine times the monolith’s success rate at a fixed ten-rollout budget, while the reactive agent is never competent at any tested budget (Section 4.4).

4.

We compare symbolic-structured, language-token, and continuous-latent codings of the same interface at matched body-blindness and identical upstream information, with endpoints frozen before training; the structured coding beats the token coding pooled over depths 2 to 4 (gap $+0.109$, exact sign-flip $p=0.031$) and a three-bit latent code collapses (Section 4.5).

5.

We show the interface ports where learned policies cannot follow at all, executing multi-step tasks zero-shot on 13 unseen arms, composing independently trained locomotion and manipulation skills with zero composite demonstrations, and carrying failure attribution, perceptual grounding, and feasibility screening across bodies (Section 4.6 to Section 4.8).

The result artifacts and the analysis code that regenerates every number, table, and figure are released as a public repository.

The thesis, stated exactly, is this. A morphology-invariant symbolic plan plus a per-subgoal grounded skill solves multi-step tasks across robot bodies where reactive continuous policies cannot, and reaches competence with several times less target data; the advantage is the morphology-invariant symbolic progress state, which the plan supplies and which an information-matched flat policy merely equals. The value of the plan is that it manufactures the progress state portably, on any body, without an oracle.

2. Related Work

Generalist multi-robot policies absorb a new embodiment by mapping every robot into a shared action space, attaching per-embodiment adapters, and fine-tuning on target data [1,2,3,4,7]. A second line builds the body into the policy, through shared modular controllers [8], graph-structured policies [9], morphology-token transformers [10], morphology-inferring encoders [11], and unified multi-embodiment locomotion architectures [12], although benchmark evidence finds such agents near zero success on out-of-distribution morphologies [13]. Both lines transfer at the level of the continuous policy, where the companion benchmark shows no measured relation between bodies predicts the outcome [5].

Zero-shot cross-embodiment manipulation was reached in 2026 by several systems that share one move, deleting body information from the interface between task reasoning and motor control. RDT2 trains on body-agnostic handheld-gripper data [14], LAP codes actions in language tokens [15], Cloak masks the end-effector out of the observation [16], KITE routes task reasoning through a contact-intent latent [17], and the earlier Mirage cross-painted the gripper visually [18]. These systems demonstrate that a coarse interface transfers but do not measure which coding is best, because each commits to one; Section 4.5 runs that comparison directly at fixed upstream information, and the companion theory paper supplies the structural reason coarseness is necessary [6].

Composing a symbolic plan with grounded continuous skills is a classical architecture. Options formalize temporal abstraction [19], task-and-motion planning interleaves symbolic search with motion generation [20], learned symbolic vocabularies support high-level planning [21] and port across agents [22], and language-model planners expose the plan as text over grounded skill libraries [23,24]. This paper does not propose a new planner; the plan here is the fixed subgoal sequence itself, and the contribution is a controlled cross-embodiment measurement, absent from that literature, of what the plan’s symbolic progress state is worth relative to information-matched and memory-equipped alternatives.

The failure mode that separates the agents is perceptual aliasing. When distinct task stages present identical observations, a memoryless policy maps them to one action, a fact recognized early in reinforcement learning [25] and formalized in the theory of partially observable decision processes [26]; under behavior cloning the policy regresses to the average expert action on aliased states [27]. The reactive collapse at depth 2 is therefore expected, and the experiments add the controlled decomposition around it, showing that one symbolic variable removes the aliasing, that recurrence does not remove it even after per-morphology tuning to depth-1 parity, and that the variable is exactly the one a morphology-invariant plan supplies on any body.

The evaluation discipline follows the companion measurement standard [28], in line with the broader push toward statistically sound robot-policy evaluation [29,30,31]. Headline claims pass an enforced acceptance gate requiring each claim to beat its strongest applicable baseline by a margin whose bootstrap 95% confidence interval excludes that baseline on independent units, with seeds aggregated per unit before intervals are computed [32], small-n contrasts accompanied by exact sign-flip tests, and designed controls, here the depth-1 null and the oracle-flat tie, reported alongside the headline.

3. Task, Agents, and Protocol

3.1. Depth-K Sequential Reach

The testbed is a sequential-reach task family in MuJoCo over six fixed-base manipulators from the Menagerie model set (panda, kinova_gen3, rethink_robotics_sawyer, kuka_iiwa_14, ur10e, franka_fr3). An episode samples K target positions in the workspace; the arm must drive its end effector to each target in order, the episode succeeds only if all K subgoals are reached in sequence, and the time budget scales with depth ($90K$ steps, $K\in \{1,\dots ,4\}$). The environment advances the active subgoal when the current one is reached, for every agent alike, so the task dynamics are identical across agents and the only manipulated variable is how the observation is factored. Demonstrations come from a damped-least-squares inverse-kinematics expert run on the depth-K task, keeping successful episodes only, and all agents are behavior cloned from these demonstrations with the same architecture family, optimizer, and epoch budget.

3.2. Three Information-Controlled Agents

The deliberative agent executes a morphology-invariant plan, reach the subgoals in order, with a single depth-1 reach skill. At each step the plan exposes the active subgoal, and the skill receives the depth-1 observation, joint positions and velocities, end-effector position, the active target, and the active-target error. The skill is trained on per-subgoal reach segments extracted from the multi-step expert rollouts, so it learns to reach the active target from any pose, including the mid-trajectory poses where subgoals 2 through K begin; one skill serves all depths, and the plan supplies the sequencing.

The oracle-flat agent is a monolithic policy on the full depth-K observation, which includes the active-target error and the normalized subgoal index. The environment hands it the symbolic progress state that the deliberative agent’s plan supplies, making it an information-matched upper bound on what a flat policy could achieve; on a real robot no such oracle announces the active step. The reactive agent is identical except that the observation is stripped of the active-target error and subgoal index, so it must infer which subgoal is active from its configuration and the K target positions. This is the realistic flat baseline, and for $K\ge 2$ its observation aliases distinct task stages that demand different actions.

The three agents pin down the quantity of interest. The oracle-flat minus reactive difference is exactly the value of the symbolic progress state, and the deliberative minus oracle-flat difference, which should be zero, checks that the plan-plus-skill construction neither gains nor loses anything beyond that state. Deliberation factorizes each expert rollout into K reusable single-step reach supervisions plus the plan, which carries zero morphological information; as a consequence multi-step competence needs no per-length retraining (Section 4.4), and a new embodiment is absorbed by re-grounding only the cheap reach skill while the plan transfers unchanged (Section 4.2).

3.3. Protocol, Transfer, and Statistics

The within-morphology experiment trains and evaluates each agent on each arm separately, sweeping depth. The cross-morphology experiment trains all agents on a single source arm, transfers to a held-out target arm by freezing the shared trunk and adapting the per-morphology encoder and head on target demonstrations, and sweeps depth. Every cell is evaluated over 60 episodes on a held-out evaluation seed, and per-depth means are reported with percentile-bootstrap 95% confidence intervals over the six arms as independent units. Headline claims are certified by the program’s enforced acceptance gate [5,28]; three gate rows are quoted here, the cross-morphology deliberation contrast (Section 4.2), the interface-coding contrast (Section 4.5), and the corroborating semantic-state row (Section 4.8).

Completion detection is verified on both sides of the interface, because the evaluation loop reads the active subgoal from the environment. The pointer is directly computable from the agent’s own observation, since the K target coordinates are part of it and a reach is defined by the task’s public success threshold; an agent-side variant maintains its own pointer, advancing when its end effector is within the success threshold of its current target, and never queries the environment. Across 6 arms, 4 depths, and 3 seeds the agent-side evaluation reproduces the env-side numbers exactly, 72 of 72 cells identical with per-depth means of 0.631, 0.608, 0.586, and 0.574 on both sides, so the loop is self-contained.

4. Results

4.1. Within Morphology, the Reactive Agent Collapses at Depth 2 and Deliberation Holds

The upper block of Table 1 reports mean success over the six arms at each depth for the three agents, with bootstrap intervals for both pairwise contrasts, and Figure 1a plots the same sweep. Two readings must be kept distinct. The first is a consistency check rather than a finding; the deliberative and oracle-flat agents are statistically indistinguishable at every depth, with every difference at most 0.014 in magnitude and every interval spanning zero, so the plan-plus-skill construction is neither better nor worse than a flat policy handed the same progress state. The second is the result. The reactive agent solves depth 1 at 0.628 and collapses to 0.069, 0.000, and 0.003 at depths 2, 3, and 4, while the deliberative agent holds at 0.631, 0.592, 0.569, and 0.558. The contrast is null at depth 1 by design, since a single reach has no progress to track, and every interval at depth 2 and beyond excludes zero by a wide margin; the effect is a threshold rather than a ramp, saturating around $+0.55$ from depth 2 onward (pooled Pearson correlation with depth $+0.54$).

The collapse is the perceptual-aliasing failure anticipated in Section 2, since for $K\ge 2$ the no-hint observation maps identical perceptual states to different expert actions. The content of the experiment is the decomposition around the collapse, in which a single symbolic variable removes the aliasing entirely and one depth-1 skill serves all depths without per-length retraining. Absolute success varies widely by arm, driven by per-arm expert quality, from 0.88 to 1.00 on kinova_gen3 down to 0.07 to 0.43 on franka_fr3, but the relative pattern, reactive collapse with deliberative-oracle parity, holds on all six arms; Table A1 in the appendix lists every cell.

4.2. The Pattern Survives Cross-Morphology Transfer and Passes the Gate

The lower block of Table 1 and Figure 1b report the same sweep when every agent is trained on a source arm and transferred to a held-out target arm as in Section 3.3. The pattern replicates the within-morphology result in every particular. The reactive agent collapses at depth 2 and beyond (0.056, 0.003, 0.000), the deliberative agent holds (0.583, 0.583, 0.564), the oracle-flat agent keeps up only because the environment hands it the active subgoal, and the deliberative-oracle differences span zero at every depth. The plan is the reason transfer costs nothing at the task-structure level; reach the subgoals in order is correct for any arm, so only the cheap reach skill needs target data.

The certified headline pools the regime where a progress state matters. Over depths 2 to 4, three seeds, and six independent target arms, the gate records deliberative success 0.590 against reactive 0.018, a gap of $+0.571$ with bootstrap 95% interval $[+0.337,+0.807]$, and the pre-registered depth-1 control gap is $-0.002$, as it must be when there is no progress to track. The claim passes the gate as the anchor positive of the program whose negatives the companion benchmark reports [5].

4.3. Memory Does Not Recover the Progress State

The natural objection to Section 4.1 and Section 4.2 is that a feedforward reactive policy cannot track progress by construction, so the fair reactive baseline is a recurrent one. Table 2 reports two recurrent controls trained on the same no-hint demonstrations. The first is a GRU trained under the same budget as the other agents; it reaches only 0.467 at depth 1, short of the feedforward reference of 0.628, and collapses at depth 2 and beyond. The second control removes the undertraining objection. Each arm’s GRU is tuned over hidden sizes $\{128,256,512\}$ and learning rates $\{{10}^{-3},3\times {10}^{-4}\}$ for 200 epochs with checkpoint selection by rollout success on a validation seed that is never the test seed, and the selected configuration is then trained at every depth and evaluated once on the standard test seed. This converged control reaches depth-1 parity with the deliberative agent, 0.606 versus 0.631 with the difference interval $[-0.008,+0.064]$ spanning zero and three of six arms individually within ten points of the feedforward reference, and it still collapses at every depth beyond one, scoring 0.006, 0.000, and 0.000 at depths 2 to 4 against deliberative values of 0.592, 0.569, and 0.558, with every difference interval excluding zero. Figure 1a overlays this control on the within-morphology sweep, where it tracks the feedforward reactive curve almost exactly. Under behavior cloning, memory does not crack multi-step progress tracking even with per-morphology tuning to convergence; a recurrent policy trained by reinforcement learning with exploration remains untested (Section 6).

4.4. The Factorization Is Data-Efficient Where It Matters

The practitioner’s question is how much target data each interface needs, and the depth-3 experiment answers it on a shared budget axis, the number of expert rollouts given identically to every agent (3, 10, 30, or 100), with the six arms as units. One budget accounting applies throughout; the deliberative skill’s segments come from depth-4 rollouts while the flat agents train on depth-3 rollouts, so a matched rollout count gives the deliberative agent roughly four thirds the per-rollout reach supervisions, and the headline ratio below is stated conservatively after dividing this factor out. Table 3 reports the budget sweep and Figure 2 plots it.

Three findings emerge. First, the deliberative agent reaches the oracle-flat agent’s best success, 0.519 attained only at 100 rollouts, using 30 rollouts (0.558), a factor of 3.3 in raw rollout count and conservatively 2.5 after the depth-accounting correction above. Second, at a fixed low budget of 10 rollouts the deliberative agent succeeds at 0.444 against the oracle-flat agent’s 0.047, roughly nine times the success rate at equal data; this is a rate ratio at a fixed budget rather than a data multiplier; the oracle-flat agent never reaches 0.444 in the tested range, so the multiplier at that level is bounded below by the peak-matching factor. Third, the reactive agent is at most 0.003 at every budget, so no amount of data in this range buys multi-step competence without a progress state. The interval on the deliberative-minus-oracle difference excludes zero at budgets 3, 10, and 30 and includes zero at 100 ($[-0.006,+0.092]$); with abundant data and a hand-fed progress state the monolith catches up at this depth. The advantage is therefore concentrated in the low-data regime and against the realistic baseline, and it grows with task depth per Section 4.1 and Section 4.2, while the oracle assumption itself is precisely what a new robot does not provide. The mechanism is the factorization; each rollout becomes K reusable single-step reach supervisions plus the free plan, and a single reach is a far simpler function to learn from few demonstrations than a depth-K behavior.

4.5. The Coding of the Interface Matters, and Structure Wins

The 2026 zero-shot systems commit to different codings of their body-blind interfaces, language tokens in LAP and a continuous intent latent in KITE, so the natural question is whether the coding choice matters when everything else is held fixed. This experiment, with design and endpoints frozen before any variant was trained, codes the deliberative interface’s planner-to-skill channel three ways at identical upstream information; the structured coding V1 passes the active-target offset as coordinates (the certified agent of Section 4.2), the token coding V2 quantizes it into a 78-way direction-magnitude one-hot in the style of language-token action coding, and the latent coding V3 passes it through an eight-centroid softmax embedding in the style of continuous intent latents. V2 and V3 transform the same skill demonstrations V1 used, train with the same frozen-core cross protocol, seeds, and epochs, and evaluate on the same episodes, so the variants differ only in coding precision.

Table 4 reports the sweep. The token coding is itself a meaningful positive for the field’s approach; it holds 0.455 to 0.506 at depths 2 to 4, more than twenty-five times the reactive level of 0.018, so a language-token-style coding genuinely carries the progress information. The structured coding is nonetheless better. Pooled over depths 2 to 4, V1 beats V2 by $+0.109$ with bootstrap interval $[+0.041,+0.175]$ and exact sign-flip $p=0.031$ over the six arms, the gate-certified row, and the per-depth gaps grow from $+0.057$ at depth 1 to $+0.119$ at depth 4. The depth-1 gap does not reach the exact sign-flip criterion at $n=6$ ($p=0.0625$, four of six arms positive), so the pattern is consistent with a per-reach precision advantage that compounds with depth, and the pooled contrast carries the claim. The gap is heterogeneous across arms, concentrated at $+0.13$ to $+0.22$ on the three transfer-hard arms (kuka_iiwa_14, sawyer, ur10e), small at $+0.05$ to $+0.07$ on the two easiest, and reversed at $-0.026$ on franka_fr3. The latent coding collapses, trailing V1 by $+0.394$ to $+0.506$ at every depth with every committed interval bounded away from zero (exact $p=0.016$ throughout) and a pooled mean of 0.102. An eight-centroid code carries roughly three bits, too coarse to place the end effector within the task’s success radius, so this arm bounds a specific low-capacity realization rather than continuous intent interfaces in general; the design’s registered expectation that all three codings would clear the reactive floor by a wide margin failed for V3, and the capacity confound is scoped in Section 6.

4.6. The Plan Ports for Free, and the Skill Is the Bottleneck

The sharpest transfer test drops all target data. A deliberative agent whose reach skill is morphology-general, here analytic damped-least-squares inverse kinematics though any body-general controller qualifies, plus the invariant plan runs on an unseen arm with zero target training. Figure 3a plots zero-shot success across 13 arms and depths 1 to 4; the agent averages 0.454, 0.371, 0.345, and 0.304 by depth, reaching 0.90 at depth 1 and 0.983 at depth 3 on well-conditioned arms such as kinova_gen3 while ill-conditioned arms such as ur5e sit near 0.10, so the level tracks per-arm skill quality. A learned per-morphology policy cannot enter this comparison at all, being dimensionally inapplicable to an unseen arm, which is the zero line in the figure.

The two-sided reading is that the plan ports for free while the learned skill is the bottleneck. Replacing the analytic skill with a learned morphology-general skill, a message-passing graph-network reach policy trained across arms, under the same plan yields 0.076, 0.015, 0.006, and 0.003 by depth, because the graph policy’s single-reach zero-shot rate is only about 0.14 and the plan cannot amplify a per-subgoal skill that usually fails. The composition is skill-limited, so a stronger body-general learned skill is the concrete next milestone toward a fully learned deliberative agent.

4.7. The Plan Composes Independently Trained Skills Across Task Families

The factorization mechanism is not specific to reach sequencing. On a composite walk-then-reach task for a Unitree G1 humanoid, an agent assembled from a locomotion module trained on quadruped-class data and a manipulation module trained on arm-class data, sequenced by the two-step plan goto then reach, succeeds at 0.983 with zero composite demonstrations (1.0 on both replicate seeds, phase-1 completion 1.0 throughout), while a monolithic policy trained on composite demonstrations needs roughly 40 of them to match, passing through 0.283 at 10 and 0.700 at 20 before reaching 0.983 at 40; Figure 3b plots this curve against the composed agent’s level. The navigation phase drives a kinematic base-mover whose legs are not actuated, so the result demonstrates plan-driven composition at zero composite-task cost rather than cross-morphology leg transfer; the genuinely cross-morphology cell is the manipulation subsystem, where arm-class sources transfer to the humanoid’s right arm at few-shot success $0.322\pm 0.096$ against a from-scratch baseline of $0.094\pm 0.039$ over three seeds, a gain of $+0.228\pm 0.100$ with all three seeds positive ($+0.183$, $+0.367$, $+0.133$).

4.8. The Symbolic Layer Also Carries Diagnosis, Grounding, and Feasibility

If the symbolic layer is the morphology-invariant locus, structure built on it should port beyond control, and three supporting results plus one corroborating gate row bear this out. Table 5 reports the first. A failure-attribution classifier over the interface’s composite divergence features, trained on one arm’s episodes with injected deliberation, grounding, and environmental failures, transfers zero-shot to a quadruped at 66.7% three-class accuracy (Wilson 95% CI $[0.578,0.745]$, $n=120$, chance 33%) with only per-morphology recalibration of the divergence baseline, against a matched quadruped-trained classifier at 80.8%, clearing a trivial episode-length-and-success classifier at 24.2% by $+0.425$ (CI $[0.311,0.539]$) and a divergence-only classifier at 52.5% by $+0.142$ (CI $[0.019,0.265]$, $p=0.025$). The environmental class transfers worst (F1 0.43 on the quadruped), since environmental signatures manifest differently in a quadruped’s body-velocity space. The same table carries the cross-simulator experiment as a negative control; the classifier moved from one simulator to another scores 70.0%, but the trivial baseline reaches 64.2% there and the difference interval spans zero ($[-0.060,+0.177]$, $p=0.336$), so that axis supports no transfer claim. Across bodies the divergence structure does work that the trivial features cannot; across simulators the shared protocol does most of it.

The interface’s core predicate is also readable from pixels, which closes the gap between the symbolic state and perception. On 96 staged frames balanced between near and far configurations, with the predicate defined as end-effector-to-target distance under 0.1 m and clear cases at least 3 cm from the threshold, an off-the-shelf vision-language model grounds the predicate zero-shot at 85.4% accuracy and F1 0.851 from a single rendered view, 94.4% on clear cases; Table 6 lists the runs and comparators. A 4B-class model reaches 74.0% accuracy (F1 0.762), and adding a second camera view with a cross-view-consistency prompt lowers both models’ accuracy, trading recall for precision, so multi-view fusion is a design problem rather than a free win. The comparators calibrate the frame set; trained pixel probes on $16\times 16$ downsampled frames reach 0.657 (logistic regression) and 0.792 (random forest) under five-fold cross-validation, and an untrained color heuristic sits at chance accuracy (0.50, with an all-positive F1 of 0.667). The zero-shot model clears chance and the untrained comparator decisively and sits numerically above the trained random-forest probe, though that last edge is not separated with confidence at this sample size.

Typing the plan buys a feasibility guarantee that an unconstrained planner lacks. On twenty goals across two platforms, fourteen feasible and six whose sensor requirements the platform cannot satisfy, the typed planner executes all fourteen feasible goals and refuses all six infeasible ones, while an unconstrained language-model planner executes the same fourteen and refuses none of the six, planning confidently for sensors the robot does not have; feasibility screening is a structural capability of the symbolic interface, orthogonal to success rate.

An independently certified gate row corroborates the layer claim from a different direction. A semantic-anchored task state improves few-shot transfer over raw observations across 29 morphologies, 0.640 versus 0.591 with gap $+0.049$ and interval $[+0.015,+0.096]$; the gain is heterogeneous, largest on kinova_gen3 ($+0.517$), robotstudio_so101 ($+0.292$), and panda ($+0.242$), and absent on ur10e and ur5e ($-0.008$ each). The nominal transfer-gain ratio is about double (0.408 versus 0.212), but roughly three quarters of that difference reflects the semantic input’s lower from-scratch floor (0.232 versus 0.378) rather than more transferred skill, so the fair statement is the few-shot difference. Deliberation and the semantic state point the same way; the transferable content lives in the coarse symbolic abstraction, not in the continuous policy.

5. Discussion

The deliberative-oracle tie is the interpretive key to every table above. Deliberation adds no control capability beyond the progress state, and hand-feeding that state to a monolith reproduces deliberation exactly, so the experiments locate the entire multi-step, cross-embodiment effect in one symbolic variable. That variable is unrecoverable by the realistic baseline, since feedforward and converged recurrent policies alike collapse without it under behavior cloning; it is free, since the plan that supplies it is the task specification itself rather than a trained artifact; and it is morphology-invariant, porting across bodies, unseen arms, and task families at zero cost where every policy-level route in the companion benchmark fails [5].

The results also say something about how the interface should be coded. The companion theory paper argues that a transferable interface must be coarse [6], and the 2026 zero-shot systems realize coarseness in different ways, tokens, masked observations, and intent latents [14,15,16,17]. The coding comparison of Section 4.5 holds task, information, data, and protocol fixed while varying only that choice, and its answer is that coarseness is necessary but not sufficient; a token coding carries the progress information well, a structured symbolic coding carries it better with the advantage compounding over depth, and a code below the task’s precision floor fails outright. Interface design, not just interface coarseness, is a live variable for the zero-shot wave.

The data-efficiency result reframes deliberation economically. The oracle-flat agent shows that with unlimited data and an oracle there is nothing wrong with a monolith at this depth, and the budget sweep shows what that concession costs, three times the demonstrations to reach the same peak and a ninefold success deficit at a ten-rollout budget. On a new robot, where demonstrations are scarce and no oracle announces the active step, both of the monolith’s crutches are absent at once.

6. Limitations

Every collapse result is under behavior cloning; a recurrent policy trained by reinforcement learning could in principle recover progress tracking through exploration, and the claim is accordingly that the plan supplies the progress state without that training burden, not that no training regime could recover it. The oracle-flat agent catches up at 100 rollouts on the depth-3 task, so the data-efficiency advantage is a low-data-regime and depth-scaled claim rather than a universal one. The task family is ordered subgoal sequencing on fixed-base arms; richer symbolic structure such as preconditions, branching, and tool use is untested, and the zero-shot result stands on an analytic skill, since the learned body-general skill is currently too weak to compose (Section 4.6). Per-depth contrasts rest on $n=6$ arms, so the claims are directions with intervals rather than precise effect sizes, absolute success varies several-fold across arms with per-arm expert quality, and the cross-morphology design uses single-source pairings rather than a source-diversity sweep. In the coding comparison, V2 and V3 are faithful analogues rather than the released LAP and KITE systems, the shared planner means the comparison speaks to the coding of the planner-skill channel, the latent coder was fit on demonstrations from five of the six arms, which favors V3, and the V3 arm bounds a three-bit realization rather than continuous-intent interfaces at realistic capacity. The composition result’s navigation phase is a kinematic base-mover, so its cross-morphology content is the arm subsystem alone. The cross-simulator diagnosis experiment is reported as a negative control, and the vision-language grounding is measured on staged frames whose edge over the trained random-forest probe is not confidence-separated at $n=96$.

7. Conclusion

Across six robot arms and four task depths, one symbolic variable separates multi-step competence from collapse. Policies that must infer task progress from perception fail at depth two regardless of whether they are feedforward or recurrent, tuned or not; policies given that variable succeed, and it makes no measurable difference whether an oracle hands it over or a plan derives it. What does differ is portability. The oracle is a fiction on a new robot, whereas the plan is the task specification itself; it transferred here across six bodies at full strength, ran zero-shot on thirteen arms it had never seen, and sequenced independently trained skills on a humanoid without a single composite demonstration. The same layer carried failure diagnosis across an arm-to-quadruped gap, was readable from pixels by an off-the-shelf vision-language model, and refused every infeasible goal that an unconstrained planner accepted.

For the cross-embodiment field the finding relocates the object of transfer. The companion benchmark shows that policy-level transfer is governed by neither morphological similarity nor data diversity, and the companion theory shows that continuous task representations cannot shed the body [5,6]. This paper completes the argument constructively; the thing that ports is a coarse symbolic state, and the architecture that manufactures it converts that portability into measured wins, more than a thirtyfold success ratio over the realistic baseline in the certified pooled contrast, several times less target data than an oracle-fed monolith, and capabilities such as zero-shot execution and composition that parameter transfer cannot express at all. The coding experiment sharpens the design guidance beyond coarseness alone; among equally body-blind codings of the same information, structure that preserves the task’s metric precision wins, with the margin compounding over depth, and codes below the precision floor fail entirely.

The measured boundaries of the claim define the next questions. The bottleneck exposed by the zero-shot experiment is the grounded skill, not the plan, so a body-general learned skill strong enough to compose would make the entire agent learned while keeping the interface symbolic; reinforcement-learned recurrence is the one untested route to progress tracking without a plan; and richer plan structure, preconditions, branching, and tool use, is the route from reach sequencing toward general manipulation. The pattern this paper certifies, a tie against information-matched baselines, collapse of realistic ones, and free transport of the symbolic state across bodies, is the standard those extensions should be held to.