Deleting Body Information from the Action Interface Causes Zero-Shot Transfer Across Robot Arms

1. Introduction

Zero-shot cross-embodiment manipulation arrived as a cluster of results in the first half of 2026, and the systems that achieved it share one structural move rather than one architecture. RDT2 trains on body-agnostic handheld-gripper data so that the policy never sees a robot-specific body [1], LAP codes actions in language tokens that name a motion rather than a joint command [2], Cloak masks the end-effector out of the observation [3], and KITE routes task reasoning through a contact-intent latent [4], while the earlier Mirage cross-painted the gripper so the policy sees a canonical arm [5]. Each of these deletes body information from the interface between task reasoning and motor control, and each then lets a body-general executor close the loop on whatever robot is present. The empirical success is real and repeated, but the field has not established why it works. No system tests that the deletion is what causes transfer rather than a coincidental design choice, none characterizes what body information the body-blind interface still carries, and none asks whether the specific coding of the interface matters or whether coarseness alone suffices.

These questions are hard to answer on the substrates the wave uses, because natural multi-robot data entangles the body with the scene. Different robots are recorded in different laboratories against different backgrounds, so a probe that recovers the robot from a representation may be reading the wallpaper rather than the arm, and a companion measurement standard documents this as a recurring failure mode in which a raw pixel control recovers embodiment identity as well as the model does [6]. Answering the causal and coding questions cleanly therefore requires a substrate on which the body can be varied while the scene is held fixed, so that any effect is attributable to the body and not to appearance. We build the causal experiments on exactly such a substrate, a sequential-reach manipulation family over simulated arms in which the task and scene are identical across bodies and the only manipulated variable is the interface, and we complement it with a scene-controlled measurement on a released model in which the same episode is re-rendered across robot embodiments so that robot identity is orthogonal to the scene by construction.

The work rides on a companion theory result and turns it from a constraint into a test. The sufficiency-invariance bound proves that any continuous task representation informative enough to drive control on a body must re-encode that body’s identity at a floor set by how body-dependent the behavior is, so a representation escapes the floor only by being coarse, meaning lossy with respect to the fine body-discriminative structure of behavior [7]. Coarseness, not discreteness in particular, is the operative property, and a discrete or symbolic code is one realization of it. That result explains why a cross-body interface must throw the body away, and it predicts that leaking the body back in should be destructive and that coarser codings should transfer where finer ones cannot. This paper puts those predictions to a causal test by intervening on the interface in both directions, measures whether the coding of a body-blind interface is a real design variable, and begins the measurement of body information inside a released model with the scene controlled.

The paper makes four contributions.

• We run a causal interface ladder on a scene-controlled substrate and show by intervention in both directions that making the action interface body-blind causes zero-shot transfer to unseen arms while a body-specific joint-space head collapses, that leaking body channels back into a shared interface destroys transfer once the leak passes a threshold, and that injecting body identity is harmful (Section 4.1).
• We locate the transfer variable precisely, showing that the body-blind interface still carries body identity far above chance yet transfer thrives at that floor and dies only above it, so the operative quantity is reliance above the interface’s own floor rather than raw recoverability, and we identify the mechanism that makes a shared joint-space head ill-posed (Section 4.1).
• At matched body-blindness and identical upstream information we compare a structured symbolic coding, a language-token coding in the style of the 2026 wave, and a continuous-intent latent, and show that structure beats tokens with the margin compounding over task depth while the low-capacity latent falls below the task’s precision floor, so coarseness is necessary but the coding is a real design variable (Section 4.3).
• On a released vision-language-action model with scene controlled by robot-swap rendering we decompose the apparent body signal into a large appearance component and a modest scene-invariant residue that exceeds a raw-pixel control in all three folds, and an in-model action-sufficiency test finds the decoded action body-light, so recoverability is not reliance measured inside the field’s own model (Section 4.4).

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 that deleting body information from the action interface is what causes zero-shot cross-embodiment transfer, that leaking it back destroys transfer thresholdwise while injecting body identity is harmful, that among equally body-blind codings a structured symbolic one transfers best, and that what a shared policy or a released model relies on is not what a probe can recover from it. The account explains the 2026 zero-shot wave and predicts the boundary at which it must fail, namely wherever the action space across bodies is not commensurable and the price of the body must be paid below the interface, one body at a time.

