Robots and World Models

The easy things are hard

A computer beat the world chess champion in 1997. Language models now pass professional exams and write working software. Yet in 2026 a robot that can walk into an unfamiliar kitchen, find a mug and load the dishwasher is still a research result rather than a product. The things a toddler does without thinking turned out to be the hardest part of artificial intelligence.

What is it?

In 1988 the roboticist Hans Moravec put it bluntly: it is “comparatively easy to make computers exhibit adult level performance on intelligence tests or playing checkers, and difficult or impossible to give them the skills of a one-year-old when it comes to perception and mobility”. This observation is now called Moravec’s paradox, and it is the right starting point for robotics.

A robot is a machine that senses the physical world and acts on it with some autonomy: an arm in a factory, a vacuum cleaner, a warehouse shuttle, a self-driving car, a humanoid. Robot learning is the part of AI that tries to make those machines acquire their skills from data and experience rather than hand-written rules.

Why is the physical world so hard?

Four things separate a robot from a chatbot, and each one gets its own section below.

• Noise and uncertainty. Cameras blur, wheels slip, lidar reflects off glass. The robot never knows exactly where it is or where things are.
• Physics does not wait. A balancing robot must correct itself hundreds of times per second, and a late answer is a wrong answer. There is no undo.
• Mistakes are physical. A wrong word in a chat can be edited. A wrong move breaks a glass, or hurts someone.
• No internet of actions. Language models learned from trillions of words people had already written. Nobody has been uploading the joint torques of their hands while folding laundry, so robot data has to be collected, slowly and expensively, one demonstration at a time.

Evolution spent hundreds of millions of years on seeing and moving, and only a sliver of that time on abstract reasoning, which was Moravec’s own explanation. The skills that feel effortless are the ones most deeply optimised, and so the ones we least understand how to write down.

Why does it matter now?

Robotics is where the big ideas of this site meet the real world. Reinforcement learning, transformers, vision-language models and generative models are all being pointed at robots, and billions of dollars are following them. At the same time, the most deployed autonomous robot, the driverless taxi, is now carrying hundreds of thousands of paying passengers a week. This lesson builds from the classical foundations that every robot still relies on (control, estimation, kinematics) to the learning-based methods and foundation models of 2025 and 2026, and is honest about which is which.

Key takeaways

• Moravec’s paradox: perception and movement, easy for people, are far harder for machines than abstract reasoning.
• Robots face noise, real-time physics, irreversible mistakes and a shortage of data that language models never had to deal with.
• Modern robots combine decades-old control and estimation with new learned models; both halves matter.

Sense, plan, act: feedback control

Close your eyes and try to touch your nose. You will get close, but you will probably miss. Open them and you never miss, because you see the error and correct it as you go. That loop of measuring, comparing and correcting is the oldest and most important idea in robotics.

What is it?

Every robot runs some version of the same loop. It senses the world, estimates its state (where am I, how fast am I moving, where is the cup), plans what to do, and controls its motors to do it. Then the world changes and the loop runs again, from tens of times a second for planning to thousands of times a second for motor control.

How does feedback control work?

A feedback controller compares where you are with where you want to be, the error e = target − measurement, and turns that error into a command. The workhorse is the PID controller, by far the most common form of feedback in engineering according to Åström and Murray’s standard textbook. Its command is a sum of three terms:

Proportional reacts to the error now, integral to its accumulated past, derivative to its trend (where it is heading).

• P, the spring. Push harder the further you are from the target. Alone it tends to overshoot and oscillate, and when something constant opposes it, like gravity, it settles short of the target: it only pushes when there is error, so some error must remain to hold the load.
• D, the brake. Oppose fast motion towards (or away from) the target. It damps oscillation. It also amplifies sensor noise, because noise looks like rapid change.
• I, the memory. Accumulate error over time. Any error that lingers keeps growing the integral until the command is large enough to remove it, so steady-state error disappears. Too much and it winds up, overshoots and oscillates slowly.

