Section 3.1: The canonical stack: sense, perceive, estimate, predict, plan, control, act

A Careful Control Loop

This section develops the technical contract for the canonical stack: sense, perceive, estimate, predict, plan, control, act into a usable mental model. First we define the object of study, then we connect it to the agent loop, then we test it with a compact implementation.

The key question in The canonical stack: sense, perceive, estimate, predict, plan, control, act is practical: what must the agent know, what can it observe, what action is available, and what evidence shows that the action worked under the stated conditions?

Theory

For The canonical stack: sense, perceive, estimate, predict, plan, control, act, the practical design rule is to make the interface inspectable before optimization begins: inputs, outputs, units, latency, bounds, and failure labels should all be visible in the saved artifact.

The canonical stack is useful because it gives each transformation a job that can be tested independently without forgetting the closed loop. A compact version is:

$$o_t \xrightarrow{\text{sense}} x_t \xrightarrow{\text{perceive}} y_t \xrightarrow{\text{estimate}} \hat{s}_t \xrightarrow{\text{predict}} \hat{s}_{t+1:t+H} \xrightarrow{\text{plan}} \tau_t \xrightarrow{\text{control}} a_t \xrightarrow{\text{act}} o_{t+1}.$$

Here $o_t$ is the raw observation, $x_t$ is calibrated sensor data, $y_t$ is a semantic or geometric percept, $\hat{s}_t$ is the agent's best state estimate, $\hat{s}_{t+1:t+H}$ is the predicted future over horizon $H$, $\tau_t$ is the chosen trajectory or skill, and $a_t$ is the executable command. The important assumption is that each arrow preserves enough information for the next stage while reducing ambiguity for the decision. The stack breaks down when one stage silently changes units, coordinate frames, latency, uncertainty, or success criteria.

Worked Example

The cleanest way to make the canonical stack concrete is to give every arrow its own function and run one observation through all seven. The toy world below is a 1-D reaching task: the body is at position $x$, a target sits at $x^\star$, and the only actuator is a bounded velocity command. Each stage does its single job and hands a typed value to the next.

import numpy as np

rng = np.random.default_rng(0)
TARGET = 1.00          # x* the agent must reach (meters)
STEP_MAX = 0.20        # actuator saturation (max move per step, meters)

def sense(true_x):                       # o_t: noisy raw reading
    return true_x + rng.normal(0, 0.02)
def perceive(o):                         # x_t: calibrated, de-biased
    return o - 0.01                      # known sensor bias
def estimate(x_meas, x_prev, alpha=0.7): # s_hat: low-pass state filter
    return alpha * x_meas + (1 - alpha) * x_prev
def predict(s_hat, a_prev, H=3):         # roll the model forward H steps
    return s_hat + H * a_prev
def plan(s_hat):                         # tau_t: desired displacement to goal
    return TARGET - s_hat
def control(tau):                        # a_t: saturate to actuator limit
    return float(np.clip(tau, -STEP_MAX, STEP_MAX))
def act(true_x, a):                      # world transition -> o_{t+1}
    return true_x + a

true_x, s_hat, a = 0.0, 0.0, 0.0
for t in range(12):
    o      = sense(true_x)
    x      = perceive(o)
    s_hat  = estimate(x, s_hat)
    s_pred = predict(s_hat, a)
    tau    = plan(s_hat)
    a      = control(tau)
    true_x = act(true_x, a)
    print(f"t={t:2d} o={o:+.3f} s_hat={s_hat:+.3f} "
          f"pred={s_pred:+.3f} a={a:+.3f} x={true_x:+.3f}")

print(f"final error = {TARGET - true_x:+.3f} m")

Expected output: the agent drives the error toward zero in under ten steps, with the command $a$ saturating at $\text{STEP\_MAX}=0.20$ on the first moves and then shrinking as $\hat{s}$ approaches the target. The value of the trace is that each column is one arrow in the equation above: if the robot misses, you can read off which stage first reported a wrong number. Try injecting a stale estimate (skip the estimate update for one step) and watch the error grow even though every other stage is correct.

Practical Recipe

1. Write the observation, action, and success metric before choosing a model.
2. Build a baseline that is simple enough to debug by inspection.
3. Add the library implementation only after the baseline behavior is understood.
4. Record failures as structured cases: perception error, state error, planning error, control error, or evaluation error.
5. Run at least one perturbation test before trusting the result.

The canonical stack: sense, perceive, estimate, predict, plan, control, act becomes useful when it is tied to a closed-loop contract for how perception, estimation, planning, learning, and control are arranged into a system. The contract names the observation stream, the action representation, the timing budget, the safety boundary, and the result artifact. That is the bridge between a readable concept and a system a skeptical builder can test.

For The canonical stack: sense, perceive, estimate, predict, plan, control, act, separate the conceptual claim, the systems claim, and the evidence claim. A good explanation, a clean API, and one successful rollout are different kinds of evidence, and the section should keep them distinct.

For The canonical stack: sense, perceive, estimate, predict, plan, control, act, a robust implementation starts with one inspectable baseline whose artifact records observations, actions, units, timestamps, seeds, termination reasons, and the perturbation applied. The maintained-tool version is useful only if it preserves that schema and lets the comparison remain construct-matched.

1. Write a one-paragraph task contract with observation, action, success, failure, and safety fields.
2. Start with the smallest simulator, dataset, or wrapper that exposes the task contract faithfully.
3. Run one deterministic smoke test and one perturbation test before scaling.
4. Save one artifact containing configuration, seed, metrics, traces, and failure labels.
5. Compare methods only when the same script evaluates the same panel, split, seed set, and metric.

When The canonical stack: sense, perceive, estimate, predict, plan, control, act fails, avoid labeling the whole method as weak. First assign the failure to perception, state estimation, planning, control, timing, data coverage, or evaluation. Then rerun one controlled perturbation that isolates the suspected cause. This pattern turns a disappointing rollout into a reusable diagnostic asset.

A practical diagnostic is to freeze the downstream stages and replay the upstream trace. If the controller succeeds when fed the logged plan, the control layer is probably not the first cause. If the planner succeeds when fed a corrected state estimate, the problem moves to perception or estimation. This replay habit turns the stack from a diagram into a fault isolation tool.