Skip to content

Posts

The work in the order it happened, one post per phase: contributions, experiments and negative results. Each number links back to the experiment log; nothing was rewritten after the fact.

Series

Papers tested

  1. fail LeWorldModel 2026-10-23
    Their rig: Push-T, OGBench-Cube, Reacher, Two-Room (sim); one GPU (model not stated) → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  2. fail DINO-WM 2026-10-23
    Their rig: PointMaze, Push-T, Wall, Reacher (sim), XArm rope / granular in NVIDIA Flex; A6000 GPU → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  3. fail RoboJEPA 2026-10-23
    Their rig: Franka Panda (DROID stack), CEM planning on a multi-GPU cluster; RoboCasa sim → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  4. fail H-JEPA 2026-10-23
    Their rig: FourRoom, Visual AntMaze, Push-T, OGBench-Cube (sim); DROID video scored offline → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  5. not tested D-JEPA 2026-10-23
    Their rig: Push-T, Reacher, Granular, RoboTwin (sim); AgileX PiPER arm with a V-JEPA 2-AC planner → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  6. fail ContactGuard 2026-10-23
    Their rig: AgileX Piper dual-arm (14-DoF), three RGB cameras; RTX 5090 → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  7. fail FAIL-Detect and SAFE 2026-10-23
    Their rig: bimanual Franka Panda station (FAIL-Detect); Franka Panda + WidowX (SAFE); A100 GPUs → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  8. fail ReAP 2026-10-23
    Their rig: LIBERO-10, RoboTwin (sim); two AgileX PIPER arms, π0.5 on a remote server, RTX 4070 detector → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  9. fail VLA-Corrector 2026-10-23
    Their rig: LIBERO and LIBERO-Plus (sim, Franka Panda); real robot not named → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  10. fail Robometer 2026-10-23
    Their rig: 21 embodiments, training hardware not stated in the text; RL on a DROID Franka Panda → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  11. reproduces SmolVLA 2026-10-23
    Their rig: SO-100 / SO-101 arms; pretraining on 4 GPUs (~30k GPU-hours) → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  12. withdrawn TurboVLA 2026-10-23
    Their rig: LIBERO and RoboTwin 2.0 (sim) on an RTX 4090; real: AgileX Piper → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  13. reproduces VLA-JEPA 2026-10-23
    Their rig: LIBERO, SimplerEnv (sim); real: Franka Research 3; trained on 8× A100 → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  14. reproduces REKI 2026-10-23
    Their rig: RoboTwin (sim, AgileX ALOHA); real: UR5 + WSG50; pretrained on 32× H100 → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  15. not proven Real-Time Chunking 2026-10-23
    Their rig: two 6-DoF arms with parallel grippers (arm model not named); π0.5, RTX 4090 inference; Kinetix sim → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  16. not proven HWM (hierarchical latent world models) 2026-10-28
    Their rig: Franka Emika Panda + Robotiq; ~130 h DROID/RoboSet → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  17. reproduces LeJEPA identifiability 2026-10-29
    Their rig: DMC Reacher (simulation) → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  18. fail SURVEYOR 2026-10-29
    Their rig: simulation only (PushT, Reacher, OGBench-Cube, Two-Room) → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  19. fail Adaptive Action Chunking (AAC) 2026-10-30
    Their rig: Realman arm + Mycobot gripper; A800 → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  20. fail PACT-VLA 2026-10-30
    Their rig: bimanual AgileX PiperX, three RealSense cameras; π0.5 on RTX 5090 / H100 / RTX Pro 6000 → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  21. not proven Horizon × depth (Euler steps vs execution horizon) 2026-10-30
    Their rig: Franka Research 3 with a ZED 2i (real); π0 / π0.5 / GR00T on A100s (LIBERO, RoboTwin 2.0 sim) → ours: SO-101 + Jetson Orin NX, ≈ €1,350
  22. fail REMORA 2026-10-31
    Their rig: AgiBot G02, head + 2 wrist cameras, 30 Hz; 8 × H200 → ours: SO-101 + Jetson Orin NX, ≈ €1,350

Engineering on the Orin

  1. engineering LeRobot on a Jetson: why there is no pip install torch, and what it took 2026-09-09
  2. engineering ACT and SmolVLA on an SO-101: a 10-trial evaluation harness on a €350 arm kit 2026-09-29
  3. engineering SmolVLA on a Jetson Orin NX: 974 → 238 ms per chunk with vla.cpp 2026-10-01
  4. engineering Twelve VLAs on a Jetson Orin NX: latency and memory with vla.cpp 2026-10-06
  5. engineering Porting ACT to vla.cpp, so a Jetson can run it without PyTorch 2026-10-12
  6. engineering Why your VLA's actions jump at every chunk boundary on real hardware, and a 0.4 ms fix 2026-10-25
  7. method p99 is not a tail: latency numbers that lie about chunked policies 2026-10-26
  8. engineering A correctness fix upstream made my checkpoint 47 % worse 2026-10-26

Evaluation and judges

  1. method Judging robot rollouts automatically: a success detector with zero false positives 2026-10-16
  2. method Verify at rest: six mid-episode monitors fail in one day 2026-10-19
  3. method Judging, part 2: the input format did the work 2026-10-20
  4. method Latent distance is not progress 2026-10-14
  5. method What the world model is actually for 2026-10-17
  6. correction Two gates I voided, and the two-line check that would have caught them 2026-10-22
  7. design v1.5: the station as a harness for a coding agent 2026-10-22
  8. engineering Training a JEPA world model on SO-101 data for $3.30 2026-10-11
  9. method World-model planning on an SO-101: the commanded joints win (0.90 vs 0.60) 2026-10-13
  10. correction TurboVLA: a policy that ignored its instruction 2026-10-08
  11. engineering VLA-JEPA on the Orin for $9.7, and why best-of-N reranking is a no-go 2026-10-08
  12. method Audit your labels where they matter: a VLM labeller that is right on average 2026-10-26
  13. method How I re-test robot-learning papers: the gate protocol as it ran 2026-10-29
  14. method VLA-JEPA's surprise as a failure warning: a robot day with nothing to warn about 2026-10-29

REMORA

They said reading progress at the peak nearest the last estimate keeps it steady and lets it fall after setbacks. On 34 of our recorded runs we compared it with simpler readouts of the same evidence. It did not hold: it cut changes to 0.70 of the simplest readout, not half, and missed most setbacks.

Stage flips per run, relative to argmax (lower is better): per-frame argmax 1.00×; REMORA readout 0.70×; bar: halvedper-frame argmax1.00×REMORA readout0.70×bar: halved

Papers tested · 22 of 22

