
Physical AI
Teach machines to perceive, decide and act in the real world.
Where AI meets hardware. Learn how robots see, map and move with ROS 2, OpenCV and SLAM; how they learn from demonstrations and reinforcement learning; and how today's frontier works — vision-language-action models, world models, world action models — through to simulation at scale, on-device deployment and safety.
Foundations: Perception, Mapping & Control.
What Is Physical AI? The Loop, the Software Stack & Three Routes
A chatbot can delete a mistake and try again; a robot that spills water can't. So what is physical AI? In this episode we animate the sense-decide-act loop and its different speeds, the five layers of the robot software stack, why more and more modules learn from data instead of hand-written rules, the three routes to controlling robots with large models (VLA, world models and WAM), and the three hard problems of physical AI: scarce data, real-time control and safety.
How Robot Software Talks: ROS 2 Nodes, Topics, Services & Time Sync
A robot runs cameras, lidar, motor control and AI models all at once. How do they split the work without dragging each other down? This episode animates ROS 2: software split into nodes, topics for continuous broadcasts, services for question-and-answer, actions for long tasks with progress and cancel; shared message formats that let modules from different teams plug together, with AI models as just another node; and timestamps, multi-sensor time sync, and bag recording that lets AI train offline.
Why Robot Arms Miss: Coordinate Frames, the TF Tree & OpenCV Calibration
The camera says the apple is 50 cm straight ahead, yet the arm grabs thin air. This episode animates robot coordinate frames and transforms: what a pose is, how rotate-then-translate transforms chain together, and how the ROS 2 TF tree tracks every frame in real time. Then we calibrate: camera intrinsics and distortion with OpenCV and a checkerboard, and hand-eye calibration between camera and arm, and why one centimeter of error means a missed grasp.
How Robots Read Images: From OpenCV Thresholds to YOLO Object Detection
To a robot, a photo is just six million numbers. Using one task, finding the apple on the table, this episode animates the two paths of robot vision: why the classic OpenCV pipeline (blur, HSV, color threshold, contours, box) works in the lab but fails on green apples and backlight; how YOLO looks at the whole image once, predicts boxes on a grid and removes duplicates with NMS to run in real time; fine-tuning with a few hundred photos, tracking, publishing to ROS 2; and what a 2D box still can't tell you.
Perception in 3D: Depth Cameras, Point Clouds & 6D Pose for Grasping
YOLO can box the mug, but the arm also needs to know how far it is and where the handle points. This episode animates 3D perception: how stereo, structured light and time-of-flight cameras measure depth, and how pixels plus depth become a point cloud; segmentation, plane removal and denoising to isolate the object; 6D pose with ICP or learned estimators, or predicting grasps directly; and why transparent and shiny objects break depth sensing.
SLAM Explained: How Robots Map a Room and Find Themselves
To locate yourself you need a map, and to build a map you need to know where you are. This episode animates SLAM: why odometry drifts, how the front end uses ORB features from OpenCV and lidar scan matching to estimate each step, how the back end spreads error across a pose graph, how loop closure snaps the whole map together and why a wrong one is dangerous, and how AI makes SLAM sturdier and teaches maps about kitchens and living rooms.
From Path to Motor Command: A*, RRT, PID & MPC Explained
Season one finale. Once a robot knows where it is and where it's going, how does that become current in its motors? This episode animates how A* finds the shortest path on a map, why robot arms use RRT random trees, what trajectory optimization and local obstacle avoidance do, what the P, I and D in PID each handle, how MPC rehearses the next second before acting, why the whole system is layered by speed, and which layers learned policies are taking over.
Robot Learning.
Learning from Demonstration: Behavior Cloning & Compounding Errors
Season two, Robot Learning, begins. Nobody can write rules for folding a towel, but a robot can learn from a few dozen human demonstrations. This episode animates imitation learning: how teleoperation records image-action pairs, how behavior cloning turns them into supervised learning and trains a policy network, why errors snowball and the robot drifts off course, and how DAgger, recovery demonstrations and action chunking help.
Reinforcement Learning for Robots: Rewards, Trial & Error and PPO
Some skills can't be demonstrated, like a four-legged robot trotting over gravel. This episode animates reinforcement learning: the loop of agent, state, action and reward, why the goal is long-term total reward, how robots exploit a badly designed reward, why we run thousands of simulations in parallel on a GPU, why exploration matters, how PPO improves the policy step by step, and the common recipe of imitating first and reinforcing after.
Sim-to-Real: Why Robots Trained in Simulation Fail, and Three Ways to Fix It
A four-legged robot runs fast and steady in simulation, then slips and falls on real grass. This episode animates Sim-to-Real: where the reality gap comes from in physics and perception, how system identification makes simulation more like the real robot, why domain randomization deliberately makes simulation messy, how adaptation modules and teacher-student training let a policy adjust on the fly, and the staged rollout from simulation to hardware.
Diffusion Policy & Action Chunking: Generating Robot Actions by Denoising
Imitation learning has two old problems: multiple valid strategies get averaged, and step-by-step prediction causes snowballing errors and jerky motion. This episode animates two key methods: action chunking, which predicts a whole stretch of actions and blends overlaps for smooth motion, and Diffusion Policy, which generates actions by denoising random noise, like AI image generation, landing on one strategy instead of the average. Plus why a few dozen demos are enough, and how to speed up slow denoising.
Where Does Robot Data Come From? Teleoperation, Handheld Capture, Video & the Data Flywheel
Large models have the whole internet's text, but robots lack data on what was seen and how the hand moved. This episode animates the four sources of robot data: teleoperation, the highest quality but slow and costly; handheld capture, cheap and able to reach real homes; human video, massive but without action labels; and simulation, unlimited but facing the reality gap. Plus the data pyramid, open cross-lab datasets, the data flywheel, and why diversity beats quantity.
Can You Trust Robot Demo Videos? How to Evaluate a Policy: Success Rates, Generalization & Blind Tests
Season two finale. Behind a flawless robot demo there may be twenty failures. This episode animates how to evaluate a robot policy scientifically: why a success rate means nothing without the number of trials, how a generalization ladder reveals what a policy really learned, why we evaluate at scale in simulation and spot-check on real robots, and fair comparisons, blind tests, efficiency and safety metrics. Plus a recap of season two, Robot Learning.
Vision-Language-Action Models.
How Large Models See: Tokens, Attention & Vision-Language Models
Season three, Route 1: VLA, begins. The foundation of a VLA is the vision-language model. This episode animates how text is chopped into tokens and turned into vectors, what attention in a Transformer does, how images are cut into patches and turned into tokens just like words through a vision encoder and projection layer, what common sense from web-scale image-text data gives robots, and VLMs' weak spot in spatial understanding and how it's being fixed.
Vision-Language-Action Models: How Large Models Control Robot Arms
A VLM can describe images; a VLA has to act. This episode animates how one robot arm action is broken into seven numbers and sliced into 256 bins to become action tokens, how a large model predicts actions one token at a time like speech (the RT-2 and OpenVLA approach), why robot data is mixed with web data in training, how VLAs bring common sense into action and handle unseen objects, and the costs in speed and precision that led to the VLM-plus-action-head design.
Flow Matching Action Heads: How VLAs Like π0 Generate Smooth Robot Actions
Diffusion policies need dozens to hundreds of denoising steps, too slow for large models. This episode animates Flow Matching: draw a straight line between noise and real actions, learn a velocity field, and follow the arrows for about ten steps to get smooth actions. Then see how π0 pairs a 3-billion-parameter VLM with a 300-million-parameter action expert to generate the next 50 actions at once, tackling long tasks like folding laundry and clearing tables, and why it beats discrete action tokens.
Fast and Slow Thinking in Robots: Dual-System VLAs & Embodied Reasoning
Large models think deeply but produce only a few actions per second, while control needs hundreds. This episode animates dual-system VLAs: a slow system that understands the scene and breaks down tasks, a fast system that generates and corrects actions in real time, linked by latent vectors or language subtasks. Then embodied reasoning and embodied chain-of-thought, where the robot writes a plan, locates objects and picks a gripper target before moving, plus the benefits and costs.
How VLAs Are Trained: Pretraining, Co-Training & Fine-Tuning
Training a VLA is like cooking: the steps matter. This episode animates the three stages: start from an open-source VLM, then pretrain on data from dozens of robots; why feeding only robot data makes the model forget, and how co-training and knowledge insulation protect its common sense; how a small set of high-quality demos and LoRA fine-tuning perfect a skill, with RL on top; and the details that decide success: data mixture, action normalization and data quality.
One Brain, Many Bodies: Can One VLA Control Every Robot?
Season three finale. Single arms, dual arms, humanoids and robot dogs have completely different bodies. Can one brain control them all? This episode animates cross-embodiment learning: how big the differences are, how a shared model handles seeing and thinking while each body gets its own input and output modules, three techniques (a unified action space, padding with masks, and embodiment prompts), and the positive and negative transfer from pooled data. Plus a recap of season three, the VLA route.
World Models.
What Is a World Model? How It Differs from VLA
Season four, Route 2: World Models, begins. A VLA asks "seeing this, what should I do?"; a world model asks "if I do this, what happens?" This episode animates the mental rehearsal behind catching a ball or pouring water, how world models learn from data instead of hand-written equations, how an encoder, transition model and decoder roll forward into the future, three uses (planning, training in imagination, and data engines and evaluation), and the problems of compounding error and physics violations.
Can Robots Learn in Their Dreams? World Models & Dreamer Explained
Reinforcement learning takes millions of falls; world models let robots practice in their dreams. This episode animates Dreamer-style methods: the three-step loop of collecting a little real experience, training a world model, and training the policy in imagination; why rolling forward in latent space is fast and cheap enough to imagine thousands of futures at once; how the actor and critic work together; how a real four-legged robot learned to walk in about an hour; and the risk of policies exploiting the model.
Can AI Learn Physics from Video? Video World Models & Interactive Worlds
Video generation models have watched so much footage that they've picked up rough rules of gravity, occlusion and collision. This episode animates why some call video models world simulators, the difference between ordinary video generation and action-conditioned interactive world models, how game world models run games in real time and learn latent actions from unlabeled video, how world foundation models for physical AI generate futures from robot actions and driving commands, and the three big problems: consistency, physics and speed.
Planning with a World Model: Imagined Trial and Error, CEM & Policy Proposals
With a world model that predicts the future, how does a robot pick the best action? This episode animates trying many candidate action sequences in imagination, scoring them against a goal image, executing only the first step and replanning; how the cross-entropy method focuses the search; why comparing in feature space beats raw pixels; pairing a policy that proposes with a world model that checks; and the upsides of new goals without retraining and better decisions with more thinking, versus heavy compute and model exploitation.
Predict Pixels or Meaning? JEPA World Models Explained
Generative world models predict every pixel and often waste effort on leaves and sand. This episode animates JEPA, proposed by Yann LeCun: encode the present and future into abstract representations, then predict and compare at the level of meaning; how to prevent representation collapse; how V-JEPA learns from video with fill-in-the-blank masking; how V-JEPA 2 does zero-shot pick-and-place in new labs from a goal image; and the strengths of predicting pixels versus predicting meaning.
World Models as Data Engines: Do They Really Understand Physics?
Season four finale. World models can plan, and they can also serve as data engines. This episode animates three uses: giving a demonstration a "makeover" with new lighting and scenes while keeping the motion; generating experiences the robot never had and recovering actions with an inverse dynamics model; and testing policies inside the world model. It also tackles the key question: research finds video models mostly copy familiar cases, and realism isn't physical correctness, so generated data needs checks and must be mixed with real data and simulation. Plus a season four recap.
World Action Models.
From World Model to World Action Model: One Model That Predicts and Acts
Season five, Route 3: WAM, begins. A VLA acts without considering consequences; a world model predicts without acting. This episode animates WAM: one model that outputs future scenes and actions together; why massive video teaches it physics while a little robot data teaches it to act; why predicting the future makes action learning better and makes the robot's intent readable; and three common designs: imagine then infer, generate together, and alternate. WAM naming isn't settled, so this season follows real papers.
Reading Actions from Video: Inverse Dynamics, Pseudo-Labels & Latent Actions
Huge amounts of video have images but no actions. How can a WAM learn from them? This episode animates how an inverse dynamics model infers the action between two frames, how a small labeled set trains it to pseudo-label massive video (2,000 hours labeling 70,000 hours in a game), why the gap between human hands and grippers blocks human video, how latent actions let a model invent its own action codes that unify human, robot and game video before translating them into real actions, and the limits.
Generating Video and Actions Together: Inside the WAM Engine
A WAM has to generate future scenes and actions together, and fast enough for real-time control. This episode animates how scenes and actions emerge together from one diffusion process, naturally aligned; how separate "noise knobs" turn one model into a policy, a world model or an inverse dynamics model, and let it train on action-free video; interleaved autoregressive designs; and speed-ups like latent-space generation, skipping image decoding, predicting only key frames, and single-pass features.
Imagine First, Then Act: Robots That Plan with Generated Video
The most intuitive way to use a WAM: generate a video of the task being done, then follow it. This episode animates how a video model generates a plan video from an instruction and an inverse dynamics model translates it into actions, why this can compose new, unseen tasks; variants that generate only a subgoal image or imagine how a person would do it; and what to do when imagined plans are physically impossible, beyond the robot's body, or drift from reality, with closed-loop re-imagining and plan checking.
VLA vs World Model vs WAM: How to Choose a Route for Robot AI
Season five finale. Among the three large-model routes there's no best, only a better fit. This episode puts VLA, world models and WAM side by side and compares them on data, speed, generalization, checkability and maturity; then offers guidance by situation: VLA for well-defined tasks with plenty of demos, adding a world model to rehearse when failure is costly, and WAM when robot data is scarce but video is plentiful. Finally, how the routes are converging, plus a season five recap.
Scaling, Deployment & What's Next.
Thousands of Robots on One GPU: Physics Simulation & Parallel Training
Season six, From Training to Deployment, begins. This episode animates how a physics simulator works: collision detection, contact and friction, integration and rendering, every millisecond; why contact is the hardest part and how rough physics lets robots exploit glitches; why moving simulation onto GPUs, with thousands of environments in parallel and data never leaving the card, cuts training from days to tens of minutes; plus ray tracing, batched rendering, phone-scanned digital twins, and the full flow from scene to real robot.
From Raw Robot Footage to Training Data: Data Pipelines & Synthetic Data
Freshly collected robot data is far from ready for training. This episode walks the data pipeline: time sync and format standardization, cleaning out failed and stalled demos, auto-labeling instructions and subtasks with large models, balancing tasks, versioning datasets and locking away evaluation sets. Then how synthetic data fills gaps: planners generating demos in simulation, turning about 200 human demos into over 50,000, and world-model makeovers. Finally, mixing real and synthetic data, and how field failures feed back into a data flywheel.
Fitting Billion-Parameter Models into Robots: On-Device Deployment & Real-Time Inference
A robot can't drag a data center around. This episode animates on-device deployment: compute modules limited by power and heat, and how to budget latency from camera to motor; how quantization, pruning, distillation and inference engines make models smaller and faster; how action chunking and asynchronous execution let the model compute while acting with smooth transitions; how edge-cloud systems fall back safely when the network drops; and why low-level servo control must always run independently.
When Robot AI Gets It Wrong: The Software Safety Layer Explained
AI models will make mistakes, and the physical world has no undo. This episode animates a robot's defense in depth: hardware emergency stops and joint limits at the core, a safety filter between model and motors that rehearses each action and minimally adjusts or rejects it, runtime monitoring that slows or stops when the model is unsure, forces spike or the AI stalls, speed and force limits when people approach, semantic safety that refuses dangerous instructions, and testing against industry standards with logging and review.
Why Self-Driving Is Going End-to-End: Modular vs End-to-End, BEV & Data Engines
The most widely deployed physical AI is the car on the road. This episode animates why the classic perception, prediction, planning and control pipeline loses information at its interfaces and relies on piles of hand-written rules; how end-to-end systems output trajectories straight from multiple cameras, and how bird's-eye view merges the camera feeds; how vision-language models, world models and fleet data engines come in; why closed-loop evaluation is essential; and how redundant sensors and safety layers provide fallbacks.
Where Is Physical AI Headed? Series Recap, Four Trends & Open Problems (Finale)
The finale of Physical AI Explained in 3 Minutes. This episode reviews all six seasons and 36 episodes on one big map: the robot software stack, robot learning, VLA, world models, WAM, and training to deployment. Then four trends in physical AI: generalist foundation models, data at scale, converging routes, and humanoids with dexterous hands; the problems still open: reliability, long tasks, touch, cost, and safety and regulation; and a learning path for anyone who wants to start building. Thanks for watching.