The Action Bottleneck

Background

The models and the symptom

A language model can pass the bar exam — a billion people now use one every week^[1] — and image and video models can paint or film anything you describe, sold as everyday consumer products. The robot arm that was supposed to be loading your dishwasher still fails often enough that there is nothing on the shelf you would even want to buy.

Robot AI runs on the same machinery as those products. Its two leading families share one recipe: the VLA — vision-language-action model: camera frames and a text instruction go in, motor commands come out, one network end to end — and the WAM — world-action model, which learns to predict future observations and actions together^[2]. (A third pattern has a language model write code that calls motion primitives^[3].) In either family, the action output itself typically comes from a diffusion or flow head that generates whole motion trajectories^[4]. And almost all of them learn the action part the same way, by behavior cloning: record a human doing the task (usually by teleoperation — a person puppets the robot while everything is logged), then train the network to reproduce the recorded actions from the recorded observations.

The shared machinery. The vision and language components arrive pretrained at web scale; the action head is trained by behavior cloning on recorded demonstrations.

In every family above, the vision and language components generalize well, and the action component is where generalization stops^[5],[6],[7]. And where generalization stops, scaling stops: a scaling curve tracks error on data the model has never seen^[8], so more data improves a model only through what it generalizes from that data — improvement without generalization is memorization, and buys nothing^[9]. The component that cannot generalize is the component that cannot scale. The classic hand-wave is Moravec’s paradox — the observation, roughly, that hard things are easy and easy things are hard^[10] — but why? We would like to analyze it and give it a reason, starting with what “scaled” actually meant for vision and language.

(If you already know this ground, jump straight to Why the action head overfits: five claims.)

What a “scaling moment” is

When people say language and vision “scaled,” they mean something specific: a predictable curve. In 2020, Kaplan and colleagues measured that a language model’s test error falls along a smooth power law as data and compute grow^[8]:

L(D) ≈ k · D^−α + L_∞

where: L(D) is the error after training on D units of data; L_∞ is the floor — the error you never get below no matter how much data you add; the exponent α says how fast the error above that floor shrinks as data grows (every doubling of D cuts it by the same fixed fraction); and k scales that shrinking part — it is the error above the floor at D = 1, and doubling it doubles the error above the floor at every D, while α alone decides how fast it falls. On a log-log plot this is a straight line, and for language it stayed straight across seven orders of magnitude of compute. Later work pinned the exponents down precisely enough that labs now budget nine-figure training runs off the curve^[11]. GPT-3 was the proof that the plan pays: abilities like few-shot learning showed up as a function of scale, not of any new architecture^[12]. Vision ran the same play: from AlexNet learning on 1.2 million labeled photos^[13] to CLIP learning from 400 million image-text pairs scraped off the web^[14] to LAION’s 5.85 billion^[15]. (This is the shortest usable account of scaling laws; for a careful full tour, see Lilian Weng’s “Scaling Laws, Carefully”^[16].)

Robot data splits into two streams, and they scaled very differently. Nobody logs motor commands as a byproduct of living, so recorded robot actions total about 11,000 hours across the major open datasets^[17],[18] — while the corpora that reached a million hours in 2026^[5] (still far below web-text scale^[19]) got there by taking the robot out of the loop: humans wearing cameras or holding grippers, no robot actions in the corpus at all^{[20],[21],[22]} — what stands in for them is the human hand’s movement, tracked as skeleton poses, a substitution the embodiment-gap section prices.

The collection race, log scale, trends fitted by least squares. Orange: recorded robot actions^{[23],[24],[25],[18]}. Blue: collected from humans, no robot in the loop^{[26],[27],[28],[22],[20],[21],[5]}. Only corpora with published hour counts are shown; the open-datasets total is plotted for scale but excluded from the orange fit, and the blue trend is set mainly by the 2025–26 commercial corpora. The ~90x gap is data collected with no robot in the loop — though the gripper-worn corpora do log human hand actions; the embodiment-gap section prices that substitution.

Despite the extremely rapid growth of robot data, in the action dimension one still cannot observe the kind of generalization ability seen in language and video^[5],[6],[7]. This failure at the level of paradigm or model architecture — a failure that more hours of data do not fix — is the subject of this essay.

The problem, stated precisely

Take one fixed robot dataset — say Open X-Embodiment, the field’s flagship shared collection^[17]. The data does not dictate how it is used: a VLA trains only an action head on it; a WAM trains an action head and a video head together. To expose the problem, use the two-head setting as a probe — the same trajectories, two prediction targets. One head predicts the upcoming video frames. The other predicts the recorded actions. The visual head behaves: training and validation losses fall together. The action head misbehaves: training error keeps falling while validation error falls, bottoms out, and then climbs — the textbook overfitting curve. Dyna Robotics reports the same signature from its ablations — 5,000 to 100,000 hours of action-labelled data, evaluated zero-shot on a 39-task robot suite: action-only training “exhibits severe and unpredictable overfitting patterns as data scales”^[5].

Now formally. A demonstration dataset is a set of trajectories

τ = (o₁, a₁, o₂, a₂, …, o_T)

where o_t is the observation at step t — everything the sensors recorded: camera frames, joint angles, gripper state, and, on the rare rigs that have them, wrist force or tactile readings — and a_t is the recorded action at step t (the motor command).

The actions were chosen by the demonstrator:

a_t = π(o_t, z) + ε_t

where π is the demonstrator’s decision rule — their policy: it turns what they currently see, o_t, into a motor command. The other two symbols are the trouble. z is the demonstrator’s private state — their intent, their habits, which side they decided to pass on — which drives their choices but never appears in the recording. And ε_t is execution noise: tremor and jitter added on top of the intended command.

The observations were produced by the world:

o_t+1 = f(o_t, a_t)

where f is physics: it takes the current state o_t and the executed action a_t and returns the next state. Unlike the demonstrator, physics hides nothing and, away from contact, adds almost no randomness: the same state and the same action give essentially the same next state.

Training on this dataset means learning to predict one of the two halves, so each head has a function it is trying to become. The vision head predicts the next observation o_t+1; a perfect vision head is a copy of physics f, and everything f depends on is visible in the data. The action head predicts the recorded action a_t; a perfect action head would be a copy of the policy π — but π reads z, and z is not in the data. (A distinction to carry: this vision head is a next-frame predictor trained on the robot data itself — not the web-pretrained vision encoder a VLA inherits. The encoder owes its generalization to web-scale pretraining; whatever the vision head does well below, it does on robot data alone.)

