The present is not a point

A sequence becomes one event only when earlier phases continue to shape the current phase. Mere availability is too weak.

Hear three notes: C, E, G. At the instant G sounds, C is physically absent. Yet you do not normally hear G as an isolated frequency. You hear it as the completion of a rising figure. If the first two notes had been G, E, the same current C would belong to a falling figure. The acoustic input at the present instant underdetermines what the present event is.

Husserl’s early analysis names three aspects of this temporal structure. The current phase is accompanied by retention of what has just elapsed and protention of what is about to occur. Retention is not ordinary recollection. You do not stop the melody and deliberately retrieve the first note as a separate object. Its just-past character remains woven into hearing the current note. Protention need not be a confident forecast. It may be only a structured openness that makes one continuation fit and another surprise. This is a phenomenological description, not an engineering specification.^{1, 2}

Addressable history and operative history

The hidden assumption behind many long-context claims is that information available somewhere in the runtime is already part of the model’s present. It is not. A book on a shelf is available to a reader, but its contents do not shape the reader’s next action until some process retrieves and uses them. Likewise, a token in a cache may be perfectly preserved yet causally dormant for a particular computation.

This gives a useful new distinction. An addressable past consists of traces that a mechanism can select again. An operative past consists of changes already carried into the current processing condition. Attention excels at selective access to addressable traces. Recurrence excels at carrying an operative summary. State-space models offer an explicitly structured form of operative propagation. Real systems often need both.

The decisive test is therefore an intervention. Run the same current input twice. In one run preserve the state produced by history A. In the other substitute the state produced by history B. If the output changes in the predicted direction, history has a causal route into the present. A probe that merely decodes history from a hidden vector is weaker. Decodability shows that information is recoverable by the probe. It does not show that the original system uses that information.