2. Related Work

The zero-shot cross-embodiment wave of 2026 is the immediate context for this work. RDT2 reaches unseen bodies by pretraining on body-agnostic handheld demonstrations [1], LAP replaces joint or end-effector actions with a language coding of the intended motion [2], Cloak removes the end-effector from the visual observation so the policy cannot condition on the specific arm [3], and KITE decouples kinematics from interaction by routing through a contact-intent latent [4], all following the earlier visual cross-painting of Mirage [5]. Read together these are four codings of one idea, a body-blind interface between task reasoning and a body-general executor, and each system commits to a single coding without testing the causal claim, the direction of the effect, the threshold, or the coding question. The experiments here supply those tests, and the companion architecture paper measures what a coarse symbolic interface buys on a multi-step task [8].

Generalist multi-robot policies take the opposite approach to a new body, absorbing it as an engineering problem by mapping every robot into a shared action space, attaching per-embodiment adapters, and fine-tuning on target data [9,10,11,12,13]. A parallel line builds the body into the policy through shared modular controllers [14], graph-structured policies [15], morphology-token transformers [16], morphology-inferring encoders [17], and unified multi-embodiment locomotion architectures [18], with recent morphology-structured attention reported to help a large model [19]. Benchmark evidence nonetheless finds such agents near zero success on out-of-distribution morphologies with train-test similarity not helping [20], and a companion benchmark shows that no measured relation between bodies predicts frozen-core transfer better than a target-only prior [21]. All of these operate at the level of the continuous policy, which is the level the sufficiency-invariance bound constrains and the level this paper intervenes on.

The mechanism this paper measures is an instance of the general lesson that a model exploits exactly the structure an objective tried to remove. Shortcut learning names the phenomenon [22], and the probing literature makes the methodological consequence precise, since linear probes understate recoverability and a meaningful probing claim needs control tasks and stronger probes [23,24,25], a point the disentanglement literature reached independently when it found that apparently clean representations hide structure only a capable model recovers [26]. Our released-model measurement uses these tools directly, certifying body recoverability with a strong nonlinear probe on episode-blocked splits and, for the causal claim about the action, an iterative nullspace projection that removes the linear body subspace before re-decoding [27]. The distinction we draw throughout, between what a probe can recover and what a decision actually relies on, is the one the probing literature warns must be kept.

The idea that an invariant representation trades against task information has a precise history in domain adaptation and fair representation learning. Adversarial invariance was popularized by domain-adversarial training [28], and a line of theory then established that forcing a representation to be invariant to a domain label lower-bounds the joint error once the label distributions differ [29,30], complementing the classical divergence bounds for adaptation [31]. The companion theory paper is the cross-embodiment counterpart, in which the quantity that cannot be removed is body identity and the floor is a directly measurable property of realized behavior [7]. This paper is the empirical frontier that result opens, and it inherits the discipline of the companion measurement standard for every contrast, reporting effects on independent units with bootstrap intervals and exact tests and comparing against the strongest trivial baseline [6,32,33,34].

3. Substrates, Interventions, and Protocol

3.1. A Scene-Controlled Manipulation Substrate

The causal experiments run on a sequential-reach manipulation family in MuJoCo over fixed-base arms drawn from a standard model set. An episode places one or more target positions in the workspace and the arm must drive its end effector to each in turn, so the task and the scene are identical across bodies and the only thing that changes from one condition to another is the interface through which the policy acts. Because the arms differ in their number of joints and in their joint-space geometry, their action spaces are non-commensurable, which is what makes a shared interface nontrivial and what lets us ask whether transfer survives when the body is deleted. The substrate carries no appearance confound of the kind that afflicts natural multi-robot data, since every body acts in the same scene, so a difference in transfer between two interfaces is attributable to the interface and not to what the policy can see of the robot.

3.2. The Interface Ladder