Both heads receive the same input x_t: the observations available at step t. In the toy experiment below, x_t is simply the last two positions, x_t = (o_t−1, o_t) — two, because two positions show where the arm is and how it is moving. That is a choice made to keep the experiment small, not a hidden assumption: real models read longer histories and a language instruction, and Claim 1 explains why neither recovers z.

To compare the two heads on one scale, score any prediction with normalized mean squared error:

NMSE = E‖ŷ − y‖² / Var(y)

where y is the true value being predicted — o_t+1 for the vision head, a_t for the action head — and ŷ is the model’s prediction of it. The numerator is the average squared miss; dividing by Var(y), the target’s natural spread, puts different targets on one scale: 0 is perfect, and 1 means no better than always guessing the average. (If the targets were tokenized, the natural score would be cross-entropy; for a diffusion head, the denoising loss. Nothing below depends on that choice: every training loss is some measure of the distance between prediction and label — in values or in distributions — and each has its own floor. NMSE is simply the cleanest to measure on this rig; Claim 2 returns to the other losses.)

One more definition does the most work in this essay:

B = E[Var(y | x)] / Var(y)

where Var(y | x) is the spread of the true values across cases whose input x looks identical. Call B the floor: the share of the target that stays undetermined even when the input is used perfectly. If identical inputs can be followed by different true values, no model — however large, however well trained — can tell which one is coming, so no model’s validation NMSE can average below B. Write B_A for the action head’s floor and B_V for the vision head’s.

The problem this essay answers, in one line: why, on the same data, the same inputs, and the same network, is the gap between validation and training error near zero for the vision head, and large and growing for the action head? Equivalently: why is the floor tiny for f and large for π — and what does gradient training do with the share of the target its data cannot pin down?

To answer it, I built the smallest rig that reproduces the phenomenon^[29]. A simulated 2D robot crosses a table to a goal, detouring around an obstacle. Each demonstration carries hidden state — the z and ε above — that the observations never show: which side the demonstrator chose (a coin flip), their turn-early-or-late style, and jitter on their command signal. The “arm” has inertia, so observed positions are a smoothed version of the raw commands — a camera sees the filtered arm; the teleop log stores the raw signal. The vision head predicts the next position; the action head predicts the raw command.

The rig. Left: demonstrations fork on a hidden coin, with turn-early/turn-late style spread. Right: the two records of one and the same motion — the action label is the jagged orange command; the observation is the smooth blue response. Both heads see identical inputs.

# One demonstration step. Hidden per episode: side (coin), turn_dist (style).
if x < OBS_X and (OBS_X - x) < turn_dist and abs(y) < 1.0:
    target = (x + 0.5, side * 1.2)        # detour waypoint
else:
    target = GOAL
d = unit_vector(target - pos)
cmd = SPEED * d + gauss(0, 0.05)          # ACTION label: intent + jitter
exec_v = 0.6 * exec_v + 0.4 * cmd         # arm inertia (low-pass filter)
pos = pos + exec_v                        # OBSERVATION: filtered response

# Two heads, identical input (last two positions):
#   vision head predicts pos_next   -> approximates physics f
#   action head predicts cmd        -> approximates the policy pi(o, z)
# Model 1: nearest neighbor (pure memorizer), 200 train / 200 val episodes
# Model 2: MLP 4 -> 240 tanh -> 2, gradient descent, 8 train / 150 val episodes

The answer to that question has three parts:

• a statistical problem inside the action target itself;
• a check at real scale — does the diagnosis survive the field’s own record?
• a measurement problem that keeps the whole thing hard to see.

The rest of this essay walks them in order.

Why the action head overfits: five claims

The statistical problem — the first of the three — resolves into five claims: each a property of the action target, each tested — the first four on this rig, the fifth on this rig and against real-robot data at scale.

Two ground rules for the rig first. Its hidden variables are put in by hand — that is what a rig is — but each one has been verified on real robots: demonstrator style is a measured training hazard at industrial scale^[30], and the overfitting itself is documented in industrial ablations up to 100,000 action-hours^[5]; the rig exists to isolate the mechanism, not to prove the phenomenon. And its knobs set its multipliers — export the shape of each result, not the constants.

Claim 1: the action label records decisions; the observation records their consequences

The core asymmetry: the two targets sit on opposite sides of the demonstrator’s decisions. Every timestep follows the same causal chain: the demonstrator decides → the hand executes → the world shows the result.

Predicting the next frame is a downstream question: given the motion so far, what happens next? By the time you ask, the decision is made and its consequences are visible — the velocity between two frames is the executed record of the recent commands.

Predicting the action is an upstream question: what will this person decide, right now? At a genuine decision point, the observation does not contain the answer. Two demonstrators in the same position go opposite ways around an obstacle. The same demonstrator turns early on Monday and late on Tuesday, with hand tremor on top. In the notation above: the target depends on z and ε, and the input x contains neither. (Conditioning on more doesn’t dissolve z. A language instruction names the task, not the grasp point or the detour side — the rig’s goal is fixed and known, and the coin is hidden anyway. And history doesn’t help at a genuine fork: until the turn begins, the choice appears in no frame.) Information theory gives this a name — the conditional entropy H(a|o), the uncertainty about the action that remains after the observation is fully used — and a decomposition:

H(a|o) = H(a) − I(a; o)

— read: total action uncertainty, minus whatever the observation reveals. For the action head this remainder is large, and its squared-error analogue is the floor defined above: everything the demonstrator’s hidden state contributes lands in B_A. For the vision head, physics f is a function — once an action has been executed, the next frame is essentially decided, and the input already shows the executed motion — so B_V is nearly zero, up to one small leak that Claim 3 makes precise.

Where each head taps the chain. The action head’s target sits upstream of the arm’s filter: z and ε land in it at full strength, and three-tenths of its variance (B_A ≈ 0.29, measured in Claim 2) is undetermined by the input. The vision head’s target sits downstream: the same unknowns arrive scaled by the filter and buried under momentum, an undetermined share of at most a quarter of one percent (B_V ≤ 0.0027 — a variance-share ceiling, unlike the measured B_A; Claim 3). Neither head can see z or ε — the chain decides how much that ignorance costs each of them.

Test. Fit a pure memorizer (nearest-neighbor) to 200 demonstrations and evaluate on 200 fresh ones. Training error: zero on both heads — a memorizer memorizes everything equally. Validation error: vision 0.0033, action 0.631 — about 190 times worse, from the same inputs, same data, same model. (A fairness note on that headline ratio: essentially all of it is the scoring scale, because the vision target buries its hard part under a large denominator — Claim 3 shows the two heads score identically on the decision content. The scale-free version of the asymmetry is: neither head knows z; only the action head is graded on it.) Then switch the hidden variables off one at a time, which decomposes that validation error into its ε and z parts:

(Three footnotes on the table. Row one re-runs the everything-hidden condition inside the decomposition script; seed-to-seed wobble, not a typo, separates its 0.62 from the 0.631 above. A memorizer’s validation error overshoots the floor itself by about a factor of two — its miss stacks the fresh episode’s hidden draw on top of the stored neighbor’s — so read the rows as like-for-like comparisons across variants; the floor itself gets measured directly in Claim 2. And one sanity check comes free: the jitter-only and decisions-only rows nearly add up to the everything-hidden row (0.36 + 0.28 ≈ 0.62), which is what independent error sources should do — and the two were built independent.)

Two rows matter most. Row three: remove every source of randomness — a fully deterministic world — and the action head is still ~240x worse (0.278 against 0.00115 before rounding), because unobserved decisions hurt exactly like noise, and unlike noise they can’t be cleaned away: they are the signal. Row four: predict the same motion one step downstream — the executed, filtered velocity instead of the raw command — and the error drops threefold, with what remains still seventy-odd times the vision head’s. The difficulty isn’t “action” as a category. It’s distance upstream: the closer the target sits to the hidden decision, the more of z and ε it contains, and the higher its floor — the gradient the field’s target engineering already climbs, with chunked trajectories, end-effector waypoints, and smoothed targets in place of raw per-tick commands.

The demonstrator’s intent is only the first entry on the missing-information list. State the principle once, generally: the floor is made of every cause the action depends on that the input does not carry — whatever its type. Intent is one. The others are physical and sensory: the forces and pressure at the fingertips, the object’s weight, friction, and compliance, temperature, the sound of a part seating home, everything occluded from the camera, even depth itself. And one is linguistic: the instruction says “pick up the mug,” never where to grip it or how hard — language conditions the task, and still underdetermines the action. Each unobserved cause adds its share to B_A. Contact-rich manipulation is not a separate problem; it is the setting where the most entries on this list go missing at once.

Cameras can’t see forces. Watch a video of a hand holding a paper cup: is the grip secure, or one newton from crushing it? The pixels are identical. Grip force, friction, incipient slip — the variables that decide fine manipulation are invisible to the camera, the sensor nearly all robot training data comes from. The channel that carries them — touch — was never digitized at scale: a 2026 tactile paper calls its 100-hour dataset “large-scale,” and within that field, it is^[31]. One hundred hours, next to a million hours of video. (Touch isn’t strictly required — surgeons completed millions of da Vinci procedures with zero force feedback before it shipped in 2024^[32] — but wherever precision meets uncertainty, it buys a lot.) And this is not hypothetical bookkeeping: when VLAs fail on contact-rich tasks, force failures form their own category, distinct from anything vision or precision explains^[33].

Contact physics amplifies tiny differences. Also checkable at home^[29]:

Setup. Simulate pushing a heavy block: force ramps up, the block sticks, then breaks free and slides — the stick-slip jerk you feel pushing furniture. Run 400 trials with friction varied by ±1% (a slightly damp table gives you that for free), against a control system with smooth damping and the same ±1%.

Result. The smooth system’s outcomes vary by about 1% — noise in, noise out. The stick-slip system near its threshold spreads 83x wider; some trials never break free at all, others slide several times as far as the typical one. Far from the threshold, the effect nearly vanishes.

Conclusion. Near contact transitions, visually identical situations produce wildly different outcomes — and real-hardware measurements show the same: repeated identical pushes of one object yield a whole distribution of results^[34]. That’s why contact tasks need many demonstrations (each lands differently), why simulators disagree with reality precisely here (a 1% modeling error explodes), and why evaluation needs many trials (single runs mean nothing). One phenomenon, three bills. And it slots into Claim 1’s ledger precisely — though not where you might expect. The world’s coin flips at contact land first in the observation: outcome variance raises the vision floor too, thinning Claim 3’s cushion, so at contact the two heads’ asymmetry actually narrows. What keeps the action head worse even there is that it has no cushion at all — and that the demonstrator reacts to forces they feel before anything shows in a frame, so the reaction enters the action target while its cause is still invisible to the input, raising H(a|o) again.

The same amplification answers the obvious counterexample — “just train in simulation, the way locomotion did.” Locomotion’s sim-to-real success is real, and it maps the boundary rather than crossing it: in locomotion the outcome depends on the robot’s own state — which the simulator knows — plus terrain that randomization can cover; manipulation stakes success on hidden properties of arbitrary objects — geometry, mass, friction, softness — at exactly the transitions where a 1% error becomes an 83x spread.

Claim 2: what the model cannot predict, it memorizes

This claim answers the objection you should be raising: if the action is genuinely unpredictable — if the floor B_A is high — shouldn’t training error also be stuck at the floor?

It would be — if the network had to predict the unpredictable part. On the training set, it can remember it instead. The coin flip in episode 137 is no longer a random variable; it is a recorded fact, and a network with spare capacity will store it, indexed by whatever incidental features identify that episode. So training error sinks below the floor — storing, not learning. On fresh validation episodes the coins are re-rolled, there is nothing to look up — and a function bent through stored noise is warped everywhere in between. Schematically, over training time t:

NMSE_train(t) → below B      NMSE_val(t) → B + damage(t)

— read: the training curve dives under the floor (anything below B is memorization by definition), while the validation curve bottoms out — at the floor when data is plentiful, above it when data is scarce — and then accumulates damage as memorization warps the function. This is the documented behavior of networks trained on noisy labels — learn the true pattern first, then memorize the noise, with validation error turning upward at the moment memorization begins^[9],^[35].

If this mechanism sounds familiar from language models, it should. Hallucination runs on the same arithmetic: when the input cannot determine the answer, even a well-calibrated model must sometimes produce confident content it has no basis for — provably so for facts that appear only once in training^[36] — and training that rewards answering over abstaining teaches models to guess^[37]. An action head faces that situation at every decision point: asked for an output its input does not determine, it answers anyway, from memory. Overfitting here and hallucination there are one disease — memory posing as reasoning wherever information is missing.

