Section 33.7: Memory, state tracking, and hallucination in physical tasks

"The model did not lie about the object's location. It simply never noticed that the object had moved. Hallucination in the physical world is a synchronization failure, not a language failure."

Section 33.7

A robot arm confidently closes its gripper on a patch of empty counter, because the mug it "remembers" was carried away eleven seconds ago and no sensor ever told the planner. That single failure captures the whole problem: by the end of this section you will be able to audit what an embodied agent remembers, decide when each remembered fact should expire, and catch hallucinated or stale state before it drives a physical action. Figure 33.7A sets the scene: memory in physical tasks is a synchronization problem between what the model believes and what the sensors currently report. Read the figure as a memory-validity audit. A planner may remember prior observations, but physical tasks require timestamps, scope, invalidation rules, and a check that retrieved state still matches the current scene.

LLM memory must be paired with explicit state tracking so that past context helps planning without overriding new sensor evidence.

Once memory and state tracking are treated as one discipline, the design problem becomes a sorting problem.

The practical question is which memories should live as symbolic facts, which should live as scene state, and how hallucinated memories should be caught before action.

Theory

Let memory items be facts \(m_i = (f_i, c_i, t_i)\) with content, confidence, and timestamp. A planner should reason over a belief state $$b_t = p(s_t \mid o_{1:t}, a_{1:t-1}, m_{1:t}),$$ not over free-floating text summaries alone. New observations should update or erase memory items whose confidence is no longer justified.

Hallucination in embodied tasks often means one of three things: inventing an object or tool, asserting a stale state as current, or carrying a wrong relational fact across scene changes. The fix is rarely 'better prompting' alone. It is usually a better contract between memory, observation, and plan verification.

Before looking at where this goes wrong at scale, it helps to fix the vocabulary: a memory item's confidence is the planner's belief that a fact is still true, and its freshness is how recently that fact was confirmed by a sensor. The worked examples below use both terms, and each empirical result that follows is best read as a report of what happens when freshness is not checked before confidence is trusted.

Two empirical results demonstrate this distinction. The SayCan system (Ahn et al., 2022) grounded language plans in a value function over robot affordances, where the value function is a learned score that estimates how likely a candidate action is to succeed given the robot's current physical situation, which reduced infeasible action selection. Its remaining failure mode was often stale object state. The model would plan to pick up an item whose location had changed since the last observation. EmbodiedBench (Wang et al., 2025) confirms the pattern at scale. On tasks with hidden state changes between replanning steps, even frontier models drop success rates by 30 to 50 percentage points relative to static scenes. A model that solves 80 of 100 static-scene tasks solves only 30 to 56 of the equivalent dynamic-scene tasks, and the sole difference is that an object moved while the planner was not watching. Both results expose the same architectural gap: an LLM that rewrites its plan from scratch each step treats its context window as ground truth, not as a belief that needs freshness gating.

Worked Example

Code Fragment 1 stores two memories with different freshness and shows how the planner should gate them before use. The example demonstrates why timestamps belong in the memory schema.

# Reject stale world-state memory while keeping durable preference memory.
# Embodied memory should store freshness and source, not just text.
# This keeps old observations from masquerading as current state.
memory = [
    {"fact": "user_prefers_blue_mug", "age_s": 600, "durable": True},
    {"fact": "red_mug_is_on_counter", "age_s": 45, "durable": False},
]

usable = [m["fact"] for m in memory if m["durable"] or m["age_s"] < 10]
print(usable)

The expected output is a memory subset where durable user preferences survive but stale scene claims do not. The point is that embodied memory should grant planning authority only to facts whose lifespan matches the kind of fact they are, not to every retrieved sentence equally.

Practical Recipe

1. Store memory items with source, timestamp, confidence, and type.
2. Separate durable preferences from dynamic world-state facts.
3. Refresh or invalidate dynamic facts before high-consequence actions.
4. Never let retrieved text bypass a verifier when the action depends on current geometry.
5. Log contradictions between memory and observation as first-class events.

This links to classical filtering and simultaneous localization and mapping (SLAM): language memories and symbolic task facts must obey the same belief-management discipline as geometric state. Without it, the planner weights a ten-minute-old caption and a ten-millisecond-old sensor reading equally.

That is also why hallucination should be decomposed. A model may hallucinate semantically, but many embodied 'hallucinations' are actually stale-state propagation errors, not fabricated facts. Better memory schemas, not bigger models, are often the right fix.

Naming stale-state propagation as the real culprit matters because its consequences in the physical world are far harsher than in text. Why stale-state propagation matters physically: a software agent that acts on outdated information returns a wrong answer. A robot that acts on outdated information applies force to the wrong place. Grasping empty space strains the wrist joint; commanding a mobile base toward a now-occupied aisle causes a collision. The physical world does not tolerate the quiet retry that a language model can regenerate at no cost. Irreversible motion makes memory freshness a safety constraint, not merely an accuracy concern.

The mechanics of stale-state propagation

How propagation happens mechanically: the planner writes facts to the context window once per replanning cycle. Those facts persist verbatim until the next cycle. Any action the planner selects between cycles therefore treats those facts as current, even after the scene has changed. The attention mechanism carries no freshness signal, so a stale fact receives the same logit weight (the raw, pre-probability score the model assigns to a token or fact before ranking it against alternatives) as a fresh one. The propagation path follows four steps: the planner writes an observation to context at \(t_k\); the scene changes at \(t_k + \delta\); the planner reads that same context at \(t_{k+1}\) without detecting \(\delta\); and the action executes against the old state. A typical LLM replanning cycle runs at roughly 1 to 2 Hz, that is, a cycle length of about 500 to 1000 milliseconds, and in practice this varies with model size and hardware. A human co-worker can displace an object in under 300 milliseconds. One replanning gap is therefore typically one and a half to three times longer than the fastest physical change in the shared workspace, enough for the scene to change at least once before the planner looks again.

Code Fragment 2 stores a memory record with provenance and freshness. This is the minimum structure needed to talk coherently about embodied hallucination instead of merely complaining that the agent 'made something up.'

1. Tag each memory by type: preference, world state, task progress, or explanation.
2. Attach timestamps and evidence sources to every remembered fact.
3. Force memory retrieval to pass through a fact-validity gate before execution.
4. Record contradiction events when perception and memory disagree.
5. Evaluate memory systems on tasks with delayed execution and hidden state changes.

# Build one provenance-rich memory record and gate it before allowing a grasp.
# The record names its evidence source and age so a stale claim cannot pass silently.
from dataclasses import dataclass

@dataclass
class MemoryRecord:
    fact: str
    source: str      # e.g. the camera frame or sensor reading that produced this fact
    age_s: float      # seconds since the fact was observed
    fact_type: str    # "preference", "world_state", "task_progress", or "explanation"

def is_actionable(record: MemoryRecord, max_age_s: float) -> bool:
    if record.fact_type == "preference":
        return True  # durable facts do not expire
    return record.age_s <= max_age_s

record = MemoryRecord(
    fact="red_mug_at_counter_pos_3",
    source="camera_frame_104",
    age_s=52.0,
    fact_type="world_state",
)

print(is_actionable(record, max_age_s=5.0))

The expected output is a provenance-rich memory record that blocks direct action because the scene fact is too old. This is exactly the kind of trace you want before calling a behavior a hallucination, since the deeper mechanism is often stale world state rather than fabricated semantics.

When memory-rich agents fail, check whether the wrong fact was retrieved, whether the fact was stale, or whether the verifier failed to challenge it. Those paths lead to very different architectural fixes.