The ladder is a single causal experiment with six rungs that vary how much body information the action interface exposes, holding the task, the scene, the training data, and the policy architecture fixed. Five source arms supply the training data and five held-out arms, disjoint from the sources, receive the policy zero-shot. One behavior-cloned policy is trained per rung on the pooled source data across three seeds, and each rung is evaluated on the five held-out arms, whose per-arm success averaged over seeds gives five independent units. The body-blind rung I0 exposes only a task-space observation, the end-effector position, the target, and their difference, and emits a body-blind end-effector displacement command that a shared damped-least-squares executor turns into each arm’s joints. The executor takes the policy’s commanded direction at a fixed calibrated magnitude, the same value a hand-coded proportional controller uses, so that every rung is compared with the magnitude physics held constant and the ladder isolates the directional information each interface carries.

The remaining rungs perturb this interface. Rungs I1 and I2 leak two and eight proprioceptive channels into the otherwise body-blind observation, and rung I3 leaks the full joint position and velocity vector, padded to a common width, so that I0 through I3 form a graded leak from body-blind to body-exposed. Rung I4 injects body identity directly by appending a one-hot token naming the source arm, which is the reverse intervention that adds body information rather than proprioception. Rung I5 replaces the body-blind action with a padded joint-space action head fed the identical I0 observation, so it is body-blind in what it sees but body-specific in what it emits, and it is the control that asks whether a shared joint-space policy can substitute for the analytic executor. Body identity is read off each rung’s interface by a strong nonlinear probe on episode-blocked splits, and per-arm proportional-controller ceilings are recorded because they bound the absolute success any interface can reach on a given arm, with a held-out mean ceiling of $0.66$.

3.3. Three Codings of a Body-Blind Interface

The coding experiment asks whether, once an interface is body-blind, the way its content is encoded still matters. It runs on a depth-K version of the sequential-reach task over six arms under a frozen-core cross-morphology protocol, in which a shared trunk is trained on a source arm and only a per-arm encoder and head are adapted on the target, and it compares three codings of the same planner-to-skill channel that carry identical upstream information and differ only in how the active target is coded. The structured coding V1 passes the target offset as coordinates and is the certified agent of the companion architecture paper [8]. The token coding V2 quantizes the offset into a seventy-eight-way direction-by-magnitude one-hot in the style of a language-token action coding. The latent coding V3 passes the offset through an eight-centroid softmax embedding in the style of a continuous-intent latent. All three are body-blind functions of the target, V2 and V3 transform the same skill demonstrations V1 used and train under the same protocol, seeds, and epochs, and all three are evaluated on the same episodes, so the only variable is coding precision, and the design and endpoints were fixed before any variant was trained.

3.4. The released-VLA Measurement

The released-model measurement uses OpenVLA, a seven-billion-parameter open vision-language-action model [35], on a rendering of Open X-Embodiment episodes in which the same trajectory is re-rendered across robot embodiments [5,9]. Because a single episode appears under several robots in the same scene, robot identity is orthogonal to scene appearance by construction, which is the control the natural multi-robot data lacks. We extract the model’s representations on the robots common to the cleanly available scenes and probe robot identity two ways, within a scene and across scenes under a leave-one-scene-out split, both episode-blocked, with a raw eight-by-eight-pixel control run through the identical probe so that any body signal the model carries beyond appearance is measured against what downsampled pixels already carry. The action half cannot be read from the mean-pooled representation, because a vision-language-action model generates its action autoregressively from late-position hidden states that mean-pooling discards, and the external end-effector-displacement target and the model’s own action are both unpredictable from the pooled representation at $R^2=-0.32$ and $R^2=-0.96$ respectively. We therefore measure action sufficiency inside the model, extracting the hidden state at the canonical first-action decode position, scrubbing the linear body subspace by iterative nullspace projection [27], and re-decoding the first action through the model’s own action head to measure how much removing the body directions moves the action, against a variance-matched removal of equal rank and a random removal.

3.5. Statistics and the Two-Tier Rule