Test. Replace the memorizer with a small network trained by gradient descent, and — to mirror per-task robot reality — give it only eight demonstrations. The vision head barely notices the poverty: training and validation error fall together to 0.0014 and 0.0019 and stay overlapped for four thousand epochs. Eight episodes are enough, because the target is the shared physics. The action head draws the curve every practitioner has seen: validation error bottoms out almost immediately (0.53, epoch 45), then trends upward for the rest of training — never regaining that minimum — while training error keeps falling: 0.31 versus 0.60 by the end.

Read those numbers against the floor, which can be measured directly on the rig: estimate Var(y|x) by the spread of action labels at matched inputs — a quarter-million fresh samples, shrinking the match radius until the estimate stops moving — and B_A ≈ 0.29. That also retro-checks Claim 1, whose memorizer landed at 0.63, a shade over twice the floor, right where nearest-neighbor theory puts it. So the best validation error, 0.53, is the floor plus what eight episodes cannot yet teach. Training error, at 0.31, is within a whisker of the floor — almost everything it sheds from here on is memorization. And validation error ends at 0.60, double the floor: the climb from 0.53 is the damage.

Same data, same network, same training — only the target differs. Left: the vision head’s two curves overlap at its floor, near zero. Right: the dotted line is the action head’s measured floor, B_A ≈ 0.29. Validation (orange) bottoms out at 0.53 — floor plus what eight episodes can’t teach — then drifts up; training (blue, dashed) ends a whisker above the floor and is still falling — anything it sheds below that line is memorization, not learning.

The ablation that separates the two halves of the thesis. If missing information is really what makes the action target unpredictable, handing the model the missing information should remove the unpredictability. For the memorizer, it does: give the action head the hidden state itself — the coin and the style parameter as two extra input columns — and validation error drops from 0.62 to 0.38, within a hair of the 0.36 that pure jitter alone produces in Claim 1’s table; the decision-driven error disappears^[29]. (Same policy, same 200 demonstrations as Claim 1’s test; only the input changed.)

For the gradient-trained network at eight episodes, the same ablation backfires: training error dives to 0.12 while validation error climbs to 8.7 — fourteen times the hidden-z network’s 0.60. With eight episodes, the style parameter doubles as an episode ID — Claim 4’s causal-confusion trap — so the network keys its memorized episodes on it and extrapolates wildly on fresh values. Grow the dataset to 200 episodes, where two hundred distinct style values no longer identify anything, and the pathology vanishes: validation error falls monotonically through all 1,500 training epochs — no bottom, no upturn — reaching 0.41 and still falling, training at 0.32 close behind^[29] — headed toward the revealed-z floor, which sits near 0.19 (half the memorizer’s 0.38, by the factor-of-two rule in Claim 1’s footnotes). The revealed-z target is merely not yet fully learned; nothing about it misleads. And the fourth cell of this grid seals it: a hidden-z network trained identically on the same 200 episodes reaches 0.48 — with 0.29 as the lowest it can ever go — while its revealed-z twin, already at 0.41, is on its way to roughly 0.19^[29]. Same data, same network, same training; the only difference is whether the missing information is in the input, and that difference decides where the curves are allowed to end.

The 2×2, on real training curves. Columns: 8 vs 200 episodes. Rows: z hidden vs z revealed as input. Hidden z is floor-bound at 0.29 at every size; revealed z explodes at 8 episodes (the style parameter doubles as an episode ID) and simply keeps learning at 200. The floor sets the destination; episode count sets the behavior on the way there.

That backfire is worth taking seriously, because it forces a precision the essay needs anyway: the floor and the overfitting are two different facts. The floor says what can never be learned from a given input — no amount of data brings the action head’s validation error below B_A while z stays hidden. The overfitting curve says what a network does with whatever its data has not yet pinned down — and hidden state guarantees such a remainder at every dataset size, while even a fully learnable target produces one when episodes are few. Missing information sets the permanent part of the failure; episode scarcity sets the temporary part; Claim 2’s curves are the two stacked.

A word on heads, because the natural objection is: isn’t this just the loss? A cross-entropy head over action tokens can represent the fork as a distribution — left 50%, right 50% — and sample one branch cleanly. It can, and the field changed heads for exactly this reason^[4]: a distributional head fixes mode averaging, the deployment failure where a deterministic net splits the difference and drives into the obstacle. But it fixes representation, not learning. Cross-entropy has its own floor — the conditional entropy H(a|o) from Claim 1; no loss can predict what the input does not determine. And it has its own way under that floor: instead of staying calibrated at 50/50, a network with spare capacity sharpens the distribution per episode, putting its probability on the recorded coin, keyed to whatever features identify the episode — the very mechanism the random-label experiments documented, under cross-entropy^[9], and the one hallucination runs on above. The measured record agrees: both Dyna’s overfitting ablations^[5] and the null result on cleverer action representations below^[6] come from modern generative heads, not MSE strawmen. Nor is the floor itself what dooms a policy — at a fork either branch works, and a calibrated sampler scoring exactly B can act perfectly. The damage is what chasing sub-floor training error puts into the network: memorized episodes, and the shortcuts of Claim 4 — and those do ride along into deployment.

Claim 3: the visual loss hides the same ignorance under an average

If physics is deterministic, why isn’t the vision head’s floor exactly zero? Because the next frame does contain one non-physics ingredient: the newest action, which carries this step’s fresh slice of z and ε. The vision head is just as unable to predict that slice as the action head. The reason its metric doesn’t show it is arithmetic. Write the vision target as

o_t+1 = m(x_t) + c · u_t

— read: a momentum part m(x) that the input fully determines (the arm keeps moving as it was moving), plus the innovation u — the genuinely new, decision-bearing content — scaled down by the arm’s inertia filter c (0.4 in the rig). Because NMSE divides by the target’s total variance, the innovation’s contribution gets diluted:

NMSE_full ≈ NMSE_innov × [c²·Var(u) / Var(o_t+1)]

— read: the visible score equals the score on the hard part, multiplied by the hard part’s tiny share of the target’s variance. Same misses; bigger denominator. (For a memorizer a second, benign term also appears — momentum mismatch between neighbors — separated out in the test below.) A frame in a real dataset is hundreds of thousands of numbers, most of which — background, table, lighting — belong to m(x). An action is 7–24 numbers — roughly one per motor — with no comparable padding. On this rig the decision-bearing share of the action target’s variance is the floor itself, B_A ≈ 0.29: three-tenths of the action target, against a quarter of one percent of the visual one. Action misses land on what matters at a hundred-odd times the density; almost every pixel “hit” is momentum.

Same ignorance, different denominator. Both targets carry the same unpredictable decision slice; the vision target buries it under momentum padding, the action target wears it as its floor.

