Informally, an autonomous robot can operate for extended periods without continuous human control, using its own sensing, computation, and actuation to achieve goals in a (possibly changing) environment. Unlike a purely automated machine that simply repeats a fixed script, an autonomous robot closes the loop using feedback from sensors to adapt its actions.

From a control-theoretic perspective, we can view the robot as a controller embedded inside the physical world. Let \( x_k \) denote the robot state at discrete time step \( k \), and \( e_k \) denote the environment state (objects, humans, obstacles, etc.). The combined “world state” is \( s_k = (x_k, e_k) \). The robot receives measurements \( y_k \) from its sensors and generates control inputs \( u_k \) (torques, wheel speeds, etc.).

\[ \begin{aligned} s_{k+1} &= F(s_k, u_k, d_k), \\ y_k &= H(s_k, v_k), \end{aligned} \]

where \( d_k \) and \( v_k \) represent disturbances and sensor noise. A robot is said to be acting autonomously over some time interval if its control inputs are generated by an internal policy based on its own measurements and internal memory, not directly commanded at each step by a human:

\[ u_k = \pi_k(y_0, y_1, \dots, y_k, g), \]

where \( g \) encodes the task goal (e.g., a desired pose or region) and \( \pi_k \) is the (possibly time-varying) decision rule implemented in the robot software.

flowchart TD
  G["Goal g (task specification)"] --> RINT["Robot internal policy pi_k"]
  ENV["Environment state s_k"] --> SENS["Sensors"]
  SENS --> OBS["Measurements y_k"]
  OBS --> RINT
  RINT --> ACT["Actuators, control input u_k"]
  ACT --> DYN["World dynamics F"]
  DYN --> ENV
  ENV --> SENS
        

This diagram is a specialization of the generic sense–think–act loop you have already seen, with emphasis on the policy \( \pi_k \) that makes the robot self-governing.

In engineering practice, the words “autonomy”, “automation”, and “teleoperation” are often used loosely. Here we give simple mathematical characterizations using discrete-time control laws.

2.1 Teleoperation (no autonomy)

In teleoperation, a human operator acts as the controller. The robot executes commands but does not choose them:

\[ u_k = u_k^{\text{human}}. \]

The robot may close low-level loops (e.g., current or velocity control), but decision-level actions (where to go, what to grasp) come directly from the human at each step. The effective closed loop is “world–human–robot”, with the robot as an actuator device rather than an autonomous agent.

2.2 Scripted Automation (open-loop w.r.t. environment)

In simple automation, the robot executes a preprogrammed sequence of commands independent of its measurements:

\[ u_k = \bar{u}_k, \quad \text{for } k = 0,1,2,\dots \]

Here, \( \bar{u}_k \) is a fixed schedule. This is analogous to an open-loop control law in linear systems. Such a system can be very precise in a highly structured and predictable environment (e.g., a fixed assembly line), but is not robust to unmodeled changes (unexpected obstacles, human presence, part position variation).

2.3 Closed-Loop Autonomy

In autonomy, the control law depends explicitly on sensor information. The simplest case is a state-feedback law you have seen in linear control:

\[ \begin{aligned} x_{k+1} &= A x_k + B u_k, \\ u_k &= K x_k. \end{aligned} \]

Substituting the feedback law gives the autonomous closed-loop system

\[ x_{k+1} = (A + B K) x_k. \]

Once the gain matrix \( K \) and the initial condition \( x_0 \) are chosen, the trajectory is fully determined without further human input. This is an example of low-level autonomy. In robotics, we often require additional capabilities beyond stabilizing a fixed point: the robot must interpret sensor data, choose goals, and respect constraints while operating in a changing environment.

To reason about autonomy, we must specify both the dynamics and the task. Let \( x_k \in \mathbb{R}^n \) be the robot state, and suppose the robot dynamics are control-affine (you have seen this structure in linear control):

\[ x_{k+1} = f(x_k) + G(x_k) u_k + w_k, \]

where \( w_k \) represents disturbances. Sensors provide measurements \( y_k \):

\[ y_k = h(x_k) + v_k. \]

A task is usually specified as reaching or maintaining a set of “good” states \( \mathcal{G} \subset \mathbb{R}^n \) while respecting constraints (safety, actuator limits):

\[ \begin{aligned} \mathcal{G} &\subset \mathbb{R}^n \quad \text{(goal set)}, \\ \mathcal{S} &\subset \mathbb{R}^n \quad \text{(safe set)}, \\ \mathcal{U} &\subset \mathbb{R}^m \quad \text{(admissible controls)}. \end{aligned} \]

A (possibly history-dependent) policy \( \pi_k \) is said to solve the task autonomously if, for all initial states \( x_0 \in \mathcal{S} \) from some domain of interest, the closed-loop system

\[ u_k = \pi_k(y_0, \dots, y_k, \mathcal{G}) \]

satisfies, with high probability or in a robust sense,

\[ \begin{aligned} x_k &\in \mathcal{S} \quad \text{for all } k, \\ x_k &\in \mathcal{G} \quad \text{for some finite } k. \end{aligned} \]

This definition emphasizes that autonomy is a property of the closed-loop behavior rather than of the hardware alone. The same mechanical platform can be teleoperated, scripted, or autonomous depending on the implemented policy.