Every contrast is computed on independent units, the held-out arms for the ladder and the target arms for the codings, with seeds aggregated per unit before any interval is formed, so that several seeds of one arm are never treated as several arms [36]. A contrast is reported with its mean gap, a percentile bootstrap ninety-five percent confidence interval over units, and, because the unit counts here are five and six, an exact sign-flip permutation test. The decision rule is two-tier, following the companion measurement standard [6]. At ordinary sample sizes a claim is significant when the interval excludes the baseline. At the small sample sizes here the percentile bootstrap is anti-conservative, so a claim is called significant only when it also clears the exact sign-flip test at $p\le 0.05$, and a contrast whose interval excludes the baseline but whose exact test does not reach that level is reported as suggestive rather than significant. Two of the headline contrasts pass the enforced acceptance gate the program uses, the leak-collapse frontier and the structured-over-token coding, and the body-blind-versus-joint-head contrast is suggestive under this rule.

4. Results

4.1. Deleting Body Information Causes Transfer, and Leaking It Back Collapses Transfer

The ladder establishes the causal claim in both directions, and Table 1 reports every rung while Figure 1 plots the transfer levels and the collapse against interface recoverability. The body-blind interface I0 transfers to the five held-out arms at $0.199$, well above the random-executor floor of $0.007$ and a substantial fraction of the $0.66$ analytic-executor ceiling, so a policy that never saw these arms and cannot see their bodies nonetheless drives them to the target. Leaking body channels back into that interface collapses the transfer. Two proprioceptive channels are tolerated, with I1 at $0.220$ statistically level with I0, but eight channels collapse transfer fivefold to $0.039$ at I2, and the full joint leak holds it there at $0.042$ for I3. The body-blind interface beats the full leak by $0.157$, an effect every one of the five held-out arms reproduces, with a bootstrap interval of $[+0.039,+0.275]$ and an exact sign-flip $p=0.031$, and it is robust to normalizing each arm by its executor ceiling. Within-scene source success is flat across the rungs, so the collapse is specialization to the source bodies rather than broken training, and it is the reverse intervention that proves the point, since adding information degrades a transfer the same policy achieves without it.

The body-blind action coding also causes transfer where a body-specific one cannot, and this is the contrast that is suggestive at the sample size available. Rung I5, the padded joint-space head fed the identical body-blind observation, transfers at only $0.038$, so I0 beats it by $0.161$ with an interval of $[+0.048,+0.276]$, positive in every seed and on four of the five held-out arms. The exact sign-flip test returns $p=0.0625$, one arm short of the threshold, and the arm that does not follow is the one with the worst executor ceiling, so under the two-tier rule this contrast is reported as suggestive. The mechanism behind it is committed and direct. Fitting a single pooled linear map from the identical body-blind observation to targets in each space, Table 2 shows that task-space end-effector targets are predictable on four of the five arms, with $R^2$ from $0.62$ to $0.74$, while joint-space targets are weak to negative, from $-0.31$ on kinova to $0.42$, because the same task observation demands different joint responses on different bodies. A shared joint-space head is therefore ill-posed except by inferring which body it is acting on, which an unseen body breaks, whereas a shared end-effector command is well-posed on every body and the analytic executor supplies the per-body joint solution for free.

Injecting body identity is actively harmful rather than merely useless, which sharpens the design guidance. Rung I4, which conditions the body-blind interface on a source-identity token, transfers at $0.117$, below I0 by $0.082$ with an interval of $[-0.128,-0.037]$ and every held-out arm degrading, an exact $p=0.031$. A wrong-token control isolates the robust half of the effect. Swapping the identity token on the source arms themselves, where both the observation and the token are in distribution, costs $0.145$ of success, and every one of the five source arms degrades under a wrong token at an exact $p=0.031$, with a modest magnitude near $0.085$ once the single high-variance arm is set aside. The policy therefore routes its behavior by the identity it is told it has, which is fine on a source arm and impossible on a new one, since a held-out body has no true token to supply. On the held-out arms the separation between a wrong token and the all-zeros token holds on only two of the five arms, the others sitting near zero under every token, so the deployment penalty on unseen bodies is suggestive while the reliance on the source arms is not. Conditioning an otherwise body-blind interface on body identity is thus counterproductive for cross-embodiment deployment, which is the opposite of the instinct to give a shared policy more information about the body it controls.

