ALearning Material
A robot is a machine that senses its environment, decides what to do, and acts on the physical world (the sense-think-act loop) to accomplish tasks autonomously (with little or no human control). That one loop, embodied in a physical machine, is what distinguishes a robot from a mere computer (which only computes) or a remote- controlled toy (which only acts on a human's commands). This opening foundations lesson defines what a robot is, the subsystems every robot is built from, the degrees of autonomy, and the architectures that organise the sense-think-act loop, the frame for the whole robotics topic.
Three ideas define a robot. First, embodiment: a robot is a physical machine acting in the real world, so it must cope with uncertainty, noise, and physical limits that pure software never faces. Second, the sense-think-act loop: it senses (sensors gather data), thinks (a controller/computer decides), and acts (actuators move the world), continuously. The closed loop that lets it respond to what actually happens, not a fixed script. Third, autonomy: the degree to which it does this by itself rather than under human control. Build from there and every robot, from a robot vacuum to a Mars rover, is the same idea at different scales.
A robot = the sense-think-act loop, embodied, built from five subsystems:
SENSE -> THINK -> ACT (repeat): the closed loop that defines a robot (embodied, autonomous)
FIVE SUBSYSTEMS:
- SENSORS: gather data (encoders, IMU, lidar, cameras) -> 'sense'
- CONTROLLER/COMPUTE: decide (the 'brain' - control loops, planning, decision-making) -> 'think'
- ACTUATORS: move/act on the world (motors, wheels, joints, grippers) -> 'act'
- POWER: energy to run it all (battery/supply) - a real constraint (limits compute, range)
- COMMUNICATION: links between parts / to the outside (buses, networks)
DEGREES OF AUTONOMY: teleoperated -> assisted -> conditional -> fully autonomous (how much it does itself)
ARCHITECTURES (how the loop is organised): REACTIVE (sense->act, fast/dumb) | DELIBERATIVE (sense->model->plan->act,
slow/smart) | HYBRID (reactive safety + deliberative planning - what real robots use)
The anatomy. Every robot is built from five subsystems: sensors (gather data: the 'sense'), a controller/ compute (decide: the 'think', the brain running control loops, planning, decision-making), actuators (move and act on the world: the 'act', motors/wheels/joints/grippers), power (energy to run it all: a real constraint that limits compute and range), and communication (links between the parts and to the outside). Degrees of autonomy range from teleoperated (a human drives it) through assisted and conditional to fully autonomous (it does the whole task itself). And architectures organise the loop: reactive (sense straight to act: fast but 'dumb', reflexes), deliberative (sense, build a model, plan, then act, smart but slow), and hybrid (reactive layers for fast safety plus deliberative layers for planning, what real robots use). The disciplines: see every robot as the embodied sense-think-act loop, know the five subsystems, place its autonomy on the spectrum, and recognise its architecture. This is the lens for the whole topic.
Formulas & method (the latency budget, and what it costs in metres). Every rate in a robot is also a distance, and that conversion is the whole of the quantitative work here:
Latency budget: add the stages in order; the cumulative time is what matters.
A stage that runs at a rate contributes its period, because an event can arrive just after a cycle started: a 10 Hz planner costs 100 ms, a 50 Hz loop 20 ms.
Stopping distance: the two terms scale differently, which is the point.
Method: list the stages, accumulate the times, multiply by for the distance, then add the braking term. To find what an improvement buys, recompute with that one stage reduced and subtract.
The autonomy scale, which the classification problems use, is levels 0 to 4: 0 teleoperated (a human drives), 1 assisted (the machine holds a speed or heading), 2 task autonomy (a human names a goal, the machine reaches it), 3 mission autonomy (the machine sequences its own tasks and handles exceptions), 4 full autonomy (no human in the loop at all). Place a machine by which decisions it makes, not by whether a human is nearby: the evidence for a level is a decision the machine takes unaided, and the evidence against the next one up is a specific exception it hands back to a human.
Why it exists. 'Robot' covers an enormous range of machines, so you need a unifying definition to reason about any of them: the embodied sense-think-act loop, built from sensors, compute, actuators, power, and communication, operating at some degree of autonomy with some architecture. This framing lets you decompose any robot into the same parts and concepts, which is the foundation the rest of the topic (geometry, kinematics, perception, decision-making) builds on, each part deepening one piece of this loop.
Mental model. A robot is like a living creature in miniature: it has senses (sensors: eyes, ears, balance), a brain (the controller: deciding what to do), muscles (actuators: moving it), needs food/energy (power), and a nervous system (communication: carrying signals between parts). And like a creature, it continuously senses, decides, and acts in a closed loop, coping with a messy real world: not running a fixed, blind script. How much it does 'by itself' (autonomy) and how its 'brain' is organised (architecture: pure reflex vs deliberate planning vs both) varies, just as creatures range from simple reflexive ones to deliberate ones.
Common misunderstandings.
- "A robot is just any automated machine / any program." A robot is specifically an embodied machine running the sense-think-act loop: it senses, decides, and acts on the physical world in a closed loop. A program that only computes (no embodiment, no acting on the world) or a fixed machine that only acts (no sensing/deciding) isn't a robot in the full sense; the closed sense-think-act loop in a physical body is the defining feature.
- "Autonomy is all-or-nothing." Autonomy is a spectrum, teleoperated -> assisted -> conditional -> fully autonomous, and most real robots sit in between (e.g. autonomous navigation with human oversight). 'How much does it do by itself?' is a degree, not a yes/no.
- "Real robots are purely reactive or purely deliberative." Pure reactive is fast but can't plan ahead; pure deliberative is smart but too slow to react to surprises. Real robots are hybrid, fast reactive layers for safety plus deliberative layers for planning, getting both reflexes and foresight.
Connections. This is the frame for the whole topic: the sense-think-act loop is the autonomy stack (autonomy- stack: perception/localization = sense, planning = think, control = act), and it traces back to the very first Python lesson's sense-think-act; the five subsystems are exactly what the course built (sensors -> embedded/PCB, control -> PID, compute/software -> Python/C++/ROS 2, actuators -> motors); architectures (reactive/deliberative/ hybrid) preview the decision-making lessons (reactive behaviours, planning) and the behaviour-tree orchestration (the planning/behaviour-trees lesson); and 'autonomy = doing the task itself' is the goal the entire topic builds toward.
BImmediate Active Recall
QUERYWhat is a robot, and what is the sense-think-act loop?
REVEAL
A robot is an embodied machine that senses its environment, thinks (decides what to do), and acts on the physical world (the sense-think-act loop) to accomplish tasks autonomously (with little/no human control). The sense-think-act loop is that continuous closed loop: sense (sensors gather data) -> think (a controller/computer decides) -> act (actuators move the world) -> repeat. It's what distinguishes a robot from a program (only computes, no embodiment/acting) or a remote-controlled machine (only acts on human commands, no autonomous deciding). The closed loop in a physical body is the defining feature.
QUERYWhat are the five subsystems every robot is built from?
REVEAL
Sensors (gather data (encoders, IMU, lidar, cameras) the 'sense'); a controller/compute (the 'brain' that decides (control loops, planning, decision-making) the 'think'); actuators (move and act on the world (motors, wheels, joints, grippers) the 'act'); power (energy to run it all (battery/supply) a real constraint limiting compute and range); and communication (links between the parts and to the outside, buses, networks). Together these implement the sense-think-act loop in a physical machine: every robot, from a vacuum to a rover, has these five.
QUERYWhat are the degrees of autonomy?
REVEAL
A spectrum of how much the robot does by itself (vs under human control): teleoperated (a human drives it directly), assisted (the human controls but the robot helps, e.g. stability/obstacle assist), conditional (the robot does the task but needs human intervention in some situations), and fully autonomous (it does the whole task itself, no human in the loop). Most real robots sit in between (e.g. autonomous navigation with human oversight). Autonomy is a degree, not all-or-nothing: 'how much does it do by itself?'
QUERYWhat are reactive, deliberative, and hybrid architectures?
REVEAL
Ways of organising the sense-think-act loop. Reactive: sense straight to act (reflexes/rules (fast but 'dumb', no planning) e.g. 'obstacle close -> stop'). Deliberative: sense -> build a model -> plan -> act (smart, plans ahead, but slow, and brittle if the model is wrong). Hybrid: combine them: fast reactive layers for safety (immediate obstacle response) plus deliberative layers for planning (route to a goal), getting both reflexes and foresight. Real robots are hybrid because pure reactive can't plan and pure deliberative can't react fast enough.
CConceptual Questions
Answer each in your own words in the box, then reveal the model answer to compare. These ask why, not how, and your answers are saved.
Why is the embodied sense-think-act loop the defining feature of a robot, and why does embodiment make robotics fundamentally harder than pure software?
REVEAL MODEL ANSWER
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.
Why do real robots use a hybrid architecture rather than a purely reactive or purely deliberative one, and what does this reveal about the trade-off between reactivity and deliberation?
REVEAL MODEL ANSWER
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.
DPractice Problems
P1 (easy). Take one concrete machine, a warehouse AMR carrying totes, and produce its subsystem table: one row per subsystem (sensing, perception/state estimation, planning/decision, control, actuation/power), naming the actual hardware or software, the rate it runs at, and the one failure that subsystem causes when it degrades.
Then draw the sense-think-act loop as a diagram annotated with those rates, and place the machine on the autonomy scale with the specific evidence that puts it there rather than one level up or down.
P2 (medium). Quantify what embodiment costs. The AMR runs at 1.5 m/s and brakes at . The chain is: camera exposure and transfer 33 ms, obstacle detection 60 ms, costmap update 25 ms, planner cycle 100 ms, control cycle 20 ms, drive and mechanical brake delay 150 ms.
Produce the latency budget as a table with the cumulative distance travelled at each stage, compute the total stopping distance, tabulate it at 0.5, 1.0, 1.5 and 2.0 m/s, and compute what halving the perception latency buys. Then state the property of this problem that a pure software system does not have.
P3 (harder). Design the hybrid architecture for the same AMR: produce the layer diagram with each layer's rate and the interface between layers, then a table assigning nine named behaviours to a layer with the reason.
The behaviours: E-stop on bumper contact, slow for a person 2 m ahead, follow the local trajectory, pick the route to aisle C, back up when the local planner fails, keep the wheel speeds on target, re-order today's pick list, avoid a pallet that appeared mid-aisle, return to the charger below 20 percent.
Then use the rate figures to say what a purely deliberative and a purely reactive robot each fail at.
Solutionsclick to reveal
P1. The subsystem table.
| Subsystem | On this AMR | Rate | What its degradation looks like |
|---|---|---|---|
| Sensing | 2D safety lidar (front), 3D depth camera, wheel encoders, IMU, bumper | lidar 15 Hz, camera 30 Hz, encoders 1 kHz, IMU 200 Hz | Dust on the lidar: phantom obstacles, the robot stops in clear aisles |
| Perception / state estimation | AMCL on a prior map + EKF fusing encoders and IMU; obstacle layer into a costmap | localisation 10 Hz, costmap 5 Hz | Pose drift: the robot is confident and 40 cm off, and clips a rack leg |
| Planning / decision | Global A* over the map, local DWA trajectory rollout, a behaviour tree for the mission | global 1 Hz (on request), local 10 Hz | Slow replanning: the robot oscillates at a doorway or stops in front of a moving person |
| Control | Differential-drive velocity controller, PID per wheel | 50 Hz outer, 1 kHz current loop | Poor tracking: it cuts corners and the path error grows with speed |
| Actuation / power | Two brushless hub motors, a 48 V pack, mechanical brakes, an E-stop loop | brake release about 150 ms | Weak brakes or a flat pack: the stopping distance grows and it is discovered by collision |
The loop, with the rates on it.
+--------------- the world -----------------+
| |
v |
SENSE lidar 15 Hz, camera 30 Hz, encoders 1 kHz
| |
v |
THINK estimate pose 10 Hz |
update costmap 5 Hz |
local plan 10 Hz |
global plan 1 Hz |
| |
v |
ACT velocity control 50 Hz -> motors ---+
brakes (150 ms to bite)
The rates are not decoration: they are the specification. The slowest stage in the chain sets how quickly the robot can respond to something new, and the next problem turns that into metres.
Where it sits on the autonomy scale.
| Level | Description | This AMR |
|---|---|---|
| 0 | Teleoperated, a human drives | no |
| 1 | Assisted, the machine holds a speed or a heading | no |
| 2 | Task autonomy, the human names a goal, the machine gets there | yes |
| 3 | Mission autonomy, the machine sequences its own tasks and handles exceptions | partly |
| 4 | Full autonomy, no human in the loop for anything | no |
The evidence for level 2, and against 3. A human or a warehouse-management system issues "collect tote 47 from aisle C"; the robot plans and executes the route, avoids people, and reports completion without further instruction. That is task autonomy. But when it finds the aisle blocked by a pallet, it stops and calls for help rather than re-sequencing the day's work, and when its localisation fails it waits for a human to re-initialise it. Handling those exceptions itself is what level 3 would mean, and it is the gap most commercial AMRs actually have.
The evidence against level 1 is equally specific: it is not merely holding a heading; it chooses a route, replans around obstacles it was never told about, and recovers from a failed local plan by backing up and trying another approach. Autonomy is measured by which decisions the machine makes, not by whether a human is nearby, and the table above is the honest way to say which those are.
P2. The latency budget.
| Stage | Duration | Cumulative | Distance travelled at 1.5 m/s |
|---|---|---|---|
| Camera exposure and transfer (30 fps) | 33 ms | 33 ms | 0.050 m |
| Obstacle detection | 60 ms | 93 ms | 0.140 m |
| Costmap update | 25 ms | 118 ms | 0.177 m |
| Planner cycle (10 Hz) | 100 ms | 218 ms | 0.327 m |
| Control cycle (50 Hz) | 20 ms | 238 ms | 0.357 m |
| Drive and mechanical brake delay | 150 ms | 388 ms | 0.582 m |
The robot travels 58 cm before the brakes even begin to bite, and every centimetre of it happens while the obstacle is already there.
The stopping distance.
Against speed:
| Speed | Reaction distance | Braking distance | Total |
|---|---|---|---|
| 0.5 m/s | 0.194 m | 0.062 m | 0.257 m |
| 1.0 m/s | 0.388 m | 0.250 m | 0.638 m |
| 1.5 m/s | 0.582 m | 0.562 m | 1.145 m |
| 2.0 m/s | 0.776 m | 1.000 m | 1.776 m |
Note the two terms scale differently. The reaction distance is linear in speed, the braking distance quadratic, so speed is cheap until it is not: going from 0.5 to 1.0 m/s costs 0.38 m of stopping distance, from 1.5 to 2.0 costs 0.63 m.
What halving the perception latency buys.
| Before | After | |
|---|---|---|
| perception | 118 ms | 59 ms |
| total latency | 388 ms | 329 ms |
| stopping distance | 1.145 m | 1.056 m, a saving of 8.9 cm |
Nine centimetres for halving the hardest part of the stack. Meanwhile the 150 ms brake delay, which is a mechanical property and often ignored in software reviews, is worth 22 cm on its own. The budget is what tells you that, and it is why the table is worth building before optimising anything.
The property a pure software system does not have: the world keeps moving while you think, and there is no retry.
A web service that takes 400 ms to decide has a slow user. A robot that takes 400 ms to decide has moved 58 cm, and the situation it decided about is not the situation it now faces. Three consequences follow, and each of them is a whole area of robotics:
Latency is a physical quantity, not a user-experience one. It converts directly into metres through the robot's speed, and metres are where the rack leg is.
A failed action cannot be replayed. Software can retry an idempotent request; a robot that has driven into the rack cannot un-drive into it. State is in the world, not in the process, so a restart does not reset it and a crash leaves the machine wherever it was.
Every input is uncertain and every output is approximate. The encoder says 1.5 m/s and the wheel is slipping; the command is 1.2 A and the motor delivers what the supply allows. The robot's model of its own state is always an estimate, which is why state estimation is a subsystem in its own right and why "just read the value" is never available.
The practical rule the budget produces: pick the speed from the stopping distance, not the other way round. In a 1.2 m aisle with people in it, 1.145 m of stopping distance is already the whole aisle, and the honest engineering answer is to run at 1.0 m/s, not to promise a faster perception pipeline.
P3. The architecture.
+-------------------------------------------------------------+
| DELIBERATIVE 1 Hz or on demand |
| mission sequencing, global route, recharge scheduling |
| works on the MAP, thinks in minutes |
+---------------------------+---------------------------------+
| a goal pose and a route (a few times a minute)
v
+-------------------------------------------------------------+
| EXECUTIVE 10 Hz |
| behaviour tree, local planner, recovery behaviours |
| works on the COSTMAP, thinks in seconds |
+---------------------------+---------------------------------+
| a velocity command (10 per second)
v
+-------------------------------------------------------------+
| REACTIVE 50 Hz to 1 kHz |
| velocity and current control, speed limiting, E-stop |
| works on RAW SENSOR DATA, thinks in milliseconds |
+---------------------------+---------------------------------+
| motor currents
v
hardware
The interface between layers is deliberately narrow: each layer sends the one below a setpoint, and the one below is free to refuse it. The reactive layer can override any velocity command from above; nothing above can override the reactive layer. That asymmetry is the safety argument, and it is why the layers are ordered this way.
The assignment.
| Behaviour | Layer | Why |
|---|---|---|
| E-stop on bumper contact | Reactive | Must act in one control cycle. No deliberation can be allowed to delay it |
| Slow for a person 2 m ahead | Reactive | A direct sensor-to-speed-limit rule; needs no map and no plan |
| Follow the local trajectory | Executive | Needs the costmap and the current plan, at 10 Hz |
| Pick the route to aisle C | Deliberative | A search over the whole map; expensive and rarely needed |
| Back up when the local planner fails | Executive | A recovery behaviour: it needs to know the plan failed, which the reactive layer cannot know |
| Keep the wheel speeds on target | Reactive | A PID at 1 kHz. Nothing above can run fast enough |
| Re-order today's pick list | Deliberative | Minutes of consequence, seconds of computation; no urgency at all |
| Avoid a pallet that appeared mid-aisle | Executive, with a reactive backstop | The executive replans around it at 10 Hz; the reactive layer stops the robot if it gets too close while that happens |
| Return to the charger below 20 percent | Deliberative | A mission decision that changes the goal, not the trajectory |
The row worth dwelling on is the pallet, because it is the one that needs two layers. The executive produces the good answer, a smooth path around it, in a few hundred milliseconds. The reactive layer produces the safe answer, stop, in 20 ms. The robot needs both, and the reason is exactly the latency budget: 0.58 m of travel elapses before any deliberated response can take effect.
What a purely deliberative robot fails at.
Its cycle is 1 Hz, so at 1.5 m/s it covers 1.5 m between decisions. An obstacle that appears after a cycle begins is hit before the next cycle starts. It also replans the whole map to react to a person stepping out, spending a second of computation to answer a question that needed a threshold comparison.
And it fails worse when it is loaded. Deliberation time depends on the problem: a longer route, a cluttered map, a harder search. Response time that varies with the problem is the one thing a safety function cannot have, which is the structural reason the E-stop is not in this layer.
What a purely reactive robot fails at.
It cannot get anywhere. With no map and no memory, it treats every wall as a local obstacle to turn away from, and the classic result is a robot that wanders a warehouse forever, or oscillates in a U-shaped bay because every escape direction looks worse than the one it came from. It cannot recognise that it has been here before, cannot choose between two routes, and cannot represent "aisle C" at all.
The trade the two failures define: reactivity buys response time and costs foresight; deliberation buys foresight and costs response time. The hybrid architecture refuses the trade by running both, at their own rates, and the diagram's one-way override arrow is what makes that safe. Slow layers set goals; fast layers keep promises; and the fastest layer always has the final word.
EFeynman Exercise
Explain to a beginner, using the analogy of a robot as a living creature in miniature: (1) why a robot is the sense-think-act loop embodied (senses, a brain, muscles, energy, a nervous system: continuously sensing, deciding, and acting in a messy real world), (2) why autonomy is a spectrum of how much it does by itself, and (3) why its 'brain' can be organised as pure reflex (reactive), deliberate planning (deliberative), or both (hybrid: what real robots use).
REVEAL MODEL ANSWER
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.
FError Analysis Framework
- Calling any automated machine or any program a 'robot'. Why: it does something automatically. Recognise: a robot specifically runs the sense-think-act loop in a physical body. Avoid: require the embodied closed loop (senses, decides, AND acts on the world), not just compute or just act.
- Treating autonomy as all-or-nothing. Why: it's 'a robot', so it's autonomous. Recognise: autonomy is a spectrum and most robots are partial. Avoid: place it on teleoperated -> assisted -> conditional -> fully autonomous (a degree).
- Designing a robot as purely reactive or purely deliberative. Why: one approach seems simpler. Recognise: pure reactive can't plan; pure deliberative can't react fast. Avoid: use a hybrid: fast reactive safety layer + deliberative planning layer.
- Ignoring power and communication as 'not real' subsystems. Why: sensors, brain, and motors seem to be the robot. Recognise: power limits compute/range and comms links the parts, both constrain the design. Avoid: treat all five subsystems (sensors, compute, actuators, power, communication) as essential.
GMini Challenge
Explain what a robot is for a new roboticist: the embodied sense-think-act loop, the five subsystems, the degrees of autonomy, and the reactive/deliberative/hybrid architectures. Explaining why embodiment makes robotics hard and why real robots are hybrid.
REVEAL MODEL ANSWER
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).
Quiz Check
A quick auto-graded check, separate from the recall cards above. Your score is pooled with the recall cards into this module's Mastery score, and completing this lesson requires the quiz submitted with pooled mastery at 80% or above.