Test. Take the very same memorizer from Claim 1 — retrain nothing — and re-grade it on the innovation alone: subtract each sample’s own momentum part from prediction and truth, and score what remains against the innovation’s variance. On this rig the innovation is the unpredictable slice of the command, so a clean re-grade must reproduce the action head’s score — and it does, to the third decimal: innovation NMSE 0.618, action head 0.618^[29]. That identity is the bookkeeping check the decomposition demands, not a discovery. On the decision-bearing content, the two heads are equally ignorant; only the denominator differs. The innovation’s share of the visual target’s variance, measured directly, is 0.0027 — the quarter of one percent claimed above — and the vision head’s tiny full score (0.0032 in this run) splits cleanly into 0.0017 of innovation misses plus 0.0015 of momentum mismatch between neighbors, a benign term a trained network mostly learns away. Dilution is the whole cushion. What the vision head knows about the decision, the action head knows too; the vision head is simply graded on a target where the decision is a rounding error. (The real-model analogue would be masking the visual loss down to the gripper-and-object pixels — the decision-bearing region; the dilution identity predicts part of the train/val gap shows up there. The cushion pads the average; it doesn’t solve manipulation.)

Two cautions on the numbers. First, 0.0027 is the innovation’s share of variance — a ceiling on the vision floor, not a measured floor. Part of the innovation is itself predictable, which is why Claim 2’s vision validation error, 0.0019, sits below the ceiling; nothing is inconsistent. Second, the cushion’s thickness is a property of the rig: our arm’s filter passes only c = 0.4 of each command into the next observation. On a stiff, position-controlled arm with joint angles in the observation, the next reading nearly is the command — c near 1 — and the cushion thins accordingly. The pixel case keeps its padding either way: a frame is hundreds of thousands of momentum-dominated numbers.

So which parts of this claim leave the rig? The split and the direction do; the numbers do not. A real frame’s padding is larger than the rig’s, not smaller — the rig has no background at all, while a real frame is mostly static pixels — so the dilution runs stronger in reality, and that is why video losses look stable at industrial scale while action losses overfit^[5]. What does not carry over is the tidy identity: a real frame also contains unpredictable content that has nothing to do with the demonstrator’s decision — other people, shadows, sensor noise — so a real vision floor is not purely the action’s slice, and no real re-grade would land exactly on the action head’s score.

The video-generation literature met this same missing information from its own side, and its history confirms the claim. Train a deterministic video model with no action input and it produces blurry futures — it averages the possible continuations, because what happens next depends on decisions it cannot see; sharp prediction required latent-variable models that sample one future instead of averaging them^[38] — the pixel-space twin of the action head’s mode-averaging problem and its distributional fix in Claim 2. And the strongest action-free world models go further: Genie, trained on unlabeled video, is forced to invent an internal latent action — a controllable action variable it discovers without ever seeing an action label^[39]. Same fact from the other direction: to predict video at all, the model must model the missing action. So why did video generation scale anyway? For exactly the two mercies this claim names: the missing slice is a rounding error of the video target, and generative samplers sample it rather than average it. The action target enjoys neither.

Claim 4: the open-loop score can improve while the policy does not

Memorization is not the only way to score well without understanding; the action target also invites shortcuts. Actions are smooth in time, so the single best predictor of the current action in the training set is the previous action. A model with history input can score well by copying its own inertia and learn nothing about why the motion happens. That failure mode is documented as the “copycat problem”^[40], and it has a broader family: any incidental feature that identifies which episode this is — background details, lighting — unlocks a memorized sequence, a pathology named “causal confusion”^[41].

Real systems fail exactly this way: VLAs above 90% on the LIBERO benchmark drop to 0% when objects, initial states, instructions, or environments are perturbed, diagnosed as rote-memorized action sequences^[7], and pooled corpora make it worse — policies trained on fragmented multi-lab datasets learn to recognize which sub-dataset they’re in from backgrounds and embodiment cues, then replay that fragment’s habits^[42]. (A control on this diagnosis: under purely visual changes — a moved camera, new lighting — much of a VLA’s failure traces to the vision encoder instead, and is repairable while the action policy stays frozen^[43]. The collapses above are not that kind: the diagnosis is memorized action sequences, the action head’s own disease.) The vision head has its own copy trick — repeat the previous frame — but that is just the momentum term of Claim 3, openly priced and honestly most of the answer.

The insidious part is where these score gains get caught. Robotics names the two settings: open-loop evaluation grades predictions against a recording, frame by frame — and there, copying inertia looks accurate; closed-loop evaluation lets the policy act, its outputs feeding back into what it sees — the difference between grading a driver against a dashcam recording and handing them the wheel. Only the second separates score from capability. Formally: open-loop metrics average the loss over the expert’s (the demonstrator’s) state distribution d_expert, but deployed performance is determined by the distribution d_π̂ that the learned policy π̂ generates by acting. Nothing ties the two together — a model can improve on the first while standing still, or collapsing, on the second.

Two ways to grade the same policy. Open loop (left): the policy’s errors never feed back, and copying inertia or predicting recorded noise scores points. Closed loop (right): outputs come back as inputs, small errors move the robot off the demonstrated states, and only capability survives.

Test. Two identical networks trained on the same hundred demonstrations; one also receives the previous raw command as an input, with the rig’s operator jitter recolored into realistic low-frequency drift (real operator noise is autocorrelated^[40]; white jitter would make the previous command uninformative). The history input now carries real information — about the operator’s drift: a signal genuinely present in the recording, and genuinely useless for control. The open-loop metric rewards it anyway: validation error drops from 0.414 to 0.287, a 31% improvement any benchmark table would celebrate. Then let both policies actually drive the arm, feeding their own outputs back: 70% success for the plain network, 73% for the history network — statistically indistinguishable across 200 rollouts (error bars the measurement section will price: wide enough to hide several points either way). The entire open-loop gain was noise prediction; none of it was control. (Note the distinction from the literature’s copycat, where the network comes to ignore the observation^[40] — nothing in this test shows that. The lesson here is milder and broader: the open-loop score also pays for predicting task-irrelevant noise, and that part of the score buys nothing in the loop.)

A first version of the experiment made the point even more rudely: with symmetric starts, both networks posted respectable open-loop numbers while succeeding on 1% of rollouts — the deterministic nets averaged the two detour modes at the decision boundary and drove straight into the obstacle, and nothing in the open-loop score hinted at it.

Claim 5: action data holds fewer real samples than it appears