The transfer variable is not what a probe can recover from the interface but what the policy relies on above the interface’s own floor. The body-blind interface is far from body-blind to a strong probe, carrying arm identity at $0.912$ from the interface observation and $0.905$ from the policy’s penultimate layer against a chance of $0.1$, because the absolute workspace geometry of a reach is itself a body fingerprint. Transfer nonetheless thrives at that floor, and it dies only when the leak pushes recoverability above it, from $0.905$ and $0.926$ at I0 and I1, where transfer is high, to $0.991$ and $0.999$ at I2 and I3, where it has collapsed, the threshold visible in Figure 1b. The interface does not need to erase the body to transfer, it needs to give the policy no body channel to specialize on, so that recoverability sits at the floor the task imposes rather than above it. This is the same structure the released-model measurement finds inside a network in Section 4.4, recoverability without reliance, and it is why the sufficiency-invariance bound predicts coarseness rather than literal invariance as the property a transferable interface needs [7].

4.2. The Commensurability Boundary

The ladder buys transfer for free above the interface because the executor needs no training on a new arm, and this is exactly the regime the 2026 wave operates in, where the action space across bodies is commensurable enough that one body-general controller closes the loop. The account therefore predicts a boundary. Where the action space is not commensurable, no shared executor exists and the price of the body moves below the interface, to be paid per body wherever it can be paid at all. Legged locomotion is the clearest case, since a gait is not a body-general end-effector command and a controller must be learned for each body at a cost of tens of millions of reinforcement-learning steps. On a fleet of five vendor quadrupeds trained under a single uniform recipe, only two attain a stable gait, the two lightest platforms at twelve kilograms with a hundred-unit position gain, while the two heavy platforms fail in the same sprint-and-fall mode and the light low-gain platform crawls. This is a five-point descriptive case with one diagnosed mechanism, a gain-dependent artifact of the uniform recipe, and we present it as a correlate with a confirmed mechanism rather than as a mass law over platforms. The point it supports is structural and does not need a law. Above a commensurable interface the body is deleted from the representation and transfer is free, and below it the body returns as a per-body control problem, so the wave’s zero-shot successes and its failure boundary are two sides of where the interface sits relative to a commensurable action space.

4.3. Structured Symbolic Coding Beats the Wave’S Codings at Matched Body-Blindness

Once an interface is body-blind, the coding of its content is still a design variable, and structure wins. Table 3 reports the three codings across task depth and Figure 2 plots them. The token coding is itself a genuine positive for the field’s approach, holding $0.455$ to $0.506$ at depths two through four, roughly twenty-five times the reactive collapse of $0.018$ that a policy without the interface suffers, so a language-token-style coding does carry the progress information across bodies. The structured coding is nonetheless better. Pooled over depths two through four it beats the token coding by $0.109$ with an interval of $[+0.041,+0.175]$ and an exact $p=0.031$, the gate-certified contrast, and the per-depth gap grows monotonically from $+0.057$ at depth one to $+0.119$ at depth four. The depth-one and depth-two gaps do not clear the exact test at these sample sizes, at $p=0.0625$ and $p=0.0781$, so the depth-one advantage in particular is suggestive, and the pattern is consistent with a per-reach precision advantage that compounds as the task lengthens. The advantage is heterogeneous across arms, largest on the transfer-hard arms and reversed slightly on one, so the pooled contrast rather than any single arm carries the claim.

The continuous-intent latent collapses, trailing the structured coding by $0.39$ at depth one and by half at depth four, with a pooled level of $0.102$. An eight-centroid code carries roughly three bits, too coarse to place the end effector inside the task’s few-centimeter success radius, so this arm bounds a specific low-capacity realization of a continuous-intent interface rather than continuous interfaces in general, and its collapse is a statement about coding precision below the task’s floor rather than about latents as such. Read together the three codings say that coarseness is necessary but not sufficient. A body-blind token coding transfers well, a structured symbolic coding transfers better with the advantage compounding over depth, and a coding below the task’s precision floor fails outright, so the coding of a body-blind interface is a live and measurable design choice for the zero-shot wave rather than a detail settled by making the interface coarse.

4.4. The Body Information in a Released VLA, with Scene Controlled

