Efficient Algorithmic Robotics
Design planning, learning, and control algorithms that use less data and computation, and run on the parallel hardware the robot carries.
Humanoid policies must learn from limited data and run within onboard compute budgets.
A useful policy must learn from the demonstrations we can collect and compute actions quickly enough for the task.
I develop planners, policies, and controllers around the available hardware and training data.
Planning algorithms need to expose independent work to use parallel hardware efficiently.
An algorithm that can't expose parallel work leaves most of a modern accelerator idle, in the lab and on the robot.
Sutton's Bitter Lesson, Hooker's Hardware Lottery: methods win when they ride the resources that scale, compute and data. I take that as a design constraint on the three things a robot must do, search for a plan, run a model, learn in a world.
Efficient algorithmic robotics: co-design each algorithm with the hardware that runs it and the data that trains it.
Three problems on the road to useful humanoids: fast planning, data-efficient policies, and the whole-body data to learn from.
A robot in clutter doesn't need one plan: it needs thousands of candidates evaluated at once, in milliseconds, while a sequential search leaves most of the GPU idle. My PhD reframes motion planning so the GPU is the natural home.
Represent candidate plans and costs as tensors for parallel search.
Five planners in my thesis share one Generate·Score·Reduce schedule under five reducers: same iteration space, same batch-major layout, not one literal code path.
GTMP turns layered-graph search into min-plus tensor operations.
Complete adjacent-layer connectivity makes every layer transition one batched min-reduction over the next-layer axis, a dense matrix–vector product in (min, +) tropical algebra (add is min, multiply is +), the coalesced work a GPU is fastest at. The N×N edge-cost evaluations are independent; the sweep returns the exact optimum on the sampled layered graph, approaching the continuum optimum as sampling density grows.
Work-optimal ordered sweep: $M$ sequential passes, each a branch-free log-depth reduction, not a serial frontier expansion. Ideal for SIMT.
MPOT uses optimal transport to update trajectories without gradients.
Entropic OT as the reducer: Sinkhorn is two batched GEMV + two divides per iteration (Work $\Theta(Tnm)$, $T$ Sinkhorn iterations), shared across the batch, no gradients or factorizations. The marginal constraints $\mathcal{U}(a,b)$ keep the coupling valid; as $\lambda\!\to\!0^+$ it sharpens toward the min-cost transport plan, the cold limit of the same reducer motif.
MPD combines a learned trajectory prior with task-cost guidance.
Cost guidance is the score of the Boltzmann target: the same reduce, now a learned denoiser.
$D_\theta$ a learned trajectory prior; $-\nabla_z J$ the cost score; $B_\psi$ a B-spline map keeping curves smooth & feasible. The warm, learned end of the family.
MTP combines global and local trajectory sampling for online control.
A $\beta$-mixture of a local and a global proposal under one MPPI temperature $\eta$: $\beta$ trades exploitation for exploration. Batched MuJoCo-XLA rollouts of the control tensor $\textcolor{#2f7d8a}{\mathbf{U}}$ make the expectation one GPU reduce, an online MPC loop on real hardware. Amortized into a policy ⇒ Chapter 3's RL at sim-farm scale.
CLOT uses optimal transport to coordinate robots under temporal-logic tasks.
Three nested reducers compose into one search. STL robustness uses the min-max semiring (not GTMP's $(\min,+)$); the Fiedler value $\textcolor{#557a3a}{\lambda_2}(L)>0$ keeps the team connected, a smooth, batchable surrogate.
Change one reducer; keep the Generate·Score·Reduce pattern, the batch axis, the parallel reduction.
| Planner | Reducer | Work $W$ | Depth $D$ |
|---|---|---|---|
| GTMP | $\min$ (tropical) | $\Theta(MN^2)$ | $\Theta(M\log N)$ |
| MPOT | $\mathrm{softmin}_\lambda$ (OT) | $\Theta(Tnm)$ | $\Theta(T\log n)$ |
| CLOT | nested OT·STL | $\Theta(R(Tnm{+}|\Phi|T))$ | $\Theta(R\log nm)$ |
| MTP | $\mathbb{E}_{p_\eta}$ | $\Theta(BH)$ | $\Theta(H+\log B)$ |
| MPD | learned score | $\Theta(KBc_\theta)$ | $\Theta(Kd_\theta)$ |
The honest limit: dense candidate tensors waste work in clutter, the open problem I carry forward is lazy, connector-aware tensor graphs. GTMP trades the single-query latency that VAMP · FCIT* · pRRTC / cuRobo optimize, for batch throughput and global exploration.
Foundation policies (VLAs) are billions of parameters, and the scarce resource is demonstrations. Two strands: inductive bias (symmetry, structure) so a VLA generalizes from few demos, and an edge runtime and compression that make the resulting policy deployable on the robot's own 8 GB chip.
vla.cpp runs VLA policies in C++ on desktop and onboard GPUs.
The action expert cross-attends a cached vision-language prefix across solver steps (prefix-KV reuse, π0-style). Parallel action-token denoising turns the batch-1 GEMV into a wide GEMM; with BitVLA's ternary (1.58-bit) weights, an IMMA integer-tensor-core kernel speeds client inference 4.0–4.6× over the CUDA-core baseline (RTX 3060, AGX Orin). The contribution is the quantized on-device C++ runtime: to our knowledge the first ggml-lineage engine to run a flow/diffusion action-expert VLA on an 8 GB edge module.
CLP identifies redundant VLA layers from activation similarity before fine-tuning.
For column-mean-centered activations $H$, adjacent layers with CKA ≈ 1 share a representation subspace ⇒ prune candidates (necessary, then confirmed by a downstream-loss check). The score itself is training-free (one forward pass); cf. ShortGPT / Gromov et al. (cosine / angular distance), the lift is this CKA criterion on VLAs.
StructSAM · structure-preserving token merging
StructSAM merges redundant tokens in Segment Anything's image encoder while preserving boundary structure and the token spectrum. Encoder FLOPs drop ~25–30% with minor mIoU/Dice loss.
EquiVLA adds rotational equivariance to pretrained robot policies.
Token-level frame averaging over $G=C_n\le\mathrm{SO}(2)$ adds rotational equivariance to a pretrained VLA. Equivariance is approximate end-to-end and exact for the EquiActor action head.
Higher success with the same demonstrations
LIBERO 78.1→92.6% at a fixed demo budget (vs the GR00T N1.5 baseline). The equivariant head trades compute for data efficiency: exact for EquiActor, approximate end-to-end, at 194 vs 64 ms/step.
PAINT selects initial noise to connect asynchronous action chunks without retraining.
Under asynchronous execution the robot keeps moving while the next chunk denoises. PAINT picks an initial noise by a masked (partial) inversion of the flow ODE in reverse time (explicit Euler), so the unmodified forward ODE approximately meets the prefix constraint at the chunk boundary (to the integrator's order). Unlike Real-Time Chunking (RTC), which soft-masks and pays a per-step gradient, PAINT is a one-time inversion, gradient-free, no retraining.
SDN selects diffusion noise for grounded, smooth actions from a frozen policy.
Sample noise vectors, keep those contrastively grounded in the task latent (robust to spurious visual cues), then pick the smoothest (minimum jerk-magnitude) action among them. Unlike learned verifiers (V-GPS, RoboMonkey), the selector is self-contained, no value function. Training-free: +8–10% success, smoother actions.
RoboGaze uses vision-language analysis to locate and classify errors in robot videos.
Route each subtask-clip to a dimension specialist, then a critic verifies, cutting spurious false positives. A 6-dim × 30-type glitch taxonomy (kinematic, contact, temporal, …): up to +43 points of description-F1 over zero-shot VLM judges (8 VLMs, 382 human-validated clips); the critic lifts clean-clip accuracy <25% → >80%.
These video evaluations can help screen synthetic training data for the whole-body policies discussed in Chapter 3.
A humanoid must walk under shifting loads and stay safe in contact-rich, forceful interaction, too high-dimensional to program. So we learn it with force-aware RL across thousands of simulated worlds, then land it on a real 70 kg humanoid with GPU footstep search and compliant control. And every teleoperation and compliant contact becomes data, the first step toward the long-term goal: a whole-body VLA.
RL is a batched reduce over thousands of parallel worlds.
The gradient is an expectation over worlds, the same batched reduce as MTP's rollouts from Chapter 1, now carrying temporal credit assignment (the advantage $\textcolor{#557a3a}{\hat A}$) and amortized into a policy. Keeping physics, reward, and the update all on the GPU (Isaac Lab · MuJoCo Playground / MJX · Newton) puts $N_{\text{env}}\!\sim\!10^3$–$10^4$ worlds in one step, so a locomotion policy trains in minutes (Rudin et al.: quadruped, 4096 envs; humanoid whole-body is harder), not days.
Track a reference motion: mocap in, whole-body control out.
A DeepMimic-style tracking reward (shown schematically; the full objective also tracks base pose, velocities, and contacts) on a retargeted reference, trained across randomized worlds, turns a dance or a martial-arts form into a deployable whole-body policy. A capability progression (not a strict chronology): PHC, ExBody2, HOVER, GMT. The hard part is the retarget and the sim-to-real gap.
Retarget a human in real time: teleoperation as a moving reference.
The same sim-trained tracking policy takes a live human pose as its reference: a per-frame IK retarget maps human keypoints $\textcolor{#557a3a}{p^{\text{human}}}$ to a feasible robot pose, so one policy both mimics clips and follows a teleoperator (cf. OmniH2O · HOVER · AMO).
The loop closes
Every teleop episode is a labeled real-seed demo, the cheapest source of the scarce data Chapter 2's engine grades and scales.
CompliantWBC uses proprioceptive force estimates to coordinate whole-body compliance.
Per-link Cartesian impedance; the external wrench is carried to each link by the adjoint $\mathrm{Ad}^{-\top}$, and a bounded force-latent residual absorbs estimation error, empirically stable. A proprioceptive Force Latent Encoder, trained on simulated ground-truth wrenches and shielded from PPO gradients, supplies the estimate $\hat f_{\mathrm{ext}}=\psi(z_F)$. A 70 kg humanoid, no wrist/ankle F/T sensors, proprioception only.
TACT-ful combines GPU foothold search with compliance training for changing payloads.
A per-foothold cost: a capture-point (DCM) stability term $d^{\text{DCM}}$ plus penalties for roughness $Q$, steepness $E$, velocity-risk $M$, minus a climb bonus $b$, minimized by a GPU-parallel footstep search, Generate·Score·Reduce again ($\arg\min$), a GTMP-cousin layered on the RL locomotion policy. Wrench-aware compliance (the layer above) carries the load, 10 kg up and 20 kg down the stairs, no force sensing.
Bodyshop and patrol use cases, public demonstrations, open-source.
Numerical tools for black-hole energy extraction and warp-drive energy conditions.
warpax uses vectorized auto-diff in JAX to check energy conditions. The Penrose study simulates 320,000 rocket flybys to test energy extraction and escape around rotating black holes.
Successful extraction with escape is rare in the broad scans, concentrated at high spin and relativistic exhaust speeds. Repos: warpax · penrose_process.
Check energy conditions in warp drive spacetimes across all observers at a point.
warpax computes curvature and stress-energy with vectorized JAX auto-diff. It uses 4×4 matrix inequalities to test energy conditions across all observers at a point, with interval bounds for certified decisions. A negative null-energy margin identifies a violating observer direction. $G=c=1$, signature $(-,+,+,+)$. Repo: warpax.
What each chapter delivers.
Different tools for different problems, aimed at one goal: useful humanoids in the real world.
The goal: a whole-body VLA.
Manipulation VLAs mastered the tabletop. The frontier is the whole body, locomotion + manipulation + contact in one policy, and the real bottleneck is whole-body data.
A lab for whole-body robot intelligence.
The thesis: the road to useful humanoids runs through a whole-body VLA, and the planning, fine-tuning, and data that make it learnable.
Thank you.
Efficient algorithmic robotics: GPU tensor planning · edge VLA policies · real humanoids · differentiable physics.