With P only, the drone settles about 1.6 m low: with K_p = 6, it takes an error of 9.81 / 6 ≈ 1.6 m to produce the 9.81 N that cancels gravity. Adding D removes the bouncing but not the offset. Adding I removes the offset, and when you add the payload the integral quietly grows until the drone climbs back to the target, without ever being told the mass changed. The greedy setting shows the other side: with too much gain the loop becomes unstable, and only the thrust limit stops the oscillation growing. Try a large K_d with sensor noise switched on and you will see the motor chatter as the derivative amplifies the noise.

Why does it matter?

Feedback is what lets a robot work despite a model of the world that is always somewhat wrong. The controller does not need to know the drone’s mass or the wind; it only needs to see the error. That is why PID loops sit inside almost every robot, including those run by large learned models: a neural network may decide where the hand should go ten times a second, while classical controllers at each joint make it actually get there. The same trade-offs (fast versus stable, responsive versus noise-sensitive) come back in every learned controller too.

Key takeaways

• Robots run a sense, estimate, plan, control loop; feedback corrects errors the model never predicted.
• PID: P pushes in proportion to the error, D damps motion, I removes persistent offsets such as gravity or a heavier load.
• More gain is not better: too much causes oscillation or instability, and derivative action amplifies sensor noise.

Knowing where you are

A GPS fix on your phone jumps around by several metres, yet the blue dot glides smoothly along the road. Something is combining each noisy reading with what it already believed. On a robot, that something is usually a Kalman filter or one of its descendants.

What is it?

State estimation is working out the robot’s state (position, velocity, orientation, the positions of objects) from sensors that are noisy, partial and delayed. The robot never observes its state directly; it infers it. The Kalman filter, published by Rudolf Kalman in 1960, is the classic way to do this, and a version of it helped navigate the Apollo missions to the Moon.

How does it work?

The filter keeps two things: a best guess of the state, and how uncertain that guess is (a covariance). Every tick it does two steps.

1. Predict. Move the guess forward with a motion model, for example “keep going at the same velocity”. Uncertainty grows, because the model is not perfect: the object might have turned.
2. Update. A measurement arrives. Blend it with the prediction, weighting each by how much you trust it. Uncertainty shrinks.

The blending weight is the Kalman gain. In one dimension it is simply:

P is the prediction’s variance, R the sensor’s. A trustworthy sensor (small R) gives K near 1; a confident prediction (small P) gives K near 0.

A worked example: the filter predicts the object is at 10.0 m with variance P = 1, and the sensor, with variance R = 4, reads 12.0 m. K = 1 / (1 + 4) = 0.2, so the new estimate is 10.0 + 0.2 × 2.0 = 10.4 m, and the variance drops to (1 − 0.2) × 1 = 0.8. The prediction was more trustworthy, so it wins most of the argument, but the measurement still pulls. For linear models with Gaussian noise this weighting is provably the best possible.

Compare the two error figures: once the filter has settled, its estimate is typically a third to a half closer to the truth than the raw readings. The process noise q is the filter’s assumption about how erratic the motion is. Set it low and the filter averages heavily, smooth but slow to notice a turn (drag the ring sharply to see it lag). Set it high and it trusts each reading, fast but jittery. Cut the sensor and the estimate coasts along its last velocity while the circle swells; when the readings return, the gain spikes and the estimate snaps back.

Why does it matter?

Everything downstream depends on the estimate. A controller given a noisy position commands noisy motion; a planner given the wrong map plans into a wall. Real robots fuse many sensors this way: wheel odometry that drifts slowly, GPS that is noisy but does not drift, inertial sensors that are fast but biased, cameras and lidar that see landmarks. Extended and unscented Kalman filters handle nonlinear models, particle filters handle multimodal beliefs (“I am in corridor A or corridor B”), and SLAM (simultaneous localisation and mapping) estimates the map and the robot’s place in it at the same time. Increasingly the perception part, recognising objects and surfaces in camera images, is done by neural networks; the fusion over time is still very often a filter.

Key takeaways

