Continuous-time neural models are now the standard tool for irregularly timed data such as intensive-care lab results, weather stations, and car sensors that each run on their own clock. The usual form is a neural ordinary differential equation (Neural ODE, a network that defines how a hidden state changes over time and is advanced by a numerical solver), with an extra step that nudges the state when an observation arrives. These models assume observations arrive in time order. Real streams break that assumption. A lab value drawn at 09:00 is entered at 11:00. A LiDAR packet is delayed on the vehicle bus behind camera frames. When a measurement stamped in the past shows up, today's models have three options: drop it, apply it as if it happened now, or rewind the hidden state and re-solve the ODE forward. Rewinding is exact but costly, and it stalls every downstream consumer that is waiting to query the state.
Databases solved the same problem decades ago. Writers do not rewrite shared state. They append small order-independent changes ("increment by 5"). Readers see a fixed committed snapshot plus whatever changes have landed. We propose a Neural ODE with the same split. A slow, exact, nonlinear trajectory is committed only up to a moving "watermark" time, behind which all data is assumed to have arrived. On top of it sits a fast overlay of additive corrections, one per late or recent observation. Each correction is computed by reading only the committed snapshot, never the other pending corrections, so the corrections commute. A late packet costs one small closed-form addition instead of a re-integration. Queries never wait. The prediction is identical whatever order packets arrive in.
Core Claim
The observation update in current continuous-time filters has a read-modify-write shape, in database terms. In Neural Jump ODEs (NJ-ODE), a jump network reads the pre-jump state $h(t_i^-)$ and writes $h(t_i^+) = h(t_i^-) + g_\psi(h(t_i^-), x_i)$. The gated updates in FusionMotion and StreamingFlow have the same shape. Because each update reads the result of the previous one, swapping two updates changes the answer. A late update also forces every later step to be recomputed.
BlockOptR supplies the fix we borrow. It removes blockchain write conflicts by turning read-modify-write into blind "delta writes." Multi-version snapshot transactions and RAMP transactions show that readers of an immutable version need never block or abort. Our claim is that the same conversion works for a latent ODE with bounded, measurable loss. The state readable at time $t$ is
$$\hat h(t) = \bar h_w(t) + \sum_{i \in P,\; t_i \le t} e^{A_\phi (t - t_i)}\, \delta_i, \qquad \delta_i = g_\psi\big(x_i,\, t_i,\, \bar h_w(t_i)\big).$$
The terms are defined as follows. $\bar h_w(t)$ is the committed trajectory: the nonlinear Neural ODE with ordinary NJ-ODE jumps, run on all observations stamped before the watermark $w$ and then extrapolated without further observations. $P$ is the set of pending observations stamped after $w$, in whatever order they arrived. $\delta_i$ is the correction for observation $x_i$ at timestamp $t_i$. It is computed from $x_i$ and the snapshot value $\bar h_w(t_i)$ only. $A_\phi$ is a learned diagonal matrix that sets how each correction decays or persists over time.
Each $\delta_i$ reads only the snapshot, and the corrections are summed. The overlay is therefore invariant to arrival order by construction. Adding a late packet costs one encoder call plus a closed-form exponential; no ODE solve is needed.
When the watermark advances from $w$ to $w'$, the pending observations in $[w, w')$ are folded into the committed trajectory by re-running the exact nonlinear jump model in timestamp order. This step is off the query path, like materialization and garbage collection in a delta log. The overlay is then cleared.
What would be new is the combination of three properties in a learned filter: an exact order-independence guarantee, non-blocking reads at arbitrary query times, and a controlled approximation to full re-integration. None of the continuous-time models in the file has any of the three.
Research Program
We build the model on the NJ-ODE code path, because its loss already penalizes both prediction error and jump size. We add a stream simulator that assigns each observation an arrival delay drawn from a chosen distribution: constant, heavy-tailed, or state-dependent.
Training samples arrival schedules and query times. The model is supervised in two ways. The NJ-ODE prediction loss is applied at the queries. A consistency term pulls the overlay read $\hat h(t)$ toward the state that exact in-order re-integration would produce at the same $t$. The re-integrated state is computed during training as a teacher. The overlay is thereby trained to be a cheap, first-order stand-in for re-solving the ODE, and $A_\phi$ learns how long a correction stays relevant.
The analysis side asks when the approximation holds. The overlay is exact when two conditions hold: the dynamics are affine in the state between $w$ and $t$, and corrections do not interact. It should degrade as pending corrections interact through the nonlinear flow. We therefore expect the gap to exact re-integration to grow with the watermark lag times a local nonlinearity measure of the learned vector field. This follows from a first-order Taylor expansion of the flow around the committed trajectory. We will test that prediction directly, and use it to pick the watermark adaptively.
A secondary theoretical question is whether NJ-ODE's convergence to the conditional expectation survives once some jumps are replaced by snapshot-read deltas. Our conjecture is that it survives in the limit of small watermark lag. We also note, as a constraint, that NJ-ODE's proof already assumes observation times independent of the state. Clinical lab ordering violates this, and so will some delay schedules. We report results under state-dependent delays separately rather than claiming guarantees there.
Baselines
The naive reference is the process-on-arrival model: plain NJ-ODE that applies each observation at its arrival time, or at its stamped time if that is still in the future, and silently absorbs disorder. This is effectively what the gated update in StreamingFlow does under jitter. A second naive point drops every packet stamped before the current state time.
The strongest competitor, and our accuracy ceiling, is exact rollback. It is NJ-ODE that rewinds to the stored checkpoint before $t_{past}$, inserts the observation, and re-solves forward. It uses the same trained vector field, the same solver tolerance, and a checkpoint cache of the same memory budget as our snapshot store. Its in-order accuracy is what the file reports for NJ-ODE: PhysioNet 2012 MSE 1.945 (versus 2.208–3.162 for Latent ODE), USHCN MSE 0.40 (versus 0.43 for GRU-ODE-Bayes), and a Heston evaluation metric of 1.33 (versus 4.24 for GRU-ODE-Bayes, which failed to converge), all from NJ-ODE. No reported result was found on Lacuna for any continuous-time model under delayed or out-of-order arrival.
The third baseline is a watermark buffer that waits until data up to $w$ has arrived before answering. It is exact but its answers are stale. We compare it at equal query latency rather than equal accuracy.
The key ablation gives $\delta_i$ read access to the running overlay state, so that corrections compose sequentially and stop commuting. This isolates whether the snapshot-read restriction costs accuracy. A second ablation replaces $e^{A_\phi \Delta t}$ with the identity, which holds the correction constant, to test whether learned propagation matters.
All models get the same data splits, encoder sizes within 10% in parameter count, and the same hyperparameter search budget.
Beating the baselines means two things. The first is matching exact rollback within a pre-registered margin: 2% relative MSE on PhysioNet and USHCN at median delay. The second is at least a fivefold reduction in function evaluations per late packet, while clearly beating process-on-arrival at every delay level.
Why not just…?
Why not just re-integrate from the past timestamp? This is the real threat. When delays are short and packets are rare, rollback may be cheap enough, and it is exact. We measure solver function evaluations and wall-clock time per late packet, along with query latency under concurrent reads, across delay distributions. If rollback costs are negligible on PhysioNet-scale data, we say so. The case for the overlay then rests on high-rate streams, where rollbacks cascade because each late packet invalidates work redone for the previous one.
Why not just buffer until the stream is complete? Buffering is exact but pays the "synchronization tax" that FusionMotion was designed to avoid. FusionMotion reports beating a synchronous BEVFusion-style fusion on Lyft L5 while reducing synchronization requirements, and running at about 0.19s per sample against about 0.64s for FIERY and StretchBEV. Our equal-latency comparison shows how much accuracy a buffer loses when forced to answer at the same moment the overlay does.
Why not just train an order-agnostic model, such as attention over the set of timestamped observations, or NJ-ODE trained with shuffled arrival orders? A set model is order-invariant, but it re-reads the whole history on every query. Shuffle augmentation makes the model robust to disorder without making it exact. We include both as baselines. We report the prediction spread across arrival permutations: the overlay's spread is zero by construction, while the shuffled model's spread is an empirical quantity. We also report per-query cost as history length grows.
Proposed Experiments
We start with the synthetic Ornstein-Uhlenbeck, Black-Scholes, and Heston processes from NJ-ODE. There the true conditional expectation is known, so the gap between overlay and rollback can be traced against delay length and against the process's nonlinearity. Heston, where GRU-ODE-Bayes already diverged, is the stress case.
We then move to PhysioNet 2012, where lab results reaching the record late is the realistic regime, and to USHCN, simulating the delays in both. We report MSE, function evaluations per packet, and permutation spread.
The stretch goal is nuScenes (nuScenes) occupancy forecasting built on the SpatialGRU-ODE of StreamingFlow, with LiDAR and camera packets jittered. The overlay then holds high-dimensional bird's-eye-view feature corrections, and the metrics are IoU and Video Panoptic Quality (VPQ). StreamingFlow's reported in-order margin of +2.4 IoU and +1.7 VPQ over FusionAD sets the scale of a degradation that would matter.
Three results decide the question. The first is whether the overlay stays within the pre-registered margin of rollback as the watermark lag grows. The second is whether the ablation in which corrections read each other buys any accuracy; if it does, commutativity has a real cost and we report its price. The third is whether the predicted scaling of the error with lag and local nonlinearity holds well enough to set the watermark automatically.
References
- Neural Jump Ordinary Differential Equations: Consistent Continuous-Time Prediction and Filtering
- FusionMotion: Multi-Sensor Asynchronous Fusion for Continuous Occupancy Prediction via Neural-ODE
- StreamingFlow: Streaming Occupancy Forecasting with Asynchronous Multi-modal Data Streams via Neural Ordinary Differential Equation
- How To Optimize My Blockchain? A Multi-Level Recommendation Approach
- Democratizing Transactional Programming
- Scalable Atomic Visibility with RAMP Transactions
- nuScenes: A multimodal dataset for autonomous driving