The released-model measurement moves the question onto the field’s own substrate and controls the confound that makes it hard, and Table 4 reports the decomposition while Figure 3 plots it. Within a scene, robot identity is recoverable from the OpenVLA representation at $0.943$, essentially matching the raw eight-by-eight-pixel control at $0.977$ against a chance of $0.143$, so within-scene body recoverability is almost entirely appearance, exactly as the companion measurement standard warns for natural multi-robot data [6]. The scene control separates the body from the appearance. Across scenes, under a leave-one-scene-out split, the model holds $0.331$ while the raw-pixel control transfers at only $0.224$, and the model exceeds the pixel control in every one of the three folds, at $0.346$ against $0.167$, $0.383$ against $0.274$, and $0.265$ against $0.232$. The model’s above-chance margin of $0.188$ is more than twice the pixel control’s $0.081$, so the released model abstracts a modest scene-invariant body component beyond what appearance alone provides. The residue is concentrated in a subset of robots, with per-robot cross-scene recall spanning $0.00$ to $0.66$, so the aggregate rather than any per-robot number carries the claim, and the decomposition is prompt-robust, since re-extracting with each frame’s real task instruction gives a within-scene $0.986$ and a cross-scene $0.311$ against $0.989$ and $0.275$ under a generic prompt.

The action half of the question is whether the model’s action decision relies on the body it can recover, and measured inside the model the answer is that it is body-light. The action-position hidden state carries robot identity at $0.802$, so the body is plainly present in the state the action is decoded from. Removing the two hundred and four linear body directions by nullspace projection, which drops nonlinear body recoverability from $0.802$ to $0.605$, perturbs the decoded first action by only $0.088$, whereas a variance-matched removal of the same rank perturbs it by $0.466$ and a random removal of the same rank by $0.043$, with an episode-clustered confidence interval on the difference between the body scrub and the variance-matched control of $[-0.40,-0.35]$ and only $2.3\%$ of frames excluded from the decode. The body directions are among the least action-relevant directions of the state, not the most, so removing them costs the action far less than removing a matched amount of generic variance. This is recoverability without reliance measured inside the released model, the same structure the ladder found at the interface level, and it is direct in-model support for the wave’s premise that a policy can carry the body and still not act on it. The measurement is scoped to the first action dimension across the scenes on disk under a partial linear scrub, since the body remains about sixty percent recoverable nonlinearly, so it is a bounded first measurement rather than a model-wide certificate, and its firm magnitudes and a wider scene set are the natural next step.

5. Discussion

The four results assemble into a causal and scene-controlled account of the body information in a cross-embodiment interface, and the account explains the 2026 zero-shot wave rather than merely joining it. The systems that reached zero-shot manipulation delete body information from the interface between task reasoning and motor control, and the ladder shows by intervention that this deletion is what causes transfer, that leaking the body back destroys transfer once the leak passes a threshold, and that injecting body identity is harmful, none of which any of those systems tested. The coding comparison shows that the choice each system made silently, tokens for one and an intent latent for another, is a real design variable, and that among equally body-blind codings a structured symbolic one transfers best with the advantage compounding over task depth. The released-model measurement carries the analysis onto the field’s own model with the appearance confound controlled and finds a modest but genuine scene-invariant body residue together with an action decision that does not rely on it. The common thread is that recoverability is not reliance. A body-blind interface still lets a strong probe recover the arm, and a released model still encodes the robot in the state it decodes from, yet the transfer that matters lives in what the policy is forced not to specialize on and the action lives in directions that are not the body directions.

The account also predicts where the wave must fail, and the prediction is structural rather than empirical. Deleting the body from the interface transfers for free only when a body-general executor can close the loop below the interface, which requires the action space across bodies to be commensurable. Manipulation arms are commensurable in end-effector space, which is why an analytic executor serves every arm and why the wave operates there. Legged locomotion is not, since a gait is body-specific and must be learned per body, and our walker fleet shows the price of that in the two of five platforms that attain a gait under a uniform recipe. The interface deletes the body from the representation, but the body’s cost does not vanish, it moves below the interface and is paid per body wherever the action space is not commensurable, which is the boundary the same account that explains the successes draws around them.

