Paper deep dive
REACT: A Fully Spiking State-Space Model for Real-Time Event-Driven Temporal Perception
Geoffroy Keime, Nicolas Cuperlier, Benoit R. Cottereau
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 9/18/2026, 3:48:42 AM
Summary
The paper introduces REACT, a fully spiking state-space model designed for real-time, event-driven temporal perception. Unlike traditional methods that accumulate events into frames, REACT processes raw events sequentially using a complex-valued spiking neuron (C-SiLIF) driven by physical inter-event intervals. This approach eliminates integration delay, enabling low-latency inference (4.6 ms) and high energy efficiency (2.8 mJ per 32,768 events with INT8 quantization). The model is evaluated on gesture recognition (DVS128-Gesture) and time-to-collision (TTC) estimation (EvTTC), demonstrating competitive accuracy and superior performance in dynamic, reactive robotic scenarios.
Entities (8)
Relation Signals (6)
ReAct → achieveslatency → 4.6 ms
confidence 95% · REACT achieves a 9.59% relative TTC error with 4.6 ms end-to-end inference latency
ReAct → evaluatedon → EvTTC
confidence 95% · On EvTTC, REACT achieves a 9.59% relative TTC error
ReAct → evaluatedon → DVS128-Gesture
confidence 95% · We evaluate REACT on gesture recognition... on DVS128 Gesture
ReAct → uses → C-SiLIF
confidence 95% · REACT uses a complex-valued spiking neuron, C-SiLIF, whose continuous-time dynamics are driven by the physical inter-event interval
INT8 Quantization → appliedto → ReAct
confidence 90% · REACT further supports... INT8 quantization, reducing the estimated energy consumption from 18.5 to 2.8 mJ
ReAct → outperforms → Event-SSM
confidence 90% · REACT achieves a comparable accuracy of 97.6% while using 26% fewer parameters... Event-SSM [14]... achieve accuracies of 97.7%
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Robotic systems operating in dynamic environments require visual perception that evolves continuously with the incoming sensory stream. Event cameras provide microsecond temporal resolution and asynchronous sensing, but most learning-based methods accumulate events into frames or temporal bins, introducing an integration delay that can limit fast reaction. Here we propose REACT, a fully spiking state-space model for event-driven temporal perception that processes raw events one by one, without temporal accumulation. REACT uses a complex-valued spiking neuron, C-SiLIF, whose continuous-time dynamics are driven by the physical inter-event interval, allowing its internal state to evolve at the temporal resolution of individual events. We evaluate REACT on gesture recognition and time-to-collision (TTC) estimation from full-field event streams, without a target bounding box or localization input. On EvTTC, REACT achieves a 9.59% relative TTC error with 4.6 ms end-to-end inference latency, within 0.15 percentage points of the best learned method while requiring no target prior. At the dataset's mean approach speed, this latency corresponds to only 4 cm of vehicle motion, compared with 1 m for the fastest competing learned method. REACT further supports anytime TTC prediction, zero-shot transfer to a different driving sequence, and INT8 quantization, reducing the estimated energy consumption from 18.5 to 2.8 mJ per 32,768 events. These results show that event-driven spiking state-space dynamics can provide low-latency, continuously updated temporal perception for reactive robotic systems.
Tags
Links
- Source: https://arxiv.org/abs/2609.19204v1
- Canonical: https://arxiv.org/abs/2609.19204v1
Trouble viewing inline? Open PDF directly →
Full Text
48,948 characters extracted from source content.
Expand or collapse full text
REACT: A Fully Spiking State-Space Model for Real-Time Event-Driven Temporal PerceptionThanks: This work was supported by the French Defense Innovation Agency (AID) under grant number 2023 65 0082. Geoffroy Keime Affiliation: CerCo, CNRS UMR5549 Affiliation: Université de Toulouse Affiliation: Toulouse, France Affiliation: IPAL, CNRS IRL, Singapore Affiliation: geoffroy.keime@cnrs.fr Nicolas Cuperlier Affiliation: ETIS, CY Cergy Paris Université Affiliation: CNRS, ENSEA Affiliation: Cergy, France Affiliation: IPAL, CNRS IRL, Singapore Affiliation: nicolas.cuperlier@cyu.fr Benoit R. Cottereau Affiliation: CerCo, CNRS UMR5549 Affiliation: Université de Toulouse Affiliation: Toulouse, France Affiliation: IPAL, CNRS IRL, Singapore Affiliation: benoit.cottereau@cnrs.fr Abstract Robotic systems operating in dynamic environments require visual perception that evolves continuously with the incoming sensory stream. Event cameras provide microsecond temporal resolution and asynchronous sensing, but most learning-based methods accumulate events into frames or temporal bins, introducing an integration delay that can limit fast reaction. Here we propose REACT, a fully spiking state-space model for event-driven temporal perception that processes raw events one by one, without temporal accumulation. REACT uses a complex-valued spiking neuron, C-SiLIF, whose continuous-time dynamics are driven by the physical inter-event interval, allowing its internal state to evolve at the temporal resolution of individual events. We evaluate REACT on gesture recognition and time-to-collision (TTC) estimation from full-field event streams, without a target bounding box or localization input. On EvTTC, REACT achieves a 9.59% relative TTC error with 4.6 ms end-to-end inference latency, within 0.15 percentage points of the best learned method while requiring no target prior. At the dataset’s mean approach speed, this latency corresponds to only 4 cm of vehicle motion, compared with 1 m for the fastest competing learned method. REACT further supports anytime TTC prediction, zero-shot transfer to a different driving sequence, and INT8 quantization, reducing the estimated energy consumption from 18.5 to 2.8 mJ per 32,768 events. These results show that event-driven spiking state-space dynamics can provide low-latency, continuously updated temporal perception for reactive robotic systems. Index Terms: Event-based data, Spiking Neural Networks, State Space Models, Time-to-Contact, Real-time Processing I Introduction Robotic systems operating in dynamic environments require visual perception that evolves continuously with the incoming sensory stream [1]. Event cameras provide microsecond temporal resolution and asynchronous sensing, making them particularly attractive for low-latency, asynchronous event-driven robotic perception. However, most learned event-based methods accumulate events into frames or temporal bins before inference, introducing a temporal integration delay and an artificial discretization of the sensor stream [1, 2, 3]. Such aggregation prevents the model from updating its state at the native event timescale and can limit timely perception in fast-moving environments. Spiking neural networks (SNNs) naturally process event streams through sparse, asynchronous updates, while state-space models (SSMs) provide an efficient framework for modeling temporal dependencies through compact dynamical states. Recent works have combined these paradigms for event-based vision, including spiking formulations of SSMs and SSM-inspired spiking neurons, but they generally do not combine event-driven spiking computation with continuous-time state evolution directly at the irregular timestamps of incoming events. As a result, the temporal structure of the event stream remains partially constrained by discrete processing or temporal aggregation. We propose REACT (Real-time Event-driven Asynchronous Computation for Temporal perception), a fully spiking, asynchronous event-driven state-space model that processes raw events sequentially as they arrive. REACT uses the complex-valued spiking neuron C-SiLIF, whose continuous-time dynamics are driven by the measured inter-event interval. The internal state is therefore updated event by event, with the elapsed time between consecutive events explicitly incorporated into the dynamics, without requiring a fixed temporal window or event accumulation. This enables REACT to preserve fine-grained temporal information while retaining the efficient linear recurrence of an SSM. We evaluate REACT on two complementary temporal perception tasks: gesture recognition on DVS128 Gesture and time-to-collision (TTC) estimation on EvTTC. For TTC estimation, REACT processes the full field of view without a supplied target bounding box, requiring temporal collision-relevant information to emerge directly from the asynchronous event stream. This provides a direct test of asynchronous event-driven temporal perception in a dynamic driving scenario. We further investigate zero-shot transfer, anytime prediction, and INT8 quantization, assessing both the temporal flexibility and practical efficiency of the proposed approach. Fig. 1: Overview of REACT. (A) Vehicle motion generates an asynchronous stream of events. (B) Each event is embedded into a fixed-dimensional vector and processed sequentially by spiking state-space blocks, whose temporal dynamics are driven by the physical inter-event interval. (C) The C-SiLIF neurons emit binary spikes when their membrane potential crosses the threshold, without resetting the underlying state, thereby preserving continuous-time state dynamics. (D) Examples of event-based visual inputs at 4, 2, and 1.2 s before collision. Red and blue spikes correspond to On and Off events, respectively. The associated RGB frames are shown for illustration only and were not used by the model. The main contributions of this work are as follows: • We introduce REACT, a new fully spiking state-space architecture for raw event streams, combining asynchronous event-by-event processing with continuous-time state evolution driven by the physical inter-event interval. This eliminates temporal accumulation while preserving continuous-time temporal dynamics at the native timescale of the sensor. • We demonstrate target-free, anytime time-to-contact (TTC) estimation directly from full-field event streams, without temporal accumulation or a supplied target bounding box. REACT continuously updates its prediction as events arrive and achieves 4.6 ms end-to-end latency with a 9.59% relative TTC error on EvTTC. • We show that the learned temporal representation supports both anytime prediction and zero-shot transfer across datasets, demonstrating its ability to provide useful temporal estimates under varying observation horizons and sensing conditions. • We quantify the efficiency potential of the fully spiking formulation for neuromorphic deployment. REACT maintains competitive gesture-recognition accuracy with a substantially smaller state-space component, while INT8 quantization reduces the estimated TTC energy from 18.5 to 2.8 mJ per 32,768 events. Code will be made publicly available upon publication. I Related Works I-A State Space Models and Spiking Neural Networks Most current event-based vision models rely on an intermediate event representation, aggregating events into pseudo-frames through hand-designed or learned strategies. While effective, these representations discard part of the fine-grained timing provided by the sensor. Processing events directly preserves this temporal resolution, but requires architectures capable of efficiently modeling long asynchronous sequences. State space models (SSMs) have emerged as efficient sequence models, scaling linearly with sequence length while maintaining bounded computational and memory costs [4, 5, 6]. The linear ordinary differential equations underlying continuous-time SSMs are structurally analogous to the subthreshold dynamics of leaky integrate-and-fire (LIF) neurons. This correspondence has motivated both spiking formulations of SSMs [7, 8] and the derivation of neuron models from SSM parameterizations [9], including SSM-inspired adaptive LIF [10, 11] and resonate-and-fire neurons [12, 13]. SSMs have also been applied directly to raw event streams, avoiding frame-based representations [14, 15, 16]. These approaches efficiently extract spatio-temporal features from asynchronous data and offer pathways toward compute-in-memory implementations [16]. However, their computation remains fundamentally dense, requiring state updates across the model as events are processed. They therefore do not fully exploit the sparse event-driven activity that underpins the energy efficiency of neuromorphic computing. This limitation is particularly relevant for temporal prediction tasks in which low latency and fine-grained timing are critical, such as time-to-contact estimation. I-B Time-to-contact Estimation Time-to-contact (TTC) denotes the remaining time before an object reaches the observer under its current relative motion. Unlike metric depth, TTC does not require recovering absolute scale or metric scene structure, making it a compact cue for reactive behaviors such as braking, landing, and obstacle avoidance [17]. Because informative visual changes become increasingly concentrated near the collision endpoint, latency is critical for accurate real-time TTC prediction [18]. Event cameras are therefore particularly well suited to TTC estimation through their asynchronous response, high temporal resolution, and high dynamic range. Event-based TTC estimation has traditionally relied on model-based approaches that fit explicit geometric or kinematic models to event streams [17, 19, 20, 21, 22, 23]. These methods typically recover the focus of expansion, motion parameters, or scene depth before deriving TTC. A smaller body of work preserves sensor asynchrony by updating a filter event by event [24], but still relies on a hand-specified observation model. Their performance is consequently constrained by assumptions such as prescribed motion patterns or planar and rigid-translation models, as well as by iterative inference [25]. Learning-based TTC estimation remains comparatively underexplored, with only a few recent approaches [26, 25]. Garl-TTC [25] is currently the only dedicated object-level framework. To the best of our knowledge, the combination of fully spiking, event-by-event processing and explicit state-space temporal dynamics remains largely unexplored for TTC estimation. I Methods I-A Event stream and input encoding An event camera outputs an asynchronous stream of L tuples ℰ=(tk,xk,yk,pk)k=1LE=\(t_k,x_k,y_k,p_k)\_k=1^L, where tkt_k is the timestamp, (xk,yk)(x_k,y_k) the pixel coordinate on an H×WH× W sensor, and pk∈0,1p_k∈\0,1\ the polarity of the brightness change. Most learning-based pipelines first accumulate this stream into frames, voxel grids, or fixed time bins. REACT consumes it directly: no event representation is constructed at any stage, and the model state is updated once per event. Each event is reduced to a spatial channel index: jk=pk⋅HW+yk⋅W+xk∈0,…,2HW−1,j_k=p_k· HW+y_k· W+x_k\;∈\;\0,…,2HW-1\, (1) and a physical inter-event interval Δtk=tk−tk−1 t_k=t_k-t_k-1, with Δt1=0 t_1=0 by convention, intervals are expressed in milliseconds. The stream is thus a pair of aligned sequences (jk,Δtk)(j_k, t_k): jkj_k carries where the event occurred and Δtk t_k carries when, the latter entering the network as a continuous quantity rather than as a bin index. The channel index is mapped to a D-dimensional embedding k=Embed(jk)∈ℝDz_k=Embed(j_k) ^D followed by layer normalisation, through a learned lookup table ∈ℝ2HW×DE ^2HW× D that can be read as a per-pixel, per-polarity synaptic fan-in. Variable-length streams are right-padded and masked for batched training; padded positions contribute to neither the loss nor the reported firing rates. Fig. 1 summarises the resulting pipeline. I-B The C-SiLIF neuron The core computational unit of our SNN is the complex-valued C-SiLIF neuron introduced by [9], whose subthreshold dynamics form a diagonal linear time-invariant state-space model with one complex state per channel, a log-parameterized decay, a learnable timestep, and S4D-Lin initialization [27]. Fabre et al. evaluate it on fixed-bin audio streams. We retain their formulation and drive the discretisation with the physical inter-event interval Δtk t_k rather than a fixed step, which is what makes event-by-event operation possible. Each of the D channels carries one independent state u∈ℂu , evolving as: dudt=Λu+bx(t),Λ=−eλre+iλim,b=bre+ibim, dudt= u+b\,x(t), =-e _re+i\, _im, b=b_re+i\,b_im, (2) where λre _re is a log-parametrized decay rate, λim _im an angular frequency, and b a complex input gain, all learned per neuron. Discretisation rescales the measured inter-event interval by a per-neuron learnable factor eρe^ρ, giving an effective step δk=eρΔtk _k=e^ρ\, t_k, so each neuron measures time in units of its own, and event-driven update. αk _k =exp((−eλre+iλim)δk), = \! ((-e _re+i\, _im)\, _k ), (3) uk u_k =αkuk−1+bk, = _k\,u_k-1+b\,z_k, (4) sk s_k =Θ(2Re(uk)−ϑ), = (2\,Re(u_k)- ), (5) with Θ the Heaviside step function, ϑ a learnable firing threshold, and sk∈0,1s_k∈\0,1\ the emitted spike. Events enter as Dirac impulses at their timestamps, so the physical inter-event interval enters the recurrence only through the transition coefficient αk _k. The factor of two follows from the real-valued observation of the conjugate-symmetric state pair, since u+u¯=2Re(u)u+ u=2Re(u). Importantly, no reset is applied to uku_k after a spike. The state recurrence therefore remains linear, while the spiking nonlinearity acts only as a readout. Because the state transition coefficient αk _k depends on the physical inter-event interval, the temporal dynamics are driven directly by the timing of incoming events. The dynamics are also stable by construction: eλre>0e _re>0 implies |αk|<1| _k|<1 for any positive interval. Equivalently, each neuron acts as a damped harmonic resonator with impulse response |b|e−eλretcos(λimt+φ)|b|\,e^-e _ret ( _imt+ ). The phase φ therefore controls the temporal phase of the neuron’s oscillatory impulse response, enabling different neurons to preferentially respond to different temporal patterns without introducing an explicit delay parameter. Gradients are propagated through (5) with an arctangent surrogate of width 22. Following the S4D-Lin initialisation adopted for C-SiLIF in [9], we set eλre=0.5e _re=0.5 and λim=π/s _im=π/s as shared initial values, sample eρe^ρ log-uniformly over 10−310^-3–10−110^-1, and initialise the input gain as bre∼(0,1)b_re (0,1) and bim=0b_im=0. The parameters λre _re and λim _im define the initial pole location, while the heterogeneous timestep ρ provides each neuron with a distinct temporal scale, and therefore a distinct effective decay and oscillation frequency. This diversity avoids starting all neurons from a homogeneous temporal configuration and provides a broad set of initial temporal responses for optimisation. I-C Sequential inference, parallel training Equation (4) is a first-order linear recurrence uk=αkuk−1+bku_k= _ku_k-1+b_k whose transitions compose associatively, (Aj,Bj)∘(Ai,Bi)=(AjAi,AjBi+Bj),(A_j,B_j) (A_i,B_i)=(A_jA_i,\;A_jB_i+B_j), (6) so the state sequence ukk=1L\u_k\_k=1^L can be obtained by an inclusive Hillis–Steele prefix scan in O(logL)O( L) sequential depth and O(L)O(L) total work, parallelised across batch elements and channels. We use this scan during training and batched offline evaluation only. At deployment the model runs strictly sequentially, one state update per incoming event, which is the regime assumed by the latency and energy figures of Secs. IV-B and IV-F. I-D Network architecture The network body is a stack of N=2N=2 residual blocks with D=128D=128 channels, operating on the token sequence produced by the embedding. Each block applies C-SiLIF independently along the temporal dimension of every channel, updating its state according to the inter-event intervals and emitting a binary spike train, and a channel-mixing linear stage then integrates information across features. The block output is combined with its input through a residual connection, which keeps optimisation stable as blocks are stacked. Every signal crossing a block boundary is therefore a spike train, and each C-SiLIF layer is driven by spikes throughout the network, so all synaptic operations reduce to accumulations. Because sequence length grows with the number of incoming events, consecutive tokens are merged between blocks by masked-mean pooling, with their inter-event intervals summed so that the compressed sequence still represents the correct elapsed physical time. We pool by a factor of 3232 on DVS128-Gesture and apply no pooling on EvTTC, which is the source of the higher per-event energy reported in Sec. IV-F. After the last block, tokens are masked-mean-pooled over valid positions and mapped by a single linear layer to the task output. On neuromorphic substrates this readout corresponds to a non-firing integrator, whose membrane potential is read out directly. I-E Task formulation and metrics For gesture recognition the readout produces a distribution over the 1111 classes, trained with cross-entropy and label smoothing. For time-to-contact we regress the inverse contact time η=1/TTCη=1/TTC rather than the time itself, since TTCTTC diverges under slow approach while η remains bounded. The readout emits a mean μi _i and a log-variance sis_i in logη η space, trained with a Gaussian negative log-likelihood, ℒNLL=1N∑i=1N[12e−si(μi−logηi)2+12si],L_NLL= 1N _i=1^N [ 12e^-s_i ( _i- _i )^2+ 12s_i ], (7) so that η^=eμ η=e^μ and TTC^=e−μ TTC=e^-μ, with sis_i providing a per-estimate uncertainty alongside the prediction. We report the EvTTC benchmark metric [28], eTTC=|TTC^−TTC|TTC×100%,e_TTC= | TTC-TTC|TTC× 100\%, (8) averaged per sequence over its full range, so that every row of Table I is scored identically. Because (8) normalises by ground-truth time, a fixed absolute error counts for little when the target is far and heavily when it is close, and a sequence average is dominated by its far portion. We therefore also report a criticality-weighted log-ratio error, MiDwMiD_w, which averages |logη^−logη|| η- η| within ground-truth TTC bands and reweights them towards imminent contact, with weights 0.50.5, 0.30.3 and 0.10.1 on [0,3)[0,3), [3,6)[3,6) and [6,10)[6,10) s following [25]. We exclude their negative-scenario term, since the sequences evaluated here contain no non-collision cases. This is the quantity on which models are selected, and it scores the part of the sequence that matters for collision avoidance rather than the part that dominates (8). I-F Datasets and training DVS128-Gesture [29] contains 1111 hand and arm gestures from 2929 subjects under three lighting conditions, recorded at 128×128128× 128, giving an embedding table of 2×128×1282× 128× 128 rows. We use the official split. Training windows are contiguous slices of 131,072131,072 events. Augmentation follows the set used by [14]: time skew, per-event temporal and spatial jitter, and random event dropping, together with the geometric augmentations of [30] (roll, rotation, scaling) and event CutMix [31]. Horizontal flipping is excluded, since mirroring exchanges gesture classes. EvTTC [28] contains collision scenarios with cars and pedestrian dummies recorded with Prophesee cameras at 1280×7201280× 720, with ground-truth TTC derived from synchronised GNSS and LiDAR. Unlike prior work on this benchmark, we supply no target bounding box: REACT predicts from the full field of view. Event coordinates are downsampled by a factor of 88 onto a 160×90160× 90 grid, with a 1010 ms refractory period per coarse pixel and polarity to suppress duplicates; the embedding table therefore contains 2×90×1602× 90× 160 rows, giving 3.73.7 M parameters in total. Training windows contain 32,76832,768 tokens, obtained by decimating a contiguous span by a factor of 1616, roughly 0.80.8 s of stream. Augmentation comprises horizontal flipping, per-event spatial jitter, random event dropping, injected clutter events, and a time skew that rescales the stream, which simulates a different approach speed. We additionally evaluate zero-shot transfer on FCWD [20] without fine-tuning. Models are implemented in SpikingJelly [32] and trained with AdamW, with weight decay disabled on the state-space parameters. We report three seeds on DVS128-Gesture and five on EvTTC. IV Experiments IV-A Gesture recognition We first evaluate the architecture on a standard neuromorphic classification benchmark, before turning to the continuous temporal prediction task of Sec. IV-B. DVS128-Gesture is the benchmark on which Event-SSM and its compute-in-memory counterpart both report results, so it measures whether a fully spiking SSM reaches the accuracy of comparable event-by-event models at a much smaller cost. Table I compares the three. Event-SSM [14] and the compute-in-memory implementation [16] achieve accuracies of 97.7%97.7\% and 97.3%97.3\%, respectively, but propagate real-valued activations between layers, requiring non-spiking computation and therefore limiting their direct deployment on spike-based neuromorphic hardware. REACT achieves a comparable accuracy of 97.6%97.6\% while using 26%26\% fewer parameters for the SSM blocks and maintaining fully spiking computation throughout the network. TABLE I: DVS128-Gesture. Parameter counts are reported as embedding ++ state-space, following [14]; the embedding is fixed by the sensor and identical across all three models. Activity denotes the fraction of units active per update. ∗Energy is estimated using the proxy described in Sec. IV-F, applied to six dense real-valued SSM layers. Best results are in bold; second-best results are underlined. Method Spiking Params (M) Prec. Memory (MB) Energy (mJ) Activity (%) Acc. (%) Event-SSM [14] ✗ 4.19+0.804.19+0.80 FP32 20.00 158.8∗158.8 100 97.7 CIM-SSM [16] ✗ 4.19+0.814.19+0.81 INT8 5.00 23.7¯∗ 23.7 100 97.3 REACT (ours) ✓ 4.19+0.044.19+0.04 FP32 16.14 50.650.6 31.1 97.6 REACT (ours) ✓ 4.19+0.044.19+0.04 INT8 4.04 7.77.7 31.1 97.2 Energy is calculated from 131,072131,072 events for REACT IV-B Time-to-contact The asynchronous nature of REACT is particularly relevant for tasks that require continuous feedback from a rapidly evolving sensory stream. We therefore apply the model to event-based time-to-contact (TTC) estimation, which provides a direct test of its ability to continuously update a temporal prediction from incoming events. Most existing approaches to event-based TTC estimation first aggregate events into pseudo-frames or voxel grids before performing the prediction. While these representations can achieve good estimation accuracy, they introduce an additional temporal latency: events must first be accumulated over a predefined temporal interval before the network can process them. Table I compares REACT with published results on EvTTC. Every prior entry receives the target as a tracked or ground-truth bounding box, and Garl-TTC [25] additionally uses frames alongside events; REACT predicts from the raw stream over the full field of view. Under that handicap it reaches 9.59±0.74%9.59± 0.74\%, within 0.150.15 percentage points of the best learned method. Parameter counts are not directly comparable across rows: REACT’s are dominated by the per-pixel embedding table, which replaces a convolutional front-end rather than supplementing it. The frame-based focus-of-expansion baseline [33] reaches a lower error still, but operates offline on rectified frames with the target given and reports no inference time, so it does not constrain a real-time budget. Accumulation latency becomes critical when the platform moves rapidly. Conventional approaches must integrate events over a finite temporal interval before producing a prediction, during which the vehicle continues to move. This creates an unavoidable gap between when visual information is acquired and when the corresponding estimate becomes available. Event-by-event processing avoids this integration delay: REACT updates its internal state and TTC estimate as events arrive, so the sensing-to-prediction latency is determined primarily by computation. Figure 3 quantifies this difference. For frame- and window-based methods, overall latency is dominated by the integration window rather than network inference, resulting in the totals reported in Table I: 113113 ms for Garl-TTC [25], 115115 ms for ETTCM [23], and at least 36443644 ms for CMax [19]. In contrast, REACT produces an updated estimate with an end-to-end latency of only 4.64.6 ms. At the mean approach speed of 9.229.22 m/s measured near the target in EvTTC, the vehicle travels only 44 cm during this interval, compared with more than 11 m for the fastest of the window-based alternatives. Fig. 2: Qualitative TTC predictions over complete sequences. (A) In-domain evaluation on the CCR1 split of the medium-overlap-50 set of EvTTC [28]. (B) Zero-shot evaluation on Sequence 1 of FCWD [20]. For each sequence, four event frames are shown at decreasing time to contact. The values above each frame indicate the ground-truth TTCs, while the colored labels in the lower-left corners show the corresponding REACT predictions (in seconds). Predictions progressively converge toward the ground truth as the time to contact decreases, with reliable estimates obtained within approximately 3 s of impact (see the critical zone in orange). REACT exhibits similar temporal prediction behavior on the unseen FCWD sequence under the domain shift, without fine-tuning. In this cases, the average vehicle speed is 9.22 m/s. TABLE I: EvTTC time-to-collision. All prior methods receive the target as a tracked or ground-truth bounding box, whereas REACT predicts directly from the raw event stream without a target prior, using the in-domain validation split of [28]. Inference time denotes the end-to-end latency reported in Fig. 3; ≥ indicates methods that do not report an accumulation window. ∗Energy is estimated using the proxy described in Sec. IV-F, applied to Garl-TTC’s ResNet-50 backbone; no prior method reports energy. Best results per column are in bold. Method Category Modality Params Prec. eTTCe_TTC (%) Target-free Async. Time (ms) Energy (mJ) Image’s FoE [33] Geometric Frame - - 3.51 ✗ ✗ - - CMax [19] Geometric Event - - 9.11 ✗ ✗ ≥3644≥ 3644 - Garl-TTC [25] Learned Event + Frame 23.5M∗23.5M FP32 9.44 ✗ ✗ 113113 197∗197 STRTTC [20] Geometric Event - - 11.22 ✗ ✗ ≥25≥ 25 - FAITH [22] Geometric Event - - 40.97 ✗ ✗ ≥155≥ 155 - ETTCM [23] Geometric Event - - 50.38 ✗ ✗ 115115 - REACT (ours) Learned Event ,3,7M FP32 9.59±0.749.59± 0.74 ✓ ✓ 4.64.6 18.518.5 REACT (ours) Learned Event ,3,7M INT8 10.26±0.8110.26± 0.81 ✓ ✓ 4.64.6 2.82.8 Energy is calculated from 32,76832,768 events for REACT. ∗Estimated parameter count with a ResNet-50. Fig. 3: Latency breakdown of time-to-contact (TTC) methods, including event accumulation (grey) and runtime (orange). Diagonal hatching indicates methods for which the event acquisition time is not reported; in these cases, only a lower bound on the overall latency can be provided. Red annotations indicate the corresponding distance travelled during this latency, computed using the mean vehicle speed near the target in the EvTTC dataset [28] (9.22 m/s). IV-B1 Zero-shot transfer To test whether the learned temporal representation is specific to EvTTC, we evaluate the same trained model on FCWD [20] without fine-tuning. FCWD was recorded with a different sensor and under different driving conditions, so the transfer is a test of the representation rather than of the training distribution. Table I reports the resulting errors alongside the in-domain figures, and Fig. 2 shows complete predicted trajectories in both settings. The behaviour is consistent across the domain shift: predictions are unreliable while the target is distant, where the expansion signal in the event stream is weak, and converge as the collision approaches. The error therefore concentrates in the region that (8) weights most heavily and that matters least operationally, which is what motivates MiDwMiD_w (Sec. I-E) as the selection criterion. TABLE I: Zero-shot transfer to FCWD [20]. The same model trained on EvTTC is evaluated on FCWD without fine-tuning or domain adaptation. Evaluation eTTC↓e_TTC (%) MiDw↓MiD_w EvTTC (in-domain) 9.3229.322 0.09860.0986 FCWD (zero-shot) 25.725.7 0.2460.246 IV-C Anytime accuracy Because no accumulation window is required, REACT can be queried at any instant, including instants at which it has seen very little of the stream. To measure how much stream it needs, we empty the state of a trained checkpoint δ ms before a query, let the model consume only the events of that interval, and record the median error at the query. An estimate is usable long before a frame-based pipeline could assemble its input: 27%27\% median error from 100100 ms of stream, which is the earliest instant at which a two-frame method such as Garl-TTC [25] has its second frame, and 20%20\% from 200200 ms. Accuracy peaks at 12.9%12.9\% around 400400 ms and then degrades to 21%21\%. By not having any form of reset in the internal state and the readout of the model, its predictions is refined as times goes on, making REACT suitable for instant prediction and high-horizon predictions (see Figure 2 to see model stabilization of prediction in function of the time) IV-D Network quantization To implement SNNs on dedicated neuromorphic hardware, the network needs to be quantized (usually on from full-precision 32-bits (FP32) to integer 8 bits (INT8). Following a similar methodology as in [16], we use quantization-aware training. From a converged FP32 model we fine-tune the model for 150150 epochs by converting only the synaptic weights and the neuron parameters to INT8 as the activation functions are already binary. By clamping the weights in INT8 and making the update and the full precision weights. This methods allows the model to fine tune progressively using full-precision copy for weight update. Over three different seeds, this gives 97.2±0.4%97.2± 0.4\% against 97.6±0.3%97.6± 0.3\% in FP32 on DVS-Gesture dataset. IV-E Ablation Study IV-E1 TTC Full-Frame Every published method on EvTTC receives the target as a bounding box, either provided by a detector and tracker or obtained from ground truth. This removes distractors from the field of view and reduces TTC estimation to the temporal evolution of a known target region [25]. While this setup is standard and effective, it introduces a separate localization stage before TTC estimation and therefore does not provide a fully asynchronous end-to-end pipeline. To disentangle the contributions of target localization and temporal estimation, we evaluate the same REACT configuration both on the full field of view and on target crops. On the held-out sequences, the TTC error decreases from 34.2% with the full frame to 28.3% with target crops, indicating that a substantial part of the gap between REACT and published results stems from target localization rather than temporal estimation. This also suggests that incorporating an ROI front-end could improve performance without modifying the underlying spiking temporal model. IV-E2 Neuron model The temporal dynamics of REACT strongly rely on its neuron model, making neuron replacement the natural ablation while keeping the rest of the architecture fixed. We compare C-SiLIF against SiLIF [9], which retains the log-reparameterized decay and learnable timestep but remains real-valued and therefore lacks an oscillatory mode, and against a standard LIF neuron, whose dynamics are governed by a single fixed decay constant. All variants are trained on EvTTC with the same two residual blocks, D=128D=128 channels, event budget, and training schedule. We evaluate LIF both in its standard form, with a spike-triggered reset, and with the reset removed as described in Sec. I-B. This isolates the contribution of the linear recurrence from that of the neuron dynamics themselves. TABLE IV: Neuron model on EvTTC. All variants share the architecture, event budget and training schedule of Sec. I-D; only the neuron differs. Best in bold, second underlined. Neuron State eTTCe_TTC (%) ↓ MiDwMiD_w ↓ LIF real, fixed decay, reset 116.9116.9 0.6810.681 LIF, no reset real, fixed decay 84.184.1 0.520.52 SiLIF [9] real, learned decay 11.4211.42 0.120.12 C-SiLIF [9] complex, oscillatory 9.39.3 0.090.09 The results are reported in Table IV. Removing the reset alone reduces the eTTCe_TTC from 116.9%116.9\% to 84.1%84.1\%, showing that preserving the state across spikes is already critical for temporal prediction. With a spike-triggered reset, the neuron repeatedly discards its accumulated temporal state, severely limiting its ability to represent long-range temporal dependencies. Both LIF variants nevertheless remain far from usable in our experimental setting, highlighting the importance of the SSM-like temporal dynamics. Replacing LIF with SiLIF reduces the error to 11.42%11.42\%, while C-SiLIF further reduces it to the reported 9.3%9.3\% on EvTTC. The distance traveled during the latency, and thus the effective blind distance, increases linearly with vehicle speed. At 100 km/h, these latencies correspond to only 12.8 cm of blind travel for REACT, compared with 3.14 m for Garl-TTC and 3.19 m for ETTCM, highlighting the practical advantage of our approach. IV-F Energy consumption We estimate inference energy for a neuromorphic deployment using the 45 nm energy proxy proposed in [34]. For each layer, the estimated energy is computed as (reads+writes)ESRAM+accEadd(reads+writes)E_SRAM+acc\,E_add, where the number of synaptic operations is determined by the number of input spikes, θin _in, measured on real data. We additionally account for two costs specific to our architecture. First, the event embedding requires D word reads per input event. Second, the C-SiLIF core reads five per-channel parameters (λre,λim,ρ,bre,bim _re, _im,ρ,b_re,b_im) at each update, compared with a single decay parameter for a conventional LIF neuron, and requires 1212 multiplications and 55 additions per event. For energy estimation, we consider the sequential deployment of the model, since the parallel associative scan described in Sec. I is used only for training and batched sequence processing. Firing rates are measured independently for each block. On DVS128-Gesture, the overall firing rate is 31.1±1.3%31.1± 1.3\% across three seeds, with 31.9±1.3%31.9± 1.3\% and 6.3±0.4%6.3± 0.4\% in blocks 0 and 1, respectively. On EvTTC, the overall firing rate is 23.2±1.2%23.2± 1.2\% across five seeds. INT8 quantization does not alter the binary spike activity and therefore leaves the firing rates unchanged. We consequently use the same measured rates for the FP32 and INT8 energy estimates, with the difference in energy arising solely from the reduced per-operation cost. The resulting estimated energy per input window is reported in Tables I and I. Channel-mixing linear layers account for approximately 90%90\% of the total estimated energy, while the C-SiLIF state-space core represents the lowest-cost major component. The estimated energy per event is 2.7×2.7× higher for EvTTC than for DVS-Gesture, primarily because event pooling is not used for EvTTC. For EvTTC, where the input windows are bounded in time, the estimated energy scales linearly with the number of events at a fixed firing rate, yielding an estimated cost of 563nJ563\,nJ per event. V Discussion We introduced REACT, a new fully spiking state-space model that processes raw event streams event by event, without frames, voxel grids, or fixed temporal bins. By combining binary neural activity with continuous-time state-space dynamics driven by physical inter-event intervals, REACT retains temporal information while avoiding explicit temporal discretization. On DVS128-Gesture, it achieves competitive accuracy with event-by-event non-spiking SSMs while using a substantially smaller state-space component, demonstrating that rich temporal dynamics can be implemented with a compact spiking formulation. The TTC experiments illustrate the relevance of this approach for robotic perception. REACT achieves 9.59±0.74%9.59± 0.74\% error on EvTTC, comparable to the best reported learning-based method, while requiring no target bounding box as input. More importantly, processing events individually yields a 4.6 ms end-to-end inference latency, avoiding the accumulation delays introduced by frame- or window-based approaches. The zero-shot experiment further indicates that the learned temporal representation can transfer across datasets, although performance degrades for distant targets. The energy analysis also provides insight into the architecture. INT8 quantization causes only a limited accuracy degradation and reduces the estimated EvTTC energy to 2.8 mJ per 32,768 events. However, approximately 90% of the estimated energy is spent in channel-mixing layers rather than in the C-SiLIF state-space core. This suggests that further sparsification of these operations may offer greater efficiency gains than optimizing the temporal dynamics themselves. These values remain analytical estimates and should therefore be validated on neuromorphic hardware. Finally, the embedding remains a major source of parameters and scales with sensor resolution. Factorized or coordinate-based embeddings, along with training on more diverse motion scenarios, are promising directions for improving scalability and robustness. Evaluation on physical neuromorphic hardware and robotic platforms will be an important step toward deployment. VI Conclusion REACT places the dynamics of a state-space model inside the spiking neuron. Processing events asynchronously brings learned models closer to anytime prediction, where an estimate is available whenever it is needed rather than once a window has closed. Nothing in the architecture is specific to time-to-contact: any task that maps a continuous event stream to a continuously updated estimate, such as steering-angle prediction, ego-motion estimation or place recognition, would be a natural fit for future ongoing works. Ultimately, such event-driven anytime perception could provide the low-latency feedback required to connect asynchronous vision directly to closed-loop robotic control. Acknowledgments We acknowledge the use of ChatGPT and Claude for assistance with language editing, clarity, and phrasing throughout the manuscript. Claude was also used for coding assistance, including Triton implementations for accelerated GPU training, factorization, and plot generation. References [1] G. Gallego, T. Delbrück, G. Orchard, C. Bartolozzi, B. Taba, A. Censi, S. Leutenegger, A. J. Davison, J. Conradt, K. Daniilidis, and D. Scaramuzza (2022) Event-based vision: a survey. IEEE Transactions on Pattern Analysis and Machine Intelligence 44 (1), p. 154–180. External Links: Document Cited by: §I. [2] D. Gehrig, A. Loquercio, K. Derpanis, and D. Scaramuzza (2019) End-to-end learning of representations for asynchronous event-based data. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), Vol. , p. 5632–5642. External Links: Document Cited by: §I. [3] X. Lagorce, G. Orchard, F. Galluppi, B. E. Shi, and R. B. Benosman (2017) HOTS: a hierarchy of event-based time-surfaces for pattern recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence 39 (7), p. 1346–1359. External Links: Document Cited by: §I. [4] A. Gu, K. Goel, and C. Ré (2022) Efficiently Modeling Long Sequences with Structured State Spaces. arXiv. External Links: 2111.00396, Document Cited by: §I-A. [5] J. T. H. Smith, A. Warrington, and S. W. Linderman (2023) Simplified State Space Layers for Sequence Modeling. arXiv. External Links: 2208.04933, Document Cited by: §I-A. [6] A. Gu and T. Dao (2024) Mamba: Linear-Time Sequence Modeling with Selective State Spaces. External Links: 2312.00752, Document, Link Cited by: §I-A. [7] M. Bal and A. Sengupta (2024) Rethinking Spiking Neural Networks as State Space Models. arXiv. External Links: 2406.02923, Document Cited by: §I-A. [8] M. I. Stan and O. Rhodes (2023) Learning Long Sequences in Spiking Neural Networks. arXiv. External Links: 2401.00955, Document Cited by: §I-A. [9] M. Fabre, L. Dudchenko, and E. Neftci (2026) SiLIF: Structured State Space Model Dynamics and Parametrization for Spiking Neural Networks. arXiv. External Links: 2506.06374, Document Cited by: §I-A, §I-B, §I-B, §IV-E2, TABLE IV, TABLE IV. [10] A. Bittar and P. N. Garner (2022) A surrogate gradient spiking baseline for speech command recognition. Frontiers in Neuroscience 16. External Links: ISSN 1662-453X, Document Cited by: §I-A. [11] M. Baronig, R. Ferrand, S. Sabathiel, and R. Legenstein (2024) Advancing spatio-temporal processing in spiking neural networks through adaptation. arXiv preprint arXiv:2408.07517. Cited by: §I-A. [12] E. M. Izhikevich (2001) Resonate-and-fire neurons. Neural Networks 14 (6), p. 883–894. External Links: ISSN 0893-6080, Document Cited by: §I-A. [13] S. Higuchi, S. Kairat, S. M. Bohté, and S. Otte (2024) Balanced resonate-and-fire neurons. arXiv preprint arXiv:2402.14603. Cited by: §I-A. [14] M. Schöne, N. M. Sushma, J. Zhuge, C. Mayr, A. Subramoney, and D. Kappel (2024) Scalable event-by-event processing of neuromorphic sensory signals with deep state-space models. In 2024 International conference on neuromorphic systems (ICONS), p. 124–131. Cited by: §I-A, §I-F, §IV-A, TABLE I, TABLE I. [15] N. Zubic, M. Gehrig, and D. Scaramuzza (2024) State space models for event cameras. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, p. 5819–5828. Cited by: §I-A. [16] X. Zhang, M. Hu, S. Lu, S. Kim, E. Y. Lee, Y. Liu, and W. D. Lu (2026) Compute-in-memory implementation of state space models for event sequence processing. Nature Communications 17 (1), p. 1513. External Links: ISSN 2041-1723, Document Cited by: §I-A, §IV-A, §IV-D, TABLE I. [17] X. Clady, C. Clercq, S. Ieng, F. Houseini, M. Randazzo, L. Natale, C. Bartolozzi, and R. B. Benosman (2014) Asynchronous visual event-based time-to-contact. Frontiers in Neuroscience 8. External Links: ISSN 1662-453X, Document Cited by: §I-B. [18] D. Falanga, K. Kleber, and D. Scaramuzza (2020) Dynamic obstacle avoidance for quadrotors with event cameras. Science Robotics 5 (40), p. eaaz9712. External Links: Document, Link, https://w.science.org/doi/pdf/10.1126/scirobotics.aaz9712 Cited by: §I-B. [19] G. Gallego, H. Rebecq, and D. Scaramuzza (2018) A unifying contrast maximization framework for event cameras, with applications to motion, depth, and optical flow estimation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), Cited by: §I-B, §IV-B, TABLE I. [20] J. Li, B. Liao, X. Lu, P. Liu, S. Shen, and Y. Zhou (2025) Event-aided time-to-collision estimation for autonomous driving. In Computer Vision – ECCV 2024, A. Leonardis, E. Ricci, S. Roth, O. Russakovsky, T. Sattler, and G. Varol (Eds.), Cham, p. 57–73. External Links: ISBN 978-3-031-72949-2 Cited by: §I-B, §I-F, Fig. 2, §IV-B1, TABLE I, TABLE I. [21] S. McLeod, G. Meoni, D. Izzo, A. Mergy, D. Liu, Y. Latif, I. Reid, and T. Chin (2022) Globally optimal event-based divergence estimation for ventral landing. In European Conference on Computer Vision, p. 3–20. Cited by: §I-B. [22] R. Dinaux, N. Wessendorp, J. Dupeyroux, and G. C. H. E. d. Croon (2021) FAITH: fast iterative half-plane focus of expansion estimation using optic flow. IEEE Robotics and Automation Letters 6 (4), p. 7627–7634. External Links: Document Cited by: §I-B, TABLE I. [23] U. M. Nunes, L. U. Perrinet, and S. Ieng (2023) Time-to-contact map by joint estimation of up-to-scale inverse depth and global motion using a single event camera. In 2023 IEEE/CVF International Conference on Computer Vision (ICCV), Vol. , p. 23596–23606. External Links: Document Cited by: §I-B, §IV-B, TABLE I. [24] Z. Wang, T. Molloy, P. van Goor, and R. Mahony (2024) Asynchronous blob tracker for event cameras. IEEE Transactions on Robotics 40, p. 4750–4767. Cited by: §I-B. [25] J. Li, S. Li, Q. Lian, P. Li, X. Chen, and Y. Zhou (2026) Toward deep representation learning for event-enhanced visual autonomous perception: the eap dataset. IEEE Transactions on Robotics 42 (), p. 1643–1661. External Links: Document Cited by: §I-B, §I-E, §IV-B, §IV-B, §IV-C, §IV-E1, TABLE I. [26] A. Bisulco, V. Kumar, and K. Daniilidis (2025) EV-ttc: event-based time to collision under low light conditions. IEEE Robotics and Automation Letters 10 (6), p. 6151–6158. External Links: Document Cited by: §I-B. [27] A. Gu, K. Goel, A. Gupta, and C. Ré (2022) On the parameterization and initialization of diagonal state space models. Advances in neural information processing systems 35, p. 35971–35983. Cited by: §I-B. [28] K. Sun, J. Li, K. Dai, B. Liao, W. Xiong, and Y. Zhou (2025) EvTTC: an event camera dataset for time-to-collision estimation. IEEE Robotics and Automation Letters 10 (6), p. 6191–6198. Cited by: §I-E, §I-F, Fig. 2, Fig. 3, TABLE I. [29] A. Amir, B. Taba, D. Berg, T. Melano, J. McKinstry, C. Di Nolfo, T. Nayak, A. Andreopoulos, G. Garreau, M. Mendoza, J. Kusnitz, M. Debole, S. Esser, T. Delbruck, M. Flickner, and D. Modha (2017) A low power, fully event-based gesture recognition system. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), p. 7243–7252. Cited by: §I-F. [30] Y. Li, Y. Kim, H. Park, T. Geller, and P. Panda (2022) Neuromorphic data augmentation for training spiking neural networks. In Computer Vision – ECCV 2022, S. Avidan, G. Brostow, M. Cissé, G. M. Farinella, and T. Hassner (Eds.), Cham, p. 631–649. External Links: ISBN 978-3-031-20071-7 Cited by: §I-F. [31] S. Yun, D. Han, S. Chun, S. J. Oh, Y. Yoo, and J. Choe (2019) CutMix: regularization strategy to train strong classifiers with localizable features. In 2019 IEEE/CVF International Conference on Computer Vision (ICCV), Vol. , p. 6022–6031. External Links: Document Cited by: §I-F. [32] W. Fang, Y. Chen, J. Ding, Z. Yu, T. Masquelier, D. Chen, L. Huang, H. Zhou, G. Li, and Y. Tian (2023) SpikingJelly: an open-source machine learning infrastructure platform for spike-based intelligence. Science Advances 9 (40). Cited by: §I-F. [33] S. Stabinger, A. Rodríguez-Sánchez, and J. Piater (2016) Monocular obstacle avoidance for blind people using probabilistic focus of expansion estimation. In IEEE Winter Conference on Applications of Computer Vision (WACV), Cited by: §IV-B, TABLE I. [34] E. Lemaire, L. Cordone, A. Castagnetti, P. Novac, J. Courtois, and B. Miramond (2023) An analytical estimation of spiking neural networks energy efficiency. In Neural Information Processing, M. Tanveer, S. Agarwal, S. Ozawa, A. Ekbal, and A. Jatowt (Eds.), Cham, p. 574–587. External Links: ISBN 978-3-031-30105-6 Cited by: §IV-F.