What is a robot? Components, autonomy & architectures

The embodied sense-think-act loop is the defining feature of a robot because it captures exactly what sets a robot apart from both a pure computer program and a simple automated or remote-controlled machine: a robot ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍closes the loop between perceiving the physical world, deciding, and acting on that world, repeatedly and (to some degree) by itself. A pure program only computes. It transforms inputs to outputs but does not sense or act on the physical world. A fixed automated machine (a conveyor, a music box) acts on the world but does not sense and decide, it blindly repeats. A remote-controlled toy acts but the deciding is done by a human. A robot is the machine that does all three (sense, think, and act) in a closed loop, in a physical body: it gathers data about the actual state of the world, decides what to do based on that data, acts to change the world, and then senses the result of its action, continuously. This closed loop is what lets it accomplish tasks in an unpredictable real world rather than executing a blind fixed script. It can respond to what actually happens. So 'embodied sense-think-act loop' is the unifying definition that fits every robot, from a robot vacuum (senses dirt/walls, decides where to go, drives, repeats) to a Mars rover, while excluding things that aren't robots. Embodiment makes robotics fundamentally harder than pure software because the physical world is ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍uncertain, noisy, continuous, and unforgiving in ways a clean software environment is not. In pure software, inputs are exact, operations are deterministic, and there are no physical consequences to a mistake beyond a wrong output. A robot, by contrast, must deal with: sensor noise and uncertainty (its sensors give noisy, partial, sometimes wrong readings: it never knows the world's true state exactly); actuation imperfection (motors don't move exactly as commanded: there's slip, backlash, delay); real-time constraints (the world doesn't wait: the robot must sense, decide, and act fast enough to keep up with physical events, or it crashes); physical limits and safety (limited power, limited force, and real consequences: a mistake can break the robot or hurt someone); and the continuous, dynamic nature of physical reality (everything is approximate and always changing). So whereas a program can assume clean, exact, consequence-free data, a robot must robustly sense an uncertain world, decide under that uncertainty, and act despite imperfect actuators and real-time and safety constraints. This is precisely why robotics needs all the foundations the rest of the topic builds: geometry to know where things are, kinematics to relate motion to wheels/joints, probabilistic perception to handle sensor noise, planning to decide under constraints, and careful systems engineering for safety. The embodied closed loop ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍is the robot, and the difficulty of closing that loop reliably in the messy physical world is why robotics is a deep engineering discipline, not just programming.

Real robots use a hybrid architecture because purely reactive and purely deliberative architectures each have a fundamental weakness that the other fixes, and a capable robot needs both the fast reflexes of reactivity and the foresight of deliberation, which only a hybrid provides. A reactive architecture maps sensing more or less directly to action ('sense -> act'), using rules or reflexes: if an obstacle is close, stop; if the line is to the left, steer left. Its great strength is speed and robustness: it responds almost instantly to what the sensors report, with no slow computation, so it handles fast, immediate situations (a sudden obstacle) well and degrades gracefully. But its weakness is that it can't plan ahead: it has no model of the world and no notion of a goal beyond its immediate rules, so it can't figure out a route to a distant destination, reason about consequences, or do anything requiring foresight. It's fast but 'dumb', easily stuck in situations that need a plan (a reactive robot can wall-follow but can't deliberately navigate to room 304). A deliberative architecture does the opposite ('sense -> build a model -> plan -> act'): it builds a model of the world, reasons over it to plan a sequence of actions toward a goal, then executes. Its strength is ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍intelligence and foresight: it can find routes, optimise, reason about consequences, achieve complex goals. But its weakness is that it's slow and brittle: building a model and planning takes time, so it can't react quickly to surprises, and if the world changes or the model is wrong, its careful plan can fail (it might be busy replanning when it should just stop for a sudden obstacle). So there's a fundamental trade-off between reactivity and deliberation: fast reflexive response versus slow intelligent planning, and you can't get both from a single layer, because the very thing that makes deliberation smart (building and reasoning over a model) is what makes it slow, and the very thing that makes reaction fast (skipping the model, going straight to action) is what makes it unable to plan. The hybrid architecture resolves this by layering both: a fast reactive layer handles immediate safety and reflexes (stop for an obstacle, stay upright) on a short timescale, while a slower deliberative layer handles planning toward goals (compute a route, sequence tasks) on a longer timescale, with the reactive layer able to override the plan when safety demands. This gives the robot ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍both. It can pursue a deliberately-planned goal and react instantly to surprises, because the two concerns run at the timescales that suit them. What this reveals is a general principle that recurs throughout robotics (and the autonomy stack): different concerns need different timescales and different mechanisms, and good architecture is about separating them (fast/reflexive for safety and immediate response, slow/deliberate for planning and goals) rather than forcing one mechanism to do everything. The autonomy stack you'll study is exactly this hybrid: fast local control and obstacle avoidance (reactive) under a global planner and behaviour tree (deliberative). So real robots are hybrid because intelligence and reactivity are both essential but fundamentally trade off, and layering them at their natural timescales is how you get a robot that is both smart and safe.

