A time-delay reservoir is a cheap physical computer: one nonlinear device, such as a laser, a microring or a spiking neuron, sits inside a feedback loop. Slicing the loop's round-trip time into short intervals turns that one device into hundreds of "virtual" neurons, and only a linear output layer is trained. These systems run at a fixed cost per input. Each sample passes through the loop once and is read out. Language models have recently shown that letting a model spend more computation on hard inputs can matter as much as making it larger. The cleanest version reuses the same block of weights several times on a hidden state instead of writing out reasoning text. We ask whether the same trick works in a delay loop. The input is held in the loop for a variable number of extra round trips before readout. A cheap stopping rule decides per input how many trips to take, and only the readout is trained, one small linear map per round trip.
The opportunity is concrete. Two known weaknesses of delay reservoirs are that they work well only in a narrow, hand-tuned operating regime and that one reservoir rarely covers several forecasting horizons. Both look like symptoms of fixed depth. Recirculating a held input through the same physical node is weight-tied depth that costs no extra hardware, only time. A delay loop is also a natural place to study why recurrent "thinking" in software models saturates and sometimes gets worse with more steps. The proposal does not try to run language-model reasoning on photonic hardware. It brings the adaptive-depth idea into the regime where reservoirs are already competitive, and it confronts the one alternative that could make it pointless: simply making the reservoir wider for the same time budget.
Core Claim
Holding an input in a contractive delay loop for $k$ extra round trips produces a sequence of states that approach a fixed point determined by that input. Reading out at intermediate trips yields features that a single, wider pass cannot produce at the same time cost, because the nonlinearity is applied repeatedly rather than once. If the linearized loop contracts by a factor $\rho<1$ per round trip, the distance to the input's fixed point shrinks roughly as $\rho^k$. The number of informative round trips should therefore scale as about $1/(1-\rho)$, which follows from requiring $\rho^k$ to stay above a noise floor when $\rho$ is near 1.
This makes three claims, each testable. First, test-time depth helps most near the "edge of chaos," where $\rho$ approaches 1. Second, the gain saturates at a predictable trip count, giving a physical analogue of the saturation seen near 64 iterations in Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach. Third, an instance-adaptive stopping rule beats any fixed trip count at equal average time per sample, because input difficulty varies, as with locally unpredictable stretches of a chaotic signal or low-SNR radio frames.
Relation to Prior Work
Two software papers supply the method and the theory we test against. The recurrent-depth transformer of Scaling up Test-Time Compute with Latent Reasoning loops a trained core block up to 64 times and stops early when successive outputs stop changing. We borrow that stopping signal, but the loop body here is a fixed, untrained physical system. Stabilizing Recurrent Dynamics for Test-Time Scalable Latent Reasoning in Looped Language Models treats looped reasoning as convergence to a fixed point and enforces a Jacobian spectral radius below one. Without that constraint, Ouro-1.4B loses 20.47% on GSM8K when going from 4 to 8 loops. That paper motivates our design and also constrains it. In a reservoir the spectral radius is a physical knob, the feedback gain, so we can sweep it directly instead of regularizing toward it. We also test the tension the research file raises against Advances in Biologically Inspired Reservoir Computing: reservoirs are supposed to forget their inputs over time ("fading memory"), yet recirculation deliberately dwells on the current input. Each extra trip should erode memory of earlier inputs. We measure this trade-off rather than assume it away.
On the reservoir side, the closest work is the chained delay reservoir of Chain-structure time-delay reservoir computing for synchronizing chaotic signal. It cascades reservoir stages, time-multiplexed on an FPGA, and reports an order-of-magnitude lower synchronization error than a single stage. That is fixed-depth, stage-specific stacking with no per-input control. Our proposal is weight-tied and uses a variable number of trips per input. The chain is therefore the strongest structural competitor. Stochastic nonlinear time series forecasting using time-delay reservoir computers motivates the horizon question: a single reservoir needed 7 hyperparameter sets for 20 horizons, while a parallel array needed 2. We ask whether reading out after different numbers of trips can replace the array. The microring reservoir in Photonic time-delayed reservoir computing based on series coupled microring resonators and the FPGA spiking reservoir in Deep Spiking Delayed Feedback Reservoirs supply the node models, the benchmark numbers and the hardware target. Neither varies computation per input.
Research Program
We first build a simulated delay reservoir. The nonlinear node follows a Mackey-Glass-type delay equation, the standard model for these systems, with $N$ virtual nodes, a random input mask and an adjustable feedback gain. We extend it with a recirculation mode in which each input sample occupies $1+k$ round trips. We compare three variants for the extra trips. The input can be held constant, withdrawn so that only feedback drives the loop, or re-injected with a different mask on each trip. Mask rotation is the reservoir analogue of re-reading the problem, and it may counteract the collapse toward a fixed point.
For each trip $j$ we fit a separate ridge readout on that trip's state. We also fit a cumulative readout over trips $1..j$, kept separate because it inflates the feature count and must be compared fairly. Two stopping rules are tested. The first, borrowed from the recurrent-depth paper's early exit, stops when successive readouts agree within a tolerance. The second is a small linear regressor trained to predict the readout's error from the state. We also test a parallel version: several noise realizations of the same recirculation are aggregated by voting or median. This draws loosely on Provable Scaling Laws for Test-Time Self-Consistency, because physical noise in a real loop gives diverse samples for free.
The analysis has three parts. We estimate $\rho$ from the linearized loop at each feedback gain and test the predicted $1/(1-\rho)$ scaling of useful trips. We measure linear memory capacity as a function of $k$ to quantify how much memory of past inputs recirculation costs. We also check whether the hard inputs, those the stopping rule sends deeper, line up with independent measures of difficulty such as the local Lyapunov exponent on Lorenz data or SNR on radio frames.
The best configuration is then ported to an FPGA spiking implementation on a Zynq board following Deep Spiking Delayed Feedback Reservoirs, to report real energy per sample and throughput. A photonic implementation is out of scope. We will report how sensitive the method is to the parameter drift that the microring paper flags: about 1 nm in ring radius is enough to shift resonances.
Baselines
The naive reference is the standard single-pass delay reservoir with $k=0$, tuned by grid search over gain, input scaling and $N$. Every method gets the same grid budget, the same train/validation/test splits and the same ridge regularization search.
The strongest existing reference on the photonic benchmarks is the series-coupled microring reservoir. Photonic time-delayed reservoir computing based on series coupled microring resonators reports NMSE 0.154 on NARMA10, against 0.187 for a 20 cm waveguide, along with 0.0018 on Mackey-Glass and 0.017 on Santa Fe laser data. These numbers come from different node physics, so we treat them as external anchors. The fair comparison is against our own single-pass reservoir reproduced at those levels.
The baseline we consider most dangerous is the width-matched reservoir. It uses a single pass with $N(1+\bar k)$ virtual nodes, where $\bar k$ is the average extra trip count. It therefore takes exactly the same loop time per sample and offers a readout of matching dimension. Recirculation beats it only if it achieves lower test NMSE at equal time per sample and equal readout size, averaged over at least ten mask seeds with confidence intervals that do not overlap.
The second structural competitor is a fixed-depth chain in the style of Chain-structure time-delay reservoir computing. It uses $1+\bar k$ stages with untied parameters and the same total time. For chaotic synchronization the file reports an order-of-magnitude gain over a single stage and an error of $10^{-3.3}$ at SNR above 42 dB, but gives no number on our forecasting tasks. For multi-horizon forecasting we compare against the parallel reservoir array of Stochastic nonlinear time series forecasting. The file reports only parameter-set counts (2 vs 7 for 20 horizons), with no NMSE value, so we will reimplement the array.
Two ablations isolate the key ingredients. Fixed-$k$ recirculation at the same average $k$ tests whether adaptivity matters beyond depth. Held, withdrawn and rotated masks test what the extra trips must contain.
Why not just…?
Why not just make the reservoir wider for the same time? This is the real threat. Time multiplexing already turns time into width, so $k$ extra trips of $N$ nodes and one trip of $kN$ nodes cost the same loop time. The only principled reason recirculation could win is that it applies the nonlinearity repeatedly, which a wider single pass cannot. Adaptivity adds a second advantage, spending time where inputs are hard. The width-matched baseline settles this directly. If it ties fixed-$k$ recirculation and adaptive halting adds nothing, we will report that the idea fails for reservoirs. That would itself be informative for physical hardware design.
Why not just chain several reservoirs, as the chain-structure work does? Chaining gives depth with separate parameters at each stage. Unlike weight-tied recirculation on a single physical node, it cannot vary depth per input. If the chain matches adaptive recirculation at equal time, the remaining argument is hardware simplicity: one node and no per-stage tuning. We will state that plainly rather than claim an accuracy win.
Why not just use a nonlinear readout, like a small MLP? The spiking reservoir work already puts an MLP readout on a delay reservoir. That moves computation into digital electronics, which partly defeats the energy argument. We include an MLP-readout baseline with a parameter count matched to the sum of the per-trip ridge readouts, and we report both error and energy per sample on the FPGA.
Why not just apply this to language-model reasoning directly? A fixed random reservoir has nothing like the trained weights inside a looped transformer. Nothing in the file suggests it could replace a transformer core on GSM8K or MATH-500. We therefore restrict the claims to tasks where reservoirs are already competitive, and we use the language-model results only as the source of the mechanism and the stability theory.
Decisive Experiments
The benchmarks come directly from the reservoir literature in the file: NARMA10, Mackey-Glass and Santa Fe laser forecasting (all reported in NMSE), Lorenz and Rössler prediction under added noise, multi-horizon forecasting on synthetic VEC-GARCH data, and MIMO-OFDM subcarrier occupancy detection across SNR levels (reported as AUC; the spiking reservoir reports 0.99 at −20 dB).
The first decisive check is the plot of NMSE against average time per sample. On it, adaptive recirculation must sit below both the width-matched reservoir and the fixed-$k$ ablation on at least three of the forecasting tasks.
The second check tests the theory. The trip count at which gains saturate should follow $1/(1-\rho)$ across the feedback-gain sweep. Gains should vanish deep in the contractive regime, where states reach their fixed point within a trip or two.
The third check tests whether adaptivity tracks real difficulty. Trip counts chosen by the stopping rule should correlate with the local Lyapunov exponent on Lorenz data and with inverse SNR on the radio task. Without that correlation, adaptivity is just noise.
The fourth check is the memory cost. Memory capacity should fall as $k$ grows, and we want to know whether mask rotation recovers it. If rotation does not recover it, NARMA10, which depends on memory, should be the task where recirculation helps least.
Finally, the FPGA port must keep the energy per sample within a small factor of the 0.199 W, sub-millisecond-per-sample regime reported for the single-pass spiking reservoir. If extra trips erase that advantage, the case for physical test-time scaling does not hold.
References
- Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach
- Stabilizing Recurrent Dynamics for Test-Time Scalable Latent Reasoning in Looped Language Models
- Advances in Biologically Inspired Reservoir Computing
- Chain-structure time-delay reservoir computing for synchronizing chaotic signal and an application to secure communication
- Stochastic nonlinear time series forecasting using time-delay reservoir computers: Performance and universality
- Photonic time-delayed reservoir computing based on series-coupled microring resonators with high memory capacity
- Deep Spiking Delayed Feedback Reservoirs and Its Application in Spectrum Sensing of MIMO-OFDM Dynamic Spectrum Sharing
- Provable Scaling Laws for the Test-Time Compute of Large Language Models