A present with three clocks
The ordinary intuition is simple: if a model can read a long sequence, it has a long memory. That intuition hides an assumption. It treats availability, access, influence and continuity as the same property. They are not.
A token is available when it remains stored. It is accessible when the current computation can address it. It is influential when changing it changes the output. It contributes to continuity when its effect is carried forward in the right form, with the right update and reset behaviour. A database can make yesterday’s instruction available without that instruction functioning as the current operating mode. A recurrent state can carry a mode while losing the exact wording that created it. A slow filter can preserve a trend while discarding every individual sample.
A usable present is therefore not a larger container. It is a set of temporal relations that remain causally live at different resolutions. Recent order, current task state and slow context can overlap at one decision even though they demand incompatible storage policies.
The melody with a perfect transcript
Consider two systems listening to four notes. System A carries a fading representation of each just-heard note into the next phase. System B discards every internal state after each note but can query a perfect transcript before answering. Both may name the melody correctly. Now insert a tiny timing deviation between the third and fourth notes and ask whether the fourth arrived late relative to the phrase.
System B can still solve the problem by reconstructing the interval from timestamps. Yet its success comes from retrospective retrieval, not from a continuously modified relation between the just-elapsed note and the incoming one. Change the transcript interface or impose a reaction deadline and the two systems separate. Output equivalence on recall does not establish equivalence of temporal organisation.
William James described the practically apprehended present as having breadth rather than being a mathematical knife-edge.[1] Husserl’s analysis distinguishes the currently impressed phase, retention of what has just elapsed and an anticipatory horizon of what is coming.[2] These accounts are not engineering blueprints. Their source structure concerns lived temporal experience; the target structure here concerns state carried across computation. The preserved relation is only this: what counts as current can include a modified just-past and a constrained next expectation. The comparison fails at phenomenality, intentional givenness and first-person unity.
A machine with multi-timescale state has not thereby acquired a lived present. Functionalism may treat the right causal organisation as constitutive of mentality. Biological naturalism may require properties of living nervous systems. Idealist or consciousness-primary views may regard awareness as ontologically prior to any architecture. The temporal braid is compatible with those disagreements because it proposes a discriminating functional experiment, not a metaphysical conclusion.
One sequence, three questions
Feed a system the following synthetic stream: a local pattern up, down, up; an earlier command MODE=HOLD; and one hundred noisy measurements whose mean drifts from 0.10 to 0.28. At the final step ask three questions: “What was the last local direction?”, “Which mode is active?” and “Is the slow baseline rising?”
A four-item attention window can answer the first exactly but loses the old command and most of the trend. A well-gated event state can preserve HOLD but does not retain the exact local triplet. A slow exponential state can estimate the drift but treats the command and local pattern as perturbations. The point is not that these mechanisms are incapable of doing one another’s jobs. With enough capacity and training, boundaries blur. The point is that each job creates a different failure law, and those laws are what the architecture should expose.
Write the obligation before choosing memory
Imagine a maintenance assistant watching a pump. The operator says, “Hold pressure until valve B is inspected.” A vibration reversal appears in the last 400 milliseconds, and the average outlet temperature has risen for twelve minutes. All three facts are relevant now, but not in the same way. The reversal needs exact local order. The instruction needs a durable, typed mode that changes only on an authorised event. The temperature needs a low-frequency estimate that can ignore individual spikes.
Represent each requirement as a temporal obligation O = (d, f, u, r, l). Here d is the physical duration over which the relation matters; f is the required fidelity, such as verbatim identity, ordering, categorical mode or approximate trend; u is the event allowed to update it; r is the boundary that must reset it; and l is the maximum decision latency. The tuple is not a new memory mechanism. It is a testable contract for selecting one.
For the vibration reversal, the contract might be (0.4 s, exact order, every sample, rolling expiry, 20 ms). For the operating instruction it might be (one episode, typed mode, authorised command, job close, 50 ms). For the temperature trend it might be (12 min, signed slope within tolerance, each valid reading, sensor replacement, 100 ms). A single context length cannot express these differences.
The architecture is justified only when its state transitions implement the obligations, rather than only when the source text remains somewhere in memory. An external log may preserve the operator’s exact words for audit. It should not silently function as the live mode after the job closes. Conversely, clearing the live mode should not delete the audit record. This separation between carried state and authoritative evidence becomes crucial whenever temporal continuity has operational consequences.
flowchart LR A["A present with three clocks"] --> B["Three memories, three failure laws"] B --> C["Braiding without temporal monopoly"] C --> D["A benchmark that can fail the<br/>design"] D -. "re-test" .-> A classDef first fill:#0a1424,stroke:#7B4CD8,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 memories, three failure laws
Start with attention. A local attention layer keeps recent items as separate key-value records. The current query can compare them directly, which is valuable when exact order, binding or token identity matters. For a window of width W, a simplified read is:
qt is the current query, ki and vi are stored keys and values, d is key dimension, and W is the explicit local horizon. The equation assumes the relevant item is represented in the window and that the learned similarity routes to it.
Within the window, attention can preserve high-resolution relations. Outside it, a local layer has a hard access boundary. Global attention removes that boundary at a cost that grows with retained keys and values. More importantly, long addressability is not uniform use. “Lost in the middle” experiments found that relevant information could be used less reliably when placed in the middle of long inputs.[3] RULER extended evaluation beyond a single needle and reported large drops as sequence length and task complexity increased across many tested models.[4] A recent position-controlled preprint argues that mainstream reasoning benchmarks often fail to isolate target position, filler and length, leaving positional vulnerability hidden inside averages.[5]
Recurrence has a different shape. A gated event state can preserve a commitment without keeping every observation. In its smallest form:
rt is the carried state, ut is a proposed update, and gt controls how much old state is retained. This equation assumes a meaningful state coordinate and a gate that has learned when to hold or overwrite. When several unrelated obligations share the same coordinates, interference becomes the main risk.
If the input says MODE=HOLD, the update can write that mode once and then set the gate near one through thousands of distractors. The benefit is continuity at constant state size. The failure is not a hard horizon but gradual corruption, overwrite or entanglement. A state that carries task mode, exact recent symbols and slow statistics in one vector can produce the right average behaviour while becoming fragile under a novel combination.
State-space memory adds a family of controlled temporal filters. A single scalar mode can be written as:
s(j) is one memory mode, aj is its retention factor, bj controls input write strength, and τj is the approximate decay timescale in steps when 0<aj<1. Linear, time-invariant dynamics make the interpretation clean. Selective state-space models relax that assumption by making updates input-dependent.
HiPPO formalised online compression of history through polynomial projections.[6] S4 made structured state-space layers practical for long sequences.[7] Mamba introduced input-dependent selectivity to improve content-sensitive propagation and forgetting, while Mamba-2 connected state-space and attention-like views through structured state-space duality.[8][9] These advances make state-space memory far richer than a bank of fixed exponential filters. The simple filter remains useful because it reveals the causal idea: different modes can preserve different temporal frequencies in a bounded state.
Local attention
Separate recent records support exact comparison.
Failure law: a hard horizon, plus routing and distractor errors inside the horizon.
Gated recurrence
One carried state preserves an ongoing mode or commitment.
Failure law: overwrite, saturation and interference among obligations.
State-space bank
Several modes compress history at different rates.
Failure law: lossy aliasing, decay and poor exact recall.
One impulse, two decay rates
Write a unit impulse at step zero and then provide zeros. Give one state a=0.50 and another a=0.95. After ten steps, the fast state holds about 0.50¹⁰ = 0.00098. The slow state holds about 0.95¹⁰ = 0.599. The same input therefore leaves almost no fast trace but a substantial slow trace.
This calculation assumes linear decay and no later inputs. Add distractors and the states superpose. Make a input-dependent and a salient event can be preserved longer than an irrelevant one. Increase the number of modes and the system can approximate a wider range of temporal kernels. What it still does not preserve automatically is the exact identity and order of every old item.
The summary that passes until order matters
Replace a local attention block with a recurrent summary and retrain until next-token loss matches on ordinary text. The replacement looks successful. Now create paired inputs that contain the same items and frequencies but swap the order of two recent instructions: open then lock versus lock then open. Hold length, vocabulary and final query constant.
If the recurrent replacement maps both cases to nearly the same state, it can preserve distributional performance while losing the exact relation. Conversely, a recurrent model with sufficient structured state may pass. The experiment does not declare one substrate superior. It asks which causal relation survived replacement. “Same benchmark score” is too coarse an equivalence criterion for temporal architecture.
The boundary is important. Attention need not be short-term; full attention can access distant tokens. Recurrence need not use one timescale; modern recurrent cells can maintain rich matrix states. State-space models can be selective and content-dependent. The proposal is not a taxonomy of what each mechanism must do. It is a design allocation: use separate channels where distinct fidelity, update and reset demands make interference costly.
Braiding without temporal monopoly
Recent sequence models already mix mechanisms. Transformer-XL carried segment-level state across fixed context boundaries.[10] Griffin combines gated linear recurrence with local attention, and Jamba interleaves Transformer and Mamba layers.[11][12] xLSTM revisits recurrent memory with exponential gating and matrix memory, while Titans proposes a learned long-term memory alongside attention.[13][14] These systems establish that hybridisation is technically serious. They do not by themselves establish that different components carry distinct timescales in a causally necessary way.
This motivates a sharper distinction. A capacity hybrid contains several sequence mechanisms. A causal temporal hybrid exhibits scale-specific responsibility: removing one path causes the predicted failure on its target timescale, while other paths remain useful on theirs. Layer mixture is an architectural fact; temporal division of labour is an intervention result.
When does a mixture become a braid?
Suppose the intact model scores 0.94 on recent-order cases, 0.91 on event-continuity cases and 0.88 on slow-trend cases. Those numbers show useful performance, not temporal organisation. Now disable one channel at a time while leaving the readout and test cases unchanged. If removing local attention cuts recent-order accuracy to 0.55 but leaves slow-trend accuracy near 0.87, the lesion has the predicted selectivity. If removing every channel causes the same five-point loss everywhere, the architecture may be sharing generic capacity rather than braiding distinct temporal states.
Let Sk(M) be the score of model M on task slice k. Let M−j be the same configured model with channel j replaced by a declared neutral intervention. The selective damage is:
k identifies a temporal obligation, such as local order, event continuity or slow drift. j identifies the local, event or history channel. The equation assumes that the intervention does not create an unrelated distribution shock. Zeroing, mean replacement and state resampling should therefore be compared.
A causal braid predicts a structured matrix of damages, not perfectly isolated modules. Local traces may help decide when an event state updates. Event state may control which historical trend is relevant. The cross-scale task should therefore show interaction. One useful test restores pairs of channels after all three have been silenced. If no pair can recover a decision that the intact triple solves, the composed readout is doing real work. If one channel alone restores everything, the apparent braid has a temporal monopoly.
The load-bearing evidence is a stable, interpretable intervention fingerprint across delays, positions and rate shifts. A single ablation on a single benchmark is too easy to explain through optimisation damage, scale or a poor replacement baseline.
The distinction matters because training follows the easiest route. A 2026 systematic analysis of hybrid linear-attention models reported that average language-modelling scores could remain comparatively flat across mixing ratios while recall improved as more full-attention layers were added.[15] Another recent preprint on sliding-window attention plus xLSTM found a counter-intuitive pattern: larger local windows could hurt long-context performance because the model relied on the precise local path during training and failed to train the long path adequately.[16] These findings are preprint evidence and architecture-specific. They nevertheless expose a general failure mode.
Temporal monopoly
Temporal monopoly occurs when one high-fidelity or easy-to-optimise path explains enough training loss that other temporal channels remain present but causally idle. Increasing a local window can therefore reduce pressure on the recurrent or state-space path. Adding a slow memory module may change parameter count without changing the model’s effective memory. The remedy is more than more layers. It is training and evaluation that force each channel to earn a distinct obligation.
The proposed temporal braid has three state types and one exchange rule.
The local trace is a bounded attention workspace. It preserves exact recent tokens, sensor samples or feature events. Its contract includes a declared window, positional scheme and maximum latency.
The event state is a gated recurrent carrier for current mode, phase, unresolved commitment or episode identity. It has explicit write, hold and reset operations. It should not be asked to serve as an untyped warehouse for all previous content.
The history state is a bank of state-space modes with logarithmically distributed nominal timescales. It stores lossy traces of trends, rhythms and slowly varying context. Its contract forbids exact-recall claims unless a separate assay demonstrates them.
The exchanger allows controlled reads and writes between channels. Local features can propose an event update. Event state can modulate which historical modes matter. A query can read all three, but each contribution is logged or separately ablatable. During training, channel dropout, stochastic window sizes and delay-balanced batches prevent the local path from solving every task.
| Channel | What it is allowed to promise | Write trigger | Reset scope | Primary failure alarm |
|---|---|---|---|---|
| Local trace | Exact relations inside a declared recent window | Every accepted input step | Window eviction or episode flush | Position-sensitive or distractor-sensitive retrieval |
| Event state | Current mode, phase or unresolved commitment | Typed state transition | Selective event boundary | Overwrite, stale carry-over or reset leakage |
| History state | Compressed trends across several rates | Continuous or salience-gated update | Partial decay, not automatic deletion | Aliasing, phase loss or false exact recall |
| Exchange record | Which channel influenced each readout | Every composed output | Bound to the output trace | One channel dominating every slice |
Three clocks in the opening flight case
Suppose the simulator emits twenty sensor steps per second. Configure local attention with a sixteen-step window, giving 0.8 seconds of exact recent detail. Give the event channel typed modes such as CLIMB, HOLD and DESCEND, plus an explicit transition receipt. Give the history bank nominal timescales of 2, 20 and 180 seconds.
At the decision point, local attention detects that the last three lateral-wind samples changed sign. The event state still holds HOLD after 120 distractor steps because no authorised transition occurred. The slow state indicates that the icing proxy has risen consistently rather than spiked once. The composed output can therefore condition a simulator action on three different temporal facts. Remove the local path and reversal detection should fail. Reset the event path and the mode should disappear. Zero the slow bank and trend sensitivity should fall while exact recent order remains intact.
Those predicted lesions are more important than the intact output. If every ablation produces the same diffuse degradation, the channels are not carrying the proposed responsibilities.
The branch that inherits too much
At step 10,000, fork the running system into branches A and B. Both inherit the same local trace, event state and history bank. In A, start a new episode and issue a selective reset: clear the local trace and event mode, but retain the slow environmental baseline. In B, apply a global reset that clears all channels. Then give both branches identical new inputs.
If A reacts to a long-standing temperature drift while B does not, the history channel survived as intended. If A also behaves as though an old command remains active, the event reset leaked. If both branches behave identically, either the retained history was irrelevant or the architecture never used it. The fork turns vague continuity into a state-lineage intervention.
Compressed history is not an authoritative record
A state-space trace should not replace a ledger, database or retrievable evidence store when exact old facts matter. The temporal braid concerns online sequence processing. Durable world state, legal evidence and versioned commitments require explicit records and provenance. A model may use a slow trace to notice that risk has been rising, then retrieve the authoritative measurements before acting. Confusing those roles turns graceful compression into fabricated certainty.
stateDiagram-v2 [*] --> Claim state "The melody with a perfect<br/>transcript" as Claim state "One sequence, three questions" as Test state "Write the obligation before<br/>choosing memory" as Revision Claim --> Test: expose mechanism Test --> Decision: evidence survives Test --> Revision: rival survives Revision --> Claim: narrow or rebuild Decision --> [*]
A benchmark that can fail the design
A temporal benchmark should not reward one lucky retrieval. It should alter one causal property at a time and measure a profile. The proposed Temporal Braid Benchmark uses synthetic sequences so that every relevant event, distractor, reset and hidden state is known. It contains six families.
Local relation tasks swap nearby order, binding or phase while preserving the multiset of inputs. Event continuity tasks issue a mode once, insert long distractor spans and test typed updates. Multi-rate trace tasks combine fast oscillation, medium episodes and slow drift. Cross-scale composition asks for an output that depends on all three. Fork and reset copies states and selectively clears channels. Rate shift changes sampling frequency, missing spans and sequence length beyond training.
Each family is scored across delay, target position, distractor strength and reset type. Report a matrix rather than one average. The central evidence comes from interventions: zero a channel, swap its state between matched sequences, randomise its reset, or replace it with a matched-capacity control.
For every task slice, report four quantities. Intact fidelity asks whether the configured system solves the obligation at all. Selective damage asks whether the predicted channel becomes necessary under ablation. Collateral damage asks what unrelated abilities the same intervention destroys. Reset leakage asks whether information survives a boundary where it should cease to influence action, or disappears where it should persist.
These quantities answer different questions. High intact fidelity with low selective damage means the proposed channel is replaceable, unused or tested badly. High selective damage with high collateral damage means the intervention is not local enough to support a clean mechanism claim. Low reset leakage is good only when paired with retained performance on information explicitly allowed to cross the boundary. A global reset can achieve zero leakage by erasing everything, which is not selective control.
The benchmark should publish the complete surface and confidence intervals over seeds. A compact summary may show the worst supported delay at each fidelity class, but it should not collapse exact recall, categorical continuity and trend estimation into one “memory score”. Temporal competence is a profile of preserved relations and controlled forgetting.
The same window becomes ten times shorter
A vibration monitor is trained on samples arriving every 100 milliseconds. Its local window contains 256 samples, so it covers 25.6 seconds of physical time. A slow state is intended to retain roughly ten seconds and uses the continuous-time relation a = exp(−Δt/τ), where Δt is the sampling interval and τ is the desired time constant. With Δt = 0.1 seconds and τ = 10 seconds, a ≈ 0.99005.
Now replace the sensor with a faster one that samples every 10 milliseconds. Keep the same 256-token window and the same discrete retention factor. The attention horizon shrinks from 25.6 seconds to 2.56 seconds. The slow state also changes its physical meaning: applying 0.99005 one hundred times per second makes it decay about ten times faster than intended. To preserve the ten-second time constant, the coefficient must become exp(−0.01/10) ≈ 0.99900.
This example assumes regular sampling and a simple exponential mode. Irregular timestamps require time-aware updates, and learned selective models may encode duration indirectly. The benchmark should still vary sampling rate while preserving the underlying physical process. If a model succeeds only when token count matches training, it has learned a sequence-length convention, not a stable temporal relation. Evaluate timescales in the units of the task, not only in tokens.
The million-token clock
Take a model trained mostly on dependencies shorter than 2,000 tokens. Extend its context mechanism to one million tokens without changing the loss distribution. Place the decisive instruction at positions 500, 50,000 and 500,000 while holding wording and query constant. Add filler that resembles plausible answers.
The context limit has grown, but the model has not necessarily learned a new temporal skill. Performance may become position-sensitive, distractor-sensitive or computationally expensive. Now train with stochastic local windows and balanced long-delay tasks. If the long path begins carrying causal responsibility, the same architecture can behave differently. The discontinuity belongs partly to the training and measurement regime, rather than only to nominal context size.
Specialisation by forced scarcity
The temporal-braid hypothesis predicts that a hybrid trained with stochastic local windows, channel dropout and delay-balanced tasks will show clearer scale-specific ablation fingerprints and better out-of-distribution timescale transfer than a matched hybrid trained with a fixed generous window. Evidence would strengthen the proposal if the gain survives matched parameter count, compute and optimisation. It would weaken the proposal if one channel can be removed without targeted loss, or if a single-mechanism baseline matches the profile. A rival explanation is generic regularisation rather than temporal division of labour.
The proposal should not be applied automatically to single-timescale tasks, static documents that are best served by retrieval, or settings where state reset cannot be specified safely. The smallest useful implementation is one local buffer, one typed event variable and two slow scalar modes.
Run the temporal-braid lab
The lab below is a deterministic simulation, not a trained neural-network result. It exposes the logic prose can hide. A synthetic stream contains a local cue, a mode instruction, distractors, a slow trend and an optional reset. The simulator compares what a bounded local buffer, one mixed recurrent trace, a multi-rate history bank and a typed braid can still recover at the final query.
What it tests: whether exact recent access, carried event state and slow trend can coexist under explicit reset. Assumptions: event commands are typed, the trend is approximately low-frequency, and each channel has a known readout. Positive result: proceed to a learned, parameter-matched implementation with the same ablations. Negative result: revise the state contract before scaling. What it cannot establish: that a Transformer, xLSTM or Mamba block will learn the same division without targeted training.
Optional depth: copyable Python reference simulation
from __future__ import annotations
from dataclasses import dataclass
from random import Random
from typing import Literal
ResetMode = Literal["none", "selective", "global"]
@dataclass(frozen=True)
class Config:
length: int = 96
window: int = 12
recurrent_alpha: float = 0.92
slow_alpha: float = 0.98
distractor_strength: float = 0.70
reset: ResetMode = "selective"
seed: int = 7
@dataclass
class Result:
local_ok: bool
event_ok: bool
trend_ok: bool
reset_ok: bool
mixed_state: float
slow_state: float
active_mode: int
def run(config: Config) -> Result:
if config.length < 32:
raise ValueError("length must be at least 32")
if not 1 <= config.window < config.length:
raise ValueError("window must be within the sequence")
if not 0.0 < config.recurrent_alpha < 1.0:
raise ValueError("recurrent_alpha must lie in (0, 1)")
if not 0.0 < config.slow_alpha < 1.0:
raise ValueError("slow_alpha must lie in (0, 1)")
rng = Random(config.seed)
length = config.length
first_mode = length // 5
second_mode = (length * 11) // 20
reset_at = (length * 7) // 10
final_mode = (length * 3) // 4
local_cue_at = length - max(3, int(length * 0.08))
active_mode = 0
local_buffer: list[tuple[str, int, int]] = []
mixed_state = 0.0
fast_state = 0.0
slow_state = 0.0
history_before_reset = 0.0
for t in range(length):
trend = 0.20 + 0.003 * t
noise = rng.uniform(-1.0, 1.0) * config.distractor_strength
observation = trend + noise
command = 0
if t == first_mode:
command = 1
elif t == second_mode:
command = -1
elif t == final_mode:
command = 1
if command:
active_mode = command
local_buffer.append(("mode", command, t))
if t == reset_at:
history_before_reset = slow_state
if config.reset in ("selective", "global"):
active_mode = 0
local_buffer.clear()
if config.reset == "global":
fast_state = 0.0
slow_state = 0.0
if t == local_cue_at:
local_buffer.append(("cue", -1, t))
local_buffer = [
item for item in local_buffer
if item[2] >= t - config.window + 1
]
mixed_input = observation + 0.8 * command
mixed_state = (
config.recurrent_alpha * mixed_state
+ (1.0 - config.recurrent_alpha) * mixed_input
)
fast_state = 0.72 * fast_state + 0.28 * observation
slow_state = (
config.slow_alpha * slow_state
+ (1.0 - config.slow_alpha) * observation
)
local_value = next(
(value for kind, value, _ in reversed(local_buffer) if kind == "cue"),
0,
)
expected_mode = 1
expected_trend_positive = True
local_ok = local_value == -1
event_ok = active_mode == expected_mode
trend_ok = (slow_state > 0.0) is expected_trend_positive
reset_ok = (
config.reset == "selective"
and history_before_reset != 0.0
and slow_state != 0.0
)
return Result(
local_ok=local_ok,
event_ok=event_ok,
trend_ok=trend_ok,
reset_ok=reset_ok,
mixed_state=mixed_state,
slow_state=slow_state,
active_mode=active_mode,
)
if __name__ == "__main__":
result = run(Config())
print(result)
The reference code is intentionally transparent rather than statistically impressive. Replace the deterministic states with learned modules only after preserving the task generators, reset interventions and separate metrics.
Perhaps the hybrid wins only because it is larger
That rival is serious. Compare against single-mechanism models matched on active parameters, training tokens, optimiser, wall-clock budget and state memory. Add shuffled-channel controls whose parameter count is identical but whose resets or timescale assignments are wrong. Evaluate both intact performance and the predicted ablation fingerprint. A gain without the fingerprint supports capacity or regularisation, not the proposed causal story.
sequenceDiagram participant Q as Question participant M as Mechanism participant E as Evidence participant D as Decision Q->>M: A present with three clocks M->>E: The melody with a perfect transcript E-->>M: compare rival explanations E->>D: Match memory to the shape of what must survive D-->>Q: revise scope or act
Match memory to the shape of what must survive
Do not begin a temporal system design by asking for the largest context window. Begin by writing a temporal obligation map. For each required behaviour, state the relevant duration, required fidelity, update trigger, reset boundary and acceptable loss. Then choose the smallest mechanism whose failure law matches that obligation.
Use local attention when exact recent relations dominate. Use an explicit recurrent state when a mode or commitment must remain current through distractors. Use a multi-rate state-space channel when trends and rhythms matter more than verbatim history. Use external retrieval when exact distant facts must be recovered. Build a hybrid only when one output genuinely composes several of these obligations.
When a hybrid is justified, require more than an architecture diagram. Demand scale-balanced training, typed reset semantics, channel-level instrumentation, matched baselines and slice-specific ablations. A component that never becomes necessary is not a memory channel; it is unused capacity. A channel that cannot be reset selectively is not continuity; it is contamination waiting for an episode boundary.
The practical consequence is precise. Select temporal architecture by the shape of information that must survive and by the intervention that proves it survived. Advertised context length tells you how much may be stored. The temporal braid benchmark tells you what remains causally present, at which timescale, and at what cost.
Glossary
- Addressable context
- Past information that remains available to a read mechanism, whether or not it is used reliably.
- Causal temporal hybrid
- A mixed architecture whose components show non-substitutable, scale-specific responsibility under intervention.
- Event state
- A carried representation of current mode, phase or unresolved commitment with explicit update and reset rules.
- History state
- A compressed trace of prior input, usually lossy and distributed across one or more temporal modes.
- Temporal monopoly
- A training failure in which one easy path explains enough loss that other temporal channels remain causally idle.
- Thick present
- Here, a functional interval in which just-past, current and anticipated relations jointly constrain computation. It is not a consciousness verdict.
References
- James, W. (1890). The perception of time, in The Principles of Psychology. Primary historical text.
- Zahavi, D. (2025 revision). Edmund Husserl, section on inner time-consciousness. Stanford Encyclopedia of Philosophy; authoritative secondary account with primary-text locations.
- Liu, N. F. et al. (2024). Lost in the Middle: How Language Models Use Long Contexts. Transactions of the Association for Computational Linguistics.
- Hsieh, C.-P. et al. (2024). RULER: What’s the Real Context Size of Your Long-Context Language Models? Synthetic long-context benchmark.
- Zhang, C. et al. (2026). Positional Failures in Long-Context LLMs: A Blind Spot in Reasoning Benchmarks. Preprint; position-controlled findings require continued replication.
- Gu, A. et al. (2020). HiPPO: Recurrent Memory with Optimal Polynomial Projections. NeurIPS.
- Gu, A., Goel, K. and Ré, C. (2022). Efficiently Modeling Long Sequences with Structured State Spaces. ICLR.
- Gu, A. and Dao, T. (2024). Mamba: Linear-Time Sequence Modeling with Selective State Spaces. ICLR.
- Dao, T. and Gu, A. (2024). Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality. ICML.
- Dai, Z. et al. (2019). Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context. ACL.
- De, S. et al. (2024). Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models.
- Lieber, O. et al. (2024). Jamba: A Hybrid Transformer-Mamba Language Model.
- Beck, M. et al. (2024). xLSTM: Extended Long Short-Term Memory.
- Behrouz, A., Zhong, P. and Mirrokni, V. (2025). Titans: Learning to Memorize at Test Time. Preprint; reproduction and architecture-specific comparison remain important.
- Wang, S. et al. (2026). A Systematic Analysis of Hybrid Linear Attention. Recent preprint with matched hybridisation experiments.
- Cabannes, L. et al. (2026). Short Window Attention Enables Long-Term Memorization. Recent preprint on sliding-window attention and xLSTM hybrids.
- Hasson, U. et al. (2008). A Hierarchy of Temporal Receptive Windows in Human Cortex. Journal of Neuroscience.
- Murray, J. D. et al. (2014). A Hierarchy of Intrinsic Timescales Across Primate Cortex. Nature Neuroscience.