Dead time and transport delay: why continuous ingestion follows

The interval that tells you nothing, then everything

Every controlled process has a moment before which nothing changes and after which everything does. Push more fuel into a furnace and the temperature at the sensor does not creep upward from the instant of the push. It sits flat, then moves. That flat interval is dead time: the delay between a change at a system's input and the first observable movement at its output.

Dead time is not the same as slowness. A process can be sluggish and still be responsive — a heavy flywheel takes a while to speed up, but it starts speeding up the moment torque is applied, and a controller watching it gets continuous information to act on. Dead time is different in kind. It gives the controller nothing, then dumps the full effect of a past action on it all at once, unannounced. The distinction matters because the two faults are treated oppositely. Sluggishness is fixed by more aggressive control action. Dead time punishes aggressive action; push harder into a loop that is not yet reporting back, and by the time it does report, you have already pushed twice.

The classic source is transport. Something physical has to travel from the point of actuation to the point of measurement: reagent down a pipe, ore along a conveyor, a drug from the vein into the brain. The delay is the travel time, and it converts into something precise in the mathematics of feedback: phase lag proportional to frequency. A controller closed around a delayed process must throttle its own gain to avoid amplifying that lag into oscillation, and it pays for the caution in variance — the process wanders further from target than a delay-free loop ever would, because the controller cannot act on what it cannot yet see.

Where the idea comes from

The problem arrived with process plants, where material has to physically move before an instrument can measure it. Callender, Hartree and Porter gave the first serious mathematical treatment of delayed control loops in 1936, working through the thermal lags in temperature regulation. Ziegler and Nichols, in 1942, turned the analysis into something an operator could use on the plant floor: their tuning rules made the ratio of dead time to the process's own time constant the single number that determined how tightly a loop could be controlled without oscillating. A loop with a large ratio simply could not be tuned tight, no matter the skill of the engineer.

The decisive move came from Otto Smith in 1957. His predictor used a model of the process to estimate what the output would be right now, compensating for the delay rather than accepting it, and effectively removed dead time from the loop the controller experiences. It was not an academic exercise. Refineries running composition control on blending lines had analysers sitting sixty to a hundred and eighty seconds downstream of the mixing point; operators detuned their loops to survive that gap, and product drifted inside specification bands wider than the chemistry required. Moving the measurement upstream, or predicting around the delay, tightened those bands by tenths of a percent — worth millions a year on a large unit, purely from attacking the delay rather than improving the controller.

The turn

Read intake — how a system receives information about the world it is meant to act on — as the delay term in a feedback loop, and something in the lineage of large models resolves that looked arbitrary before.

A Large Language Model closes its loop around a corpus assembled once and then frozen. Whatever happens in the world after the collection cutoff does not exist for the model until a new one is trained, which is months away at best, often over a year. That gap is the model's dead time, and it is fixed at deployment, not at inference. No amount of additional parameters or better attention mechanisms shortens it, for the same reason no amount of clever control action shortens the time it takes fluid to move down a pipe: the delay is a property of the transport, not of the controller sitting at the end of it.

A Large World Model narrows the gap dramatically but only for a while. While a scene is present, the model closes its loop at something close to sensor latency: milliseconds, not months. But the loop is torn down the moment the scene ends. Nothing persists to be updated afterward. It is a genuinely fast loop, and a genuinely short-lived one — high bandwidth purchased at the cost of any duration.

A Large Universe Model is the arrangement in which every stream that was ever opened stays open, so the delay on any given belief is set by the slowest channel actually feeding it, not by a release schedule chosen in advance. This is why provenance belongs in the argument as a control mechanism rather than a housekeeping virtue: to shorten a loop you first have to know which measurement inside it is stale, and by how much. A belief with a timestamp and a decay curve is a controller's estimate of its own dead time. A belief without one is a controller flying blind about the one number that determines how hard it can safely act.

The claim, stated narrowly

The strong and defensible version of the thesis is this: the achievable bandwidth of any decision loop is bounded above by roughly the reciprocal of its largest dead time, and in a frozen-corpus system, that dead time is the training cutoff. Improving the model's quality does not relax the bound, because the bound is set by when information arrives, not by how well it is processed once it does. Continuous intake, carrying dated provenance on every stream, is the only move that attacks the dominant delay directly. And the position is terminal on this axis for a simple reason: the limit of shortening delay is zero delay on every stream, and there is no negative dead time to buy beyond that.

Three objections, taken seriously

A sufficiently good internal model should predict past its cutoff, the way a Smith predictor removes delay from a plant without touching the measurement rate at all.

This is the serious form of the frozen-corpus defence, and it is correct as far as it goes. Model-based prediction genuinely buys back bandwidth; that is the entire content of Smith's 1957 result. But it buys it back only in proportion to the model's fidelity and only for disturbances resembling the ones it was fitted on. Smith predictors are known to be brittle: a modest error in the assumed dead time can destabilise a loop that would have been merely sluggish under direct measurement. Prediction converts a measurement problem into a model-fidelity problem, and over a horizon of a year, in a world that does not hold still, fidelity decays. Continuous intake is what keeps the mismatch bounded.

Most decisions do not need low dead time. Contract law, structural engineering, most of a general education, change slowly enough that a corpus serves them fine; paying for continuous ingestion everywhere is bandwidth nobody uses.

This objection lands, and it defeats any version of the claim that asks for universal real-time refresh. The stationary majority of knowledge is well served by something close to a frozen corpus, and treating every fact as equally perishable is wasteful rather than rigorous. The narrow claim survives because value concentrates in the non-stationary tail — prices, outages, regulatory changes, other people's current beliefs — where the cost of delay is not linear but explosive: variance grows, then the loop oscillates outright. The right architecture stratifies by required dead time rather than refreshing everything uniformly, and that stratification is exactly what per-stream provenance is for.

Shortening the loop can make things worse. Faster sensing without matching filtration feeds raw noise straight into the actuator — this is how bullwhip effects and flash crashes happen, not despite fast information but because of it.

This is the strongest objection on the table, because it names a real and repeated failure rather than a hypothetical one. The 1987 crash and the 2010 flash crash are both cases where loops were made fast relative to their filtering, not slow. The honest reply narrows the claim rather than dismissing it: noise amplification is a gain-tuning problem, solvable inside a loop that has the measurement; dead time is a structural bound that no amount of tuning removes regardless of measurement quality. A fast noisy signal can always be low-pass filtered back down to a safe rate. A stale signal cannot be filtered up into freshness. Continuous intake with explicit staleness metadata gives a controller the option to slow itself down deliberately; a hard cutoff removes the option to speed up at all.

The misreading, disowned

The claim is often flattened into: models get out of date, so refresh them more often, like replacing an old almanac. That is not the mechanism. Delay does not simply make an answer wrong at the margin; it puts corrections out of phase with the disturbances they are meant to address, which is what turns a merely dated system into an unstable one under real feedback. Nor does the argument ask for constant reading of everything. It concerns the largest dead time in a given loop, not the average across all of them, and it concerns knowing which measurement is old, not maximising refresh rate for its own sake. A system that ingests everything, indiscriminately, without tracking which stream is stale, has not solved the control problem; it has just moved the same blindness to a different clock speed.

What this does and does not establish

This establishes that intake sets a hard upper bound on responsiveness, that the bound is structural rather than a matter of model quality, and that continuous ingestion with dated provenance is the only architecture that directly attacks it — which is why the third position on this axis has no successor to make room for. It does not establish that most reasoning needs that bandwidth, that fast ingestion is safe without filtering, or that a frozen corpus is inadequate for the stationary majority of what anyone asks. The bound is real. Most loops never come near it.