The last claim moves from the quality of each sample to the count of them. Every frame of every episode samples the same shared physics — that function is common across episodes, tasks, even datasets. Actions carry new information only at decision points: when to turn, where to grasp, how hard to squeeze. Everything between decisions is autocorrelated filler, mostly predictable from the previous step. As a rule of thumb,

N_eff ≈ (episodes) × (decisions per episode) ≪ (frames)

— read: the effective sample count for the action head is the number of independent choices in the dataset, not the number of recorded timesteps. A 200-step trajectory might contain five genuinely independent choices — a fortyfold shrinkage already, and real trajectories logged at 30–50 Hz stretch the ratio into the hundreds — which means the action head sits much further left on any scaling curve than the raw dataset size suggests.

Test. Part of the claim is testable on the rig: hold the frame budget fixed and trade frames for episodes. With ~170 training frames, the memorizer’s action validation error falls from 0.85 at 8 episodes to 0.76 at 16 — and saturates by 32 (0.75), once the rig’s few hidden conditions are covered — while halving the frames of the same 8 episodes barely moves it, 0.85 to 0.88 (30 seeds)^[29]. Frames inside an episode are nearly redundant; episodes are what carry information. (An honest limit: that redundancy is a property of any smooth time series — the rig’s observation stream shows it too — so this test establishes the shrinkage, not anything action-specific. The action-specific content is the decision arithmetic above, and the diversity exponent is beyond a one-obstacle world.) The other half — that generalization scales with conditions — needs real scale, and the cleanest real-robot data-scaling study on record supplies it: 40,000+ demonstrations, 15,000+ evaluation rollouts; demonstrations per environment saturate at around fifty, while generalization follows a power law in the number of environments and objects^[44]. Counted the way that matters, a dataset’s size is its number of conditions, not its number of frames.

The five claims at a glance:

What the labs already do about it

The flagship systems no longer train the action head alone; the field’s own habits concede the diagnosis. Dyna-2 stabilizes its action learning with video co-training^[5]; Physical Intelligence goes further and blocks the action head’s gradients from touching the language backbone, co-training the backbone on web data instead, because raw action gradients measurably degrade it^[45]. The vision and language objectives act as ballast for a target too thin and too noisy to sail on its own.

The controlled evidence arrived in 2026. Toyota Research Institute ran the most rigorous co-training study to date — 89 policies, 58,000 simulated and 2,835 real-robot trials — and found exactly this pattern: co-training on vision-language data consistently improves a robot policy’s generalization, while robot-only training measurably erodes the backbone’s abilities^[6]. The same study carried a result that should sting anyone betting on cleverer action representations: discrete action tokens and latent actions extracted from video produced no statistically significant gains, and one action-token scheme actively decreased generalization^[6].

And the rig’s hidden-style variable is the one AgiBot measured: operator diversity — different teleoperators’ personal styles in otherwise identical situations — can actively hurt training, and debiasing operators’ velocity profiles helps^[30]. In our terms: they lowered H(a|o) and got a better policy for it.

That is the statistical problem: each action sample teaches less and misleads more. Everything so far, though, is a rig and a claims list. The natural question is whether the field’s own record at scale agrees — it does, and the next section walks through it; the one after asks what our instruments can even see.

Beyond the rig: what more data actually buys

“Then collect more.” The field has — the past three years saw the biggest data-collection push in robotics history — and the record of what happened is the claims replayed at scale. Walk through it and the location of the bottleneck is unambiguous: the learning, not the logistics.

More of the same data does not help

In the cleanest real-robot data-scaling study on record, demonstrations per environment saturate at around fifty^[44]. And in Dyna-2’s ablations, spanning 5,000 to 100,000 hours of action-labelled data, action-only training overfits more severely and less predictably as the data grows^[5] — Claim 2’s memorization dynamic, observed in an industrial pipeline. If raw volume were the missing ingredient, these are not the curves it would draw.

Diversity helps, for the reason the claims predict

That same study finds generalization follows a power law in the number of training environments and objects^[44], with a striking practical translation: four data collectors, one afternoon, thirty-two environment-object pairs — roughly 90% success in entirely new environments with unseen objects^[44]. AgiBot’s million-trajectory study agrees — task diversity beats per-task quantity^[30] — and a controlled follow-up finds the diversity dimensions that matter most are unglamorous ones: camera poses and spatial arrangements^[46]. This is the overfitting story seen from the data side: another demonstration of the same condition mostly re-samples the same hidden coins — more memorizable noise — while a new environment adds structure the shared, learnable layers can actually absorb. Scale works where the sharing works, and nowhere else.

The biggest corpus swap hits the embodiment gap

The obvious escape from small robot corpora is human video: humans move all day, and Dyna-2’s million-hour egocentric corpus does yield a genuine scaling law — more human hours, measurably better robot^[5]. A thin one, though: the fitted error exponent is about D^−0.018, five times shallower than the ~D^−0.095 Kaplan measured for language data^[5],[8].

The field’s published scaling laws, side by side. Left: Dyna-2’s own two fitted laws^[5] — the embodiment gap is the vertical distance, narrowing from ≈3x to ≈2.2x over a thousandfold more video. Right: every exponent normalized to the same starting point. Language^[8] cuts error roughly in half per 1,000x data; Dyna’s usable robot-transfer law manages 39%, its human-video law 12% — and the steepest curve on the chart, driving’s open-loop law^[47], is the one that failed when the model actually drove. Steepness on a proxy is not capability.

But what that scaling law buys the robot is capped by a transfer penalty: the same model’s zero-shot predictions of robot actions come out two to three times worse than its predictions of human actions — roughly 3x at the small end of Dyna-2’s own ladder, narrowing to roughly 2.2x at a million hours^[5]. (An open-loop number, note — by the standards of the measurement section below, it grades the pretraining objective, not deployment.) This is the embodiment gap: watching a thousand hours of chopstick use teaches a lot about food and grip strategy, and still doesn’t hand a two-fingered rubber gripper the motor program. Bodies don’t share muscle memory. Notice that this is Claim 1 operating across bodies: within one body, the demonstrator’s motor channel is already hidden from the camera; between a human body and a robot’s, still more of it is. For the action head, human video is mostly more vision data. (Not entirely: Dyna mines action-like labels from its video, and the mapping is worth seeing in full. The tracked wrist pose becomes the robot’s end-effector trajectory; the distance between thumb and index finger becomes a gripper open-close signal^[5]. That is the whole bridge: a human hand compressed to one pose and one aperture number, replayed on a two-fingered gripper. The 2–3x penalty above is what survives that retargeting — and note it is measured against a parallel gripper, the easy case; a five-fingered dexterous hand has no such two-number summary, so the mapping problem grows with the hand.)

