Definition
Robotics is the field of building machines that sense their surroundings, decide what to do, and act on the physical world — and its connection to AI is the software stack that turns raw sensor readings into motion: computer vision to perceive, planning to choose an action, and control to execute it against real hardware. What makes it distinct from ordinary software is that the world it acts on is continuous, noisy, and unforgiving in a way a benchmark never is: a bug does not throw an exception, it drops the box.
A robot is any machine that closes this loop from sensing to action. That covers a fixed industrial arm bolted to a factory floor, a wheeled warehouse robot, a legged machine like Boston Dynamics' Spot, and a self-driving car, which is a robot that happens to carry passengers. The mechanical engineering — motors, joints, structure — has been solved well enough for decades; a modern arm can weld the same seam thousands of times a shift with sub-millimetre repeatability. The hard, unsolved part, and the reason robotics sits in an AI glossary, is getting a machine to behave sensibly when the environment is not the one it was programmed for.
That difficulty has a name. Moravec's paradox, articulated by roboticist Hans Moravec in the 1980s, is the observation that the things humans find hard — chess, arithmetic, formal logic — are easy to automate, while the things any toddler does effortlessly — walking across a room, recognising a face, picking up a cup without crushing it — are brutally hard for machines. Sensorimotor skill is billions of years of evolution compressed into reflexes we cannot introspect; abstract reasoning is a thin recent layer. A program can beat the world's best chess player, and the same lab's best robot still cannot reliably clear a dinner table. Everything that follows on this page is a consequence of that inversion.
How It Works
Almost every robot runs the same conceptual loop — sense, perceive, plan, control — over and over, but the interesting engineering is in how fast each stage runs and how they layer.
Sensing gathers raw data: cameras, LiDAR, force sensors, joint encoders, an inertial measurement unit. Perception turns that data into a model of the world — computer vision identifies objects and estimates where they are, sensor fusion combines several imperfect sensors into one estimate of the robot's own state. Planning decides what to do given a goal and that world model. Control converts the decision into the exact currents sent to each motor, then measures the result and corrects, thousands of times a second.
The rates of these layers differ by orders of magnitude, and understanding that hierarchy is most of understanding how a robot works. A low-level controller keeping a joint on target typically runs at roughly 1 kHz — a fresh correction every millisecond — because a physical system going unstable does so fast and a slow loop lets it fall over before it can react. A higher-level policy that decides what motion to make runs much slower: in OpenAI's dexterous-hand work the learned control policy issued new targets at roughly 12 Hz while the low-level controller underneath it ran at that ~1 kHz. The pattern is general — a fast, dumb loop keeps the machine stable and safe; a slower, smarter loop tells it where to go.
Controlling those motors means reasoning about degrees of freedom (DOF). To place a rigid object anywhere in three-dimensional space you need six numbers: three for position (x, y, z) and three for orientation (roll, pitch, yaw). So an arm needs at least six independently driven joints to reach an arbitrary pose, which is exactly why the canonical industrial arm is a 6-DOF machine; arms with seven joints add a redundant degree of freedom so they can reach the same point while bending around an obstacle. Working out the joint angles that put the gripper at a desired pose (inverse kinematics) and the torques that produce a desired acceleration (dynamics) is the mathematical core of making an arm move.
The part AI changed is planning and perception under uncertainty. Classical robots were programmed: an engineer specified the trajectory and the robot replayed it, which works perfectly as long as the world matches the plan. Learning-based robotics replaces the specification with a policy — a function from sensor readings to motor commands, often trained with reinforcement learning — so the machine can handle situations nobody enumerated in advance. The catch is how that policy gets trained, which is where the physical world exacts its price.
Real-World Applications
- Industrial manipulation: Fixed 6-DOF arms from vendors like FANUC, KUKA and ABB do the bulk of the world's welding, painting, and assembly. These are the mature, profitable heart of robotics — high precision, high repeatability, in a controlled environment the robot never has to reason about.
- Legged and mobile robots: Boston Dynamics' Spot (a quadruped) and Atlas (a humanoid) are the reference points for dynamic balance and locomotion over uneven ground — the Moravec-hard problem of walking, made to look easy on video and still extraordinarily difficult to make reliable.
- Self-driving vehicles: An autonomous car is a robot whose perception and planning stack must run in an open, adversarial world at speed; the safety engineering that entails is its own subject in autonomous vehicle safety and autonomous systems.
- Warehouse and logistics: Mobile robots that shuttle shelves and sort packages are among the largest real deployments, precisely because a warehouse is a semi-structured environment — messier than a factory cell, far tamer than a public road.
- Surgical robots: Systems such as Intuitive Surgical's da Vinci translate a surgeon's hand motions into fine, tremor-filtered instrument movements. Here the robot is a precise teleoperated tool rather than an autonomous agent, which is often exactly the right division of labour.
Key Concepts
- Sensors and actuators: Sensors (cameras, LiDAR, force sensors, encoders) are how a robot reads the world; actuators (motors, servos, grippers) are how it changes it. A robot is fundamentally the loop that connects the two.
- Manipulators versus mobile robots: A fixed-base arm always knows exactly where its base is, so its whole problem is joint angles. A mobile robot's base moves through the world, which adds an entire second problem — estimating its own position (localization) and building a map (SLAM). The distinction changes the core algorithms, not just the hardware.
- Degrees of freedom and configuration space: The DOF count is the number of independent numbers needed to describe the robot's pose; the space of all those numbers is its configuration space, and planning is really the problem of finding a safe path through it.
- Kinematics and dynamics: Kinematics relates joint angles to end-effector position ignoring forces; dynamics adds mass, inertia and torque. Fast, stable control needs both.
- Perception and control policies: Computer vision supplies the world model; a control policy — engineered or learned via reinforcement learning — maps that model to action. The shift from engineered to learned policies is what connects modern robotics to embodied AI.
Challenges
The recurring theme is that the physical world does not cooperate, and the failures are specific.
The sim-to-real gap is the one that breaks deployments. Reinforcement learning for control needs a staggering number of trials — OpenAI's dexterous-hand system needed the equivalent of roughly 100 years of experience to learn a single in-hand manipulation task robustly. No real robot can perform a century of trial and error, so the training happens in a physics simulator, where that 100 years was compressed into about 50 hours of wall-clock time across a pool of 384 machines with 16 CPU cores each. But a simulator's friction, contact, mass, latency and sensor noise never exactly match hardware. What breaks: take a policy trained in simulation and deploy it directly on a real robot without domain randomization — deliberately varying those physical parameters during training — and it will typically fail, because it overfitted to the exact, wrong physics of the simulator. Randomizing the simulation so no single set of parameters is trusted is what lets the policy survive contact with reality; skipping it is the classic reason a demo that worked in sim collapses on the bench. The depth of this problem is the subject of embodied AI.
Safety around humans is not a feature bolted on at the end. A 6-DOF industrial arm moves fast enough to injure, so traditional deployments cage it off entirely; collaborative robots (cobots) trade speed for force-limiting and collision detection so they can share space with people, and getting that trade-off certified is slow, hard work.
Reliability in the long tail is where most robots quietly stall. A policy that succeeds 95% of the time sounds impressive and is often useless: at one action per second, a 5% failure rate means a fault every twenty seconds, and unlike a software retry, a robot that has knocked something over is now in a state it was never trained on and cannot reset itself out of.
Sample efficiency is the open research frontier behind all of this. Humans learn a new manipulation skill in a handful of tries; the numbers above show how far machine methods still are from that, which is why so much effort goes into simulation, imitation learning from human demonstrations, and reusing knowledge across tasks rather than learning each one from scratch.
Future Trends
The dominant research direction is foundation models for control — vision-language-action models that map camera images and a natural-language instruction directly to robot commands, importing common-sense knowledge that no realistic amount of robot data could ever teach. This is the frontier where robotics and machine learning are merging fastest, and it is covered in depth under embodied AI.
Underneath that, domain randomization is hardening into default practice. What began as a trick for one lab's robot hand is becoming the expected discipline: training against a randomized distribution of physics parameters, rather than one nominal model of the world, is increasingly how any simulation-trained policy is expected to earn its transfer to real hardware.
The deeper shift is that learned control is starting to displace hand-tuned control for the hardest dynamic tasks. In legged locomotion over rough terrain and agile flight, policies trained in simulation are beginning to outperform decades of carefully engineered controllers — moving the robotics engineer's job from writing the controller by hand to designing the training environment that produces one.