Goal (the paper's): Track task progress through errors and recovery: a progress distribution from a frozen-VLM backbone with a per-camera recurrent memory, trained against a target that falls inside error intervals, read out causally at the peak nearest the previous estimate; shown on ReSTEP (AgiBot G02, two logistics tasks).

Its hypotheses:

  • Picking the supported peak nearest the previous estimate tracks progress through errors better than a per-frame readout. (§3.3 (Eq. 3); Table 2 (A5)) fail
  • A recurrent memory beats an explicit window of past frames. (Table 2) not tested here
  • REMORA tracks progress better than SARM. (Table 2) not tested here

Verdict: fail · Claim tested: Reading a progress distribution out at the supported peak nearest the previous estimate steadies the estimate and lets it fall during real setbacks, with no worse detection of the stages. · Bar: Against per-frame argmax: premature not higher and missed ≤ +2 points (P1); flips halved, CI upper ≤ 0.7 (P2); a decrease inside ≥ 50 % of the reversal windows with ≤ 20 % false regressions (P3). · n: 34 test episodes of the 69 rollouts, 7 reversal windows

Theirs vs ours: D2 (25 error episodes): peak selection vs the median readout MAE 6.04 → 3.31 (×10⁻²), Spearman 0.870 → 0.959 vs premature 0.22 vs 0.25, missed equal (P1 pass); flips 0.70 × argmax, CI 0.48–0.94 (P2 fail); setback recall 2/7, false 0.52 (P3 fail); MAE 0.184 vs median 0.218 · Not proven: Three progress atoms from hand-written evidence, not a learned 201-bin distribution; the reversal windows are a mechanical criterion, not human error labels; the recurrent memory and the backbone are not tested.

Paper: arXiv 2610.39125 · Code: no code link found

Claims:

  • fail nearest-peak progress readout below per-frame progress readout on readout flips per episode — theirs MAE 6.04 → 3.31 (×10⁻²) vs the median readout · ours flips 0.70 × argmax (CI 0.48–0.94); setback recall 0.29 (2/7), false regressions 0.52 (paper §3.3 and Table 2 (peak selection vs median readout on the error task))
  • not tested recurrent progress memory below explicit frame window on progress MAE — theirs MAE −3.3 %, curvature error −14 % (paper Table 2 (MAE −3.3 %))
  • not tested REMORA progress model below SARM reward model on progress MAE — theirs lower MAE and smoother on both tasks (paper Table 2)

Compute: External GPU: no. Orin NX CPU (feature extraction in the lerobot-jetson container). Cost: $0. · Reproduce: 2026-10-31-paper-vs-hardware-remora-readout · First published: 2026-10-31 · Updated: 2026-10-31

Tracking Task Progress Through Errors and Recovery (Wang, Niu, Zhu et al., arXiv 2610.39125) argues that a progress estimate should be able to go backwards: when the robot drops the object, progress should fall, then recover. Its model needs eight H200s. Its readout rule does not, so I tested the rule on the 69 rollouts this rig already has.

Adaptive Action Chunking (AAC)

They said a robot policy can pick each motion chunk's length from how much 20 samples disagree. On recorded runs and on the robot's computer we checked the chosen lengths and the cost. It did not hold: lengths mostly stayed at the minimum, and one decision took 4,751 ms.

One 20-sample decision, ms (lower is better): paper (A800) 106 ms; Orin (sequential) 4,751 ms; bar 298 mspaper (A800)106 msOrin (sequential)4,751 msbar 298 ms

Papers tested · 19 of 22

Goal (the paper's): Choose each action chunk's length at inference from how much N sampled chunks disagree, so a VLA commits to long chunks where it is confident and short ones where it is not; shown on RoboCasa, LIBERO and three real tasks.

Its hypotheses:

  • The entropy-chosen chunk length follows the task's phases: long in transport, short near the grasp. (Fig. 3–4) fail
  • Adaptive chunks raise success over fixed chunks in simulation and on a real arm. (Tables 1–3; Table 5 (real world 67.0 → 82.0 %)) not tested here
  • Sampling N chunks in a batch adds little cost: negligible below N = 10, about 20 ms at N = 20. (Table 4 (A800)) fail

Verdict: fail · Claim tested: Chunk length chosen from the entropy of N sampled chunks follows the task's phases (long in transport, short at the grasp), lowers the boundary jump, and costs little with batched sampling. · Bar: median h in transport ≥ grasp window + 2; jump with AAC + overwrite ≤ fixed + overwrite at d = 8; an N = 20 decision ≤ 298 ms on the Orin. · n:* 254 decisions on 20 recorded episodes; 10 timed decisions per N

Theirs vs ours: h follows the semantic phases (Fig. 3–4); real world 67.0 → 82.0 %; N = 20 costs 106 ms vs 83 ms on an A800 ("about 20 ms inference delay"; negligible below N = 10) vs h 2 in transport and 2 at the grasp (86 % of decisions at the floor); jump 0.973 vs 0.940; N = 20 decision 4,751 ms (sequential) on the Orin · Not proven: No arm run (the bowls task is at ceiling for SmolVLA); vla.cpp has no batched sampler, which would change the cost but not the entropy rule.

Paper: arXiv 2604.04161 · Code: no code link found

Claims:

  • fail entropy-chosen chunk length above grasp-window chunk length on median chunk length h in transport — theirs long in transport, short at the grasp · ours 2 vs 2 (paper Fig. 3–4 (h follows the semantic phases))
  • fail AAC with prefix overwrite at most fixed chunk with prefix overwrite on median boundary jump — theirs no boundary-jump measurement; real-world success 67.0 → 82.0 % (Table 5) · ours 0.973 vs 0.940 (paper §1 and Fig. 6 (qualitative; no boundary metric))
  • fail N-sample decision at most pass mark on ms per decision on the Orin NX — theirs 106 ms (A800, batched) · ours 4,751 ms (paper Table 4 (N = 20: 106 ms vs 83 ms on an A800, "negligible"))

Compute: External GPU: no. Gate 0 on the Orin NX at 25 W (PyTorch, ~3 h); gate 1 on the Orin at MAXN_SUPER + jetson_clocks (vla.cpp). Cost: $0. · Reproduce: 2026-10-30-paper-vs-hardware-adaptive-chunking · First published: 2026-10-30 · Updated: 2026-10-30

Adaptive Action Chunking at Inference-time for VLA Models (AAC; Liang et al., CVPR 2026, arXiv 2604.04161) lets a flow-matching policy choose each chunk's length from how much N sampled chunks disagree. SmolVLA is a flow-matching policy, so the rule applies to my SO-101 as written.

Horizon × depth (Euler steps vs execution horizon)

They said a robot that commits to long motion chunks can use 2 sampling steps instead of 10. On our arm's computer we measured how tightly 2 steps group the planned motions, and the time saved. Not proven: on 20 frames, 2 steps kept 0.78 of the 10-step spread (paper: 0.51) and saved 41 ms.

Spread with 2 steps, as a share of 10 (lower = tighter): paper (π0) 0.51; this rig (SmolVLA) 0.78; bar 0.70paper (π0)0.51this rig (SmolVLA)0.78bar 0.70

Papers tested · 21 of 22

Goal (the paper's): Show that, for frozen flow-matching VLAs, the effect of cutting Euler steps depends on how long the robot commits to a chunk: fewer steps hurt under frequent replanning and help under long open-loop commitment; shown on LIBERO, RoboTwin 2.0 and a real Franka.

Its hypotheses:

  • Few Euler steps contract the sampled action cloud around an unchanged centroid. (Proposition 1; §III-D) not proven
  • Under long open-loop commitment, two steps match or beat ten while cutting inference time. (Table I; Fig. 3; latency figures) reproduces
  • Two steps avoid thermal throttling on edge GPUs. (§IV (end): 0.04 NFE per step; asserted, no thermal measurement) not tested here

Verdict: not proven · Claim tested: With long open-loop commitment, cutting a flow-matching VLA's Euler steps from 10 to 2 contracts the action cloud around an unchanged centroid, saves most of the inference time and avoids edge-GPU thermal throttling. · Bar: median R(2)/R(10) ≤ 0.70 with the centroid within 0.05 relative and 3°; N = 2 latency ≤ 0.85 × N = 10 on the Orin, N = 10 within 5 % of 238 ms. · n: 20 frames × 32 draws; 50 timed chunks per N; 2 × 10 min thermal per power mode

Theirs vs ours: R(2)/R(10) 0.51, centroid shift 3.2 %; 14.3 → 2.6 ms per step (A100); "eliminating edge GPU thermal throttling" vs R(2)/R(10) 0.78 (CI 0.73–0.81), centroid 0.018 and 2.35°; 196.1 vs 237.5 ms per chunk (0.83, vision 151 ms); no throttling at N = 10 on the Orin, at MAXN_SUPER or 25 W · Not proven: The contraction is between the bar and the fail line, so the arm gate (success at N = 2 vs 10) is not run; one policy, one task.

Paper: arXiv 2610.32102 · Code: no code link found

Claims:

  • not proven two Euler steps below ten Euler steps on action-cloud radius — theirs R(2)/R(10) 0.51 · ours R(2)/R(10) 0.78 (paper Proposition 1; §III-D (R(2)/R(10) = 0.51 on π0))
  • reproduces two Euler steps below ten Euler steps on ms per chunk on the Orin NX — theirs 14.3 → 2.6 ms per step · ours 196.1 vs 237.5 ms (paper Table I (14.3 → 2.6 ms per control step, A100))

Compute: External GPU: no. A1 on the Orin NX at 25 W (PyTorch); A2 and A4 at MAXN_SUPER + jetson_clocks and at 25 W (vla.cpp). Cost: $0; A2 and the MAXN half of A4 re-run once. · Reproduce: 2026-10-30-paper-vs-hardware-horizon-depth · First published: 2026-10-30 · Updated: 2026-10-30

Coupling Execution Horizon and Sampling Depth in Flow-Matching VLA Policies (Yang et al., arXiv 2610.32102) says that when a robot commits to a long chunk, two Euler steps are as good as ten and much cheaper. My SO-101 already runs SmolVLA with its whole 50-step chunk committed, so the claim lands on its default setting.

PACT-VLA

They said choosing among several motion chunks with the newest camera frame adds no delay. On recorded runs we tested the choice, and on the robot's computer the delay. The choice helped, but a full cycle took 1,200 ms, 37 control ticks instead of 8.

Delay in control ticks (lower is better): naive async 8 ticks; PACT 37 ticks; bar ≤ naivenaive async8 ticksPACT37 ticksbar ≤ naive

Papers tested · 20 of 22

Goal (the paper's): Under asynchronous execution, sample several candidate chunks and keep the one the frozen policy finds most consistent with the newest observation before the switch, with no verifier to train and no added control-step delay; shown on Kinetix, LIBERO and a bimanual PiperX.

Its hypotheses:

  • Selecting by flow residual under the pre-commit observation picks better chunks than a random pick or the stale observation. (Appendix D.2; Fig. 4) reproduces
  • The selection adds no control-step delay, because the extra pass overlaps with execution. (§3 (pipelining), Table 4) fail

Verdict: fail · Claim tested: Picking among N sampled chunks by their flow residual under the pre-commit observation fits what happens next better than a random or stale pick, with no added control-step delay. · Bar: PACT beats a random pick and the stale-observation residual at d = 8 (CIs < 0); its delay on the Orin ≤ the naive delay; at that delay it still beats a single sample. · n: 20 episodes, 254 boundaries per delay

Theirs vs ours: bimanual PiperX 82.0 % vs naive async 60.0 %; no added control-step delay on the evaluated GPUs (generation 35–49 ms, with verification 59–65 ms, both d = 2 at 30 Hz, Table 4) vs offline −0.27° vs random and vs the stale residual (both CIs < 0); on the Orin 1,200 ms per cycle, 37 control ticks vs 8 · Not proven: The verification time is projected (vla.cpp has no velocity query); at the measured delay a 50-step chunk cannot fill the executed window, so the transfer clause is not computable; no arm run.

Paper: arXiv 2610.28019 · Code: no code link found

Claims:

  • reproduces PACT selection below random pick on executed-window error — theirs +0.44 points over random (Kinetix); 82.0 vs 60.0 % (PiperX) · ours −0.27° error vs a random pick (CI −0.44 to −0.09) (paper Appendix D and Fig. 4)
  • fail PACT cycle equals naive async cycle on control-step delay — theirs no added delay · ours 37 ticks vs 8 (paper ("no added control-step delay" on the evaluated hardware; Table 4: generation 35–49 ms, with verification 59–65 ms, both d = 2))
  • reproduces PACT cycle above naive async cycle on control-step delay · ours 37 ticks vs 8 (our measured comparison)

Compute: External GPU: no. Gate B on the Orin NX at 25 W (PyTorch); gate A on the Orin at MAXN_SUPER + jetson_clocks. Cost: $0. · Reproduce: 2026-10-30-paper-vs-hardware-pact · First published: 2026-10-30 · Updated: 2026-10-30

PACT-VLA: Speculative Action-Chunk Verification with Pre-Commit Observations (Zhu et al., arXiv 2610.28019) samples several chunks and keeps the one the policy itself finds most consistent with the latest frame before the switch, "with no added control-step delay". The selection works on my recorded episodes. The delay is where it breaks on a Jetson.

LeJEPA identifiability

They said a world model trained on goal-directed runs recovers the true robot state only partly and unevenly. On our arm we compared its internal numbers with the joint angles the arm logs. It held: it explained 0.565 of the joints' variance on average, 0.91 at the shoulder, 0.27 at the wrist.

Joints read from the latent, mean R²: W1 (LeJEPA) 0.565; frozen DINOv2-S 0.867; bar < 0.80W1 (LeJEPA)0.565frozen DINOv2-S0.867bar < 0.80

Papers tested · 17 of 22

Goal (the paper's): Derive the conditions under which a JEPA trained with SIGReg recovers the true latent state of the system, and show where goal-directed data breaks that recovery.

Its hypotheses:

  • On goal-directed trajectory data, recovery of the true state is partial and anisotropic. (§6.2, Table 2 (DMC Reacher trajectories)) reproduces
  • Under an isotropic random walk the latent recovers the state up to a linear map. (§5.1, Theorem 1; §6.2, Table 2 (OU pairs R² = 0.95)) not tested here

Verdict: reproduces · Claim tested: A SIGReg JEPA trained on goal-directed data recovers the true latent state only partially and unevenly. · Bar: W1's mean R² from latent to joints < 0.80; anisotropy (max − min per-joint R²) ≥ 0.20; the higher-R² model has the higher G1b top-1. · n: 8 447 validation frames, 25 episodes; 2 models

Theirs vs ours: anisotropic recovery on trajectory data, identifiable under isotropic random walks (simulation) vs W1 mean R² 0.565, anisotropy 0.639 (shoulder lift 0.91, wrist flex 0.27); frozen DINOv2-S 0.867 / 0.301 · Not proven: The random-walk side (gate 1: random-walk data on the arm and a retrain) is not run; B3 compares two models.

Paper: arXiv 2605.26379 · Code: no code link found

Claims:

  • reproduces SIGReg JEPA latent below pass mark on latent-to-joints R² — theirs anisotropic recovery on trajectory data (simulation) · ours 0.565 (paper §6.2, Table 2)
  • reproduces SIGReg JEPA latent at least pass mark on per-joint R² anisotropy — theirs anisotropic (simulation) · ours 0.639 (paper §6.2, Table 2)
  • not tested SIGReg JEPA latent equals pass mark on latent-to-joints R² — theirs identifiable (simulation) (paper §5.1 Theorem 1; §7)

Compute: External GPU: no (Orin NX). Cost: $0. One extraction redone after a red-channel bug. · Reproduce: 2026-10-29-paper-vs-hardware-lejepa · First published: 2026-10-29 · Updated: 2026-10-29 · Findings: A one-timestamp indexing bug, found by a consistency check →

When Does LeJEPA Learn a World Model? (Klindt, LeCun, Balestriero; arXiv 2605.26379) asks when a SIGReg JEPA's latent recovers the true state of the system. A robot arm logs that state for free: the joint positions. So on my SO-101 I can measure directly what the paper could only measure in simulation.

SURVEYOR

They said a fixed distance threshold between imagined and reached states accepts good plans and rejects bad ones. On 69 real runs we measured that threshold in our world model. It did not hold: the threshold here is 1.249, not their 0.20, and it caught 3/8 failures.

Equivalence threshold τ (lower is better): paper 0.200; this rig 1.249; bar 0.40paper0.200this rig1.249bar 0.40

Papers tested · 18 of 22

Goal (the paper's): Let a latent-world-model planner consume drafted subgoals speculatively, accepting each step while the imagined and reached latents stay within a calibrated threshold; shown in simulation (PushT, Reacher, OGBench-Cube, Two-Room).

Its hypotheses:

  • A threshold calibrated on task-equivalent state pairs (τ = 0.20) separates acceptable from unacceptable plan steps. (method and experiments) fail
  • The accept rule keeps good drafted plans and rejects bad ones. (experiments) fail

Verdict: fail · Claim tested: A threshold on the imagined-vs-reached latent distance accepts good plans and rejects bad ones (τ = 0.20). · Bar: τ below the 10th percentile of non-equivalent pairs and ≤ 0.40; as a monitor ≥ 5/8 failures at ≤ 2/42; ≥ 0.05 AUROC over a shuffled drafter. · n: 69 rollouts (primary 50: 42 successes, 8 failures)

Theirs vs ours: τ = 0.20 in simulation (PushT, Reacher, OGBench-Cube, Two-Room) vs τ = 1.249 on W1 latents of 69 real rollouts; as a monitor 3/8 at 6/42 (S = 30), AUROC 0.756 vs shuffled 0.560 · Not proven: FF-JEPA's diffusion drafter is not available (W1's own imagination stands in); no closed-loop planning.

Paper: none (NeurIPS 2026 workshop) · Code: no code link found

Claims:

  • fail latent accept threshold at most pass mark on accept threshold τ — theirs τ = 0.20 · ours τ = 1.249 (paper, τ = 0.20 (simulation))
  • fail latent accept rule at least pass mark on failures caught — theirs simulation only · ours 3/8 at 6/42 (paper (accepts good plans, rejects bad ones))

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-29-paper-vs-hardware-surveyor · First published: 2026-10-29 · Updated: 2026-10-29

SURVEYOR (Certified Speculative Plan Consumption for Latent World-Model Planning, a NeurIPS 2026 workshop paper) accepts a drafted plan step when the latent the world model imagined and the latent actually reached are close enough. Its encoder is the one released with LeWorldModel, the same recipe as my W1, so the accept rule can be tested on real rollouts.

How I re-test robot-learning papers: the gate protocol as it ran

We wanted to know how our gate loop actually ran, not how it was meant to run. We went back over every gate in the log: bar committed, run, verdict, row, recompute folder. Of 74 gates, 20 failed their bar.

Evaluation and judges · 13 of 14

Type: method · Result: Bars committed before the run, a four-word verdict vocabulary, a judge at rest with 0 false positives, separate gos for money and arm time, costs with retries; the v1.5 harness has not run end to end. · n: 74 gates, 16 papers, 55 work-stack items

Not proven: That the protocol catches every error; the v1.5 harness, G24 and the data-engine fields have not run.

Compute: External GPU: no; no new run. Every figure is recomputed from the experiment log, the register and the paper-vs-hardware folders. · Reproduce: – · First published: 2026-10-29 · Updated: 2026-10-29

Every result on this site went through the same loop: write the pass rule down, commit it, run, apply the rule and nothing else, log the row, publish a folder that recomputes the number. That loop has produced 74 gates in the experiment log, and 20 failed their bar. This post is about the loop itself, and only about the parts of it that have actually run.

VLA-JEPA's surprise as a failure warning: a robot day with nothing to warn about

We wanted to know if a policy's own world model is surprised before it fails on the arm. We ran it on sealed layouts, some with the bowls moved, with the bar fixed first. It succeeded on 20 of 20, so there was no failure to warn about.

Evaluation and judges · 14 of 14

Type: method · Result: Not proven: VLA-JEPA completed 20 of 20 sealed layouts (9 off-nominal), so there was no failure for its surprise to warn about. · n: 20 rollouts on the arm, 0 failures

Not proven: Whether VLA-JEPA's surprise warns before a failure; a harder layout set is next.

Compute: External GPU: no (Orin NX, arm). Cost: $0. · Reproduce: 2026-10-29-vla-jepa-surprise-robot-day · First published: 2026-10-29 · Updated: 2026-10-29

VLA-JEPA carries its own world model. If that model is surprised when a grasp goes wrong, the policy could warn about its own failures with no extra network. I set a robot day up to test it, and the policy didn't fail once.

HWM (hierarchical latent world models)

They said a second, coarser world model predicts further ahead than the fine one beyond about one second. On our data we trained both levels and compared their errors up to 2 seconds. Not proven: the coarse level never beat the fine one, with error 0.759 against 0.563 at 2 seconds.

Prediction error at 2 s (lower is better): W1, step by step 0.563; high level, learned 0.759; bar 0.95 × W1W1, step by step0.563high level, learned0.759bar 0.95 × W1

Papers tested · 16 of 22

Goal (the paper's): Plan long manipulation tasks with a two-level world model: a high level over learned macro-actions proposes waypoints, a low level plans primitive actions toward them; shown on a real Franka trained on about 130 hours of DROID and RoboSet.

Its hypotheses:

  • Beyond about one second, the high-level model predicts the future latent better than the low-level model. (Fig. 6 (crossover near 1.25 s)) not proven
  • Learned macro-actions align with the true motion better than a handcrafted delta-pose summary. (Table 4b (cosine 0.88 vs 0.80)) reproduces
  • Hierarchical planning succeeds on real pick-and-place where flat planning does not. (§3.1, Table 1 (70 % vs 0 %)) not tested here

Verdict: not proven · Claim tested: A high-level world model over learned macro-actions beats the low-level model beyond about 1 s (their Fig. 6 crossover). · Bar: Crossover in [1.0, 2.0] s; at 2 s high-level error ≤ 0.95 × low-level; learned macro-actions ≥ net joint displacement on cosine. · n: 700 val anchors, 25 episodes (157 train, ~0.6 h)

Theirs vs ours: low level better up to 1 s, high level from 1.5 s (Fig. 6; ≈ 0.367 vs 0.385 at 2 s, read off the plot); cosine 0.88 ± 0.03 vs 0.80 ± 0.02 vs no crossover: W1 0.382 ± 0.005 → 0.563 ± 0.007, high level 0.769 ± 0.009 → 0.759 ± 0.009 (0.73–2 s); cosine 0.608 ± 0.007 vs 0.551 ± 0.006 · Not proven: Open confound: ~0.6 h of one task vs their ~130 h, so data scale is not separated from the method. Baselines and the overfitting reading are post-hoc.

Paper: arXiv 2604.03208 · Code: kevinghst/HWM_PLDM (minimal implementation on PLDM, linked from the project page)

Claims:

  • not proven high-level world model below low-level world model on latent error at 2 s — theirs 0.367 vs 0.385 at 2 s · ours 0.759 vs 0.563 at 2 s (ratio 1.35) (paper §3.4, Fig. 6 (crossover between 1 s and 1.5 s; ≈ 0.367 vs 0.385 at 2 s, read off the plot))
  • reproduces learned macro-actions at least net joint displacement on cosine to the true macro-action — theirs 0.88 vs 0.80 · ours 0.608 vs 0.551 (paper §3.4, Table 4b (0.88 ± 0.03 vs 0.80 ± 0.02))

Compute: External GPU: yes (vast.ai RTX 3090): ≈ $0.4, including the invalid first run. Latent extraction on the Orin NX: $0. · Reproduce: 2026-10-28-paper-vs-hardware-hwm · First published: 2026-10-28 · Updated: 2026-10-28 · Findings: I need a long-horizon latent predictor →, I need to encode an action chunk →

HWM (Zhang, Terver, Zholus et al., FAIR at Meta / NYU / Mila / Brown; CoRL 2026, arXiv 2604.03208) stacks two latent world models: a low level over primitive actions, and a high level over learned macro-actions that jumps several seconds at once. The figure I could test offline is the one that says when each level wins. On my data the high level never wins, and I can't tell yet whether that is the method or the amount of data.

Audit your labels where they matter: a VLM labeller that is right on average

We wanted to know whether labels that look fine on average are right where a metric needs them. We checked a vision-language labeller's failure onsets, frame by frame, on 5 episodes against the video. The median error was 6 frames, but on retried grasps it was up to +289 frames late.

Evaluation and judges · 12 of 14

Type: method · Result: VLM onsets are +6 frames on median but +110 / +289 on retries; all judge errors were recordings past the reset. · n: 5-episode spot check; 88 rollouts

Not proven: The spot check is n = 5.

Compute: External GPU: no. External API: Gemini onset labels, cents; the judge ran on a Mac. · Reproduce: 2026-10-23-paper-vs-hardware-reap · 2026-10-23-paper-vs-hardware-robometer · First published: 2026-10-26 · Updated: 2026-10-26 · Findings: Audit your labels where they matter →

Two evaluation problems on my SO-101 rollouts had the same shape: the labels were fine on average and wrong exactly where the metric looked.

  • Failure onsets marked by a VLM. The median error was 6 frames, but the error was 110 and 289 frames on the episodes a failure monitor most needed.
  • A deterministic success judge. It missed its accuracy bar, and every one of its errors was a recording that ran past the end of the task.

Neither showed in an aggregate number. Both showed when I looked per failure type and per error.

p99 is not a tail: latency numbers that lie about chunked policies

We wanted to know why our latency numbers showed a fast policy with occasional hiccups. We logged every call's latency and marked where each motion chunk began. Every slow call was a full chunk inference, and the SmolVLA loop was blocked 39 % of each trial.

Engineering on the Orin · 7 of 8

Type: method · Result: For chunked policies p99 is one chunk inference; SmolVLA's synchronous loop is blocked 39 % of each trial. · n: 10 trials per row

Not proven: Synchronous loop only.

Compute: External GPU: no (Orin NX, M1 Mac, arm). Cost: $0. · Reproduce: 2026-09-29-three-policies-so101 · First published: 2026-10-26 · Updated: 2026-10-26 · Findings: p99 is not a tail for chunked policies →

My first gate runs reported select_action latency the usual way: p50 and p99 per trial. For SmolVLA on a Jetson Orin NX, p50 was a few milliseconds and p99 was about a second. That reads like a fast policy with an occasional hiccup.

It is not. Every one of those slow calls was a full chunk inference, on a fixed schedule, and the control loop spent 39 % of every trial blocked on them. For chunked policies, p50 and p99 describe two different operations, not one distribution.

A correctness fix upstream made my checkpoint 47 % worse

We wanted to know if an upstream bug fix changed what our trained checkpoint computes. We ran its world predictor on its own validation data with the old and the fixed code, nothing else changed. Under the fix its loss was 47 % higher, worse on all 25 episodes.

Engineering on the Orin · 8 of 8

Type: engineering · Result: LeRobot's rotary fix raises a legacy checkpoint's world-model loss by 47 % (R = 1.473), worse on 25/25 episodes. · n: 200 windows, 25 episodes

Not proven: One checkpoint, in distribution.

Compute: External GPU: no (Orin NX, ~10 min). Cost: $0. · Reproduce: 2026-10-26-vla-jepa-rope-compat · First published: 2026-10-26 · Updated: 2026-10-26 · Findings: An upstream correctness fix made a checkpoint 47 % worse →

LeRobot fixed a real bug in VLA-JEPA's world predictor: its rotary position embedding was not a rotation. I had a checkpoint trained before the fix. Run under the fixed code, its world-model loss is 47 % higher on its own training distribution, worse on all 25 episodes. The fix is right. The checkpoint was trained around the bug, so the fix silently changes what the checkpoint computes. This post is about checking for that before you upgrade.

Why your VLA's actions jump at every chunk boundary on real hardware, and a 0.4 ms fix

We wanted to know why the arm's commands jump each time a new motion chunk takes over. We measured the jump offline on 254 chunk boundaries, then tried overwriting the new chunk's start. The jump fell to the size of a normal step, at 0.4 ms per chunk on the Jetson.

Jump at the chunk seam cut vs naive async, %: prefix overwrite 71–73 %; bar 50 %prefix overwrite71–73 %bar 50 %

Engineering on the Orin · 6 of 8

Type: engineering · Result: A prefix overwrite cuts the chunk-boundary jump 71–73 % against naive async at +0.4 ms; tuned LeRobot identity is close. · n: 254 boundaries per delay, 20 episodes

Not proven: Task success on the arm is not measured.

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-25-vla-chunk-boundary-jumps · First published: 2026-10-25 · Updated: 2026-10-26 (LeRobot RTC baselines added) · Findings: I need smoother chunk boundaries →, Prefix conditioning in vla.cpp →, Prefix overwrite at chunk boundaries (offline) →

Run a chunked VLA asynchronously on a real arm and the command jumps every time a new chunk takes over. On my SO-101 with SmolVLA, the step at the switch was a median 3.4 times a normal step, and on a test boundary served by the real engine the jump was 58.7°. Against naive async, a gradient-free prefix overwrite inside the denoising loop brings the jump down to the size of a normal step, adds 0.4 ms per chunk on a Jetson Orin NX, and leaves the default path bit-identical. LeRobot's own gradient-free RTC mode, tuned, gets close on the jump; the overwrite's edge over it is no parameter to tune and an exact prefix. It has not been tested for task success on the arm yet. This post covers what I measured, and what I did not.

ContactGuard

They said a world model can predict a failed grasp before contact by imagining the next moments. On our arm we built the same monitor and compared it with the current camera view. It did not hold: imagining scored 0.70, the plain current view 0.82.

ContactGuard probe AUROC: imagined latent 0.70; current latent 0.82; bar 0.85imagined latent0.70current latent0.82bar 0.85

Papers tested · 6 of 22

Goal (the paper's): Detect grasp failures before contact for a chunked policy, by rolling an action-conditioned latent world model forward under the chunk the policy already emitted and reading the imagined latent with a small probe; shown on a dual-arm AgileX Piper with ACT.

Its hypotheses:

  • A probe on the imagined latent after the grasp predicts grasp failure better than a probe on the current latent. (Table 2 (0.98 vs 0.84)) fail
  • The monitor can abort a grasp before contact, without access to the policy. (§3.5 (online pre-contact monitor), §1) not tested here

Verdict: fail · Claim tested: An event-anchored probe on imagined latents predicts grasp failure better than the current latent. · Bar: AUROC ≥ 0.85 and ≥ 0.05 above the current latent. · n: 65 scored rollouts, 21 failures

Theirs vs ours: AUROC 0.98–0.99 imagined vs 0.84–0.92 current over four grasp tasks (Cup 0.98 vs 0.84) vs 0.70 imagined vs 0.82 current · Not proven: Mixed policies and two views against their single policy and three views; corruption control pending.

Paper: arXiv 2608.13438 · Code: no code link found

Claims:

  • fail imagined-latent probe above current-latent probe on failure AUROC — theirs AUROC 0.98–0.99 vs 0.84–0.92 over four grasp tasks (Cup 0.98 vs 0.84) · ours 0.70 vs 0.82 (paper Table 2 (ROC AUC, Cup .982 vs .840))
  • reproduces current-latent probe above imagined-latent probe on failure AUROC · ours 0.82 vs 0.70 (our measured comparison)

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-23-paper-vs-hardware-contactguard · First published: 2026-10-23 · Updated: 2026-10-23 · Findings: I need a probe on a world model's latents →

ContactGuard (Zheng, Johnson-Roberson, Zhi; arXiv 2608.13438) is the closest paper to what I run: a LeWM-style world model used as a pre-contact failure monitor on a real arm. Their monitor works. Mine, built to the same protocol, does not, with the opposite sign.

D-JEPA

They said a small ranking add-on, trained on the outcome of every candidate, picks better motions than the world model. We trained it on our recorded runs with stand-in labels, not with real outcomes. Not tested: with those labels the regret stayed at 0.263, the same as the world model alone.

Ranking regret (lower is better): D-JEPA (W1R) 0.263; action only −0.007; bar 0.10D-JEPA (W1R)0.263action only−0.007bar 0.10

Papers tested · 5 of 22

Goal (the paper's): Close the gap between a world model's global predictive geometry and the decision among the few candidates that compete for execution, with a set operator that corrects each candidate's score, trained on counterfactual execution of every candidate.

Its hypotheses:

  • Among the top few candidates, latent goal distance misorders successes and failures. (§3, Fig. 2c–d) not tested here
  • A permutation-equivariant ranking operator on frozen world models raises planning success over the base models. (§4 (operator), §6, Tables 1–2) not tested

Verdict: not tested · Claim tested: A decision-aligned ranking operator on a frozen world model picks better action chunks. · Bar: G1b regret ≤ 0.10 and ≤ the action-only baseline + 0.05. · n: 703 val anchors

Theirs vs ours: +4 to +17 points vs regret 0.263 (W1 alone 0.263; action-only −0.007) · Not proven: Proxy labels (executed chunk = success); the executed-candidate version is not run.

Paper: arXiv 2609.24749 · Code: NEBULIS-Lab/D-JEPA

Claims:

  • not tested decision-aligned ranking operator below latent world-model ranking on G1b regret — theirs +4 to +17 points · ours regret 0.2631 (W1 alone 0.2630) (paper §6, Tables 1, 2 and 4 (+4 to +17 points))

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-23-paper-vs-hardware-d-jepa · First published: 2026-10-23 · Updated: 2026-10-23

D-JEPA (Liu, Wu, Wen, You, Zhang, Hao, Lin, Su; arXiv 2609.24749) names my strongest negative result — latent distance misorders the few candidates that compete for execution — and proposes a fix. I ran the fix with the wrong labels. This post says what the paper's test needs and why mine was not it.

DINO-WM

They said a planner built on a large frozen image model plans to a goal image better than learned ones. On our arm we measured how well its features track the arm and rank candidate motions. Partly: it reads the arm's pose well (0.92 of the variance) but ranks motions worse than ignoring the camera.

Ranking 8 action chunks, top-1: DINO-WM (W2) 0.55–0.61; action only 0.68–0.90; bar 0.8DINO-WM (W2)0.55–0.61action only0.68–0.90bar 0.8

Papers tested · 2 of 22

Goal (the paper's): Plan for manipulation and navigation with a world model built on frozen DINOv2 patch features, so that no task-specific visual representation has to be learned; a transition model predicts the next patch features and CEM plans toward a goal image, in six simulated environments.

Its hypotheses:

  • A transition model on frozen DINOv2 patches plans to goal images better than world models that learn their own representation. (Table 1 (Push-T 0.90 vs DreamerV3 0.30)) fail
  • Patch features, not a pooled global vector, carry the spatial detail manipulation needs. (Table 2 (encoder ablation)) not tested here

Verdict: fail · Claim tested: A predictor on frozen DINOv2 patches plans better than one on a learned latent. · Bar: G1b top-1 ≥ 0.8 at some target distance. · n: 25 val episodes, 703 anchors

Theirs vs ours: Push-T planning success 0.90 vs arm-pose R² 0.92 (vs 0.57 for W1); G1b top-1 0.55–0.61; no-model baseline 0.68–0.90 · Not proven: One training each (W2 lost, W2′ retrained); planning not run in closed loop.

Paper: arXiv 2411.04983 · Code: gaoyuezhou/dino_wm

Claims:

  • fail latent world-model ranking above action-only baseline on G1b top-1 — theirs Push-T planning success 0.90 · ours 0.61 vs 0.68–0.90 action-only (paper §3.2 and §4.3, Table 1 (planning with DINO-WM))
  • reproduces frozen-DINOv2 world model above JEPA world model on arm-pose R² — theirs not reported for an arm pose · ours 0.92 vs 0.57 (paper §4.4, Table 2 (frozen pretrained features encode the scene))

Compute: External GPU: yes (vast.ai): W2 < $1, W2′ ~$0.65, probes ~$0.06; ~$1.7. · Reproduce: 2026-10-23-paper-vs-hardware-dino-wm · First published: 2026-10-23 · Updated: 2026-10-23

DINO-WM (Zhou, Pan, LeCun, Pinto; arXiv 2411.04983) is the recipe behind W2: frozen DINOv2 patches plus a learned dynamics model. It had the better representation and lost the same planning gate as W1, more slowly.

FAIL-Detect and SAFE

They said a statistical band fitted on successful runs keeps false alarms at a chosen rate. On our arm we fitted it to a world model's surprise and set that rate to 5 %. It did not hold: it flagged 22.7 % of successful runs and caught 46 % of failures.

Successful runs flagged, % (lower is better): paper: at most α 5.0 %; this rig 22.7 %; bar 1/20paper: at most α5.0 %this rig22.7 %bar 1/20

Papers tested · 7 of 22

Goal (the paper's): Detect policy failures at run time from scores built without failure data (FAIL-Detect) or from a probe on a VLA's own features trained on both outcomes (SAFE), with a conformal band that fixes the false-alarm rate.

Its hypotheses:

  • A conformal band calibrated on successful rollouts keeps false alarms at or below the chosen rate α on in-distribution successes. (FAIL-Detect §IV-B; SAFE §4.3) fail
  • Learned scores flag failures early enough to matter, on simulated and real robots. (FAIL-Detect Fig. 4–5; SAFE Table 1, Fig. 4 and 6) fail

Verdict: fail · Claim tested: A conformal band on a learned failure score keeps false alarms at α while catching failures. · Bar: Successes flagged ≤ 1/20; failures flagged ≥ 50 %. · n: 22 + 22 successes, 25 failures, 20 splits

Theirs vs ours: false alarms ≤ α on in-distribution successes (conformal coverage bound) vs 22.7 % of successes flagged at α = 5 %; 46 % of failures caught · Not proven: One world model's surprise as the score; their own scores were not reimplemented.

Paper: arXiv 2503.08558, arXiv 2506.09937 · Code: CXU-TRI/FAIL-Detect, vla-safe/SAFE

Claims:

  • fail conformal failure band equals conformal level α on successes flagged — theirs false alarms ≤ α · ours 22.7 % at α = 5 % (FAIL-Detect §IV-B; SAFE §4.3 (coverage ≥ 1 − α))
  • fail conformal failure band at least pass mark on failures caught — theirs high recall at the target α · ours 46 % (FAIL-Detect Fig. 4–5; SAFE Table 1)

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-23-paper-vs-hardware-contactguard · First published: 2026-10-23 · Updated: 2026-10-23

Two papers, one experiment: both calibrate a time-varying conformal band on successful rollouts and flag a run that leaves it. FAIL-Detect (Xu et al., TRI; arXiv 2503.08558) does it on learned OOD scores with no failure data; SAFE (Gu et al., UofT/TRI; arXiv 2506.09937) on a probe of the VLA's own features trained with failures. I ran the band on W1's surprise (W1-C2). It failed, and the way it failed is the way FAIL-Detect's own hardware section describes.

H-JEPA

They said a slow upper layer in a stacked world model tracks progress toward the goal. On our arm we checked whether its distance to the goal falls steadily along recorded runs. It did not hold: it signalled a stall that was not there 52 % of the time.

False stalls, % of runs (lower is better): H-JEPA level 2 52 %; bar 10 %H-JEPA level 252 %bar 10 %

Papers tested · 4 of 22

Goal (the paper's): Stack JEPA world models into a hierarchy with a distinct latent space per level, so that upper levels plan in abstract states over longer horizons and hand subgoals down; shown in simulation, with an open-loop fidelity measure on DROID.

Its hypotheses:

  • A hierarchy of distinct latent spaces plans long-horizon tasks with less planner compute than a flat model. (Fig. 6 (AntMaze 18 % → 73 %)) not tested here
  • The lower level's cost to the subgoals handed down falls steadily along expert trajectories (Spearman 0.89–1.00), more consistently than its cost to the final goal (0.48–0.75). (§4.2, Fig. 8; Table 10 (Spearman 0.89–1.00)) fail
  • Upper levels drop fast-varying entities when the data has an entity-frequency gap above about 2×. (Fig. 4–5) not tested here

Verdict: fail · Claim tested: A slow second level makes latent distance track task progress. · Bar: Progress monotonicity Spearman ρ ≤ −0.80; false stalls ≤ 10 %. · n: teleop val episodes (monotonicity, stalls); 88 rollouts (sanity check)

Theirs vs ours: subgoal-tracking Spearman 0.89–1.00 vs level-2 ρ −0.73; false stalls 52 % · Not proven: Outside the paper's regime (no entity-frequency gap on this task).

Paper: arXiv 2610.06805 · Code: no code link found

Claims:

  • fail second-level latent distance at most pass mark on progress Spearman ρ — theirs subgoal-tracking (level-1 cost to level-2 subgoals) Spearman 0.89–1.00; no level-2 distance-to-goal reported · ours ρ −0.73; false stalls 52 % (paper, subgoal-tracking Spearman 0.89–1.00)

Compute: External GPU: no (Mac). Cost: $0. · Reproduce: 2026-10-14-g6-progress-latents · First published: 2026-10-23 · Updated: 2026-10-23

H-JEPA (Zhang, Terver, Rabbat, LeCun, Balestriero; arXiv 2610.06805) stacks LeWorldModels across timescales. I tested its level-2 slow feature as a progress signal (G6b) and it failed. Reading the paper afterwards, the paper's own Fig. 5 predicts that failure.

LeWorldModel

They said a small world model, trained from camera images, learns a robot's motion well enough to plan with. On our arm we checked whether it ranks the motion actually taken first among 8 candidates. It did not hold: it was right 0.60 of the time, below a check that ignores the camera.

Ranking 8 action chunks, top-1: world model 0.60; action only 0.68–0.90; bar 0.8world model0.60action only0.68–0.90bar 0.8

Papers tested · 1 of 22

Goal (the paper's): Train a small world model end to end from pixels, with no frozen encoder and no EMA target, kept from collapse by SIGReg alone, and plan with it by sampling actions in its latent space; shown in simulation (Push-T, Two-Room, Reacher, OGBench Cube).

Its hypotheses:

  • A 15M-parameter JEPA world model trained end to end with SIGReg learns dynamics stable enough to plan with. (§3.1, Eq. (3); Fig. 6) reproduces
  • At a matched planning-compute budget it plans more successfully than DINO-WM and about 48× faster; without that match it leads on Push-T and Reacher only. (Fig. 3 (Push-T at fixed FLOPs 90 % vs 13 %; 0.98 s vs 47 s per plan)) fail
  • A linear readout of its latent recovers object state. (Table 1 (Push-T probes)) not tested here

Verdict: fail · Claim tested: A small JEPA world model learns the arm's dynamics well enough to plan with it. · Bar: Dynamics: beat copy-last, every corruption ≥ 1.3 at K = 30. Planning: rank the executed chunk first among 8 in ≥ 0.8 of anchors. · n: 25 val episodes, 703 anchors

Theirs vs ours: Push-T planning 90 % at matched FLOPs vs dynamics 0.31 vs 0.89 copy-last (reproduces); planning top-1 0.60 vs 0.68–0.90 for an action-only baseline (fail) · Not proven: Closed-loop planning on the arm was never run; one training seed.

Paper: arXiv 2603.19312 · Code: lucas-maes/le-wm

Claims:

  • reproduces JEPA world model below copy-last baseline on open-loop latent error at K = 30 — theirs Push-T planning 90 % at matched FLOPs · ours 0.31 vs 0.89 copy-last (not stated: the premise of §3–4 (planning needs a usable dynamics model))
  • fail latent world-model ranking above action-only baseline on G1b top-1 — theirs Push-T planning 90 % · ours 0.60 vs 0.68–0.90 action-only (paper §4 (planning by ranking imagined outcomes))
  • reproduces action-only baseline above latent world-model ranking on G1b top-1 · ours 0.68–0.90 vs 0.60 (our measured comparison)

Compute: External GPU: yes (vast.ai): ~$6.60 incl. $2.96 of failed attempts. · Reproduce: 2026-10-23-paper-vs-hardware-leworldmodel · First published: 2026-10-23 · Updated: 2026-10-23 · Findings: I need to rank candidate action chunks →

LeWM open-loop error at 30 steps (lower is better): world model 0.31; copy last frame 0.89world model0.31copy last frame0.89

One paper, one arm. This series takes each paper I actually tested on a SO-101 + Jetson Orin NX, states what the paper claims and how its authors measured it, puts my number next to theirs, and says what the gap means. Numbers are from journal/EXPERIMENTS.md; gate IDs are the register's.

LeWorldModel (Maes, Le Lidec, Scieur, LeCun, Balestriero; arXiv 2603.19312) is the recipe behind W1, the world model that runs on my arm. Four gates tested it: dynamics (G0), planning (G1b), progress (G6a), outcome readout (G10).

Real-Time Chunking

They said building each new motion chunk to match the one already running removes jumps at the joins. On recorded runs we compared a simple overwrite of the shared part with their method. Not proven on the arm: the overwrite removed most of the jump, adding 0.4 ms.

Jump at the chunk seam cut vs naive async, %: prefix overwrite 71–73 %; bar 50 %prefix overwrite71–73 %bar 50 %

Papers tested · 15 of 22

Goal (the paper's): Let a flow-matching policy run asynchronously without jumps at chunk boundaries, by generating each new chunk as an inpainting of the actions already committed; shown on dynamic simulated tasks and a bimanual robot with added latency.

Its hypotheses:

  • Conditioning the new chunk on the committed actions removes the discontinuity at chunk boundaries. (§3.1–3.2 (ΠGDM guidance, Eq. 2–3); Fig. 3–4) not proven
  • With it, task throughput stays flat as inference latency grows, where synchronous execution falls. (Fig. 6) not tested here

Verdict: not proven · Claim tested: Conditioning a new chunk on the executing one removes the jump at chunk boundaries. · Bar: Best gradient-free method cuts the median jump ≥ 50 % against naive async, drift ≤ +10 %, within 667 ms. · n: 254 boundaries per delay, 20 episodes

Theirs vs ours: throughput flat across added latency (π0.5, real robot) vs prefix overwrite cuts the jump 71–73 % against naive async at +0.4 ms; tuned LeRobot identity mode is close · Not proven: Offline smoothness only; task success on the arm not measured for any mode.

Paper: arXiv 2506.07339 · Code: Physical-Intelligence/real-time-chunking-kinetix

Claims:

  • not proven prefix overwrite at least pass mark on median boundary-jump cut — theirs throughput flat across added latency (π0.5, real robot) · ours 71–73 % at +0.4 ms (paper §3.1–3.2, Fig. 4 (qualitative; no jump metric reported))

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-25-vla-chunk-boundary-jumps · First published: 2026-10-23 · Updated: 2026-10-26 (soft-mask correction)

Real-Time Chunking (Black, Galliker, Levine, Physical Intelligence; arXiv 2506.07339) treats the next action chunk as an inpainting problem. My gradient-free prefix overwrite uses the paper's soft mask without its gradient, and the paper says where gradient-free inpainting should lose.

ReAP

They said a risk score that looks at the next planned motions warns before a robot fails. On our arm we built that risk score and asked it to warn before 8 recorded failures. It did not hold: it caught 3/8 failures while flagging 5/42 good runs.

ReAP risk head AUROC: v1 (time leak) 0.929; v2 true actions 0.789; v2 shuffled 0.708v1 (time leak)0.929v2 true actions0.789v2 shuffled0.708

Papers tested · 8 of 22

Goal (the paper's): Warn of a VLA's failure before it happens, with a detector on a compact visual state trained on a ramp target (no onset labels) and a predictor that rolls that state forward under the policy's next action chunk.

Its hypotheses:

  • Conditioning the risk prediction on the policy's next action chunk improves warning over the same model with shuffled or zero actions. (Table 3b) reproduces
  • The monitor warns earlier and more accurately than action-uncertainty, OOD and classifier baselines. (Table 1, Table 2a) fail

Verdict: fail · Claim tested: A risk head on an action-conditioned latent warns before failures. · Bar: ≥ 5/8 failures caught at ≤ 1/20 false interventions; action-conditioned iff true ≥ shuffled + 0.05. · n: 50 episodes, 8 failures (and all 69)

Theirs vs ours: bTWA 0.65–0.78 in simulation (Table 1), 0.60–0.82 on the real robot (Table 2a) vs v1 AUROC 0.93 came from time and length; v2 0.789 vs 0.708 shuffled, 3/8 at 5/42 · Not proven: 8 failures; v1 onsets VLM-labelled.

Paper: arXiv 2610.16309 · Code: no code link found

Claims:

  • reproduces action-conditioned risk head above shuffled-action risk head on failure AUROC — theirs bTWA 0.683 vs 0.618 shuffled (no AUROC reported) · ours 0.789 vs 0.708 shuffled (paper Table 3b (action-conditioned 0.683 vs shuffled 0.618 bTWA; the next planned chunk))
  • fail action-conditioned risk head at least pass mark on failures caught — theirs bTWA 0.70–0.78 · ours 3/8 at 5/42 (paper Table 1 (detection time), Table 2a)

Compute: External GPU: no (Orin NX). External API: Gemini onset labels, cents. · Reproduce: 2026-10-23-paper-vs-hardware-reap · First published: 2026-10-23 · Updated: 2026-10-23 · Findings: I need an online failure monitor →, W1 as an online monitor next to the policy →

ReAP (Liu, Qing, Wei, Hou; arXiv 2610.16309) trains a failure-supervised visual space and an action-conditioned risk predictor on top of it. My "ReAP-style risk head" is the closest any monitor got to my bar — and it is a stripped version with two confounds the paper's own design removes.

REKI

They said robot policies without memory get stuck going back and forth between poses. We measured that back-and-forth in our 69 recorded runs, then trained the memory version. It held: 24.0 % of failed runs oscillated; with memory, 1 run in 40 did.

Runs that oscillate, %: paper, all runs 18.6 %; this rig, all runs 20.3 %; this rig, failed runs 24.0 %; bar 10 %paper, all runs18.6 %this rig, all runs20.3 %this rig, failed runs24.0 %bar 10 %

Papers tested · 14 of 22

Goal (the paper's): Give a VLA a short memory of past frames with register tokens cached across steps, so it stops oscillating between visually aliased poses; trained on public data only and evaluated on LIBERO-Plus, RoboTwin, RoboCasa and real robots.

Its hypotheses:

  • Policies without memory oscillate between poses in a measurable share of episodes; register memory cuts it. (Fig. 5b (18.6 % without, 4.1 % with)) reproduces
  • Most of the gain comes from reading the first past frame at inference. (Fig. 5a) not tested here
  • A 2.4B VLA pretrained only on public data matches larger in-house models. (Fig. 4) not tested here

Verdict: reproduces · Claim tested: Policies without memory oscillate between poses at a measurable rate. · Bar: ≥ 10 % of failed episodes oscillate (their criterion). · n: 69 published rollouts

Theirs vs ours: 18.6 % without memory, 4.1 % with vs 20.3 % of all episodes, 24.0 % of failures; REKI trained on my data: 19/20 + 19/20 on the arm, oscillates in 1/40 · Not proven: That memory causes the drop to 1/40: the K = 1 (memory off) control is not run. REKI does not build for the Orin (served from an RTX 3090).

Paper: arXiv 2610.22178 · Code: kyutai-labs/reki

Claims:

  • reproduces policy without memory at least pass mark on oscillating share of failures — theirs 18.6 % of all episodes and about half of the failed ones oscillate without memory (RoboTwin Clean, §6.2, Fig. 5b) · ours 24.0 % of failures, 20.3 % of all episodes (paper, 18.6 % without memory, 4.1 % with)
  • reproduces REKI at least pass mark on success on the arm — theirs UR5 + WSG50 real-robot success · ours 19/20 + 19/20 (paper §7, Fig. 8)

Compute: External GPU: yes for REKI (vast.ai): training $11.25 + smoke $0.60, serving $1.20, total $13.05. Oscillation audit on the Orin NX: $0. · Reproduce: 2026-10-23-paper-vs-hardware-reki · First published: 2026-10-23 · Updated: 2026-10-28 (REKI trained and run on the arm) · Findings: REKI 2.4B on the Orin →

REKI (Marrie, Pacaud, Ramanana Rahary, Chen, Böhle; Kyutai / Inria; arXiv 2610.22178) gives a VLA a memory through register tokens and measures the oscillation it removes. I voided my own latency measurement of it and then found the same oscillation in my policies with their metric.

RoboJEPA

They said a world model pretrained on 15 000 hours of robot video predicts what comes next from the actions. On our arm we tested its predictions on our clips and timed it on the robot's computer. It used our actions, but its image encoder alone took 526 ms, too slow to run on the robot.

9-step error below copy-last, % (higher is better): 300M 11.8 %; 1B (30 clips) 15.8 %; bar 15 %300M11.8 %1B (30 clips)15.8 %bar 15 %

Papers tested · 3 of 22

Goal (the paper's): Measure how an action-conditioned predictor on frozen V-JEPA 2.1 features scales with compute across 12 embodiments, fit a law that extrapolates to held-out model sizes, and plan with the large models on a real Franka.

Its hypotheses:

  • Latent-rollout error on held-out scenes follows a compute law that extrapolates to 4B and 8B models. (§3.1, Table 2) fail
  • Planning capabilities emerge in order with compute: end-effector control, holding, scene geometry, object dynamics. (Fig. 6–9) not tested here
  • The larger models plan grasp, lift and pick-and-place on a real Franka from a single image goal. (Table 3) not tested here

Verdict: fail · Claim tested: Pretrained RoboJEPA predicts our latents, uses the actions, and runs on the robot's computer. · Bar: 9-step L1 ≥ 15 % below copy-last (300M) and ≥ 5 % below shuffled actions; 2-view encoder ≤ 200 ms on the Orin. · n: 60 clips (30 for 1B), 25 episodes

Theirs vs ours: rollout error frontier near E ≈ 0.22; latency not reported vs 11.8 % below copy-last (300M; 1B 15.8 % on 30 clips); 9–10 % below shuffled; encoder 526 ms on the Orin NX · Not proven: 1B on a partial sample; TensorRT not tried.

Paper: arXiv 2610.10515 · Code: facebookresearch/robo_jepa

Claims:

  • fail pretrained RoboJEPA below copy-last baseline on 9-step latent L1 — theirs rollout error frontier near E ≈ 0.22 · ours 11.8 % below copy-last (paper §3.1, Table 2 (DROID holdout, E = 0.218))
  • fail RoboJEPA encoder at most pass mark on ms per encoder call on the Orin NX — theirs latency not reported · ours 526 ms (our measured comparison)

Compute: External GPU: yes (vast.ai, Gate A): ~$1.2. Gate B on the Orin NX: $0. · Reproduce: 2026-10-23-paper-vs-hardware-robojepa · First published: 2026-10-23 · Updated: 2026-10-23 · Findings: RoboJEPA's encoder on the Orin →

RoboJEPA (Zholus, Assran et al., Meta FAIR; arXiv 2610.10515) is a scaling law for latent world models trained on 15 000 hours of robot video, including 21.5k LeRobot community episodes from arms like mine. Two gates: can the encoder run on the Orin, and does the pretrained predictor use my actions.

Robometer

They said a large reward model, trained on a million robot videos, can judge runs on robots it never saw. We asked it, untrained, to tell failed from successful runs on 2 099 public SO-101 arm runs. It did not hold: 0.818 out of 1, under our 0.85 bar; on our runs a robot-trained judge, Flora, passed.

Failure judging, pooled AUROC: Robometer-4B 0.818; episode length 0.938; bar 0.85Robometer-4B0.818episode length0.938bar 0.85

Papers tested · 10 of 22

Goal (the paper's): Train a general robot reward model on a vision-language backbone, from about a million trajectories across 21 embodiments with progress, preference and success heads, and use it zero-shot to score progress, rank trajectories and detect failures.

Its hypotheses:

  • The reward model tracks task progress on embodiments it was not trained on. (Table I (VOC 0.92 / 0.94)) fail
  • It detects failures zero-shot better than other reward models and token-uncertainty baselines. (Table IV (F1 0.81)) fail
  • As a reward it improves online and offline RL, including on an SO-101. (Q3, Fig. 7) not tested here

Verdict: fail · Claim tested: A 4B reward model judges SO-101 rollouts zero-shot. · Bar: Pooled AUROC ≥ 0.85 and within-policy ≥ 0.8 on ≥ 5 of 7 policies. · n: 2099 + 88 rollouts

Theirs vs ours: VOC 0.94 on out-of-distribution evaluation sets (0.92 in-distribution) vs pooled AUROC 0.818 on 2099 ArmnetBench rollouts; episode length alone 0.938 · Not proven: Zero-shot only; the LoRA run never trained.

Paper: arXiv 2603.02115 · Code: robometer/robometer

Claims:

  • fail learned reward model at least pass mark on failure AUROC — theirs failure-detection F1 0.81 (no AUROC reported); VOC 0.94 OOD · ours 0.818 pooled (paper Table IV (zero-shot failure detection))
  • fail learned reward model above episode length on failure AUROC — theirs no episode-length baseline in the paper · ours 0.818 vs episode length 0.938 (not a paper comparison: the paper's premise that a learned judge beats hand-made signals)
  • reproduces episode length above learned reward model on failure AUROC · ours 0.938 vs 0.818 (our measured comparison)

Compute: External GPU: yes (vast.ai): ~$8.55–9.55 incl. a LoRA run that never trained and an OOM re-score. · Reproduce: 2026-10-23-paper-vs-hardware-robometer · First published: 2026-10-23 · Updated: 2026-10-23 · Findings: I need to tell success from failure in a rollout →

Robometer (Liang, Korkmaz, Zhang, Hwang et al.; arXiv 2603.02115) is a 4B reward model trained on a million trajectories. I tested it zero-shot as a judge on my own rollouts and on a 2 099-rollout public SO-101 benchmark. Episode length beat it on every held-out task. The paper never computes episode length.

SmolVLA

They said a small robot policy works on a low-cost arm and runs on cheap hardware. On our arm we ran it 10 times and timed it on the robot's computer. It held: 9 of 10 runs succeeded, and our engine cut each step to 238 ms.

SmolVLA chunk inference on the Orin NX, ms: PyTorch 974 ms; vla.cpp 390 ms; vla.cpp + FA 238 ms; async budget 667 msPyTorch974 msvla.cpp390 msvla.cpp + FA238 msasync budget 667 ms

Papers tested · 11 of 22

Goal (the paper's): Build a small, open vision-language-action model trained on community LeRobot data that matches much larger VLAs, runs on consumer hardware, and can run asynchronously; shown in simulation and on SO-100 / SO-101 arms.

Its hypotheses:

  • A 450M VLA pretrained on community SO-100 data matches or beats much larger VLAs on real low-cost arms. (Table 3–4 (SO-101 LEGO 90 %)) reproduces
  • Asynchronous inference keeps the arm moving while the next chunk is computed. (Algorithm 1; Fig. 5) not tested here
  • Pretraining on community data raises real-arm success (51.7 → 78.3 % on SO-100, Table 5). (Table 5) not tested here

Verdict: reproduces · Claim tested: A 450M VLA succeeds on an SO-101 task and can run on low-cost hardware. · Bar: 10-trial operator-judged gate (no numeric pass mark registered); chunk inference within the async budget (667 ms). · n: 10 trials per engine

Theirs vs ours: SO-101 LEGO 90 % in distribution; latency not reported for Jetson vs 9/10 on bowls; 974 ms in PyTorch, 238 ms with vla.cpp on the Orin NX · Not proven: The bowls task is at ceiling for every policy; asynchronous execution not timed on the arm.

Paper: arXiv 2506.01844 · Code: huggingface/lerobot

Claims:

  • reproduces SmolVLA at least pass mark on success on the arm — theirs 90 % (SO-101 LEGO) · ours 9/10 (paper Table 4 (SO-101 Pick-Place-Lego, 90 % in distribution))
  • reproduces SmolVLA chunk inference below async budget on ms per action chunk on the Orin NX — theirs latency not reported for Jetson · ours 238 ms (vla.cpp + FA), 974 ms PyTorch (our measured comparison)

Compute: External GPU: no (Orin NX, arm). Cost: $0; SmolVLA training cost not recorded. · Reproduce: 2026-10-23-paper-vs-hardware-smolvla · First published: 2026-10-23 · Updated: 2026-10-23

SmolVLA (Shukor, Aubakirova, Capuano et al., Hugging Face; arXiv 2506.01844) is the policy behind almost every number on this site. Its paper's ablation tables are the manual for running it on a Jetson; three of them predicted things I later measured.

TurboVLA

They said a light policy without a large language model still follows its instruction. On our arm we trained it on our two tasks and swapped the instruction. Our claim that it ignored the instruction is withdrawn: the data caused the 0.020° change, not the model.

TurboVLA task swap, degrees of pan: ours (path A) 0.020°; LIBERO control 5.525°; bar 5°ours (path A)0.020°LIBERO control5.525°bar 5°

Papers tested · 12 of 22

Goal (the paper's): Make a lightweight VLA without a full VLM backbone (DINOv3 vision and a BERT text encoder fused for an action decoder) that is fast enough for real-time control; shown on LIBERO and RoboTwin 2.0 in simulation and on an AgileX Piper.

Its hypotheses:

  • A policy without a large VLM backbone still follows the language instruction. (§4 ablations, Table 3 (LIBERO-Goal 97.4 → 11.6 without language)) withdrawn

Verdict: withdrawn · Claim tested: Our claim that the architecture made the policy ignore its instruction. · Bar: Task swap ≥ 5° and per-layout ≥ 75 % → our port was the bug; < 1° with the control ≥ 0.095 → the data. · n: 25 val episodes, 8 frames

Theirs vs ours: LIBERO-Goal 97.4 → 11.6 without language (Table 3) vs upstream's own trainer on our data: task swap 0.020°, per-layout 38.9 %; control, their released LIBERO checkpoint run here: 0.105 (≈ 5.5° of pan) · Not proven: One seed; two tasks only, instruction redundant on 94 % of frames.

Paper: arXiv 2607.27205 · Code: H-EmbodVis/TurboVLA

Claims:

  • withdrawn TurboVLA on our data at least pass mark on task-swap action change — theirs LIBERO control 5.5° of pan · ours 0.020° on our data; LIBERO control 5.5° (our measured comparison)

Compute: External GPU: yes (vast.ai): path A ≈ $2.0 + ~$0.8 of failed starts. · Reproduce: 2026-10-23-paper-vs-hardware-turbovla · First published: 2026-10-23 · Updated: 2026-10-23

TurboVLA (Xie, Yao, Wu et al.; arXiv 2607.27205) drops the language model from the VLA and binds vision to text with Grounding-DINO-style cross-attention. My port failed on a two-task dataset, I concluded it ignored the instruction, then I found my port differed from the paper in four places, then I ran the paper's own trainer on my data. The faithful model ignores the instruction too. The data was the whole story.

VLA-Corrector

They said a small model watching camera statistics and actions flags a failing run early enough to fix it. On our arm we trained the same kind of watcher on 50 recorded runs. It did not hold: it caught 2/8 failures, below our bar.

Failed runs caught, of 8: verifier (GRU) 2/8; W1 latent drift 0/8; bar 5/8verifier (GRU)2/8W1 latent drift0/8bar 5/8

Papers tested · 9 of 22

Goal (the paper's): Keep a frozen π0.5 on task by detecting deviations with a learned verifier on observable history (cheap visual statistics, state and action, a GRU) and prompting recovery when it fires; shown in LIBERO and LIBERO-Plus and on a physical arm.

Its hypotheses:

  • A verifier on observable history detects execution risk (AUROC 0.902) close to a privileged rule-based verifier. (§ Failure Detection and Recovery Analysis (AUROC 0.902); Fig. 4) fail
  • Prompting recovery when the verifier fires raises success under perturbations. (Fig. 3, Table 3; real-robot results) not tested here

Verdict: fail · Claim tested: A verifier on observable history flags a failing rollout early enough to correct it. · Bar: ≥ 5/8 failures at ≤ 1/20 false interventions. · n: 50 episodes, 8 failures

Theirs vs ours: 54-feature GRU verifier AUROC 0.90 vs the paper's verifier family on our rollouts (a GRU on pooled RGB statistics and actions): 2/8 caught at 3/42 false interventions, AUROC 0.59; cosine drift of the W1 latent 0/8, AUROC 0.30 · Not proven: Their exact 54-feature verifier (with proprioceptive state) and its recovery prompt were not run here; our GRU uses pooled RGB statistics and actions.

Paper: arXiv 2609.06508 · Code: no code link found

Claims:

  • fail observable-history verifier at least pass mark on failures caught — theirs AUROC 0.90 · ours 2/8 caught at 3/42, AUROC 0.59 (§ Failure Detection and Recovery Analysis (AUROC 0.902); Fig. 4)

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-19-six-monitors-w1 · First published: 2026-10-23 · Updated: 2026-10-23

VLA-Corrector (Song, Qian, Feng, Song; arXiv 2609.06508) wraps a frozen π0.5 in a tiny learned verifier that routes a recovery prompt. I borrowed one of its signals — cosine drift of the latent — as a monitor. It caught nothing. The part of the paper I should have borrowed is the verifier's design.

VLA-JEPA

They said a robot policy pretrained on human videos without actions trains cheaply and runs well. We trained it on our data for about $10 and ran it on the arm 10 times. It held: 9 of 10 runs succeeded, at 355 ms per chunk on the robot's computer.

Time per chunk, relative to 1 sample (lower is better): 1 sample 1.00×; 8 samples 1.84×; bar 1.5×1 sample1.00×8 samples1.84×bar 1.5×

Papers tested · 13 of 22

Goal (the paper's): Pretrain a VLA on human videos without actions through a latent world model, so that its latent action tokens carry state-transition structure without leaking future frames; evaluated on LIBERO, SimplerEnv, LIBERO-Plus and a real Franka.

Its hypotheses:

  • Pretraining on action-free human video through a leakage-free latent world model improves robustness to perturbations. (Table 3 (LIBERO-Plus 79.5 vs 62.9 without human video)) not tested here
  • The model reaches state-of-the-art success on LIBERO and transfers to a real arm with 100 demonstrations. (Table 1; Fig. 4) reproduces

Verdict: reproduces · Claim tested: VLA-JEPA trains cheaply on SO-101 data and runs on the robot. · Bar: 10-trial operator-judged gate (no numeric pass mark registered); for reranking (H0): oracle / mean error ≤ ~0.7 and N = 8 ≤ 1.5× the latency. · n: 10 trials; H0 on the teleop val split

Theirs vs ours: +1.1 over no-human-video on LIBERO (Table 1); no latency reported vs 9/10 for ~$9.7; 355 ms per chunk on the Orin NX; reranking no-go (0.76, 1.84×) · Not proven: Perturbation robustness (their main claim) not tested.

Paper: arXiv 2602.10098 · Code: ginwind/VLA-JEPA

Claims:

  • reproduces VLA-JEPA at least pass mark on success on the arm — theirs real Franka: ahead of π0 and π0.5 in-distribution and with object-layout changes, second on unseen tasks (Fig. 4) · ours 9/10 (paper §4.4, Fig. 4 (real Franka))
  • fail best-of-N reranking at most pass mark on oracle-to-mean error ratio · ours 0.76, 1.84× latency (our measured comparison)

Compute: External GPU: yes (vast.ai): ~$9.7 for the fine-tune. Everything else on the Orin NX, $0. · Reproduce: 2026-10-23-paper-vs-hardware-vla-jepa · First published: 2026-10-23 · Updated: 2026-10-23

VLA-JEPA (Sun, Zhang, Qi et al.; arXiv 2602.10098) pretrains a VLA on human video through a latent world model. I trained it for $10, ran it on the arm at 9/10, and tested whether its eight samples were worth choosing between. The paper's honest ablation row says what to expect: robustness, not accuracy.

v1.5: the station as a harness for a coding agent

We wanted to know what a one-person robot lab needs to run trials unattended and keep data clean. We specified a harness from nine recent papers on agent harnesses and self-improvement. It is a design: the agent stays outside the 33 ms control tick, and nothing has run end to end.

Evaluation and judges · 7 of 14

Type: design · Result: A station design where the coding agent dispatches unit actions and batches and never sits inside the 33 ms tick. · n: —

Not proven: Not run end to end on the arm.

Compute: None; reads results from the folders above. · Reproduce: no run behind this post · First published: 2026-10-22 · Updated: 2026-10-22

Three weeks of gates reduced the world-model stack to a verifier and a shadow signal. What remained was the actual bottleneck of a one-person robotics lab: deciding what to record next, running trials unattended, and keeping the training data clean. v1.5 is that loop, specified from nine recent papers on agent harnesses and self-improvement, and partly built. It has not run end to end on the arm yet; this post is a design note, not a result.

Two gates I voided, and the two-line check that would have caught them

We wanted to know whether two benchmark results on the Jetson measured what they claimed. We reloaded each script's model the strict way and checked whether its timing parts added up. One timed a random encoder, with 192 missing keys; the other timed the wrong model.

Evaluation and judges · 6 of 14

Type: correction · Result: G11-A timed a random encoder and G12 a stand-in model; both gates are void. · n: two gates

Not proven: The voided numbers support nothing.

Compute: External GPU: no (Orin NX). Cost: $0. · Reproduce: 2026-10-22-voided-gates · First published: 2026-10-22 · Updated: 2026-10-22 · Findings: Two gates voided by a two-line check →

On 2026-10-18 two Jetson gates went into the register with bars frozen beforehand: G11-A passed, G12 failed. Both were voided the same day. G11-A timed the right model with the wrong weights; G12 timed the wrong model. Neither was a training or hardware problem. Both were caught by checking what the script had actually loaded.

Judging, part 2: the input format did the work

We wanted to know which judge could read a run's outcome from video, beyond our two-bowl rule. We gave a robot-trained judge and three general models the same clip and question, with a bar fixed first. The robot judge caught every failure at 2/42 false alarms, and its untrained base model nearly matched it.

Evaluation and judges · 3 of 14

Type: method · Result: With Flora-Rewarder's input, a general Qwen3.5-27B passes too (7/8 at 2/42): the input format did the work. · n: 50 episodes, 8 failures

Not proven: One prompt per model; Flora's licence is noncommercial.

Compute: External GPU: yes (vast.ai, ≥ 80 GB): ~$2.2. External API: Gemini ~$2.75. Total ~$4.95. · Reproduce: 2026-10-20-flora-rewarder-input-format · First published: 2026-10-20 · Updated: 2026-10-20 · Findings: I need to tell success from failure in a rollout →, The input format did the work, not the robot fine-tune →

The deterministic judge is right but narrow: it knows about two coloured bowls. Any new task needs a judge that reads video. NVIDIA's Flora-Rewarder-27B, a robot-trained outcome scorer, passed where Gemini had failed the day before. The ablation says why, and it is not the robot training.

Verify at rest: six mid-episode monitors fail in one day

We wanted to know if any monitor could catch a failing run before it ended. We ran every mid-run checker in the design on 50 fresh runs, with the bars fixed the night before. Every monitor failed; the world model's live reflex fired on 42/42 successful runs.

Evaluation and judges · 2 of 14

Type: method · Result: Six mid-episode monitors miss their bars; the best, L2 surprise, catches 2/8 at 2/42. · n: 50 episodes, 8 failures

Not proven: One world model; one prompt per VLM.

Compute: External GPU: no (Orin NX). External API: Gemini 3.8 Flash, ~$2.1–3.1 (one figure estimated: the API did not report it). · Reproduce: 2026-10-19-six-monitors-w1 · First published: 2026-10-19 · Updated: 2026-10-19 · Findings: I need an online failure monitor →, Mid-episode monitors miss; verify at rest instead →

One Jetson day, no arm motion, every mid-episode verifier in the v1.0 design run against 50 fresh rollouts with the bars frozen the night before. Stage trackers, VLM judges and the world-model reflex all failed. One offline engine experiment passed. The architecture that came out of it (v1.1) verifies only at rest, and that rule has not moved since.

What the world model is actually for

We wanted to know if a world model could read a run's outcome, and see it coming. We tested its latent at the moment of judgement and 30 steps earlier, against which policy ran. The outcome readout scored 1.000, but on runs it had seen in training.

Evaluation and judges · 5 of 14

Type: method · Result: The latent reads outcomes at rest (AUROC 1.00 vs the judge) and anticipates failures before execution (+0.18 over policy identity). · n: 88 rollouts

Not proven: Step 2 is compared against policy identity only.

Compute: External GPU: no (Mac). Cost: $0. · Reproduce: 2026-10-17-g10-outcome-readout · First published: 2026-10-17 · Updated: 2026-10-17

With a judge that is right at rest, the world model finally had a fair question: can it read the judge's verdict from the latent, and can it see it coming? G10 ran on the Mac for free. It is the one world-model gate that passed cleanly, and the next post is about how much of it survived contact with fresh data.

Judging robot rollouts automatically: a success detector with zero false positives

We wanted to know if a robot run could be judged automatically without ever calling a failure a success. We wrote a fixed camera rule, with no learning, that checks the two bowls once the arm is still. On 88 runs it was right 94.3 % of the time and never called a failure a success.

Evaluation and judges · 1 of 14

Type: method · Result: A deterministic top-camera judge at rest: 0 false positives, 94.3 % on 88 rollouts. · n: 88 rollouts, 26 failures

Not proven: A narrow fail of its 95 % bar; reset marks set by eye.

Compute: External GPU: yes (vast.ai) for Robometer: ~$8.55–9.55 incl. a LoRA run that never trained and an OOM re-score. The deterministic judge: Mac, $0. · Reproduce: 2026-10-23-paper-vs-hardware-robometer · First published: 2026-10-16 · Updated: 2026-10-16 · Findings: I need to tell success from failure in a rollout →, Deterministic top-camera judge at rest →, A deterministic judge at rest, never a false positive →

Ten operator-judged trials are fine. An autonomous loop that records hundreds of rollouts and fine-tunes on the good ones is not, because every success it mislabels trains the policy on a failure. This is the day the judge became the most important component in the stack, and the day a published 4B reward model lost to 40 lines of OpenCV.

Latent distance is not progress

We wanted to know if distance in a world model's latent space could measure progress toward the goal. We checked whether that distance falls steadily over successful runs, then tried a hierarchical version. It did not: the arm's path loops, and the hierarchical version still had 52 % false stalls.

False stalls, % of runs (lower is better): H-JEPA level 2 52 %; bar 10 %H-JEPA level 252 %bar 10 %

Evaluation and judges · 4 of 14

Type: method · Result: Distance to a goal latent does not track progress (ρ −0.32 to −0.50; a second level reaches −0.73 against a −0.80 bar). · n: teleop val episodes

Not proven: Monotonicity measured on teleop episodes only.

Compute: External GPU: no (Mac). Cost: $0. · Reproduce: 2026-10-14-g6-progress-latents · First published: 2026-10-14 · Updated: 2026-10-14 · Findings: Latent distance to the goal is not progress →

If a world model cannot rank actions, maybe it can tell how far along a task is: distance in latent space to the goal frame should fall as the arm gets closer, and a stall is when it stops falling. Zero labels needed. G6a tested that; G6b tested a hierarchical version four days later. Both failed the same way.

World-model planning on an SO-101: the commanded joints win (0.90 vs 0.60)

We wanted to know if a world model could plan on our arm by ranking candidate motions. We asked it to pick the real motion among 8, against a check that reads only the commanded joints. The joints won, scoring up to 0.90 vs 0.60 for the best world model.

Ranking 8 action chunks, top-1: world model 0.60; action only 0.68–0.90; bar 0.8world model0.60action only0.68–0.90bar 0.8

Evaluation and judges · 9 of 14

Type: method · Result: Ranking action chunks, the world model's top-1 is 0.60 against 0.68–0.90 for an action-only baseline. · n: 703 val anchors

Not proven: Closed-loop planning was not run.

Compute: External GPU: no for these gates (Mac). The models: W1 ~$6.54 (see the $3.30 post), W2 < $1, probes ~$0.06. · Reproduce: 2026-10-23-paper-vs-hardware-leworldmodel · First published: 2026-10-13 · Updated: 2026-10-13

G1b asked the question that decides whether a latent world model can plan on this arm: given the expert chunk and seven decoys, does imagining each one rank the expert first? Two world models, one bigger pretrained one, and a baseline with no model at all. The baseline won.

Porting ACT to vla.cpp, so a Jetson can run it without PyTorch

We wanted to know if the most common policy on this arm could run on a Jetson without PyTorch. We ported it into the vla.cpp engine and checked it against PyTorch on fixed inputs and on the arm. The port merged upstream; speed was never the point, since PyTorch already ran it at 59 ms per chunk.

Engineering on the Orin · 5 of 8

Type: engineering · Result: ACT added to vla.cpp (merged upstream as #38); the PyTorch checkpoint scores 9/10 on the Orin NX gate. · n: 10 trials

Not proven: The vla.cpp ACT path was not gated on the arm.

Compute: External GPU: no (Orin NX + Mac). Cost: $0; ACT training cost not recorded. · Reproduce: 2026-10-12-act-vlacpp-port · First published: 2026-10-12 · Updated: 2026-10-12 · Findings: ACT in vla.cpp →

ACT is the most common SO-101 policy and vla.cpp did not have it. Merged as vla.cpp #38 after a scoping issue (#37) the maintainer approved in a day. The pitch was never speed: PyTorch ACT already runs at 59 ms per 100-action chunk on the Orin. The pitch is no PyTorch at inference: no 5.5-hour source build, no 12–24 GB image, and CPU-only boards can run it.

Training a JEPA world model on SO-101 data for $3.30

We wanted to know if a small world model trained on our arm's videos was worth building on. We trained it for $3.30 and tested it against fixed bars before any use. Its error 30 steps ahead was 0.31 vs 0.89 for copying the last frame, so it passed.

LeWM open-loop error at 30 steps (lower is better): world model 0.31; copy last frame 0.89world model0.31copy last frame0.89

Evaluation and judges · 8 of 14

Type: engineering · Result: A multi-view LeWM (W1) trains for $3.30 and beats copy-last at every horizon (0.31 vs 0.89 at K = 30). · n: 25 val episodes

Not proven: One training seed; planning not shown here.

Compute: External GPU: yes (vast.ai): $3.30 for the run + $2.96 of failed attempts + ~$0.28 environment bring-up = ~$6.54. · Reproduce: 2026-10-23-paper-vs-hardware-leworldmodel · First published: 2026-10-11 · Updated: 2026-10-11

LeWM (the stable-worldmodel recipe: a JEPA trained end to end from pixels, no reconstruction) on the 182 bowls episodes, two camera views, 100 epochs. Gate G0 asked whether the model is real before anything is built on it.

TurboVLA: a policy that ignored its instruction

We wanted to know why a policy trained on two bowl tasks did the same motion for both instructions. We traced it to the data, then reran the original authors' trainer on the same data. Only about 6 % of frames differ between the two tasks, so ignoring the instruction still fits the rest.

TurboVLA task swap, degrees of pan: ours (path A) 0.020°; LIBERO control 5.525°; bar 5°ours (path A)0.020°LIBERO control5.525°bar 5°

Evaluation and judges · 10 of 14

Type: correction · Result: The policy ignored its instruction on the two-task bowls data (0/3 on the last port); the claim that our port caused it was withdrawn on 2026-10-23. · n: 3 arm trials on the last port; 25 val episodes

Not proven: Only two tasks; the instruction is redundant on 94 % of frames.

Compute: External GPU: yes (vast.ai). The port-era trainings behind this post: cost not recorded; the later path-A rerun: ~$2.8 incl. ~$0.8 of failed starts. · Reproduce: 2026-10-23-paper-vs-hardware-turbovla · First published: 2026-10-08 · Updated: 2026-10-23 (port claim withdrawn)

Ten days of work, several variants, a published PyPI package, and a closed project. TurboVLA fine-tuned on the two-task bowls data learned to perform whichever task it had seen last, whatever the instruction said. The failure taught me two things about data that the later datasets were built around.

Corrected 2026-10-23

The conclusion below about the model was wrong. My port differed from the paper in four places, and the paper's own trainer, run on the same data with the paper's initialisation, also ignores the instruction (task swap 0.020° vs 0.105 for the same model on LIBERO-Goal). The data finding (fact 7) is the whole story. Full account: TurboVLA.

VLA-JEPA on the Orin for $9.7, and why best-of-N reranking is a no-go

We wanted to know if picking the best of several planned motions could improve a robot policy. We sampled 8 motion chunks per step and measured how much they differed and what they cost. They barely differed, took 1.84× the time, and their plain average captured 45 % of the possible gain.

Time per chunk, relative to 1 sample (lower is better): 1 sample 1.00×; 8 samples 1.84×; bar 1.5×1 sample1.00×8 samples1.84×bar 1.5×

Evaluation and judges · 11 of 14

Type: engineering · Result: VLA-JEPA fine-tuned for ~$9.7 scores 9/10 on the arm; best-of-8 reranking is a no-go (0.76, 1.84×). · n: 10 trials; H0 on the teleop val split

Not proven: The paper's robustness claim is not tested.

Compute: External GPU: yes (vast.ai): ~$9.7 for the fine-tune (retries not itemised). H0 and the arm gate on the Orin NX: $0. · Reproduce: 2026-10-23-paper-vs-hardware-vla-jepa · First published: 2026-10-08 · Updated: 2026-10-08

The first world-model idea was the obvious one: let the policy propose several action chunks, let a latent world model imagine each one, keep the best. Before building any of it, I checked whether the premise held. It did not.

Twelve VLAs on a Jetson Orin NX: latency and memory with vla.cpp

We wanted to know how fast twelve robot policies run on the Jetson board most hobby arms use. We ran the engine's own benchmark template on each, one evening, with every model file checked. SmolVLA took 411.2 ms per inference at the defaults; the fastest model took 27.4 ms.

Engineering on the Orin · 4 of 8

Type: engineering · Result: Minimum ms per inference for twelve VLAs on an Orin NX, from Octo 27.4 to Evo-1 893.2. · n: 20 repetitions, best of 3 processes per model

Not proven: Engine latency on fixed inputs, not the robot loop.

Compute: External GPU: no (Orin NX only). Cost: $0. · Reproduce: 2026-10-06-twelve-vlas-orin · First published: 2026-10-06 · Updated: 2026-10-06

vla.cpp (the llama.cpp-style engine for vision-language-action models) had benchmark reports for the Orin Nano Super and the AGX Orin, and nothing in between. The Orin NX 16 GB is the board most hobby arms end up on. This report fills the gap and is merged upstream as vla.cpp #36.

SmolVLA on a Jetson Orin NX: 974 → 238 ms per chunk with vla.cpp

We wanted to know if SmolVLA could run fast enough on the Jetson to stop stuttering. We served the same trained policy through a lighter engine, vla.cpp, and ran 10 trials per engine. One motion chunk took 238 ms instead of 974 ms, and 8 or 9 of 10 trials succeeded.

SmolVLA chunk inference on the Orin NX, ms: PyTorch 974 ms; vla.cpp 390 ms; vla.cpp + FA 238 ms; async budget 667 msPyTorch974 msvla.cpp390 msvla.cpp + FA238 msasync budget 667 ms

Engineering on the Orin · 3 of 8

Type: engineering · Result: SmolVLA 974 → 238 ms per chunk on the Orin NX with vla.cpp; 9/10 and 8/10 on the arm. · n: 10 trials per engine

Not proven: Success differences are within noise at n = 10.

Compute: External GPU: no (Orin NX, 20 trials on the arm). Cost: $0; SmolVLA training cost not recorded. · Reproduce: 2026-10-23-paper-vs-hardware-smolvla · First published: 2026-10-01 · Updated: 2026-10-01 · Findings: I need lower latency on a Jetson →, SmolVLA chunk inference on the Orin →

974 ms per chunk made SmolVLA stutter on the Orin NX. Serving the same checkpoint through vla.cpp brought it to 238 ms with no loss in task success.

ACT and SmolVLA on an SO-101: a 10-trial evaluation harness on a €350 arm kit

We wanted to know if a learned policy could run reliably on our arm, measured the same way each time. We built a harness that runs fixed trials and logs every motion, then tested two policies. Both worked, 9/10 or better, but one took 974 ms per motion chunk on the Jetson.

Engineering on the Orin · 2 of 8

Type: engineering · Result: ACT 10/10 (M1) and 9/10 (Orin NX), SmolVLA 9/10 on both; SmolVLA takes 974 ms per chunk on the Orin. · n: 10 trials per policy and machine

Not proven: The task is at ceiling for every policy; success is operator-judged.

Compute: External GPU: none for the gates (Orin NX, M1 Mac, 40 trials of 25 s on the arm). Checkpoint training: cost not recorded. · Reproduce: 2026-09-29-three-policies-so101 · First published: 2026-09-29 · Updated: 2026-10-27 · Findings: The $200 arm executes what it is told →

Correction, 2026-10-29

This post first said "$300 arm", then (2026-10-27) "$230 arm", the list price of the follower and leader. What I actually paid: €350 for the SO-101 pack (follower, leader and the wrist camera). The title now says €350 arm kit and the URL is unchanged. Every part with its price source is on the rig page.

Before any research question, the arm had to run a learned policy reliably and I had to be able to measure it the same way every time. This post is the baseline everything else is compared against.

LeRobot on a Jetson: why there is no pip install torch, and what it took

We wanted to know why LeRobot will not install on a Jetson with one command, and what fixes it. We built the whole software stack from source in a container image, now merged into LeRobot. The full build took 5 h 33 min, and the PyTorch compile alone was 92 % of it.

Engineering on the Orin · 1 of 8

Type: engineering · Result: LeRobot runs on the Orin NX from a container with a JetPack-built torch and a source-built torchcodec. · n: one board

Not proven: One JetPack release.

Compute: External GPU: no (Orin NX only). Cost: $0. · Reproduce: 2026-09-09-lerobot-jetson-container · First published: 2026-09-09 · Updated: 2026-09-09

pip install lerobot fails on a Jetson Orin with an error that says almost nothing. The cause: LeRobot needs Python ≥ 3.12 and torchcodec ≥ 0.11 on aarch64 with CUDA, and no channel (NVIDIA's redist, the community index) ships a cp312 CUDA torch wheel for Jetson. The fix is a Docker image that builds the stack from source; it is merged upstream as LeRobot #4599 and published on GHCR. This post is about the traps underneath it.