• Robots infer their state from noisy, partial sensors; they never observe it directly.
• A Kalman filter alternates predict (uncertainty grows) and update (uncertainty shrinks), weighting each by its reliability.
• The filter’s assumptions matter: trust the motion model too much and it lags, trust the sensor too much and it jitters.

Arms, reach and paths

You decide to pick up a cup and your hand simply goes there. A robot arm has to answer a surprisingly hard question first: to put the gripper exactly here, what angle should every joint be at? And then a second one: how do I get there without hitting anything?

What is it?

Kinematics is the geometry of motion, ignoring forces. Forward kinematics goes from joint angles to where the hand ends up; it is straightforward trigonometry. Inverse kinematics (IK) goes the other way, from a desired hand position to joint angles, and is where the difficulty lives: there may be two solutions, infinitely many, or none at all.

How does it work?

For a two-link arm in a plane, with upper arm L₁ and forearm L₂, forward kinematics is:

Inverting it uses the law of cosines. The distance from shoulder to target fixes the elbow angle: cos θ₂ = (x² + y² − L₁² − L₂²) / (2 L₁ L₂). If the right-hand side falls outside [−1, 1], the target is out of reach. Otherwise θ₂ = ± arccos(…), which gives the two solutions, elbow up and elbow down. With 1 m and 0.7 m links, a target 1.2 m away needs cos θ₂ = (1.44 − 1 − 0.49) / 1.4 ≈ −0.036, so the elbow bends about 92° one way or the other.

Real arms have six or seven joints, where closed-form answers are messy or do not exist. Then IK is solved iteratively: compute the Jacobian (how much the hand moves for a small change in each joint), step the joints to reduce the distance to the target, and repeat. It is gradient descent on a geometric error, and it is what the second mode of the demo does.

Outside the ring there is no solution, so the best the arm can do is point straight at the target. Inside the small inner circle it is also stuck: with a shorter forearm the hand cannot fold back onto the shoulder. Make the links equal and the hole vanishes. The iterative solver lands on one of the same two answers, but which one depends on where it started, a small lesson in how local optimisation behaves.

Motion planning: getting there without hitting anything

Knowing the final joint angles is not enough; the path between must avoid obstacles, including the robot’s own body. For a 7-joint arm the space of configurations is seven-dimensional, far too big to cover with a grid like the ones A* searches in the pathfinding lab. Sampling-based planners sidestep this. The best known, the rapidly-exploring random tree (RRT), repeatedly picks a random point, finds the nearest node in its tree, and grows one short collision-free step towards it. Random samples land mostly in large unexplored regions, so the tree is pulled outward into open space.

The path is found but it is jagged and usually far longer than necessary. That is typical: RRT is fast at finding some path, not a good one. In practice the result is smoothed afterwards, or an asymptotically optimal variant (RRT*) keeps rewiring the tree as it grows.

Why does it matter?

Every pick-and-place robot in a factory runs IK and a planner many times a minute, and most learned robot policies still output hand poses that IK and low-level controllers turn into joint commands. Understanding the workspace also explains design choices: a seventh joint gives an arm redundancy, infinitely many ways to put the hand in the same place, which it can use to avoid obstacles or joint limits.

Key takeaways

• Forward kinematics maps joint angles to hand position; inverse kinematics does the reverse and can have two, many or no solutions.
• Many-jointed arms solve IK iteratively with the Jacobian, a form of gradient descent on the hand’s distance to its target.
• Sampling-based planners such as RRT find collision-free paths in high-dimensional spaces quickly, but not optimally.

Learning in simulation

Reinforcement learning needs millions of attempts, and most of them fail. A real robot would break long before it learned. So robots learn in simulation, where a thousand copies can fall over in parallel at a thousand times real speed. The catch is that the simulator is never quite right.

What is it?

Sim-to-real transfer means training a controller in a physics simulator and then running it on hardware. The reality gap is everything the simulator gets wrong: friction, motor delays and strength, masses, flexible parts, sensor noise, and how things look. A policy optimised hard enough against one simulator will exploit its flaws, just as an RL agent exploits a flawed reward.