In many realistic tasks, the robot cannot measure the full state \( x_k \) directly. It must build some internal representation (an internal state) from its sensor history. Let \( z_k \) denote this internal state, updated from observations and previous internal state:

\[ \begin{aligned} z_{k+1} &= \phi(z_k, y_{k+1}), \\ u_k &= \psi(z_k, g). \end{aligned} \]

Here, \( \phi \) is an internal model (which could be as simple as a low-pass filter or as complex as a full estimator), and \( \psi \) maps the internal state to control. Even in purely deterministic linear control, you have seen a special case: the observer–based controller.

\[ \begin{aligned} \hat{x}_{k+1} &= A \hat{x}_k + B u_k + L (y_k - C \hat{x}_k), \\ u_k &= K \hat{x}_k. \end{aligned} \]

In this controller, the internal state \( z_k = \hat{x}_k \) is the estimated robot state. The robot is autonomous if it can maintain and update such internal state representations on its own, using sensors and computation, to achieve its goals.

Conceptually, higher “intelligence” in robotics often means richer internal state representations and more expressive policies \( \pi_k \), but the basic closed-loop structure remains the same.

In practice, autonomy is rarely all-or-nothing. Instead, we speak about degrees of autonomy or levels of automation along several dimensions:

• Decision autonomy: who selects goals, paths, and actions.
• Perception autonomy: who interprets sensor data (e.g., does a human label objects?).
• Execution autonomy: who handles low-level control and constraint enforcement.
• Temporal autonomy: how long the robot can operate without human intervention.

A simple quantitative measure for decision autonomy over a discrete-time horizon \( k = 0,1,\dots,N-1 \) is the intervention-based autonomy index. Let \( \iota_k \) be an indicator of human intervention at time step \( k \):

\[ \iota_k = \begin{cases} 1, & \text{if a human overrides or directly chooses } u_k, \\ 0, & \text{otherwise.} \end{cases} \]

Then define the autonomy index over the interval as

\[ A_N = 1 - \frac{1}{N} \sum_{k=0}^{N-1} \iota_k. \]

We have \( 0 \leq A_N \leq 1 \). Extreme cases:

• \( A_N = 0 \): human intervenes at every step (pure teleoperation).
• \( A_N = 1 \): no interventions (fully autonomous over that horizon).

This simple metric ignores how “difficult” the decisions are, but it already reveals an important fact: autonomy depends not only on the controller design but also on the environment and operational practice.

flowchart LR
  T0["Teleoperation: A_N ~ 0"] --> MIX["Shared control: 0 < A_N < 1"]
  MIX --> FULL["Full autonomy: A_N ~ 1"]
        

More sophisticated metrics also consider task complexity (e.g., uncertainty, disturbance magnitude) and performance (success rates, safety margins). These will connect later to planning and learning methods in advanced courses.

Using the safe set \( \mathcal{S} \) and goal set \( \mathcal{G} \) introduced earlier, we can characterize autonomy in terms of robust goal satisfaction. For simplicity, consider a deterministic disturbance-free system

\[ x_{k+1} = f(x_k, u_k), \quad u_k \in \mathcal{U}. \]

A feedback policy \( \pi(x) \) induces closed-loop dynamics

\[ x_{k+1} = f(x_k, \pi(x_k)). \]

For a given pair \( (\mathcal{S}, \mathcal{G}) \), define the winning set \( \mathcal{W} \):

\[ \mathcal{W} = \left\{ x_0 \in \mathcal{S} \;\middle|\; \exists \text{ feedback policy } \pi \text{ such that } x_k \in \mathcal{S} \ \forall k,\; x_k \in \mathcal{G} \text{ for some finite } k \right\}. \]

Intuitively, \( \mathcal{W} \) is the set of initial conditions from which the robot can autonomously achieve the task without leaving the safe set. The larger \( \mathcal{W} \) is (for a fixed robot and environment), the “more capable” the robot is for that task. Enhancing autonomy often means enlarging \( \mathcal{W} \) through better sensing, more powerful actuators, or more sophisticated decision logic.

In advanced courses, you will see algorithmic tools (from reachability, game theory, and planning) used to compute or approximate \( \mathcal{W} \). Here, it is enough to recognize that autonomy is tightly tied to robustness of closed-loop performance across a range of initial conditions and environments.

Later lessons in this chapter will discuss reactive, deliberative, and hybrid architectures. At this stage, you only need the high-level idea:

• Reactive autonomy: policies \( \pi_k \) depend mostly on the most recent measurements (like static or low-memory feedback). Typical in fast, reflex-like behaviors.
• Deliberative autonomy: policies use internal models of the environment and future consequences of actions. Requires explicit internal state and planning over time.
• Hybrid autonomy: combines fast reactive layers with slower planning layers, sharing information through internal state variables.

In all cases, autonomy is realized as some structured policy \( \pi_k \) implemented in software on top of the physical system you have studied in previous chapters (mechanics, actuators, sensors, computing, and software architecture).

In this lesson, we grounded the intuitive idea of robot autonomy in the mathematics of dynamical systems and feedback control. We modeled the robot–environment interaction as a closed-loop system, distinguished teleoperation and open-loop automation from genuine autonomy, and introduced simple autonomy metrics and the concept of a winning set for tasks defined by safe and goal sets. We also emphasized the role of internal state and memory in enabling robust autonomous behavior under partial information and noise. Subsequent lessons will explore how different software architectures realize such policies and how planning and learning extend these ideas.