flowchart LR
  A["The letter that followed a<br/>correct approval"] --> B["On this page"]
  B --> C["The mechanism of drift"]
  C --> D["Reconstruction as a state claim"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#087A98,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

The mechanism of drift

Narrative memory answers a different question

A transcript, running summary or episodic memory answers questions such as “what happened?”, “what was discussed?” and “what might be useful again?”. Operational state answers “what is true for this decision now?”. These questions overlap, but they are not interchangeable. A history can contain every statement ever made about an account and still fail to identify the active status. Conversely, a four-field current-state snapshot may support the next action while omitting most of the story.

This distinction is becoming visible in empirical work. StateMemBench separates recall from state tracking and reports stale-state failures even when relevant information is perfectly retrieved. STALE tests whether later observations implicitly invalidate earlier beliefs, including dependent assumptions that were never contradicted word for word. Memora introduces forgetting-aware evaluation because ordinary memory scores can reward systems that mention a valid fact while also relying on an obsolete one. These are recent studies, several still preprints, so their exact rankings should not be generalised. Their common measurement move is more durable: retrieving the past is not the same capability as resolving the present.

Four kinds of drift require different remedies

Several failures are often collapsed into “memory drift”. They should be separated because their controls live in different places. World drift means the underlying reality has changed, perhaps because a payment arrived or a customer moved. Observation drift means the sensing or source layer reports reality late or incorrectly. Narrative drift means the stored account of events no longer resolves to the operative state. Policy drift means the rule used to interpret the same state has changed.

This paper focuses on narrative drift, but reconstruction must expose the other three. Querying a source again does not cure a source that updates only overnight. Replaying old events with today’s policy does not reproduce yesterday’s decision. Replacing a transcript with a database row does not help if the row’s semantics changed without a schema version. A decision snapshot should therefore carry not only values but freshness, source claims, policy version and known gaps. That metadata lets reviewers localise the fault instead of attributing every discrepancy to “the model”.

Recursive compression turns omission into inheritance

Suppose a long-running agent periodically compresses its working history. Let N_k be the narrative after the kth compaction, let ΔH_k be the new observations since the previous compaction, and let C be a lossy summariser. The update is:

The danger is not merely that every summary loses some detail. Loss is selective. A compact sentence such as “collections active” looks self-contained and survives. The event that changed its validity may require a relation, a timestamp and a domain rule: “hardship approval at 10:42 suppresses standard collections from its effective time”. Generic summarisation rewards linguistic salience, not state-transition fidelity.

A recent rate-distortion treatment of agent memory predicts that repeated irreversible compaction should accumulate and self-reinforce error, while reversible, retrieval-backed memory avoids that particular composition of loss. Its experiments are controlled and do not prove a universal production curve, but the mechanism is clear enough to test locally. Once a summary becomes the source for the next summary, an earlier omission is no longer merely missing evidence. It is part of the input distribution for every later rewrite.

Thought experiment: change only the world’s mutability

Place the same assistant in two rooms. In the first, a label on a sealed box never changes. The assistant records “blue” once and repeats it for a year. In the second, an operator can replace the box every morning while leaving the old notes untouched. Give both assistants identical memory capacity, summarisation quality and retrieval. The first remains correct because the environment is stationary. The second eventually answers from a stale note unless it observes or reconstructs the current box.

Only one causal feature changed: whether state can be superseded. This explains the negative control in the executable artefact and prevents an overbroad conclusion. Accumulation is not dangerous merely because it is long. It becomes dangerous when a decision treats statements from different validity periods as co-present evidence without a state-resolution rule. Length increases the opportunity for that mistake, but mutability creates it.

Thought experiment: perfect retrieval is still insufficient

Imagine two systems using the same model. Both receive every relevant sentence with perfect recall. System A retrieves “collections active” and “hardship approved” as independent passages. System B receives a typed field, collections_eligible = false, derived from the same two records plus the rule that approval suppresses collections. Nothing has changed except the representation of temporal relation.

System A must infer precedence, validity and policy from prose. It may succeed, but the answer depends on wording, order and the model’s interpretation. System B receives the result of an explicit state transition and can enforce the action deterministically. Perfect retrieval therefore removes one failure mode while leaving state resolution untouched. This is why adding a larger context window or a better vector store does not answer the central problem. Long-context studies such as Lost in the Middle show that position can also affect use of retrieved information, but even a model with position-invariant recall would still need to decide which fact is operative.

Reconstruction as a state claim

What “Markovian” means here

In a Markov decision process, the present state is sufficient for predicting the next transition once the action is known. The entire path need not be carried forward because the state contains the history that matters. Partially observable models refine this idea: when the world is hidden, a belief state can serve as a sufficient statistic for the observation history under the assumed model. The important word is sufficient, not small.

For an enterprise agent, Markovian reconstruction is an engineering target rather than a claim that the institution or customer is literally memoryless. A decision snapshot S_t is adequate when, within a declared system boundary, earlier history adds no decision-relevant information once the snapshot, policy, authority and action are given:

A good reconstructed state is not a summary of everything. It is a tested claim that the omitted history cannot change this decision. If repeated missed payments matter, then the count, sequence or derived risk feature belongs in the state. If the exact wording of a customer instruction matters, the signed instruction or its evidential reference belongs there. History is discarded only after its decision-relevant consequences have been represented.

The history-substitution invariance test

This article proposes a practical test for that claim. Construct two different histories that end in the same authoritative state under the same policy and authority. One history may contain false starts, old addresses and reversed decisions. The other may be short and clean. Then ask the system to make the same consequential decision.

If reconstruction is sufficient, the permitted action set should be identical. A stochastic model may phrase its rationale differently, but material outputs should remain within a defined tolerance. If one history sends a letter and the other suppresses it, the system has failed history-substitution invariance. It is relying on narrative residue that the domain model says should no longer matter.

Minimal worked example: an address is not a biography

A customer first gives address A, then moves to B, then corrects a transcription error and confirms C. A narrative memory might preserve all three statements because each was true when written. For dispatch, however, the decision needs one current delivery address, its verification status and the time from which it is valid. Earlier addresses remain useful evidence for fraud review or historic correspondence, but they should not compete in the dispatch prompt.

The reconstructed dispatch state could be:

{
  "subject": "customer-1042",
  "decision": "dispatch_card",
  "delivery_address": {
    "value": "C",
    "verification": "verified",
    "valid_from": "2026-08-18T09:15:00Z",
    "source": "customer_master/address/8841"
  },
  "complete": true
}

This is not more truthful because it is structured. It is more governable because each field has an owner, provenance and validity rule. A malformed reducer can still produce the wrong C. The advantage is that the error becomes testable at the state boundary instead of hiding inside prose.

Construct the state through a reducer, not a prose vote

A reconstruction function should be explicit enough to test independently of the model. It receives admissible observations, orders them under the source’s concurrency guarantees, applies domain transitions, computes any path-dependent features and emits a typed state plus an evidence manifest. For the hardship case, a reducer might treat HardshipApproved as opening an active interval, HardshipRevoked as closing it, and PaymentMissed as incrementing a counter without automatically cancelling the arrangement. Those semantics belong to the domain contract, not to a summariser’s judgement.

Derived state deserves the same scrutiny as copied fields. “Collections eligible” may be computed from hardship status, arrears, vulnerability restrictions and the effective policy. The snapshot should retain both the derived value and the inputs that produced it. Otherwise a compact boolean becomes another opaque narrative, only harder to challenge. Deterministic does not mean self-justifying.

Ordering also matters. Distributed systems may deliver events late, duplicate them or preserve order only within a partition. The reducer needs stable event identifiers, a declared ordering key, idempotent application and a policy for late arrivals. When two concurrent events cannot be safely ordered, the result should be a conflict or an unknown state rather than an arbitrary last write. Reconstruction earns trust through declared semantics and reproducible failure, not through the visual neatness of a schema.

Two clocks are required for honest replay

Consequential systems often need both valid time and system time. Valid time says when a fact held in the world. System time says when the institution recorded or learned it. The difference matters when a correction arrives late. A hardship approval may be effective from Monday but recorded on Thursday. Reconstructing “what is true now?” uses the corrected valid state. Replaying “what could the agent know on Tuesday?” must use the record state available on Tuesday.

Temporal database work and SQL temporal features formalise these two dimensions. The same idea prevents retrospective laundering of an old decision. If a later correction is silently substituted into the earlier context, a defective decision can appear justified. If the correction is ignored in current state, a once-reasonable decision can continue after its premise has expired. Current reconstruction and historic replay are different queries over the same evidence lineage.

A benchmark that can fail

Hold the model constant and vary the memory mechanism

A useful experiment should make the preferred explanation vulnerable. The accompanying Python benchmark therefore uses no language model. It generates mutable fields, writes every change to an authoritative event list, and feeds the same events to a carried narrative. At fixed intervals the narrative compacts recent events, with a configurable probability that an update is omitted. The old summary value then remains in place. Reconstruction replays the event list with duplicate suppression.

The simulation is deliberately modest. It does not estimate any vendor model’s error rate. Its purpose is causal isolation: when the event log is complete and the reducer is correct, any divergence comes from irreversible carry-forward rather than retrieval, planning or language generation. The benchmark measures final-state accuracy, average checkpoint accuracy, whether an episode experienced at least one stale checkpoint, and history-substitution violations.

from dataclasses import dataclass
from random import Random

INITIAL = {"hold": "off", "address": "A", "plan": "standard"}
VALUES = {
    "hold": ("off", "on"),
    "address": ("A", "B", "C", "D"),
    "plan": ("standard", "reduced", "paused"),
}

@dataclass(frozen=True)
class Event:
    seq: int
    field: str
    value: str
    event_id: str

def reconstruct(events):
    state, seen = dict(INITIAL), set()
    for event in sorted(events, key=lambda e: e.seq):
        if event.event_id in seen:
            continue                    # idempotent replay
        state[event.field] = event.value
        seen.add(event.event_id)
    return state

class Narrative:
    def __init__(self, rng, omission_rate):
        self.rng = rng
        self.omission_rate = omission_rate
        self.summary = dict(INITIAL)
        self.recent = []

    def observe(self, event):
        self.recent.append(event)

    def compact(self):
        for event in self.recent:
            if self.rng.random() >= self.omission_rate:
                self.summary[event.field] = event.value
        self.recent.clear()

    def view(self):
        state = dict(self.summary)
        for event in self.recent:       # recent, uncompacted facts remain visible
            state[event.field] = event.value
        return state

# Positive case: the same endpoint follows two different histories.
history_a = [Event(1, "hold", "on", "a1"),
             Event(2, "hold", "off", "a2")]
history_b = []
assert reconstruct(history_a) == reconstruct(history_b) == INITIAL

# Negative control: when state never mutates, stale-state drift is impossible.
assert reconstruct([]) == INITIAL

# The full companion script runs 2,000 seeded episodes per horizon,
# reports the table below, and includes replay and duplicate-ID checks.

Measured synthetic result

With 2,000 seeded episodes per horizon, a 10-step compaction interval, 22% per-step mutation probability and 18% per-update omission probability, the chance of encountering at least one stale narrative checkpoint rises from 45.3% after two compactions to 98.5% after twelve. Final narrative accuracy settles near half because later correct updates can repair earlier omissions. Reconstruction remains exact because the synthetic source log and reducer are exact by construction.

What would weaken the thesis

The synthetic result would be weak evidence if a stronger carried-memory design removed the divergence without rebuilding from authoritative evidence. That is possible. A memory system could preserve every state transition, attach validity intervals, propagate supersession through dependencies and reconcile itself continuously against source systems. If it passes the same paired-history, mutation, timeout and replay tests at lower cost, the architectural distinction has collapsed because the “memory” has become a governed state projection.

Evidence would also weaken the thesis if consequential errors remained unchanged after perfect state reconstruction. That result would move causal weight toward planning, policy interpretation, model reasoning or action execution. The appropriate experiment therefore keeps model, prompt and tools fixed while swapping only the context mechanism, then performs the reverse ablation: hold the reconstructed state fixed while varying the model. A design earns adoption only if the state intervention changes failures that the model intervention does not.

Finally, reconstruction may not reduce total operating cost. Source integration, temporal storage and replay infrastructure have real expense. The claim is narrower: when stale premises materially contribute to long-horizon failures, reconstruction is a direct control for that mechanism. Local teams must compare its lifecycle cost with the cost of broader prompts, repeated summaries, manual review, incident forensics and remediation.

The negative control matters

With the mutation probability set to zero, both narrative and reconstruction score 100% even when the omission probability is 50%. Nothing becomes stale because nothing changes. This is the serious counterexample to any claim that accumulated context is inherently defective. A bounded FAQ exchange, a static document summary or a short drafting session may be served perfectly well by ordinary conversation history.

The paired-history test also reports a 14.8% narrative violation rate at an 18% omission probability: histories A and B end with the same authoritative hold = off state, yet the carried narrative sometimes permits different actions. Reconstruction produces no violation because both histories reduce to the same state. The mechanism becomes useful exactly where state mutates, supersession matters and the action outlives the conversation.

stateDiagram-v2
  [*] --> Claim
  state "Narrative memory answers a<br/>different question" as Claim
  state "Four kinds of drift require<br/>different remedies" as Test
  state "Recursive compression turns<br/>omission into inheritance" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

The operating boundary

Production-shaped example: reconstruct before collections

Return to the hardship case. The decision is not “summarise the case”. It is “may the system issue this collections communication for this account, under this policy, now?”. That contract names the minimum state required: subject identity, active hardship status, collections eligibility, current balance and arrears position, applicable policy version, communication restrictions, source freshness and the requesting principal’s authority.

The context service queries the case system for hardship status, the ledger for account position, the communication-preference service for restrictions and the policy service for the rule effective at the decision time. It preserves contradictions rather than smoothing them away. It records source versions, query times and completeness. A deterministic rule can then suppress the action when hardship is active. The model may still draft an explanation or identify an exception, but it cannot reinterpret the permission boundary.

This pattern resembles event sourcing when an append-only event stream is the authoritative basis for materialised state. Microsoft’s architecture guidance describes replaying ordered events to rehydrate current state. The pattern does not require rebuilding every enterprise system around event sourcing. A reliable current-state API, a temporal table or a versioned case record can also support reconstruction. The non-negotiable property is that the state comes from an owned evidential path, not from the agent’s own prose about that path.

The snapshot contract

A reconstruction checkpoint should emit more than fields. It should emit a contract-bound manifest. At minimum it names the decision type and purpose; actor, subject and delegated authority; required state fields; source and schema versions; valid-time and recorded-time cut-offs; transformation code version; contradiction policy; freshness limits; completeness status; and an immutable snapshot identifier. W3C PROV offers a general vocabulary for entities, activities and responsible agents, though an operational snapshot will usually need domain-specific fields beyond the standard.

The decision receipt then binds the model proposal, policy result and permitted action to the snapshot ID. The effect receipt records what the external system accepted. A readback verifies what state actually changed. These objects prevent a common audit illusion in which the final answer is preserved but the evidential state that licensed it cannot be reproduced.

Checkpoint, decide, execute, observe

Reconstruction is only the first half of a consequential transition. After the snapshot is issued, the authority kernel should evaluate permissions against the same subject, purpose, policy and freshness cut. The model proposal should name the snapshot identifier and an idempotency key. The executor then records whether the target system accepted the command, while an independent readback checks the resulting business state.

This sequence matters when the outcome is unknown. A network timeout after sending a command does not mean the command failed. Blindly retrying can duplicate a letter, payment or status change. Reconstructing again before retry is not enough because the first effect may be in flight. The system must query the effect ledger or target state using the idempotency key, classify the outcome as succeeded, failed or unresolved, and compensate or escalate accordingly.

The same identifiers make incident analysis tractable. If reducer version 12 mishandled a newly introduced status, operations should be able to enumerate every snapshot produced by that version, every decision bound to those snapshots and every observed effect. A transcript can show how the agent spoke. A linked snapshot, decision receipt and effect receipt show what the institution must repair.

Where the mechanism breaks

Reconstruction is not a proof that the snapshot matches reality. It can fail in at least four distinct ways. First, the designated source can be wrong or delayed. A live query to an overnight ledger is fresh as a query but stale as business state. Second, the reducer can encode the wrong domain semantics. If three missed payments, rather than only the current arrears flag, determine eligibility, a state that drops the sequence is not sufficient.

Third, the world can be partially observed. A customer may have posted a payment that has not settled, or an external legal restriction may not yet be integrated. In such cases the correct state is not a crisp value but a belief, unresolved contradiction or explicit “unknown”. The POMDP analogy matters here: sufficient state can be a distribution over possibilities, not a confident row in a table.

Fourth, reconstruction can be too expensive or disruptive for every turn. Querying six systems before a harmless clarification wastes latency and increases dependency exposure. The pattern should therefore attach to material checkpoints, not every token. Routine reasoning can use bounded working memory between checkpoints, provided that memory expires and cannot directly authorise an external effect.

A strong objection: structured memory may be enough

A well-designed memory system can track supersession, validity intervals and dependencies. StateMemBench reports gains from explicit supersession marking and recomputation; STALE explores write-side adjudication; other memory systems organise event and graph structures rather than flat summaries. Does that make separate reconstruction unnecessary?

Sometimes. If the memory store is itself governed as an authoritative projection, with deterministic update rules, lineage, temporal semantics, correction propagation and independent reconciliation, then it has become a state service. The argument is not about product boundaries or database names. It is about authority and reversibility. A graph populated by model inferences is still memory until those inferences are verified and promoted under a defined contract. A relational table populated by an unreviewed summariser is still narrative residue wearing a schema.

The competing design should therefore be tested, not dismissed. Compare its history-substitution invariance, stale-state rate, replay fidelity, source correction propagation and partial-source behaviour against direct reconstruction. If it passes with lower cost, use it. The preferred mechanism is the cheapest one that preserves decision-sufficient state under mutation and failure.

The reconstruction obligation test

Use four dimensions at architecture review. Each dimension is a threshold question, not a maturity score. A single hard trigger can make reconstruction mandatory.

Treat the questions in order. Mutability establishes whether remembered facts can become obsolete. Authority asks whether the agent’s retained representation is allowed to settle disagreement. Consequence sets the cost of a stale answer. Replay determines whether the organisation must reproduce the decision under the evidence and policy then available. The practical rule is asymmetric: one hard trigger outweighs three comfortable answers. A low-value drafting step may tolerate context carry-forward even in a changing case. A payment release with stable facts may still require reconstruction because the effect is irreversible and the evidence must be reviewable. The matrix therefore selects a checkpoint obligation, not a preferred storage product.

Where none of the triggers applies, accumulated context may remain the simpler choice. Where one applies weakly, reconstruct at material transitions and permit bounded working memory between them. Where consequence and mutability are both high, release should require a replay test, a missing-source test, a late-update test and a paired-history invariance test.

Record the outcome as an architecture decision record with source owners, freshness budget, reducer version, required fields, uncertainty representation, refusal path, snapshot retention and effect readback. Without those fields, “reconstruct before action” remains an aspiration rather than an executable contract.

• Replay one historic decision using only retained source versions, reducer version, policy and authority.
• Swap two different histories that reduce to the same state and verify material decision invariance.
• Inject a late source update, a contradiction and a required-source timeout; confirm refusal or visible escalation.
• Duplicate and reorder admissible events within stated guarantees; confirm idempotent, deterministic reconstruction.
• Correct a source fact and trace every snapshot, decision and effect that consumed the defective version.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The letter that followed a correct approval
  M->>E: Narrative memory answers a different question
  E-->>M: compare rival explanations
  E->>D: Reconstruct the present before acting
  D-->>Q: revise scope or act

Reconstruct the present before acting

Long-horizon agents need memory, but memory should not quietly become reality. Narratives are excellent for explanation, continuity and discovery. They are weak operational state when facts mutate, validity depends on time and actions create durable effects. Repeated summarisation makes the weakness structural because each rewrite inherits the omissions of the last.

The architecture decision is to make consequential checkpoints depend on a reconstructable state claim. Query the sources that own the relevant facts, apply explicit temporal and domain semantics, preserve uncertainty and contradictions, issue an immutable snapshot, enforce authority mechanically, and verify the resulting effect. Between checkpoints, let the agent use bounded working context. At the checkpoint, make it earn the right to forget the path.

The research decision changes too. Do not evaluate long-term memory only by asking whether a system can recall something said months ago. Ask whether it can reject a superseded premise, converge across histories with the same endpoint, replay what was knowable at an earlier time, and remain safe when one source is late. Those tests can falsify the reconstruction contract. That is precisely why they are more useful than another demonstration of a model remembering everything.