How does it work?

The most widely used remedy is domain randomization: rather than trying to make one perfect simulator, train across many deliberately different ones. Tobin and colleagues trained an object detector only on simulated images with random textures, colours, lighting and camera positions, and it worked on real photos; to the network, reality looked like just one more variation. The same idea applies to physics: randomize masses, friction, delays and motor strengths, and the policy has to learn behaviour that works for all of them.

The most famous example is OpenAI’s robot hand that solved a Rubik’s Cube in 2019. The finger control policy was trained entirely in simulation, with automatic domain randomization that widened the ranges whenever the policy mastered the current ones. On the real hand it succeeded about 60% of the time on scrambles needing 15 face turns and 20% on the hardest scrambles, and it coped with perturbations it never trained on, such as a rubber glove. (The sequence of face turns came from a classical solving algorithm; what was learned was the dexterous manipulation.)

The single-simulator search picks aggressive gains near the edge of its map, because in a world with no delay, reacting harder is always better. On the real robot, with 80 ms between sensing and acting, those gains overcorrect: the pole buzzes back and forth and the motor spends most of its time pinned at its limit. The randomized search finds gentler gains that are a little worse in any single simulator but good in all of them, and it balances calmly. Set the delay to 0 ms and the aggressive policy wins again, which is the honest trade-off: robustness costs a little peak performance. Notice too that the randomized cost map has a smaller bright region: fewer policies survive every world.

Why does it matter?

Simulation is how most legged robots now learn to walk, how many drones learn to fly, and how robot-learning companies multiply their scarce real data. GPU-based simulators run thousands of robots in parallel, and generative world models (later in this lesson) promise simulations learned from video rather than hand-built. But the gap never fully closes. Contact-rich tasks like folding cloth or handling food are hard to simulate faithfully, which is one reason learning from real demonstrations has surged.

Key takeaways

• Simulators let robots practise safely and fast, but a policy optimised for one simulator exploits its mistakes.
• Domain randomization trains across many varied simulators so that reality looks like one more variation.
• Robust policies are usually gentler: they give up a little performance in any one world to work in all of them.

Learning from demonstrations

The fastest way to teach a person to tie a knot is to show them. Robots can learn the same way: a human drives the robot through a task, the robot records what it saw and what it did, and a neural network learns to copy. It works remarkably well, until the robot makes its first small mistake.

What is it?

Imitation learning learns a policy from expert demonstrations. Its simplest form, behaviour cloning, is ordinary supervised learning: inputs are observations, labels are the expert’s actions. The demonstrations are usually collected by teleoperation, a person controlling the robot through a joystick, a VR headset or a puppet copy of the arm, so the recorded actions are ones the robot can physically perform.

How does it fail?

Supervised learning assumes that training and test data come from the same distribution. In control, they do not. An expert keeps the car in the centre of the lane, so the data contains almost no examples of what to do when the car is near the edge. The cloned policy makes a small error, finds itself slightly off-centre, a state it has barely seen, makes a bigger error there, and drifts further into the unknown. Errors compound. Ross, Gordon and Bagnell showed that for behaviour cloning the expected number of mistakes can grow with the square of the task length, rather than linearly.

Their fix is DAgger (dataset aggregation). Let the learner drive. Ask the expert to label every state the learner visits with what the expert would have done there. Add those labels to the dataset, retrain, and repeat. The training data now covers exactly the states the learner actually gets itself into, including the mistakes.

The cloned policy usually leaves the road partway round the lap. Extra expert laps barely help, and the scatter plot shows why: every expert sample sits in a tiny cluster at zero offset and zero heading error, so more of them add nothing new. After one or two DAgger rounds the plot spreads out towards the road edges, the learner now knows how to steer back, and it completes laps reliably. The expert was never better; only the data changed.

Why does it matter?

