Agentic and self-improving sensing systems

"They gave me eyes, then a hand to move the eyes, then permission to decide where to look. The permission was the dangerous part."

A Newly Autonomous AI Agent

The agentic loop: perceive, decide, act, and measure again

A conventional perception model is a function \(f\colon x \mapsto \hat{y}\): a fixed sensor stream in, a label out. An agent replaces that with a loop over a policy \(\pi\) that, at each step, chooses an action from a menu that includes physical acts (aim the camera, sweep the radar, power up an idle microphone) and computational acts (call a foundation model, request a human label, retrain a head). What makes it agentic is that sensing is now a decision, not a given. The classic name for this is active perception: instead of passively receiving whatever the environment sends, the system picks the next observation to maximally reduce its own uncertainty about a task.

Why bother, when a fixed sensor suite is simpler? Because measurement is expensive and the informative measurement is rare. A drone inspecting a wind farm cannot image every blade from every angle on one battery charge; it must spend its limited flight budget on the views that resolve the most doubt. Formally, if the agent holds a belief \(p(s)\) over hidden state \(s\), the value of a candidate observation \(o\) is its expected reduction in entropy,

and the policy greedily (or with lookahead) selects the action expected to yield the largest information gain per unit cost. This is the same next-best-view logic that drives active SLAM, and it inherits its belief machinery from the Bayesian filters of Chapter 9 and the world models of Chapter 53, which supply the predictive \(p(o \mid s)\) the agent needs to imagine an observation before paying for it.

Self-improvement: the data flywheel and its labels

The second decision an agent internalizes is how to change its own weights. A self-improving sensing system generates fresh training signal from its own operation and folds it back in, ideally getting better every cycle without new human annotation. Three mechanisms supply the labels. First, self-labeling: a high-confidence prediction, or a slow high-quality model, teaches a fast cheap one (pseudo-labels and distillation). Second, physical consequence: the world eventually reveals the truth, so a predicted bearing failure is confirmed or refuted weeks later and that outcome becomes a label for free. Third, cross-modal agreement: when a confident modality vouches for an ambiguous one, as when lidar geometry labels a hesitant radar return, following the multimodal fusion of Chapter 50.

The reference point for this at the frontier is RoboCat (Bousmalis and colleagues, DeepMind, 2023), a self-improving manipulation agent that fine-tunes on a task from a handful of demonstrations, deploys the fine-tuned policy to generate its own new trajectories, and retrains on that self-collected data, lifting success rates without additional human teleoperation. The lesson generalizes cleanly to sensing: an agent that can act can manufacture its own training set. The hard part is never generating data; it is generating data that is both novel and correct.

LLM agents as sensing orchestrators

The active-perception policy above was numeric. A parallel and newer thread lets a language model be the policy: it reads sensor summaries, reasons in text, and calls sensing and analysis tools to gather more evidence before committing to an answer. The pattern is ReAct (Yao and colleagues, 2022), which interleaves reasoning traces with tool-calling actions, extended to sensing operations in Chapter 22. A monitoring agent facing an unexplained vibration spike can, in one loop, call a spectral-analysis tool, query the maintenance log, request a fresh high-rate capture from the edge node, and only then escalate to a human, having assembled a citable chain of evidence. Some agents also self-improve at the skill level rather than the weight level: the Voyager agent (Wang and colleagues, 2023) grows a reusable library of verified skills over time, a strategy that maps directly onto an operations agent accumulating validated diagnostic playbooks.

Feedback loops and how they rot

A self-improving loop is a control system, and control systems have unstable modes. The signature failure is the confidence trap: an agent self-labels only its confident predictions, so it trains exclusively on cases it already handles, its errors on the hard tail go unseen and uncorrected, and measured accuracy climbs while true accuracy on rare events quietly rots. A related pathology is distributional lock-in: an active-perception policy that only measures where it expects signal stops measuring the regions where the world is changing, and blinds itself to the very drift it exists to catch. Both are invisible to any evaluation run on the agent's own self-collected data, because that data is exactly what the bias has curated.

The defenses are structural, not clever. Reserve a fraction of the acquisition budget for forced exploration, measurements chosen at random or by pure uncertainty rather than by expected reward, so the tail keeps getting sampled. Gate every self-label through a calibrated uncertainty test (conformal prediction from Chapter 18 gives a distribution-free way to admit only labels the model is provably confident about, and to route the rest to a human). Hold out a small, frozen, human-curated benchmark that the agent can never train on, and watch for the gap between that benchmark and the agent's self-reported score widening: it is the earliest sign the flywheel is spinning off the truth. And treat any online adaptation as test-time adaptation under shift, with the safeguards of Chapter 66.

import numpy as np

rng = np.random.default_rng(0)
N_SENSORS = 8
# Each sensor's true reliability (unknown to the agent) and current belief variance.
true_noise = rng.uniform(0.1, 2.0, N_SENSORS)   # hidden state
belief_var = np.ones(N_SENSORS)                  # our uncertainty per sensor
BUDGET, EXPLORE = 60, 0.2                         # 20% forced exploration

def query(i):
    """Pay to measure sensor i; variance of its estimate shrinks like 1/n."""
    return true_noise[i] + rng.normal(0, true_noise[i])

counts = np.zeros(N_SENSORS)
for t in range(BUDGET):
    if rng.random() < EXPLORE:
        i = rng.integers(N_SENSORS)              # forced exploration: hit the tail
    else:
        i = int(np.argmax(belief_var))           # exploit: measure where we doubt most
    query(i)
    counts[i] += 1
    belief_var[i] = 1.0 / (counts[i] + 1.0)      # information gain updates the belief

print("queries per sensor:", counts.astype(int))
print("remaining uncertainty:", np.round(belief_var, 3))

What's Next

In Section 72.6, we step back from any single frontier technique and survey the open research problems and evaluation gaps that cut across all of them, including the entangled test distributions and stale-benchmark pathologies this section only gestured at, before the capstone asks you to build a full system of your own.