Every lesson is something you run.
No videos to watch. Each tile below opens a live bench (real MuJoCo physics, parametric CAD, embedded firmware, Verilog synthesis, a virtual factory) that you edit, run, and get graded on. Pick one and start.
Exploring Intelligence: The Matching Principle
One idea, carried from a 1928 antenna to a theory of mind. A wave meets a boundary and whatever does not match comes back, and that same geometry reappears as lost channel capacity, as a bandwidth budget you cannot overspend, as the heat of erasing a bit, as a robot's contact chattering against a wall, and finally as surprise. You start with no prerequisites and finish by writing one function that reproduces every answer you earned along the way. The Smith Chart Navigator and the passivity disk are your instruments throughout.
Waves, reflection, and the scariest chart in engineering
Meet the founding image of the course: a wave hits a boundary, and whatever does not match comes back.
▶ Run the lab →What is information?
Put a number on surprise, so that later we can ask what a channel costs.
▶ Run the lab →What is an agent?
Draw the loop that makes something an agent, and find the one place it can touch its world.
▶ Run the lab →Impedance everywhere: the universal matching principle
Show that the same theorem sizes an antenna and a gearbox.
▶ Run the lab →Channels, capacity, and the matched filter
Move the matching idea out of impedance and into information.
▶ Run the lab →Bandwidth is a budget: Bode–Fano
Meet the conservation law that says a perfect match over a band is impossible.
▶ Run the lab →The physical price of a bit: Landauer
Find the exchange rate between information and heat.
▶ Run the lab →Learned matching: when AI designs the interface
Hand the matching problem to a network and watch it become a coordinate system a model works in.
▶ Run the lab →Impedance control and contact: staying inside the disk
Discover the safety condition for touching an unknown world, and find that it is the Smith chart's unit disk.
▶ Run the lab →Morphological computation: the body as computer
Watch a body solve a problem its controller could not.
▶ Run the lab →The free energy principle: matching as cognition
Reach the top of the ladder: surprise as the last reflected wave.
▶ Run the lab →Curiosity: seeking the reflected wave
Turn the free-energy agent active, make it seek the mismatch, and find exactly when curiosity buys speed and when it does not.
▶ Run the lab →Development: the U-shaped curve
Watch a learner *develop* (memorize, then over-generalize, then reconcile) the fingerprint that tells an entity apart from a controller.
▶ Run the lab →Capstone: a theory of intelligence as matching
Collapse the whole course into a single function, and make it reproduce every answer you earned.
▶ Run the lab →Physics-Informed Physical AI
The physical world will not be solved by data alone: action-labeled data is scarce, and a black-box net that has never heard of energy or momentum extrapolates dangerously. This course teaches the alternative, inject the physics you already know into a learner, at one of three places: the data (guided), the loss (informed), or the architecture (encoded). You build every method on-device in the browser, driving the real ferromotion Rust library compiled to WebAssembly: reverse-mode autodiff, physics-informed neural nets, Lagrangian and Hamiltonian nets, Neural ODEs, structure-preserving integrators, equation discovery, and differentiable control. Physics → AI → Physical AI, one runnable rung at a time.
The machine that follows gradients
Watch a learner improve by computing the exact gradient of its error and stepping downhill, and meet the engine that makes it exact: reverse-mode automatic differentiation, the keystone under every method in this course.
▶ Run the lab →The universal approximator
Stack neurons into a network and watch it bend onto any continuous curve. Meet the multilayer perceptron and the theorem that makes it powerful, and the catch that makes physics necessary.
▶ Run the lab →The equation of motion
See the physics a black box has never heard of: the equation of motion M(q)q̈ + C(q,q̇)q̇ + G(q) = τ, computed live by ferromotion as a double pendulum swings. This structured knowledge is the prior every method from here on injects into a learner.
▶ Run the lab →Energy, and why integrators drift
A frictionless system conserves energy forever, but a careless simulator invents or leaks it. See why the update rule decides, meet structure-preserving integration, and understand the failure mode that haunts every learned dynamics model.
▶ Run the lab →Solve an equation with no data
Train a network to satisfy a differential equation directly, with no solution data at all. The loss is the equation's residual. This is the physics-informed neural network, the method that named the field.
▶ Run the lab →Conserve energy by construction
Build a network that cannot violate energy conservation, the Hamiltonian Neural Network, and watch it hold a clean orbit where a black box, trained on the same data, spirals away. This is the structural fix for the drift you saw in Module 2.
▶ Run the lab →Learn the structure, not the map
Build a network that keeps the equation of motion's structure and learns only its physical pieces, the mass matrix and the potential, with the inertia guaranteed valid by construction. This is the Deep Lagrangian Network, and it recovers ferromotion's own dynamics from data.
▶ Run the lab →Learn the flow, predict the future
Learn a system's continuous dynamics by training THROUGH an ODE solver, the Neural ODE, and watch its rollout predict the trajectory past the data it was trained on. Meet the integrator-in-the-loop idea behind Variational Integrator Networks.
▶ Run the lab →Discover the equation
Recover a system's governing equation directly from data, not a black-box fit, but an actual formula. Meet SINDy and the sparsity knob that separates the real terms from the noise.
▶ Run the lab →Make it linear
Turn a nonlinear system into a linear one, not by approximating, but by changing coordinates. Meet the Koopman operator: lift the state through the right observables and the dynamics become exactly linear.
▶ Run the lab →Interpretable by construction
Build a model whose every part is a number you can read, a blend of local linear models, and get an accurate, data-efficient fit that an engineer can inspect and trust, unlike a black-box network.
▶ Run the lab →Control by gradient
Tune a controller by backpropagating a trajectory cost through the closed loop, the payoff of a differentiable model. See why one gradient per rollout beats reinforcement learning's thousands of episodes.
▶ Run the lab →Learn in imagination
Close the whole loop: identify a model of an unknown plant from data, tune a controller entirely inside that learned model, and deploy it on the real system. The complete physics-informed pipeline, on-device.
▶ Run the lab →The industry agrees: structure-as-differentiation, at scale
See that the principle this course has built lesson by lesson (a physics-structured, differentiable model, identified and controlled by gradient) is the same bet three 2025–2026 efforts are placing at industrial and research scale: Newton (GPU differentiable physics, contributed to the Linux Foundation by Disney Research, Google DeepMind, and NVIDIA), gradient-based system identification on real robots using MJX, and OrbiSim's argument that a world model should itself be a differentiable physics engine rather than a generative video predictor.
▶ Run the lab →Your device is a fabric
See the real cross-fabric runtime measure your device and route each workload to the backend that wins on it (tiny work to the CPU, large work to your GPU) the adaptive heterogeneous compute the whole course runs on.
▶ Run the lab →"It Runs" Is Not "It Runs In Time"
Measure three costs that a passing test cannot see: whether the policy meets its deadline, whether the control tick allocates, and whether your own benchmark number is allowed to be quoted. Pass = you drive the clock into each of its three health states, explain why two of them are different failures rather than degrees of one, and make a timing measurement refuse to be quoted.
▶ Run the lab →The model meets reality
Calibrate a robot's masses and friction from recorded torques by exact gradients through the dynamics, real-to-sim, the single most validated use of differentiable physics.
▶ Run the lab →The Grasp Number Lies Twice
Take the two numbers everyone grades a grasp with - a force-closure quality and a stick-or-slip flag - and find what each one hides. You will discover that a coplanar grasp is full rank in six dimensions rather than degenerate; that the force-closure number is a direction-sampled UPPER bound whose value falls threefold as you probe more finely, so a claim read off it can be a property of the sampler rather than of the grasp; and that a contact reported as stuck has usually already lost a quarter of its stuck area. Pass = you read the rank, read how far the quality metric still moves under finer sampling, and find the load at which a stick-area monitor warns against the load at which a Coulomb monitor does.
▶ Run the lab →The Robot Is the File
Price three conventions in a robot description in newton-metres, and find out that the pose you test in decides which of them you can see. You will read a joint limit that means something different depending on the joint type, watch a length-scale error change a torque by a factor that is not the length ratio, flip a header token and move gravity, and discover a pose where a hundred-fold error is exactly invisible. Pass = you state all three errors as numbers and explain why one of them cannot be undone by rescaling the answer.
▶ Run the lab →When coefficients break
Know when the lumped coefficient model of a rotor, hull, or pour stops telling the truth, and how a resolved, verified, differentiable fluid solver reveals the fix, live in your browser.
▶ Run the lab →Don't trust a PINN, certify it
A PINN drives a residual toward zero, a soft penalty, not a guarantee. Compute an a-posteriori certificate: a rigorous bound on the true error from the trained net's own residual, needing no true solution. Then watch the same idea become an energy certificate on a controller and on a frozen policy. Soft → structural → proven.
▶ Run the lab →The Gradient That Lies
Measure, on a contact you can solve exactly, that the gradient a differentiable simulator returns does not converge as the contact stiffens - it diverges as the square root of stiffness and points the wrong way over most of the usable range. Then find out WHICH PART of the simulator is responsible, because the obvious answer is the wrong one. Pass = you read the divergence exponent off the lab, find a stiffness where the sign is wrong, and show the same contact model getting the right answer once the integrator changes.
▶ Run the lab →The Reference That Shares Its Machinery
Take a measurement you already trust and find out what it actually measures. You will split the contact-gradient error into the part the integrator causes and the part the contact model causes, discover they move in opposite directions, and learn the two ways a reference lies to you: by sharing machinery with the thing it scores, and by having a noise floor above the number you wanted to quote. Pass = you name the integrator share and the model share at 1e6, and say why an answer that moves when you change the probe is not an answer.
▶ Run the lab →What a Certificate Cannot Claim
Learn to read a verification result as a claim with preconditions rather than a number. You will make the same system return Certified, Refuted and Undecided; discover that one of those transitions involves no change to the geometry at all; find a green verdict that means nothing; and find a fourth failure the lab uncovered in itself, a bound that was only valid in a region nobody checked. Pass = you produce all three verdicts, explain which control caused each, and say what the precondition check found.
▶ Run the lab →The Energy-First Turn: Computing as a Function of Energy
Electricity, not transistors, is now what schedules the next model. This course teaches you to price computing in joules and to tell an honest energy claim from a flattering one: where the joules actually go, why data movement rather than arithmetic is the bill, which substrates escape it, and what evidence would count as proof. You leave able to audit an efficiency claim rather than repeat it, and to tell a claim a cleverer algorithm can destroy from one it cannot.
How cheap is computing allowed to be?
Compute the Landauer limit yourself and measure how far above it a real operation sits. The gap is the headroom the whole field is arguing about.
▶ Run the lab →The bill is data movement, not arithmetic
Build the energy ledger of a small workload and find out which side it is actually on. This is the fact that decides what a cheaper computer must look like.
▶ Run the lab →Computation as relaxation
Solve the same problem twice (once by executing a fixed sequence, once by letting a system settle into a low-energy state) and compare what each one costs.
▶ Run the lab →The receipt, and why grades never blend
Build an energy receipt that carries its own provenance, then compose several and watch the composite take the weakest grade rather than the average.
▶ Run the lab →Dequantize an advantage yourself, then find the one that survives
Build a speedup that looks like new-hardware magic, destroy it with a classical algorithm, and then measure the one advantage that no algorithm can take away.
▶ Run the lab →Measuring Energy in Physical AI: Where You Put the Meter
A robot energy figure is only meaningful once you say where the meter was and which definition of energy you used. This module builds both, on one two-axis instrument, and ends with a reporting record a reviewer can actually check.
Where you put the meter
Measure one motion at four planes and show the answer changes.
▶ Run the lab →Three ways to lose the same joule
Split braking energy into recycled, exported and burnt, and show a mains meter cannot separate them.
▶ Run the lab →The one-volt race
Show that a comparator tolerance, not the control law, can decide where a machine's energy goes.
▶ Run the lab →1/T³ and 1/T
Fit the scaling exponent for two published energy models and show they disagree.
▶ Run the lab →The reporting record
Build an energy report a reviewer can check, using what the existing standards already supply.
▶ Run the lab →Sim to Real: The Road to Physical Agency
A policy that works in simulation and fails on a body has met one of four walls: the world model is wrong, the action-conditioned transition function is wrong, a sensing channel has degraded rather than failed, or the body itself has drifted. This course measures each wall against the published record, in five languages, and teaches the discipline that decides whether any of those measurements can be ranked at all. Every lab reproduces a figure from TR-2026-35 on your own machine, with the standard library and nothing else.
Four walls, and which one nobody is watching
Count the attention paid to each wall on both sides, 15 open problems named in the practitioner session against 25 Institute holdings, and work out which wall is under-attended. The answer depends on the normalisation, and saying which one you used is part of the answer.
▶ Run the lab →Who reset the scene: the variance that governs every ranking
RoboChallenge measured a real success rate moving from 0% to 100% with task, props and model held fixed, varying only which class of human reset the scene. Compute what sample size a ranking would need to survive that, and find out which lever actually moves it.
▶ Run the lab →A world model can look right and move wrong
Rank the seven EWMBench models on appearance and on action-conditioned dynamics, correlate the two orderings, and test the correlation against a null you enumerate rather than assume.
▶ Run the lab →Angle is the integral of angular velocity, so say so in the loss
Take the one result in the review where a physical prior on the transition moved real-robot success, recover the trial count behind its two percentages, and test the effect against the resolution of that counter.
▶ Run the lab →Four bands and a missing axis
Rebuild the French randomisation ladder from 0 out of 20 to 93 per cent, price the marginal gain of every rung, and audit which physical channels the ladder never varies.
▶ Run the lab →Three bands, one real number
Read the Korean three-tier sweep for what it prices, separate a converged success rate from a convergence budget, and check a reported percentage against its own stated trial count.
▶ Run the lab →The contact limit is a published field
Read ISO/TS 15066:2016 Annex A as an instrument rather than as an adjective, and turn its energy limits into an admissible approach speed for a 1 kg and a 20 kg effective robot mass.
▶ Run the lab →Friction, assumed everywhere and estimated nowhere
Price the shipped vendor friction prior of 0.1 to 1.25 in the two currencies it actually spends, newtons of clamp force and probability of slip, then audit every friction quantity the review located and count the dimensionless ones.
▶ Run the lab →Certified at one corner, measured on the task almost nowhere
Reproduce what ISO 9283 pins down about drift, then reproduce the one retrievable protocol that measures drift on a task, and work out what a twenty-trial cell can resolve.
▶ Run the lab →What identification costs, in trials and then in joules
Fit the compute against accuracy exponent for a published identification sweep, then price one identification run in joules and see how far the reported inputs carry you.
▶ Run the lab →The accounting unit with no measured instance
Adjudicate thirteen stated gaps against a five-region record, count where the binding constraint actually sits, and close on the one quantity that a standard now requires and that five sweeps did not locate as a measurement.
▶ Run the lab →Energy as Evidence: What a Machine Can Prove About Itself
Software asserts. Energy is spent. A power trace is the one account of a machine's activity its own code cannot simply write, which makes energy the natural substrate for a machine that has to demonstrate its behaviour rather than claim it. This course builds that argument and then bounds it, on measured data: which measurement plane can see what, how far a physics model of a body actually predicts, and the two places the meter goes blind. Then it follows one candidate mechanism — a machine proving it is the machine it claims to be — from plausible to nearly dead to rescued, ending at the question that is still open. Every figure carries its source.
The body decides what the joules reveal
Show that the compute-to-actuation ratio is set by the workload, not the chassis, and that it inverts the common assumption.
▶ Run the lab →Which plane can see it
Show that a hidden load is visible or invisible depending on which rail the meter sits on, with both readings correct.
▶ Run the lab →The joule you cannot forge
Build the expected-power model for a body and use its residual as the detection floor.
▶ Run the lab →The leak you find with an IMU
Show that energy crossing a subsystem boundary is undetectable electrically, and that a second sensing modality is what finds it.
▶ Run the lab →Verify the instrument
Show that an energy monitor can be entirely dead while producing confident output, and that only a known load reveals it.
▶ Run the lab →Who gets to define the method
Show that a measurement method is adopted, not imposed, and locate the morphologies whose method is still unwritten.
▶ Run the lab →The difference between twins
Establish that two motors of the same model differ measurably, and find that number without buying anything.
▶ Run the lab →Which number can be a name
Show that a coefficient can only serve as an identity if it is individually identifiable, and find which one is.
▶ Run the lab →The fingerprint that melts
Show that the identity dissolves under ordinary operation, find the crossover temperature, and rescue it with the cheapest possible instrument.
▶ Run the lab →Energy First Architecture
The physics-first thesis, built in the browser: one scalar energy a body descends to act, and the same energy is the proof it will not diverge. Descend it to control, read its decrease as the certificate, get that certificate for free by structuring the energy as a port-Hamiltonian (at any number of joints, where a box proof cannot), and gate a task policy so it verifies before it commits. No bolted-on verifier; one energy, and the proof is the objective. This is an active research line, not ours alone (co-learned port-Hamiltonian models with passivity-based safety certificates, arXiv 2604.26172 and 2512.24493, and physics-driven world models like PH-Dreamer); what you build here is the open, on-device, readable version of it.
To act is to descend an energy
Control a pendulum by descending a shaped energy, the energy IS the controller, not a policy bolted to one.
▶ Run the lab →The same energy is the proof
See that the energy you descended is, unchanged, a Lyapunov certificate: it provably decreases along the closed loop.
▶ Run the lab →Structure, not proof
Earn the certificate by CONSTRUCTION at any number of joints, where proving it box-by-box is astronomically infeasible.
▶ Run the lab →Verify before you commit
Put a certificate gate on a task policy: veto an unsafe action before it commits, a guarantee, not a score.
▶ Run the lab →Design and Simulation of Devices
Model a Physical AI device in parametric CAD and prove it out in simulation before any hardware: geometry, mechanisms, dynamics, and the design→simulate→improve loop.
Code is the Clay: Primitives & Solids
Create a named solid of specified dimensions in real build123d and inspect it in the 3D viewer. Pass = the solid's bounding box matches the target within tolerance.
▶ Run the lab →Workplanes & Sketches: 2D Becomes 3D
Place a 2D sketch on a workplane and extrude it into a solid, then cut a feature through it. Pass = the resulting build123d Part has the target bounding box AND the target volume (the through-hole removes the right amount of material).
▶ Run the lab →Your First Parametric Part
Drive a real build123d part from named Python variables instead of magic literals, so one number reshapes the whole solid. Pass = result is a 60 x 40 x 8 mm plate with a centered 6 mm through-hole: bounding box within +/-0.1 mm AND volume within +/-1 mm3 of 18973.81 (box volume minus the drilled cylinder), proving the hole is really cut, not faked.
▶ Run the lab →Driven Dimensions & Relationships
Express a part's dimensions as formulas of a single driver parameter so derived dimensions stay consistent when the driver changes - verified by the bench measuring the real OpenCascade bounding box against an exact target.
▶ Run the lab →Constraints & Valid Ranges: A Part Family
Build a real parametric part that lands inside a fixed spec envelope: drive its dimensions so the solid's bounding box and material volume both fall within tolerance of the published datasheet, proving the part is a legal member of the family rather than an out-of-range variant.
▶ Run the lab →Locating Parts in Space
Position parts in a shared coordinate frame with Pos (and Rot when needed) so the combined assembly fills an exact envelope - placing one solid on top of another and grading the bounding box of the fused part within tolerance.
▶ Run the lab →Joints & Degrees of Freedom
Define a joint between two parts and correctly state and realize its allowed motion - revolute vs. prismatic - exposing exactly one intended degree of freedom and no others.
▶ Run the lab →A Mechanism That Moves
Compose joints into a linkage and sweep the input through its full range to confirm the output traces the target motion path with no self-collision.
▶ Run the lab →From CAD Body to Physics Body
Turn a geometric body into a physics body by giving it the right mass, then simulate on real MuJoCo until the spring-loaded part settles at the spec deflection (-0.10 m).
▶ Run the lab →Force Balance: Spring vs Gravity
Tune the spring stiffness so the spring force balances the load's weight at the target deflection, reading force equilibrium straight off a real simulation.
▶ Run the lab →Reading the Verdict: Did It Settle?
Learn that touching the target once is not passing: add damping so the device truly SETTLES (velocity → 0), and read the simulator's settle verdict correctly.
▶ Run the lab →The Improvement Loop: Measure → Tune → Re-Sim
Diagnose a failing device from sim telemetry and adjust the correct parameter(s) in the correct direction to bring it to spec, and prove the change was driven by the measured data, not by guessing.
▶ Run the lab →Capstone: Design, Simulate, Validate & Optimize a Device
Deliver a complete, multi-feature parametric part to an exact spec: a mounting bracket = base plate + cylindrical boss + through-hole. Build it in real build123d on the OpenCascade kernel, then validate it against the spec by reading its bounding box (60 x 40 x 20 mm) and its volume (~20607.4 mm^3). Geometry valid, spec compliant within tolerance.
▶ Run the lab →Programming Physical AI
One simulated differential-drive rover, commanded at three rising depths (visual blocks, Python scripting, and bare-metal MCU), re-solving the same tasks at each depth until you can choose the right level of abstraction for a physical-AI task and prove it.
The Embodied Loop
Wire a sense->decide->act loop that drives the rover forward and halts it within 0.25 m of the goal with no overshoot.
▶ Run the lab →React and Avoid
Build a reactive rule-based behavior using conditionals so the rover avoids an obstacle and still reaches the goal with zero collisions.
▶ Run the lab →Blocks Are Python
Read the Python generated by a block program and correctly predict the effect of editing a single generated line before running it.
▶ Run the lab →Reading the World
Write control(obs) that reads the rover's goal_bearing each step and steers toward the goal pad, turning the differential-drive wheels so the rover reaches the goal within tolerance instead of driving blind.
▶ Run the lab →The PID Loop
Write a proportional heading controller in Python control(obs) that eases the rover onto a goal pad within a tight 0.12 m tolerance, with no overshoot or weave.
▶ Run the lab →Plan With a State Machine
Design a finite-state controller in Python control(obs) that switches modes (SEEK far away, ARRIVE up close, AVOID near a wall) to drive the real MuJoCo rover onto the goal pad and settle within tolerance.
▶ Run the lab →Learn From Data
Train a simple classifier mapping sensor readings to a discrete action and run it on the rover, meeting held-out accuracy >= 0.85 and goal completion with zero collisions.
▶ Run the lab →Reinforcement Learning
Define a reward function and train an RL policy in-sim to convergence (smoothed reward >= 6.0) with a greedy rollout that reaches the goal safely and efficiently.
▶ Run the lab →Imitation and Sim-to-Real
Clone a demonstrated trajectory with behavioral cloning to RMSE <= 0.12 m and correctly explain why a sim-perfect policy can fail on real hardware.
▶ Run the lab →GPIO, Peripherals & the Control Loop
Write your first no_std Rust firmware: own the rover's peripherals, blink a GPIO LED, and drive the motors from the control loop to reach the goal.
▶ Run the lab →Timers, PWM & Proportional Drive
Use PWM motor channels and the millisecond clock to replace bang-bang control with a smooth proportional controller that settles in the pad without overshoot.
▶ Run the lab →Async Tasks & the Real-Time Loop
Structure firmware the Embassy way, with concurrent concerns on one real-time loop, by running a navigator AND a fixed-rate LED heartbeat off the millisecond clock, without blocking.
▶ Run the lab →Full Autonomy in Python
Combine perception and control into one control(obs) that reliably drives the differential-drive rover to the goal pad within tolerance on real MuJoCo physics, fixing a partial starter controller.
▶ Run the lab →Optimize the Critical Loop to the Metal
Re-implement the full autonomy control loop as no_std embedded Rust firmware against the rover HAL, with proportional steer-and-ease plus a non-blocking heartbeat, and prove it lands the rover inside a tight 0.12 m tolerance running directly on the metal.
▶ Run the lab →Manufacturing Physical AI
Take a part from a clean CAD model to a humming, optimized production line inside a browser-native virtual-factory twin: deciding how to make it, generating its process plan, taming tolerance and variation, balancing the line, and optimizing a whole factory against throughput, cost, and yield.
What "manufacturable" means
Given the sensor-mount CAD part, identify at least 3 manufacturability problems and state why each is a problem, each mapped to the correct defect class on a fixed grader seed.
▶ Run the lab →Choosing a material and a process
For the sensor-mount part and a stated requirement (strength, cost, count), select a material+process pairing and justify it against at least two alternatives, using the twin's estimated cost, time, and feasibility.
▶ Run the lab →Designing for the process (DFM)
Modify the part's geometry to remove ≥2 flagged DFM violations while preserving its functional dimensions, and verify the inspector now passes.
▶ Run the lab →From geometry to toolpath
Generate a valid roughing + finishing toolpath for a pocket and explain how tool diameter and stock define what the path can and cannot reach.
▶ Run the lab →Process parameters
Choose spindle speed, feed, and depth-of-cut that complete the cut with no overload and an acceptable surface-finish score, and state the trade-off each parameter drives.
▶ Run the lab →Sequencing a process plan
Order a multi-operation plan into a valid sequence, choosing setups, and justify why the order is forced by datums and the surfaces each operation creates.
▶ Run the lab →Tolerances: the band a part must live in
Assign tolerances to ≥2 critical dimensions and predict how tightening or loosening each changes cost and fit, reaching a functioning fit at the lowest cost.
▶ Run the lab →Where variation comes from
Run a batch, read the output distribution, identify which process parameter drives the spread, and reduce it.
▶ Run the lab →Tolerance stack-up
Predict whether a chain of toleranced parts will assemble using both worst-case and statistical (RSS) stacks, and state when each method applies.
▶ Run the lab →Assembly sequencing
Produce a feasible assembly order for a multi-part product and explain at least one constraint (access, fastening, fit) that forbids an alternative order.
▶ Run the lab →Throughput & the Bottleneck
Find a line's bottleneck (the station with the slowest per-machine cycle) and fix it so the line meets its throughput target.
▶ Run the lab →Balancing the Line
Balance a multi-station line so no single station dominates, including the SECOND bottleneck that appears once you fix the first, to hit a high throughput target.
▶ Run the lab →Yield, scrap & process capability
Compute a line's yield and process-capability index (Cp/Cpk) from a batch, and raise yield above a target by centering and/or narrowing the process.
▶ Run the lab →Optimizing Under Competing Targets
Hit the throughput target at MINIMUM cost. Every machine costs money, so add capacity only where it actually buys throughput (the bottleneck), staying within budget.
▶ Run the lab →Capstone: Run & Optimize a Virtual Factory
Take a full five-station line from below target to meeting both a throughput spec and a tight machine budget: the whole manufacturing toolkit (bottleneck, balancing, cost) at once.
▶ Run the lab →AI + Uncrewed Aircraft
Autonomy for drones, sim-first and NDAA-clean: build the whole stack (control, perception, estimation, planning, and the multi-agent swarm, where the code you write is the code that flies the aircraft) on-device, so the boundary is the aircraft's own, and staying aloft under wind and GPS-loss is viability held under disturbance.
Hover a Quadrotor
Size the four rotor speeds so total thrust exactly cancels weight, holding a hover to machine precision.
▶ Run the lab →Close the Loop
Add a PD controller on altitude that drives the quad from the ground to a target height and holds it with no steady-state drift.
▶ Run the lab →Find the Target
Detect a bright target in a noisy image and report its pixel centroid, the input a tracker or a controller acts on.
▶ Run the lab →Estimate Motion
Estimate how far the scene shifted between two frames, optical flow, the GPS-free motion cue behind position hold and VIO.
▶ Run the lab →Fuse the Sensors
Fuse a noisy altitude sensor with an accelerometer through a Kalman filter that beats either sensor alone.
▶ Run the lab →Track Through a Turn
Estimate a turning aircraft's 2-D position from noisy range fixes with an Extended Kalman Filter, linearizing a nonlinear measurement, the way a real autopilot's EKF2 does.
▶ Run the lab →Plan a Mission
Order a set of survey waypoints into a short tour so the aircraft covers the area without wasting battery on backtracking.
▶ Run the lab →Learn to Fly
Tune a control gain by trying and scoring rollouts, beating a fixed baseline, the seed of learned control.
▶ Run the lab →Formation Without a Leader
Drive a group of drones into an even line using only local averaging, leaderless consensus that survives a dropout.
▶ Run the lab →The Swarm Bench
Fly the whole fleet through the real deterministic WGSL solver, and understand why the same controller flies the aircraft.
▶ Run the lab →Silicon for Physical AI
Design the silicon that runs Physical AI, from a single NAND gate to an edge-AI accelerator, then out to a real chip. Logic, synthesis, timing, quantization, AI-assisted design, and the economics of getting made, with TinyTapeout as the real-fab capstone.
The Universal Gate
Build AND, OR, and NOT using only NAND, proving one gate is enough to compute anything.
▶ Run the lab →The Adder
Compose gates into a full adder, then chain them into an 8-bit ripple-carry adder that actually adds.
▶ Run the lab →Write It in Verilog
Write a real adder in Verilog and synthesize it with the actual Yosys, then watch it pass on the synthesized netlist.
▶ Run the lab →Synthesize: Fewer Gates
Take a function written as a raw sum of every true row and factor it into far fewer gates, what logic synthesis (Yosys) does for a living.
▶ Run the lab →The Critical Path
Compute a design's critical-path delay and see why a ripple-carry adder can't hit a fast clock, the timing half of PPA.
▶ Run the lab →The MAC Array
Build a multiply-accumulate array that performs a matrix multiply, and count the MACs, the fundamental work of a neural accelerator.
▶ Run the lab →Quantize for the Edge
Quantize a float matmul to int8 and show the accuracy holds, the move that lets Physical-AI inference run in a fraction of the power and memory.
▶ Run the lab →Verify the Machine
Catch a bug in AI-generated RTL by writing a testbench, the verification-first discipline that makes AI-assisted design usable.
▶ Run the lab →The Cost of Getting Made
Compare the real cost of paths to silicon and see why leading-edge is esoteric while open shuttles put a real chip within reach.
▶ Run the lab →Tape Out Your Tile
Connect the whole course into the real flow, RTL to a fabricated tile, and see the honest node ceiling and the path to a chip you can hold.
▶ Run the lab →Capstone: Design a Wake-Word Tile
Pull the whole course into one design: an always-on wake-word accelerator tile for a hearable, correct in logic, closing timing, meeting throughput within a power and area budget, verified, and cheap enough to actually fabricate.
▶ Run the lab →Rust for Physical AI
A language, not a syntax tour. You learn Rust by writing the firmware that drives a 3D rover: every lesson compiles real no_std Rust to WebAssembly and runs it as the live control loop. When the borrow checker rejects a bug, you watch it reject the bug before the robot could ever make it. Ownership and memory safety without a garbage collector, the type system as a modelling tool, zero-cost abstraction, and the one-binary seam from browser sim to bare metal, the substrate (Ferric) that makes the boundary the robot's own, on-device, no cloud: the reasons Physical AI is being written in Rust.
Ownership: the Compiler Catches It First
Understand ownership and moves by reading a real borrow-checker error and fixing it, so firmware that misuses a peripheral fails to build instead of misbehaving on the robot.
▶ Run the lab →Borrowing: Share Without Giving Away
Use shared and mutable references to pass the peripherals into helper functions without moving them, the everyday tool for structuring firmware into readable pieces.
▶ Run the lab →Option: No Null, No Silent Bug
Model a sensor's 'no reading' sentinel as Option<f32> and handle it with match, so a missing measurement can never be used as if it were a real distance.
▶ Run the lab →Enums: States You Cannot Get Wrong
Model the controller as an enum state machine and let exhaustive matching force every state to be handled, so an unhandled mode is a build error rather than undefined behaviour on the robot.
▶ Run the lab →Traits: Reusable Control, Zero Cost
Define a Controller trait, implement it on a Pursuit struct, and call it through a generic function, seeing that the abstraction adds no runtime overhead on the metal.
▶ Run the lab →One Source, Two Targets
Write the portable control core and understand the seam: the same control() that compiles to WebAssembly here also cross-compiles to a Cortex-M or RISC-V target, with only the HAL changing.
▶ Run the lab →Correct, and On Time
Build an eased proportional loop and understand why no garbage collector means a constant-time tick, the property behind reproducible control that the Institute's determinism work depends on.
▶ Run the lab →Capstone: The Portable, Deterministic Controller
Compose the whole course into one firmware, a Controller trait, a Phase state machine, and a non-blocking heartbeat, and land the rover inside a tight 0.12 m pad with the status LED beating, all in no_std Rust.
▶ Run the lab →Embodied AI Design: Humanoids for Work and Play
Design an embodied AI end to end, the body and the behavior, for the two arenas pulling humanoids into the world: work and play. You size a joint in real MuJoCo, build a walking gait, transfer it from simulation with domain randomization, build the foundation-model stack that turns pixels into actions (the priors, not the guarantee, what makes each action safe is the certificate it commits under, and its economy is joules per viability-second), give motion style through dance and martial-arts form, and probe how a robot learns by playing. Grounded in the 2026 reality of humanoids on real lines and in real homes, it closes on the question the field is actually asking: how a robot amplifies people instead of replacing them.
Sizing a Joint Actuator
Size a compliant joint's holding stiffness so it supports a leg segment at a target crouch, the balance a real series-elastic actuator must strike.
▶ Run the lab →Reach: Kinematics and the Workspace
Solve the inverse kinematics of a 2-link arm to show how a body's link lengths and joints set the space it can reach.
▶ Run the lab →Standing Up: the Support Base
Design a humanoid's feet so its center of mass stays over the support base and it does not topple, the most basic stability constraint of any legged body.
▶ Run the lab →Active Stance: Coordinated Whole-Body Control
Write a controller that commands a real MuJoCo humanoid into a deep, coordinated stance and holds it upright, the active counterpart to the passive support base.
▶ Run the lab →Stepping to Recover: the Capture Point
Compute where a biped must step to arrest a push, using the capture point of the linear inverted pendulum, the reduced-order model roboticists design stepping balance with.
▶ Run the lab →A CPG Gait: Physics Plus a Kiss of Control
Build a central pattern generator that drives a rhythmic gait, letting the body's dynamics do most of the work while a small control signal moves it forward.
▶ Run the lab →Sim-to-Real by Domain Randomization
Choose a controller that survives the reality gap by optimizing worst-case behavior across a randomized ensemble of robot models, the recipe behind 84-93% zero-shot transfer.
▶ Run the lab →The Bridge, Not From Scratch
Show why a robot policy learns from a handful of demonstrations when it starts from a pretrained backbone's features, versus needing far more data from scratch.
▶ Run the lab →Action Chunking and the Two Systems
Show why predicting a short horizon of actions from one observation tracks a moving goal better than a purely reactive policy, the idea behind pi-0 and Figure's Helix.
▶ Run the lab →Dance: Style and the Beat
Make a robot's motion expressive by synchronizing its gait to a musical beat, the entrainment at the heart of choreorobotics.
▶ Run the lab →Martial Arts: Forms and Timing
Compose a martial-arts form from timed keyframe poses, hitting each on time while keeping the center of mass over the support base.
▶ Run the lab →Play: The Drive That Expands the Body
Show that an agent that plays at the edge of its competence expands what it can do far faster than one chasing random goals, play as a self-directed curriculum.
▶ Run the lab →Curiosity: Learning Before Rewards
Show that an agent driven by novelty explores far more of its world than a random walk, the mechanism by which robots (and children) learn through play before any goal is set.
▶ Run the lab →Agency and Action Efficiency
Implement the action-efficiency score that measures goal-directed intelligence, and see why brute force scores near zero while an efficient, guided agent scores high.
▶ Run the lab →Where the Robot Earns Its Place
Analyze a production line to find the bottleneck and deploy a humanoid work cell where it actually raises throughput, the deployment reality of 2026.
▶ Run the lab →Amplify, Not Replace
Design the division of labor between a human and a humanoid so the pair beats either working alone, while keeping high-value craft work with the person.
▶ Run the lab →Capstone: Design Ada, a Companion Humanoid
Pull all six modules into one coherent humanoid design for a named work-and-play role, and prove the design is internally consistent, strong and stable enough to work, articulate and efficient enough to play.
▶ Run the lab →Robot Learning: From Demonstrations to a Released Policy
Teach a robot to reach by showing it, not programming it. You turn demonstrations into data, clone the behavior with a linear policy and then a small neural network trained by gradient descent, learn the honest test that separates generalizing from memorizing, and finish by running the Institute's released checkpoint, the exact forward pass, before watching the real weights drive the arm live. Every lesson runs on your device.
Program vs. Policy
See why a hand-written controller falls short on a reach task, and why the data itself becomes the program.
▶ Run the lab →The Dataset Is the Program
Prepare a demonstration set the way a policy needs it: normalized inputs and an honest, episode-level split.
▶ Run the lab →Linear Behavior Cloning
Fit the simplest possible policy, one linear map from observation to action, in closed form, and measure it on held-out episodes.
▶ Run the lab →A Neural Policy, Trained by Gradient Descent
Build a small multi-layer policy with the same shape as the released checkpoint, and train it by gradient descent until it beats the linear floor.
▶ Run the lab →When Cloning Drifts: DAgger
See why a cloned policy drifts on the states it visits, and fix it with DAgger, training the policy on its own distribution.
▶ Run the lab →Did It Learn, or Memorize?
Tell generalization from memorization by comparing training error to held-out error, and see why normalization is what buys the difference.
▶ Run the lab →Crossing the Reality Gap
See why a policy that is perfect in simulation can fail on real hardware, and make it robust with domain randomization.
▶ Run the lab →Beyond Frozen: The On-Robot Flywheel
See that 2026's best robot policies keep learning after deployment, and why gating an update on the worst case, not the average, is the harder problem this course has been building toward.
▶ Run the lab →Run the Released Checkpoint
Run the exact forward pass of the released checkpoint, understand its 17,923 parameters, and hand off to the live demo.
▶ Run the lab →How Many Seeds Does a Ranking Need?
Compute how much evidence a claim like 'policy A beats policy B' actually requires, and what a multi-task suite does to that number. Pass = you derive the seed count for a 0.8-versus-0.7 comparison, confirm it empirically, and state the cost of comparing 31 tasks at once.
▶ Run the lab →Capstone: Build the Whole Pipeline
Assemble everything (normalize, split by episode, train, and verify on held-out episodes) into one shippable policy, then go make your own in Forge.
▶ Run the lab →Vision-Language-Action: Build a Policy You Can Talk To
Build a vision-language-action policy from the ground up, because to judge the incumbent path of embodied AI, you must first build it. You make vision that turns pixels into places, language that grounds open-vocabulary instructions, and an action head that joins them; you prove it obeys words rather than memorizing a target; and you meet the honest costs a VLA pays a body (it is data-hungry, it fails out of distribution, and it carries no guarantee before it acts) plus the two problems we hit shipping our own: compositional order, and why motion needs more than one frame. Build the incumbent, know exactly what it costs, then see the physics-first inversion in the Energy First Architecture course, where one energy is the controller and its own proof.
See: pixels to a place
Turn a camera frame into where things are, the first job of a VLA's vision.
▶ Run the lab →Be told: ground the instruction
Ground colour words in an embedding space so novel phrasings still land on the right target, open-vocabulary language in miniature.
▶ Run the lab →Act: build the VLA
Combine vision and language into a policy that sees both targets, obeys the instruction, and acts toward the named one.
▶ Run the lab →Does it obey?
Prove the policy follows the instruction rather than chasing a fixed target, by flipping which colour you ask for.
▶ Run the lab →When words have order
Confront the compositional-order problem, 'red on green' vs 'green on red', and apply the honest fix our stacking VLA uses.
▶ Run the lab →Motion needs memory
See why a single frame under-determines the action, and why stacking frames, the 46.6%→82.9% jump on real pixels, recovers it.
▶ Run the lab →The frontier: four models, two bets
Place 2026's frontier VLAs on the predict-vs-control map, and see in miniature why factoring channels lets a policy reach combinations it never saw.
▶ Run the lab →Physical AI for Space Logistics and Transportation
Space logistics is a velocity budget you compose and a chain of maneuvers an autonomy stack flies. Compute the rocket-equation wall and pay it down with infrastructure; propagate relative motion with Clohessy-Wiltshire and solve a two-impulse rendezvous; estimate a tumbling target with a Kalman filter; and seat a part by force, not position. Every bench runs the real math behind the Charlot Lab's orbital-logistics instruments.
The rocket-equation wall
See why a single vehicle paying the whole velocity budget hits an exponential wall, and where a destination becomes physically unreachable.
▶ Run the lab →Composing the budget
Pay the budget down with reusable infrastructure and autonomous in-space transport, and reach destinations a single vehicle cannot.
▶ Run the lab →Relative motion: Clohessy-Wiltshire
Propagate a chaser's motion near a target on a circular orbit, and discover the two behaviours that make rendezvous non-obvious.
▶ Run the lab →Two-impulse rendezvous
Solve for the burn that flies a chaser to the target in a chosen time, price both burns, and find the faster-costs-more tradeoff.
▶ Run the lab →Estimating a non-cooperative target
Track a noisy, tumbling target with a constant-velocity Kalman filter and show it beats using the raw measurements.
▶ Run the lab →Seat it by force: compliant servicing
Insert a part into a socket with misalignment, and show that force control seats it where rigid position control jams.
▶ Run the lab →World Models: Learn a Simulator You Can Imagine In
Build a world model, a learned simulator that predicts what happens next, from the ground up. You fit the smallest one to a real system, roll it forward to imagine the future and watch error compound, make it nonlinear and latent the way Dreamer and DIAMOND do, then plan with it and finally play a pixel-space world the way Genie 3 does. It ends where the 2026 frontier actually is: Meta's V-JEPA 2 (physics learned from a million hours of video, then robot control from a little real data) and NVIDIA's Cosmos world-foundation models, the same imagine-then-act loop the Institute's own runs live and on-device. And it meets that frontier's honest limits: benchmarks like PhysicsMind show today's world models lean on superficial cues and routinely violate balance, torque, and inertia, which is why structured, physics-grounded models (port-Hamiltonian dynamics, PH-Dreamer) are the live research direction; and a rollout's score is not proof it is safe to run for real, which is why runtime verification of an imagined plan, before you commit it, is being built now, ours included.
Predict the next state
Meet the world model in one line: a map from (state, action) to the next state, learned from experience.
▶ Run the lab →Imagine a trajectory
Roll the model on its own predictions to imagine the future, and watch prediction error compound.
▶ Run the lab →A model that bends
Give the world model a nonlinear basis so it can fit the curved parts of physics a straight line misses.
▶ Run the lab →Imagine in a latent
Compress a high-dimensional observation to a small latent, then imagine the future inside it, the core trick of modern world models.
▶ Run the lab →Plan by imagining
Use the world model to choose actions, search plans in imagination, commit only the best to the real world.
▶ Run the lab →A playable world
Build a pixel-space, action-conditioned world model and play it, the exact principle behind Genie, Oasis, and our on-device world model.
▶ Run the lab →Certify, don't just score
See the difference between trusting a plan because the model scored it well, and trusting it because it was certified to stay inside what the model actually knows.
▶ Run the lab →Dendritic Computation: Learning Without Forgetting
The unit at the base of deep learning is a single weighted sum, and a real neuron is not. Build the dendritic unit from the ground up: see why one point neuron can't solve XOR but a dendritic one can, watch a standard network catastrophically forget a task while a context-gated dendritic network keeps it, and recognize the same dendritic gating hiding inside attention and mixture-of-experts. It ends on the honest question (if the richer unit is better, why did the point neuron win?) and its answer: the hardware lottery. Grounded in Beniaguev 2021, Poirazi & Mel, Numenta's Active Dendrites, Chavlis & Poirazi 2025, and Hooker 2020.
The point neuron, and why it won
Meet the unit at the base of every network, one weighted sum and a threshold, and see both its power and its limit.
▶ Run the lab →The neuron is a network
See the load-bearing fact: a real neuron's dendrites each apply their own nonlinearity, so one neuron computes what a point neuron needs a whole network for.
▶ Run the lab →Catastrophic forgetting
Watch the failure that keeps today's models frozen: a network learns a second task by overwriting the first.
▶ Run the lab →Dendrites that don't forget
Fix the forgetting: let each task's context fire its own sparse set of dendrites, so tasks stop sharing weights.
▶ Run the lab →The dendrite, hiding in the frontier
See that attention, mixture-of-experts and gated layers are the dendritic operation (multiplicative, conditional compute) in GPU-friendly form.
▶ Run the lab →The hardware lottery
Answer the real question: if the richer unit is better, why did the point neuron win? Because the hardware of this era rewards dense matrix multiplies.
▶ Run the lab →Agentic Physical AI: The Open Skill Layer
Build the open, cross-vendor skill layer that turns any policy into a robot skill: it installs, checks the body's declared capabilities against what the skill needs, and holds every action inside a runtime envelope on-device. You implement capability negotiation, the runtime envelope, policy-agnostic skills, LeRobot composition, and a safe MCP tool (then author and ship your own. The runtime clamp is the floor, not the guarantee) a box constraint bolted around the policy; the guarantee that matters is a certificate on the action's own energy, baked in (see Energy First Architecture).
Will this run on my robot?
Answer a skill's compatibility against a robot's capabilities, before anything moves.
▶ Run the lab →The safety envelope lives in the runtime
Bound ANY policy, even a hijacked one, with a runtime that clamps every command.
▶ Run the lab →One contract, any policy
Swap an analytic policy for a learned one without touching the contract, envelope, or wire.
▶ Run the lab →Compose LeRobot, one adapter, any checkpoint
Drive different LeRobot architectures through one `.select_action` adapter, with action chunking.
▶ Run the lab →MCP for robots, done right
Expose a robot to a language model over a tool that enforces the safety envelope in the protocol.
▶ Run the lab →Capstone, author and ship a skill
Write a skill contract, validate it, gate it, and run it inside its own safety envelope.
▶ Run the lab →Connection Systems: From a Snap to a Policy
The bridge from a maker's snap-together kit to a learned policy on real hardware. Build the sense-think-act loop in code, read a sensor over a real bus, watch a block graph become a policy that out-learns your hand rule, switch a magnet that holds for free (the energy a body already has can be the guarantee, the seed of the certificate idea) and clone an expert from its own demonstrations.
The loop you can hold
Write a sense-think-act controller that drives an agent to a target, and see that the graph you snapped together is a program.
▶ Run the lab →What the wire carries
Read a real sensor value off a two-wire bus and route it into a decision -- the connector layer, in code.
▶ Run the lab →The graph is a policy
Watch a learned think block discover a fix your hand rule could not -- the step from maker to physical AI.
▶ Run the lab →The magnet, switched
Model an electropermanent magnet: hold force versus gap, and why switching beats holding.
▶ Run the lab →From teleop to a released policy
Record demonstrations from an expert, clone a policy by least squares, and deploy the clone.
▶ Run the lab →Perception to Policy: From a Sensor to a VLA
The ladder from a raw sensor to a vision-language-action policy, one rung at a time, with a model you train on-device at every step: turn a sensor stream into features, train a kilobyte classifier, wire perception into a decision, clone a policy from demonstrations, hit the generalization wall and see what a VLA adds, learn a world model and plan a policy inside it, then learn a reward model to judge and improve any behaviour. The bridge nobody teaches whole.
The sensor speaks in numbers
Turn a stream of raw 8-bit sensor readings into a small, centred feature vector a model can learn from.
▶ Run the lab →A kilobyte classifier
Train a tiny softmax classifier on features -- on-device learning, the TinyML rung -- and see it generalize to views it never saw.
▶ Run the lab →Perception becomes a decision
Close the loop: turn the classifier's output into an action so the agent reaches its goal.
▶ Run the lab →Clone the expert
Fit a policy to recorded demonstrations and deploy the clone on goals it never saw.
▶ Run the lab →The generalization wall, and what a VLA adds
See a cloned policy fail outside the world it was trained in, then fix it with diverse data -- the honest reason VLAs exist.
▶ Run the lab →Learn in imagination
Learn a model of the world's hidden dynamics from random play, then plan a policy that acts correctly in reality -- without ever training in the real world.
▶ Run the lab →Learn the reward
Learn a reward model from preferences, so you can judge and improve any behaviour without hand-writing what good looks like.
▶ Run the lab →Frontiers in Physical AI: Ternary
The multiply is the enemy. Three states {−1,0,+1} delete it, and with it the binary tax of multiplier arrays, the data-movement wall, and leading-edge fabs. Backed by information theory, arithmetic, and material science, this course builds the case in code: the trit is the optimal atom, a ternary policy matches full precision, and multiply-free silicon runs on a mature, sovereign node. Ternary is the bridge from the binary world to post–von-Neumann computing, and the only way forward for embodied AI at the edge.
Bits, trits, and the best radix
Compute that one trit carries log2(3)=1.585 bits and that base 3 beats base 2 on radix-economy cost averaged over a large range of integers.
▶ Run the lab →The multiply is the enemy
Given a tiny edge policy, count its MACs and price them with the Horowitz @45nm energy constants to show that multiplies dominate arithmetic energy (~80%) and that a single DRAM read outweighs every add combined.
▶ Run the lab →Three states delete the multiply
Implement a matrix-vector product with ternary weights using only add, subtract, and skip, no multiplies, and prove it is bit-for-bit identical to x@W (max error < 1e-9).
▶ Run the lab →Absmean: rounding a net to three states
Ternarize a Gaussian weight matrix with the BitNet b1.58 absmean rule (scale = mean(|W|)) so that every value lands in {-1,0,+1} and the zero fraction, by the rule's scale-invariance, lands inside the 0.2-0.45 band.
▶ Run the lab →Train for ternary: QAT matches FP32
Train a 2-H-2 MLP on XOR-quadrants with quantization-aware training and a straight-through estimator so that, evaluated with weights restricted to {-1,0,+1}, it reaches >=90% test accuracy, matching its FP32 twin.
▶ Run the lab →BitVLA: the trit ships in production
Given the cited BitVLA record (arXiv:2506.07530: 1.4 GB footprint, 11.0x smaller and 4.4x faster than a full-precision OpenVLA-OFT baseline, matched task performance), show that a memory ratio and a latency ratio cannot be multiplied into one 'total win' number, then count which of the three legs of the ternary+energy+certificate slot BitVLA closes -- and which two remain open.
▶ Run the lab →The honest joules
Given cited per-operation energies, the learner computes an honest end-to-end joule ledger for a ~1e5-param policy and shows the FP32-to-ternary energy speedup is ~tens x (not ~1000x) because memory movement, not arithmetic, dominates once the multiplies are deleted.
▶ Run the lab →Why the multiply-free win is a memory win
On real edge silicon, show that a naive ternary decode is stalled by a branchy unpack, then replace the select-chain with a branch-free arithmetic decode v=(c^2)-2, bit-identical, and the measured decode kernel jumps from 2.6x to 5.8x faster than bf16.
▶ Run the lab →Silicon anyone can make
Show by gate count that deleting the multiplier array cuts an 8-bit datapath from ~n^2 to ~n gates (ratio >= 6x), and argue this is what lets a mature node do edge-AI inference.
▶ Run the lab →The end-to-end trit (capstone)
Ship one ternary edge policy end-to-end: QAT-ternarize a trained FP32 policy so its accuracy holds (>=0.85) with zero multiplies at inference, then count the three binary re-encode taxes a naive stack pays and prove the end-to-end trit removes all three.
▶ Run the lab →