Imitation learning is currently the main way robots learn manipulation. Low-cost teleoperation rigs and policy architectures that predict short chunks of future actions, often with diffusion or flow-matching models that can represent several valid ways to do the same thing, made it possible to teach a robot to cook, fold or assemble from a few dozen to a few hundred demonstrations. The DAgger insight has come back at scale. Physical Intelligence’s π*0.6 (2025) adds human corrections during the robot’s own attempts and then reinforcement learning from its experience on top of demonstrations; the company reports that this more than doubled throughput on some of its hardest tasks, such as making espresso drinks and assembling boxes.

Key takeaways

• Behaviour cloning treats control as supervised learning on expert (observation, action) pairs.
• Small errors lead to unfamiliar states where errors grow: distribution shift makes mistakes compound.
• DAgger labels the states the learner itself visits; more of the same expert data does not fix the problem.

Robot foundation models

Ask a 2022 robot to “pick up the extinct animal” and it would have no idea what you meant. Ask a 2023 vision-language-action model and it picks up the toy dinosaur, though no robot demonstration ever mentioned dinosaurs. It learned what a dinosaur is from the web, and how to pick things up from robots.

What is it?

A vision-language-action model (VLA) is a large neural network that takes camera images and an instruction in plain language and outputs robot actions directly. It is built by starting from a vision-language model, the kind described in the multimodal lesson, and teaching it to speak in motor commands as well as words. The goal is a generalist robot policy: one model for many tasks, objects, places and even robot bodies, rather than one hand-built system per task.

How does it work?

RT-2 (Google DeepMind, 2023) showed the trick in its simplest form: turn actions into text. Each dimension of the arm’s motion is discretised into 256 bins, each bin is written as a token, and the model is fine-tuned on robot trajectories alongside its usual web image-and-text data. Across about 6,000 real trials it generalised far better to new objects and instructions than its predecessors, and followed commands that required web knowledge, such as placing an object on a particular number or icon, or picking an improvised hammer (a rock).

Data is the bottleneck, so labs started pooling it. The Open X-Embodiment collaboration combined datasets from 22 robot types and 21 institutions, covering 527 skills, and found that models trained on the mix improved on several robots at once: experience transfers between bodies.

Since then, the leading designs have converged on a few ideas:

• Continuous action heads. Physical Intelligence’s π0 (2024) adds a separate “action expert” trained with flow matching, a relative of diffusion, to output smooth chunks of continuous joint commands for dexterous tasks such as folding laundry. Its successor π0.5 (2025) co-trains on robot, web and high-level planning data, and cleans kitchens and bedrooms in homes it has never seen.
• Frontier models as the backbone. Gemini Robotics (Google DeepMind, 2025) builds on Gemini 2.0, adds a separate embodied-reasoning model for spatial understanding, and reports learning some new short tasks from as few as 100 demonstrations and adapting to new robot bodies.
• Fast and slow thinking. Several systems split a slow, deliberate vision-language planner from a fast motor policy, echoing the sense-plan-act loop: the big model decides what to do a few times a second, a smaller one decides how, many times a second.

Why does it matter, and what is still missing?

VLAs are the first robot controllers that can be told what to do in words and generalise, at least partly, to objects and places they were not trained on. That is a genuine change. It is also early. Reported success rates in unfamiliar homes are well short of what a product needs, most results come from the companies building the models, evaluation setups differ from paper to paper, and robot datasets remain orders of magnitude smaller than the text that trained language models. Treat headline demos as existence proofs, not as reliability measurements.

Key takeaways

• A VLA fine-tunes a vision-language model to output robot actions, so web knowledge about objects and words transfers to control.
• Pooling data across many robots (cross-embodiment) helps each of them; data scarcity is still the main bottleneck.
• 2025-26 VLAs use continuous action heads and fast/slow splits; results are promising but mostly self-reported and far from product reliability.

World models: imagine, then act

Before you step off a kerb you already know what will happen: your foot will land, your weight will shift, the car in the distance will not reach you. You ran a simulation in your head. A world model gives a robot the same ability, learned from experience.

What is it?