Every skill still needs an anchor

Whatever the pretraining diet, one ingredient appears in every published system: a small dose of data collected on the actual robot, doing the actual task. Call it the anchor. In Dyna-2’s case it is ten hours or less per task^[5]; in the published record, no demonstrated precision skill — millimeter insertion, latch opening, careful placement — appears without one.

The anchor has two awkward properties. It doesn’t transfer: ten hours of lockbox data buys lockbox opening, not shirt folding — a pianist who must practice ten hours for every new song, on every piano separately. Scale doesn’t replace it, but scale works through it: Dyna-2’s lockbox task, with its anchor held fixed, scores 0% when the video corpus is 100,000 hours and 90% at a million^[5]. (Ten-trial evaluations, note — 0/10 and 9/10 — but this jump is large enough to survive even the measurement section’s strictures: Fisher’s exact test puts it at p ≈ 10⁻⁴.)

The anchor, then, is not a nuisance to optimize away; it is a structural residue — the slice of the skill that only the robot’s own body, in the actual task, can supply. Which suggests the right engineering question: not how to delete the anchor, but how to make it dynamic — collected, refreshed, and grown by the deployed system’s own operation instead of gathered once per task and frozen. That is the direction experience-based recipes already point: RECAP-style training on a policy’s own rollouts and corrections is, in effect, an anchor that maintains itself^[48].

The anchor’s sharpest live test arrived as this essay was being revised. Generalist’s GEN-1.5 reports one-shot in-context learning: show the robot a single 3-to-12-second demonstration and it attempts the task with no gradient updates — 59% (±10%) average success across ten tasks, rising to 83% (±9%) after ten gradient steps on five minutes of data — built on the wearable-gripper data engine behind GEN-1^[21],[49]. Read against this section: the anchor did not vanish, it shrank. A per-task demonstration is still required; the tasks are, in Generalist’s own words, “simple and short-horizon,” the rates “modest,” and in-context skills “more brittle than finetuned models”^[49]. But an anchor that fits in twelve seconds is an anchor turning into a prompt — the dynamic-anchor direction above, arriving faster than expected. If in-context robot learning scales the way in-context language learning did, the second watch item below starts to fall.

And is the embodiment gap at least closing with scale? Unknown. The published curve rests on four corpus sizes; fit it, ask where human-video pretraining matches robot-native performance, and the statistically consistent answers run from ten million hours to roughly 10¹⁷ — the latter several times more than all the hours humanity has ever lived (about 3×10¹⁶)^[50]. That is not a forecast; it is a shrug with error bars. Treat any “N billion hours to human-level” headline accordingly.

(The one visible exit from purpose-built collection is exhaust — robots minting data as a byproduct of paid work, a flywheel that already exists in miniature^[48] — but exhaust begins only once a robot is worth deploying, which is exactly the bootstrap this section describes.)

The measurement problem: proxies lie and trials cost

The statistical problem says the signal is bad; the record at scale says more of the same signal does not fix it. The third problem is quieter: in robotics, even knowing whether you improved costs money — and the cheap substitutes mislead.

Clean curves on the wrong metric

The curves that look LLM-clean live on proxy metrics. Xiaomi’s robot foundation model, pretrained on 100K+ hours of handheld-gripper data, reports validation action error falling steadily across its controlled data- and model-size runs, which use subsets of that corpus — a genuinely Chinchilla-shaped curve^[22]. But validation error is an open-loop number — in Claim 4’s notation, an average over d_expert, while the thing you care about lives on d_π̂. And the in-distribution version of the number separates models remarkably poorly: TRI’s co-training study found its gains in generalization tests, with in-distribution scores largely unmoved^[6], and Dyna-1 and Dyna-2 both pass “at close to 100%” on in-house evaluations — then land at 46% versus 87% at customer sites^[5].

Whether the proxy predicts a working robot is exactly the question — and the sharpest answer on record comes from autonomous driving, where a 30,000-hour study fit a near-perfect open-loop power law (correlation −0.963) and then reported plainly that the relationship does not hold in closed-loop evaluation, where the model actually drives^[47]. The curve was real; the capability it implied was not. (Claim 4’s test showed the same divergence in miniature: a 31% open-loop improvement, zero closed-loop gain.) One honest complication: driving’s verdict is contested — a Waymo study on 500,000 hours reports that closed-loop metrics improve with scale too^[51]. Read the divergence as a standing hazard of the proxy, not a law that closed-loop cannot scale.

Testing is the hidden tax

Beneath the proxy problem sits a brute-force one. Measuring a language model is nearly free: an evaluation is a script — thousands of questions, minutes, pennies, repeatable. A robot evaluation is a physical event: stage the scene, run the policy, watch it succeed or drop the cup, reset, repeat, with a human standing there throughout.

And closed-loop is the only evaluation that counts, because a policy — unlike a chatbot benchmark — generates its own test distribution. Each small error moves the robot into a state slightly outside the demonstrations, where it errs a bit more, producing a stranger state still. Imitation theory prices this compounding:

J_expert − J(π̂) = O(δ · T²)

— read: if the learned policy errs with probability δ per step on the expert’s states, its shortfall over a task of T steps grows not like δT (errors adding up) but like δT² — because one error at step t can poison all remaining T − t steps, and there are ~T opportunities to make it^[52]. (This is the imitation literature’s classic O(εH²) compounding bound, with H the horizon — restated in δ and T because this essay has already spent ε on the demonstrator’s tremor and H(·) on entropy; it is proved for discrete actions with 0–1 loss, so treat the continuous-control version as directional.) That quadratic is provably a worst-case lower bound for any offline method, not an artifact of weak algorithms — the missing information is recovery behavior, which demonstration datasets don’t contain^[53].

The known escape routes map onto the field’s current agenda. Losses that learn calibrated distributions instead of point estimates can cancel the penalty in forgiving environments^[54]. That is part of why language models degrade gracefully where regression-trained policies snap: they train with log-loss, on a medium full of written self-correction. And training on the policy’s own rollouts plus corrections closes the distribution gap directly — Physical Intelligence’s RECAP recipe, which reports roughly halved failure rates on its hardest tasks^[48].

How many closed-loop trials does a trustworthy verdict need? The statistics are unforgiving. The uncertainty of a measured success rate shrinks only with the square root of the trial count:

N ≈ p(1−p) · (1.96 / w)²

— read: to pin a true success rate p inside a margin of ±w with 95% confidence, you need roughly that many trials; at p = 0.9 and w = 0.02 the estimate is ~860, and the exact binomial (Clopper-Pearson) interval pushes it to ~1,030^[55],[56]. I checked what this means at the field’s actual sample sizes^[29]:

Setup. Two simulated policies with true success rates 80% and 75%. “Evaluate” each with N trials, declare the higher scorer better, repeat the comparison 40,000 times, count wrong verdicts.

Result. At N=10 per policy — inside the field’s published range, where evaluations run “N ≤ 25 rollouts per condition, almost always without confidence intervals”^[57] — the verdict is wrong or tied about half the time. At N=20, 42%. At N=100, still 22%.

Conclusion. At the field’s typical sample sizes, a claimed 5-point improvement is close to a coin flip. Doing it properly costs a day of robot time per comparison, versus seconds for an LLM benchmark. Scaling ran on fast iteration; robotics pays a toll at every lap.

The price of a trustworthy verdict. Two simulated policies with true success rates 80% and 75%, each judged by N trials, 40,000 repeated comparisons. At the field’s typical N ≤ 25, the ranking is close to a coin flip.

Simulation partially works: the SIMPLER benchmark reproduces real policy rankings at correlation r=0.924^[58], and automated cells now run real-robot evaluations without a human^[59]. But SIMPLER’s own scope statement limits its tasks to “largely rigid body objects whose dynamics can be reasonably well-approximated by modern physics simulators”^[58]. Rigid objects are the tasks where the least information is missing. Where the inputs are most incomplete — manipulation of arbitrary, unsensed objects — the simulator escape closes too.

So why is action the exception?

Because three problems stack, and each would be survivable alone.

The signal is worse. Action prediction is an upstream question: it must guess decisions at the moment they are made, before their consequences appear in any observation. Its floor B_A is high — hidden intent, style, tremor — and on training data, that undetermined share invites shortcuts and gets memorized. That is why, on identical data, the action head overfits and the visual head — downstream of every decision, behind its thick momentum cushion — visibly doesn’t: measured against its own tiny ceiling, even the vision head carries the same gap (Claim 3); the cushion hides it.

More data, by itself, does not fix it. The field’s own record matches the rig: same-condition volume saturates or overfits; gains follow condition diversity, because only shared structure can be absorbed; human video arrives with a ~3x embodiment discount; and a per-task anchor survives every corpus size yet published.

The measurement is blind or expensive. The metrics that scale most cleanly are open-loop proxies averaging over the wrong distribution — and where closed-loop scaling has been measured at all, the verdict is still contested; the evaluation that counts is physical, slow, and statistically hungry — and the compounding-error arithmetic (δT²) means small per-step differences matter enormously, precisely where measurements are noisiest.

And the three are at their worst together where the most information is missing — manipulation of arbitrary objects, where forces, materials, and intent are all off-camera at once. Notice what’s absent: no impossibility, no paradox, no missing genius. Just a signal-quality problem, a price list, and a measurement gap. That is the optimistic reading. Paradoxes don’t yield to engineering; problems do — noise can be modeled, shortcuts regularized away, prices fall on published curves, and better evaluators are an engineering project already underway.

If you train these models

The diagnosis converts to practice directly; each habit below is a result from above, turned around to face your own training run.

• Measure your floor before you scale. Estimate the local spread of action labels at matched inputs — the direct measurement that put the rig’s floor at B_A ≈ 0.29^[29]. Training error below the floor is memorization by definition; progress is validation error closing on the floor, not training error sinking under it.
• Lower H(a|o) at the source. Debias operator styles^[30], and prefer action targets further from the raw tick — the chunked and trajectory-level targets the field’s strongest policies already use^[4]. (The rig’s version — executed velocity instead of raw command, a threefold drop from 0.62 to 0.22 — is an open-loop number by the standards two bullets down; read it as mechanism evidence, not a capability claim.)
• Never train the action head alone. Co-train the backbone on video or vision-language data^[5],[6] and insulate it from raw action gradients^[45] — robot-only training measurably erodes it^[6].
• Spend collection budget on conditions, not repetitions. Demonstrations per environment saturate around fifty while generalization follows a power law in environments and objects^[44] — and the diversity that pays most is unglamorous: camera poses and spatial arrangements^[46].
• Budget the anchor in, not out. The published record shows no precision skill demonstrated without per-task on-robot data, and scale works through the anchor, not around it^[5] — so plan for the anchor as an input, or better, design it to refresh itself through deployment.
• Read validation action error as a debugging tool, never a capability claim. It averages over d_expert, not d_π̂: the rig’s 31% open-loop improvement bought zero closed-loop gain, and driving’s near-perfect open-loop power law (r = −0.963) did not survive handing the model the wheel^[47] — though Waymo’s larger study contests that verdict^[51], so treat the divergence as a hazard to test for, not a certainty either way.
• Buy verdicts at their real price. Pinning a 90% success rate inside ±2 points takes ~1,030 trials^[55],[56]; at N=10, inside the field’s typical N ≤ 25^[57], a 5-point improvement is close to a coin flip. Claim only what your trial count supports.

None of this solves the bottleneck; it is what respecting it looks like.

What to watch

Signals that would mean this picture is breaking:

1. An action-only model that scales cleanly — no video co-training ballast, no gradient insulation — would mean the statistical problem has been solved at the objective level, not patched.
2. An anchor-free precision demo: millimeter-tolerance work with zero task-specific robot data. No published system has done it; the day one does, the per-task line item starts dying.
3. Human-video corpora reaching ~10 million hours, where the competing theories of the embodiment gap separate measurably^[50]. Dyna already calls its million hours “only the beginning” of that axis^[5].
4. A simulator that ranks policies correctly on cloth or deformables — the result SIMPLER’s authors scope away from today^[58].
5. An anchor that maintains itself — a deployed system whose per-task on-robot data is collected and refreshed by its own operation rather than gathered once and frozen. The moment the anchor becomes a byproduct of use, the last per-task requirement starts to dissolve.

One caveat to carry: the load-bearing 2026 numbers here — Dyna-2’s, GEN-1’s — are self-reported by the labs that produced them, and nobody can independently replicate a million-hour training run. I’ve verified what the sources say; whether it reproduces is a different question. That uncertainty is, fittingly, the measurement problem again — and it’s the part of this essay I expect to age fastest.