The design guidance that follows is specific and partly counterintuitive. A shared cross-body interface should be body-blind in what it commands and coarse in how it codes that command, and it should not be conditioned on body identity even when identity is available, because a policy that can route behavior by identity will do so and will then fail on a body whose identity it cannot know. The coding should be as structured as the task’s precision allows, since structure buys transfer that a token coding leaves on the table and a coding below the task’s precision floor fails outright, and the right target for the executor below the interface is a body-general controller wherever the action space admits one. These are testable statements about interface design, and they are the operational content of treating coarseness as the property a transferable interface needs and reliance rather than recoverability as the quantity that governs transfer.

6. Limitations

The causal ladder is behavior cloning on a manipulation substrate with a shared analytic executor whose per-arm ceilings bound the absolute success any interface can reach, so the ladder speaks to the directional information each interface carries at a fixed magnitude rather than to end-to-end control quality. The leak-collapse frontier is significant under the two-tier rule, while the body-blind action coding contrast against a joint-space head is suggestive, positive on four of five arms with an exact $p=0.0625$, and the arm that does not follow is the one with the weakest executor ceiling. The coding comparison holds the planner fixed and varies only the coding of the planner-to-skill channel, its token and latent arms are faithful analogues rather than the released systems they echo, and its latent arm bounds a three-bit realization rather than continuous-intent interfaces at realistic capacity, so the depth-one coding advantage is suggestive and the pooled contrast carries the claim. The released-model measurement rests on three scenes and three cross-scene folds with the body residue concentrated in a subset of robots, a cross-rendering artifact that is detectable and may inflate the residue, and an action-sufficiency half measured on the first action dimension under a partial linear scrub that leaves the body about sixty percent recoverable nonlinearly. The commensurability boundary is a five-point descriptive case with one diagnosed gain-dependent mechanism and is offered as a correlate rather than a law over platforms. None of the released-model or boundary results is a gate-certified headline, and they are reported as the bounded preliminary measurements they are, while the two interface contrasts that pass the enforced gate are the leak-collapse frontier and the structured-over-token coding.

7. Conclusions

The zero-shot cross-embodiment wave of 2026 works by deleting body information from the interface between task reasoning and motor control, and this paper shows on a scene-controlled substrate that the deletion is the cause and not a coincidence. A body-blind end-effector interface transfers to arms it never saw, leaking body channels back into it collapses that transfer once the leak passes a threshold, and conditioning it on body identity is worse than useless, each effect established by intervention on the interface with the task, the scene, and the data held fixed, and each reproduced across held-out bodies. The transfer that survives does not require the interface to be body-blind to a probe, which it is not, but to be coarse enough that the policy has no body channel to specialize on, so that what a probe can recover from the interface and what the policy relies on come apart. The same separation appears inside a released model, where the robot is plainly present in the state the action is decoded from yet removing the body directions barely moves the action, which is direct in-model evidence for the premise the wave rests on.

Beyond establishing the cause, the paper turns two questions the wave left implicit into measured answers. The coding of a body-blind interface is a real design variable rather than a detail settled by coarseness, and among equally body-blind codings a structured symbolic one transfers best with the advantage compounding as the task lengthens, while a coding below the task’s precision floor fails. The body information a released model carries beyond scene appearance is modest but genuine, exceeding a raw-pixel control in every fold once the scene is controlled, and the action it decodes is body-light. Together these give the first causal and scene-controlled account of the body-information content of a cross-embodiment interface, an account that explains the wave’s successes and draws its failure boundary in the same stroke, at the line where a commensurable action space gives way and the price of the body must be paid below the interface one body at a time.

For the field the practical consequence is a short list of design commitments and a research frontier. A transferable interface should command body-blind and code coarse and structured, should refuse body identity even when it is available, and should sit above a body-general executor wherever the action space admits one. The frontier is to push each of these past its present scope, to a learned rather than analytic executor that would make the whole agent learned while keeping the interface coarse, to non-commensurable action spaces where the boundary predicts the deletion strategy must give way, and to a firm multi-scene measurement of body reliance inside released models. The pattern this paper establishes, that transfer is governed by reliance rather than recoverability and that a body-blind coarse interface is what a shared policy needs, is the standard those extensions should be held to.