A world model is a learned model that predicts what will happen next, given the current state and an action. With one, an agent can try actions in imagination, which is cheap and safe, before committing to one in reality. In the language of reinforcement learning this is model-based control, as opposed to model-free methods such as Q-learning that learn what to do without ever predicting the future.

How does it work?

The simplest recipe has two parts. First, learn the model: collect transitions (state, action, next state) and fit a predictor, from least squares to a large neural network. Then plan with it: imagine many candidate action sequences, roll each forward through the model, score the imagined futures, and execute the first action of the best one. Then look again and replan. This last loop is model-predictive control (MPC), and it is feedback control again at a higher level: the plan is always slightly wrong, so the robot only ever commits to its next step.

With only 12 steps of experience the imagination is badly off and the boat wanders or fails. After one or two practice sessions the imagined futures line up with reality and the boat heads straight for the goal around the rocks. Speed up the river and the model is suddenly wrong, but MPC still reaches the goal on a drifting, curved path, because it replans from the true position every tenth of a second. Practise again and the model catches up. The small error that remains comes from the river banks, which a linear model cannot represent.

From toy models to video world models

Ha and Schmidhuber’s “World Models” (2018) learned a compressed code for game frames, a recurrent network that predicted the next code, and a tiny controller, which could even be trained entirely inside the model’s dream. DreamerV3, published in Nature in 2025, learns its behaviour from imagined trajectories in a learned latent space; with one fixed configuration it handles over 150 tasks, and it was the first algorithm to collect diamonds in Minecraft from scratch, without human data.

Two directions stand out in 2025-26:

• Predicting in representation space. Meta’s V-JEPA 2 is pretrained on over a million hours of video to predict the missing parts of videos as abstract features rather than pixels. An action-conditioned version, trained on under 62 hours of robot video, planned pick-and-place tasks on robot arms in two new labs with no data from those labs and no task-specific reward, by searching for actions whose predicted outcome matches an image of the goal.
• Generating whole interactive worlds. Google DeepMind’s Genie 3 (August 2025) generates explorable environments from a text prompt at 24 frames per second in 720p, staying consistent for a few minutes, and has been used to give a game-playing agent new worlds to train in. Its makers list real limits: a narrow action space, short sessions, and no guarantee of physical accuracy.

The hope is that such models become the simulators of the future, learned from the world’s video rather than hand-written, closing the reality gap from the other side. Whether generated worlds are accurate enough to train physical skills that transfer is one of the most active open questions in the field.

Key takeaways

• A world model predicts the next state from the current state and an action, so the robot can try actions in imagination.
• Model-predictive control imagines many futures, executes only the first step of the best, and replans; feedback absorbs model error.
• Modern world models range from latent-space learners (Dreamer, V-JEPA 2) to interactive video generators (Genie 3); physical accuracy is the open question.

Out in the world

The most widely deployed learning-based robot in 2026 does not have arms or legs. It has four wheels, a roof full of sensors and no one in the driver’s seat, and in March 2026 it was giving 500,000 paid rides a week across 10 US cities, up from 50,000 in May 2024.

What does a self-driving car teach us?

A driverless car is every section of this lesson at once. It senses with cameras, lidar and radar; estimates its position and tracks every nearby car, cyclist and pedestrian; predicts where each of them will go next, which is a world model; plans a trajectory; and controls steering and speed. Learned models now do much of the perception and prediction, and increasingly the planning, while the whole system is validated for many millions of miles in simulation and on real roads.

It is also the only robot with large, published safety data. A peer-reviewed study by Waymo researchers covering 56.7 million rider-only miles through January 2025 found 79% fewer crashes with any reported injury and 81% fewer crashes with an airbag deployment than human drivers on the same kinds of roads in the same cities, with 95% confidence intervals of 71–85% and 69–90%. Waymo’s own safety hub, updated with data through June 2026 and 271.3 million rider-only miles, reports 82% fewer injury crashes and 95% fewer crashes causing serious injury or worse.

What about humanoids?