flowchart TD
  A["The present is not a point"] --> B["Three machines, three kinds of<br/>past"]
  B --> C["Measure preservation, not<br/>window size"]
  C --> D["Where the analogy breaks"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#5B5CF6,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

Three machines, three kinds of past

A cache keeps traces apart, a recurrence blends them through repeated updates, and a state-space model controls the geometry of that blending.

The cache: the past as an addressable archive

In autoregressive transformer inference, earlier tokens contribute keys and values that can be reused when a new query arrives. The cache saves recomputation and lets the current token attend back to prior positions. Its central advantage is content-addressable access with positional detail. A model can, in principle, recover one earlier item without compressing every intervening item into a single fixed-width vector.

That advantage does not remove two limits. First, the trace must remain inside the retained window or an external memory system. Eviction creates a hard boundary. Second, availability does not guarantee use. Long-context models can perform differently when the same relevant evidence is moved from the beginning or end into the middle, and a nominal window can exceed the length at which multi-step tracing or aggregation remains reliable.^{12, 13} Transformer-XL added segment-level recurrence so that hidden states from previous segments could extend dependencies beyond a fixed segment and reduce context fragmentation.⁴ Yet those cached states still behave primarily as preserved material to be addressed by later attention.

The recurrence: the past as a rewritten condition

A recurrent network does not normally keep every earlier input as a separate object. It applies an update repeatedly. The new state is a transformation of the old state and the new input. This produces a direct causal chain across time. The price is compression. Many distinct histories can map to the same state, and later inputs can overwrite earlier information.

Gating mechanisms such as LSTM were introduced to improve learning across long lags by controlling what enters, remains in and leaves the carried state.⁵ Recurrent Memory Transformer makes the design more explicit: learned memory tokens pass information between segments while local attention processes each segment.⁸ The key engineering question is not whether recurrence “remembers”. It is which distinctions the update preserves and which it deliberately collapses.

The state-space model: the past as a controlled mixture

A linear state-space model writes the update as st+1 = Ast + Bxt and the readout as yt = Cst. Repeated substitution shows that an input from k steps ago contributes through AkB. The eigenvalues and geometry of A determine which modes decay quickly, which persist and which oscillate. Instead of one forgetting rate, the system can carry several timescales.

HiPPO reframed recurrent memory as online approximation: compress the history of a signal into coefficients of chosen basis functions under an explicit weighting of the past.⁶ S4 made structured state-space layers computationally practical for long sequences.⁷ Mamba made state propagation input-dependent, so the model could selectively pass or forget information rather than apply one time-invariant filter to every token.⁹ Mamba-2 then exposed a mathematical duality between structured state-space layers and classes of attention-like matrices.¹⁰ This kinship matters, but it does not erase the operational difference between preserving a set of individually addressable traces and carrying a bounded recurrent state.

A trace is a shape, not a yes-or-no property

Suppose a single pulse arrives at time zero and nothing relevant follows. A perfect cache with an eight-step window gives the pulse a rectangular influence profile: fully available for seven later steps, then absent at the eviction boundary. A leaky recurrence with retention factor 0.8 gives a geometric profile: after four steps the pulse contributes 0.84 = 0.4096; after ten it contributes about 0.107. A two-mode state with weights 0.4 and 0.6, and decay factors 0.5 and 0.95, gives a fast response plus a slow tail. After four steps its contribution is about 0.514; after ten it is about 0.360.

These numbers are illustrative, but the causal lesson is general. The cache has high fidelity followed by a cliff. The one-rate recurrence trades fidelity for smooth persistence. The two-rate state preserves a graded residue across more than one horizon. The relevant object is the impulse-response shape: how an event’s influence is distributed through later computation. A long tail is not automatically desirable. If an obsolete instruction or transient fault continues to influence action, persistence becomes contamination. The design target is a task-matched response, including an intentional route to forgetting.

Measure preservation, not window size

The right unit of comparison is a temporal preservation profile: which distinctions survive, for how long, through which boundary, and with what causal effect.

Needle retrieval is useful, but it asks one question: can the system recover an item placed far away? It does not reveal whether the item continuously shaped intermediate processing, whether order survived compression, whether later evidence revised the carried state, or whether the mechanism tolerated interruption. The RULER benchmark broadened long-context testing to include multi-hop tracing and aggregation, precisely because plain retrieval does not exhaust long-context use.¹³ Work on associative recall likewise finds meaningful architectural differences between attention and efficient recurrent alternatives.¹¹

The proposal here is a smaller, causal instrument. A temporal preservation profile reports five independent properties. It is not a single score and it is not a consciousness indicator.

Each dimension should be measured under matched resource and training conditions. State size, parameter count, compute, sequence distribution and readout capacity can otherwise masquerade as architectural effects. A positive result permits a narrow claim: this configured system preserves this causal distinction under these interventions. A negative result does not prove that the architecture can never preserve it. It may expose a training, optimisation or interface failure.

Revision is the neglected temporal test

Many benchmarks treat the past as fixed evidence waiting to be retrieved. Real temporal systems often need to reinterpret it. Imagine a vibration spike initially classified as a fault. Three steps later a calibration packet reports that the sensor was being tested. A good state should go beyond append “calibration” beside “fault”. It should change the present operational meaning of the earlier spike, suppress the alarm path and preserve a receipt explaining why.

A cache offers the raw ingredients for revision because both records remain separately addressable. Whether revision occurs depends on the query and reasoning path. A recurrent state may have already compressed the spike into an alarm variable. Revision then requires a learned inverse or an explicit compensating update. A state-space trace may decay the spike naturally, but decay is not correction. The system could forget the evidence without recording that its interpretation changed. This is why temporal state and evidence ledger must remain separate: one controls current processing, while the other supports reconstruction and audit.

The intervention is simple. Hold the current input fixed and compare three inherited states: one produced before calibration, one after correct revision, and one after merely appending the calibration event without changing the alarm state. A successful model should align its output with the revised state and expose a causal difference from the append-only rival. Revision tests whether the past is transformable under new evidence, rather than only persistent.

Executable lab: perturb the carried past

The lab below compares three deliberately simple mechanisms. The cache keeps a cue perfectly until a fixed window expires. The recurrence carries one exponentially decaying state. The state-space toy carries a fast and a slow mode. Synthetic distractors enter after the cue. An optional interruption either restores or clears runtime state.

Move the controls and watch the cue’s causal contribution at the final probe. The experiment exposes logic that prose hides. A cache has a cliff. A one-rate recurrence has a smooth but inflexible decay. A two-rate state can retain a longer tail while still responding quickly. None of these curves predicts the behaviour of a trained language model. They show what the update rules themselves permit.

function cueResponse({delay, cacheWindow, alpha, slowAlpha, interrupted, restored}) {
  const survivesBoundary = !interrupted || restored;
  const cache = survivesBoundary && delay < cacheWindow ? 1 : 0;
  const recurrent = survivesBoundary ? alpha ** delay : 0;

  const fastAlpha = 0.58;
  const fastWeight = 0.42;
  const slowWeight = 1 - fastWeight;
  const ssm = survivesBoundary
    ? fastWeight * fastAlpha ** delay + slowWeight * slowAlpha ** delay
    : 0;

  return {cache, recurrent, ssm};
}

Run the full causal protocol

The browser lab isolates one effect. A real evaluation should use a candidate family and matched rivals. Train or configure a cache-based model, a recurrent model, a state-space model and, when justified, a hybrid under matched budgets. Generate synthetic sequences where one causal property changes at a time. Then intervene on state directly.

1. Define the event relation that must survive, such as “pressure before vibration within five steps”.
2. Generate matched positive, reversed-order, delayed, interrupted and distractor-heavy sequences.
3. Record the exact runtime objects regarded as state: token cache, memory tokens, recurrent vector, SSM modes and external summaries.
4. Swap states between histories while holding the current input fixed. Zero or omit one component at a time.
5. Measure task accuracy and the intervention effect. A large state perturbation with no output change suggests dormant information or an irrelevant state component.
6. Repeat after serialization, migration and restoration. Treat a failed restart as a configured-system failure, rather than only a model error.

stateDiagram-v2
  [*] --> Claim
  state "Addressable history and<br/>operative history" as Claim
  state "The cache: the past as an<br/>addressable archive" as Test
  state "The recurrence: the past as a<br/>rewritten condition" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Where the analogy breaks

Temporal preservation is a functional property. The lived character of a just-past phase is a different claim with a different evidence burden.

The engineering comparison now has a precise preserved relation: an earlier phase can remain causally operative in the current phase, and its influence can be tested by intervention. The comparison fails at several points. Machine state is specified from an external, third-person description. Husserlian retention is described as a mode in which the just-past is given within experience. A vector’s decay coefficient does not establish an indexical “now”, prereflective self-manifestation, felt continuity or an experienced horizon.

No preservation profile, however strong, turns temporal organisation into evidence of phenomenal temporality by itself. A functionalist may regard the profile as one necessary part of a broader causal organisation. A biological naturalist may hold that the relevant organisation depends on living processes that the benchmark omits. Physicalist and emergentist accounts may seek additional neural or system-level mechanisms. Idealist, neutral-monist, panpsychist, dual-aspect and process views distribute the explanatory burden differently. The same behavioural and state-intervention results remain compatible with several of these positions. The experiment discriminates architectures, not metaphysics.

The strongest alternative explanation

A model may pass the proposed battery because training shaped a task-specific detector, not because it possesses a general temporal architecture. The pressure-before-vibration latch might be a narrow circuit that does not transfer to language, planning or other timescales. This is not a defect in the test. It is a limit on the conclusion. Generality requires a portfolio of tasks, unseen delays, changed event vocabularies and cross-domain transfer. Causal state use should survive those variations before the word “general” is earned.

Conversely, a model may fail because the readout or optimisation never learned to exploit an architecture’s capacity. Mamba’s selective state update was motivated partly by the difficulty of content-sensitive propagation in earlier state-space models.⁹ More recent work continues to target state tracking and the recall gap, including a current Mamba-3 preprint that reports architectural changes aimed at richer state updates.¹⁴ That result is preliminary. It supports the importance of state tracking as an engineering problem, not a final ranking of model families.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The present is not a point
  M->>E: Addressable history and operative history
  E-->>M: compare rival explanations
  E->>D: Write the temporal contract before choosing memory
  D-->>Q: revise scope or act

Write the temporal contract before choosing memory

Stop selecting temporal architectures by advertised context length. Specify the temporal contract first.

When a system must act across time, write down the exact relation the past must preserve. Must it quote an earlier record exactly? Track a slowly changing latent condition? Distinguish A-before-B from B-before-A? Revise an interpretation when new evidence arrives? Survive a pause, model swap or server migration? These are different obligations.

The contract should name six things: the candidate system boundary, the mutable state objects, the event distinctions that must survive, the maximum delay, the permitted compression loss and the interruption semantics. It should also state how stale state is cleared. Preserving everything is neither possible nor desirable. A trustworthy temporal system must forget on purpose as well as remember on demand.

A large context window can still be the right engineering choice. It is simply not the conclusion. The decision changes from “How much history can this model hold?” to “By what causal route must this history remain operative, and which intervention proves that it did?” Once phrased that way, architecture, testing and system boundaries become one design problem.