The model on paper versus the robot in the room
Earlier in this chapter we built controllers that lean hard on a model of the robot. Computed-torque control and feedback linearization, for instance, cancel the robot's own dynamics by computing exactly the torques predicted by its inertia matrix and gravity terms — and then commanding a clean, textbook response on top. That trick is beautiful when the model is right. The trouble is that the model is never quite right.
Picture an arm that was tuned empty, then asked to pick up a full paint can. Its effective mass just jumped, so the carefully-cancelled gravity term is now wrong and the arm sags. Add joint friction that changes as the grease warms up, gears that develop play after a year of use, and a slow drift in the sensors, and the gap between paper and reality only widens. This guide is about controllers that expect to be wrong and stay stable anyway.
Two answers: learn the unknowns, or armor against them
Adaptive control takes the optimistic route: if a parameter is uncertain, learn it while the robot runs. The controller carries a running estimate of, say, the payload mass, watches how the actual motion deviates from the predicted motion, and nudges that estimate up or down to shrink the error. Lift the paint can and, within a second or two, the controller has talked itself into the heavier mass and the sag disappears — no human re-tuning required.
Robust control takes the pessimistic route: don't try to pin down the unknown, just design for the worst plausible case. You tell the controller the mass lives somewhere between 1 and 5 kilograms and ask for a single fixed design that stays stable across that whole band. The result is a controller that never needs to learn and never gets surprised — at the cost of being a bit conservative when conditions are actually mild, like wearing a raincoat on a day that turns out sunny.
Sliding-mode control is the most aggressive member of the robust family. It defines a target surface in the error space — for example, 'position error plus velocity error equals zero' — and then switches the control effort hard and fast to slam the system onto that surface and pin it there. Once the robot is on the surface, the math guarantees it slides toward the goal regardless of the exact mass or friction. It is wonderfully insensitive to model error.
Which route to pick is a real engineering choice. Adaptive control shines when uncertainty is large but slowly changing and you can afford a short learning transient. Robust and sliding-mode control shine when you need a guarantee from the first millisecond and can tolerate some conservatism or chatter. Many production systems blend them — adapt the slow stuff, armor against the fast stuff.
Seeing what you can't measure: state observers
The second kind of wrongness is missing measurements. Modern control likes to act on the robot's full state — every joint's position and velocity, maybe internal flux or temperature — but real robots rarely sense all of it. An encoder gives you position; clean velocity often has to be inferred, and quantities like elastic deflection inside a force-controlled joint may have no sensor at all. So how do you do full-state feedback when you can't see the full state?
A state observer reconstructs the hidden state from the outputs you can measure. The Luenberger observer is the cleanest example: run a software copy of the robot's model in parallel, feed it the same commands, and let it predict what the sensors should read. Compare that prediction to the real sensor reading; whenever they disagree, feed the difference back to correct the internal model. The copy converges to the true hidden state, and now you have estimated velocities and internal variables to feed into full-state feedback.
# Luenberger observer, one update step x_hat = x_hat + dt * (A @ x_hat + B @ u) # predict from the model copy y_hat = C @ x_hat # what the sensors SHOULD read x_hat = x_hat + L @ (y_meas - y_hat) # correct by the measurement gap # L is the observer gain; bigger L trusts the sensor, smaller L trusts the model
An observer only works if the hidden state actually leaves a fingerprint on the outputs — the property called observability. If two different internal situations would produce identical sensor readings forever, no observer can tell them apart, and the reconstruction fails. Checking observability before you trust an observer is as basic as checking that a bridge can hold the load before you drive across.
One more practical lever ties this section to the rest of the chapter: gain scheduling. Instead of a single fixed controller (or observer), you pre-tune several and switch or blend between them based on an operating condition — arm extended versus folded, slow versus fast. It is a lightweight cousin of adaptive control: you don't learn new gains online, but you do change which pre-baked gains are active as the robot's effective dynamics shift.
Putting it together — and looking past the edge
No real robot runs just one of these in isolation. On a walking humanoid, everything in this chapter stacks up at once inside a whole-body controller: an observer estimates the body's velocity and where its center of mass is heading, an optimizer juggles balance, reaching, and joint limits in a single solve, and robust or adaptive terms quietly absorb the friction and payload changes underneath. The methods of this guide are not competitors — they are layers in the same stack.
Notice the recurring pattern across this whole chapter: write down the best model you can, then add machinery to survive the part you got wrong. Impedance control survived contact you couldn't predict; adaptive and robust control survive parameters you couldn't pin down; observers survive states you couldn't measure. 'Handle the model error gracefully' is arguably the through-line of advanced control.
The frontier pushes that idea further. Learning-based control replaces the hand-written model with one learned from data — and a vision-language-action model or policy trained by imitation learning can pick up the messy friction and contact effects that no equation captured. Further out still, brain-computer interfaces let a human's neural signals become the reference the controller tracks, turning a robotic limb into an extension of intention. The honest core stays the same: the model will be wrong, so build control that copes.