Humanoid robots attracted enormous investment in 2025 and 2026, on the argument that a human-shaped robot fits a world built for humans and can learn from videos of people. The hardware has improved quickly. The evidence about autonomy is thinner: most public material consists of company videos rather than measured success rates, and at Tesla’s October 2024 event many of the Optimus robots’ interactions with guests were remotely operated by staff, which was not made clear at the time. Remote operation is a legitimate way to collect training data. It is not the same as autonomy, and demos rarely tell you which you are watching.

What is still hard?

• Reliability. A task with many steps succeeds only if every step does. The demo below shows how fast that compounds. A home robot that fails once a day is a novelty; a factory robot needs to fail less than once in thousands of cycles.
• Dexterity and touch. Human hands have dense touch sensing and more than twenty degrees of freedom. Most robot grippers are still two parallel fingers with little or no tactile feedback, and contact-rich tasks remain hard to simulate.
• Data. The largest robot datasets are tiny next to the text and video corpora behind language models. Teleoperation, simulation, human video and world models are all bets on filling that gap.
• Safety. A robot that shares a room with people needs guarantees that a statistical model cannot easily give: force limits, emergency stops, verified low-level controllers, and an understanding of when it is out of its depth.
• Work and society. Warehouse and factory automation already changes jobs; general-purpose robots would do so much more widely. The pace is uncertain, and so are the effects on wages and the kinds of work that remain. These are decisions for societies, not just engineers.

At 99% per step, a 50-step task (open the cupboard, find the plate, grasp it, lift, and so on) succeeds only about 60% of the time, and a 200-step task about 13%. Getting from impressive demo to dependable product means driving that per-step failure rate down by orders of magnitude, or building systems that notice and recover from their own mistakes. It is the same arithmetic that explains the compounding errors of behaviour cloning.

Key takeaways

• Driverless cars combine every part of the robotics stack and are the one robot with large-scale, partly peer-reviewed safety data.
• Humanoid progress is real in hardware, but autonomy claims need success rates, not videos; teleoperation is common and not always disclosed.
• Reliability, dexterity, data and safety are the open problems; per-step errors compound quickly over long tasks.

Check your understanding

Seven scenarios. Each one asks you to apply an idea from the lesson to a situation a robotics engineer might actually face.

A delivery drone uses a PD controller for altitude. In calm air it settles smoothly, but always about 0.8 m below the target, and the gap grows when it carries a parcel. What is the most direct fix?

References

Papers, textbooks and primary sources behind the claims in this lesson. Company-published figures are marked as such in the text. For a single deep starting point, Åström and Murray’s Feedback Systems is free online and covers the control half of this lesson in depth.

References

1. [1]

   Mind Children: The Future of Robot and Human Intelligence(opens in a new tab)

   Hans Moravec, 1988

   Harvard University Press. The source of what became known as Moravec’s paradox: reasoning is easy for computers, perception and mobility are hard.

2. [2]

   Feedback Systems: An Introduction for Scientists and Engineers (2nd edition)(opens in a new tab)

   Karl J. Åström and Richard M. Murray, 2021

   Princeton University Press, free online. Includes a full chapter on PID control, integral action, derivative filtering and windup.

3. [3]

   A New Approach to Linear Filtering and Prediction Problems(opens in a new tab)

   Rudolf E. Kalman, 1960

   Journal of Basic Engineering 82(1), 35–45. The recursive predict-and-correct estimator now called the Kalman filter.

4. [4]

   Domain Randomization for Transferring Deep Neural Networks from Simulation to the Real World(opens in a new tab)

   Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba and Pieter Abbeel, 2017

   IROS 2017. An object detector trained only on simulated images with randomized textures, lighting and cameras works on real images.

5. [5]

   Solving Rubik’s Cube with a Robot Hand(opens in a new tab)

   OpenAI (Ilge Akkaya et al.), 2019

   A policy trained entirely in simulation with automatic domain randomization controls a real five-fingered hand. The move sequence comes from a classical solver.