A robot is best understood as a living creature in miniature. First, a robot is the sense-think-act loop, embodied, just like a creature: it has senses (sensors: eyes, ears, a sense of balance), a brain (the controller that decides what to do), muscles (actuators: motors and wheels and joints that move it), needs food/energy (power: a battery), and a nervous system (communication: signals carried between its parts). And like a living thing, it continuously senses what's around it, decides what to do, and acts: then senses the result: over and over, coping with a messy, unpredictable real world rather than blindly following a fixed script. That closed loop, in a physical body, is what makes it a robot (a calculator only thinks, a music box only acts: a robot does all three, in the world). Second, autonomy is a spectrum of how much it does by itself. Some 'robots' are really driven by a human (teleoperated: like a remote-control car); some ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍help the human (assisted); some do the task but need help sometimes (conditional); and some do the whole job themselves (fully autonomous: like a robot vacuum that cleans the house on its own). It's not 'robot or not'. It's how independent it is, a dial from human-driven to fully self-driving. Third, its 'brain' can be organised in three ways. Pure reflex (reactive): it just reacts: 'something's in front of me, stop!': fast, like flinching, but it can't plan a route. Deliberate planning (deliberative): it builds a picture of the world and thinks out a plan: smart, like working out a route on a map, but slow to react to surprises. Both together (hybrid): fast reflexes for safety plus careful planning for goals: which is what real robots use, because you want a robot that can plan its way to the goal and instantly stop when a child steps in front of it. So: a robot is a little creature that senses, thinks, and acts in the real world (built from senses, a brain, muscles, energy, and a nervous system), as independently as it's designed to be (the autonomy dial), with a brain that's reflexive, deliberate, or, for real robots, both. That's the lens for the whole topic: everything else deepens one piece of this creature.

A robot = the embodied sense-think-act loop: an embodied machine that senses (sensors gather data), thinks (a controller decides), and acts (actuators move the world), in a continuous closed loop, to do tasks autonomously. The closed loop in a physical body distinguishes it from a program (only computes) or a remote-controlled machine (only acts on human commands). It responds to what actually happens, not a blind script.

The five subsystems: sensors (gather data: 'sense'), controller/compute (the brain: decide: 'think'), actuators (move/act: 'act'), power (energy: limits compute/range), communication (links between parts and outside). Every robot, vacuum to rover, has these.

Degrees of autonomy (a spectrum): teleoperated (human drives) -> assisted (robot helps) -> conditional (robot acts, human intervenes sometimes) -> ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍fully autonomous (whole task itself). Most robots sit in between, a degree, not all-or-nothing.

Architectures (organising the loop): reactive (sense -> act; fast reflexes, can't plan), deliberative (sense -> model -> plan -> act; smart but slow/brittle), hybrid (fast reactive safety + deliberative planning: what real robots use).

Why embodiment makes robotics hard: the physical world is uncertain, noisy, real-time, and unforgiving: a robot must handle sensor noise (never the exact true state), actuation imperfection (slip/lag), real-time constraints (the world doesn't wait), and physical limits/safety (real consequences): unlike clean, consequence-free software. That's why robotics needs geometry, kinematics, probabilistic perception, planning, and safety engineering.

Why real robots are hybrid: reactivity (fast, can't plan) and deliberation (smart, slow) fundamentally trade off and ‍​‌‌​​‌‌​​‌‌‌​​‌​​‌‌​​‌​‌​‌‌​​‌​‌​​‌​‌‌​‌​‌‌‌​​‌‌​‌‌​​​​‌​‌‌​‌‌​‌​‌‌‌​​​​​‌‌​‌‌​​​‌‌​​‌​‌‍one layer can't give both, so robots layer a fast reactive safety layer and a slower deliberative planning layer, each at its natural timescale, getting both reflexes and foresight (smart and safe). This is exactly the autonomy stack (the autonomy-stack lesson): perception/localization = sense, planning = think, control = act: the frame the whole topic deepens (geometry, kinematics, perception, decision-making each refine one piece).