6. [6]

   A Reduction of Imitation Learning and Structured Prediction to No-Regret Online Learning(opens in a new tab)

   Stéphane Ross, Geoffrey J. Gordon and J. Andrew Bagnell, 2011

   AISTATS 2011. Introduces DAgger and shows why plain behaviour cloning’s errors compound with the length of the task.

7. [7]

   π*0.6: a VLA That Learns From Experience(opens in a new tab)

   Physical Intelligence, 2025

   Recap: demonstrations, then expert corrections during the robot’s own attempts, then reinforcement learning from its own experience.

8. [8]

   RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control(opens in a new tab)

   Anthony Brohan et al. (Google DeepMind), 2023

   Represents robot actions as text tokens and co-fine-tunes a vision-language model on robot and web data. Evaluated in about 6,000 real trials.

9. [9]

   Open X-Embodiment: Robotic Learning Datasets and RT-X Models(opens in a new tab)

   Open X-Embodiment Collaboration, 2023

   Pooled data from 22 robot types and 21 institutions, covering 527 skills. Models trained on the mix transfer skills between robots.

10. [10]

    π0: A Vision-Language-Action Flow Model for General Robot Control(opens in a new tab)

    Kevin Black et al. (Physical Intelligence), 2024

    RSS 2025. A pretrained vision-language model plus a flow-matching action expert, trained on data from many robots. Tasks include laundry folding and box assembly.

11. [11]

    π0.5: a Vision-Language-Action Model with Open-World Generalization(opens in a new tab)

    Physical Intelligence (Kevin Black et al.), 2025

    Co-training on robot, web and semantic-prediction data lets the model clean kitchens and bedrooms in homes it has never seen.

12. [12]

    Gemini Robotics: Bringing AI into the Physical World(opens in a new tab)

    Gemini Robotics Team (Google DeepMind), 2025

    A vision-language-action model built on Gemini 2.0, and Gemini Robotics-ER for spatial reasoning. Learns some new short tasks from about 100 demonstrations.

13. [13]

    World Models(opens in a new tab)

    David Ha and Jürgen Schmidhuber, 2018

    A compressed visual code, a recurrent model that predicts the next code, and a tiny controller, which can even be trained inside the model’s own dream.

14. [14]

    Mastering diverse control tasks through world models(opens in a new tab)

    Danijar Hafner, Jurgis Pasukonis, Jimmy Ba and Timothy Lillicrap, 2025

    Nature 640, 647–653. DreamerV3 learns behaviour in imagination; one configuration across 150+ tasks; first to collect diamonds in Minecraft from scratch.

15. [15]

    V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning(opens in a new tab)

    Mido Assran, Adrien Bardes, David Fan, Quentin Garrido, Russell Howes et al. (Meta FAIR), 2025

    Pretrained on over a million hours of video, then under 62 hours of robot video; plans pick-and-place on Franka arms in new labs zero-shot.

16. [16]

    Genie 3: A new frontier for world models(opens in a new tab)

    Google DeepMind, 2025

    Interactive worlds generated from text at 24 frames per second in 720p, consistent for a few minutes. A limited research preview.

17. [17]

    Waymo’s skyrocketing ridership in one chart(opens in a new tab)

    Kirsten Korosec (TechCrunch), 2026

    500,000 paid rides a week across 10 US cities in March 2026, up from 50,000 in May 2024.

18. [18]

    Comparison of Waymo Rider-Only Crash Rates by Crash Type to Human Benchmarks at 56.7 Million Miles(opens in a new tab)

    Kristofer D. Kusano et al., 2025

    Traffic Injury Prevention 26(sup1). Peer-reviewed, authored by Waymo researchers. Data through January 2025.

19. [19]

    Waymo Safety Impact(opens in a new tab)

    Waymo, 2026

    Company-published, regularly updated crash-rate comparison. Figures quoted here cover rider-only miles through June 2026.

20. [20]

    Tesla Optimus bots were controlled by humans during the ‘We, Robot’ event(opens in a new tab)

    Rebecca Bellan (TechCrunch), 2024

    Reporting that many of the humanoids’ interactions with guests were remotely operated by staff.