Signal Engine & Architecture

This technical deep dive explores the core architecture of Nomentum's neuromorphic signal processing engine. Learn how market data becomes synaptic states and how our device-inspired model generates trading signals.

Data Sources

The Signal Engine integrates multiple data streams to create a comprehensive view of market microstructure. Real-time trade data, order book dynamics, and liquidity metrics feed into our neuromorphic processing pipeline.

1) Data Inputs & Fusion (provider-agnostic)

The engine consumes normalized, loss-bounded views of on-chain activity and adjacent market context. At Beta, the fusion layer is source-agnostic and may be backed by enterprise Solana providers and comparable RPC/analytics services. Inputs are pre-validated, time-aligned, and clipped to compact domains before entering the synapse:

• Microflow: short-window net buy/sell deltas, cadence density.
• Liquidity context: depth/impact surrogates, mapping to τ_slow.
• Trade distribution: micro vs. block flow normalization.
• Volatility bands: short-horizon scale for impulse bounds.
• Integrity features: holder concentration, episodic bundling, large-holder turnover, new-holder velocity.

Fusion outputs are unitless, bounded features suitable for stable neuromorphic updates. No single provider is assumed; mapping is defined by invariants (cadence, clipping, monotonicity) rather than vendor details.

Core NOMFET Model (Gf/Gs, decay, STDP, saturation/noise)

At the heart of our system lies the NOMFET model, implementing synaptic plasticity through dual exponential decay. The model captures facilitation and depression regimes with biologically-inspired time constants.

2) Mathematical Formulation

Let S(t) be the signed spike process derived from microflow. The synapse has fast and slow components G_f, G_s with decay τ_f, τ_s:

dG_f/dt = -G_f/τ_f + k_f · S(t)
dG_s/dt = -G_s/τ_s + k_s · S(t)
G       = w_f · G_f + w_s · G_s,  with  w_f=0.6, w_s=0.4

In discrete time with step Δt, we use bounded updates with saturation/variability terms to reflect device-inspired behavior and avoid divergence:

G_f ← clip( G_f · e^{-Δt/τ_f*} + α_f · φ(G_f) + β_f · σ · w(p) · M )
G_s ← clip( Gs · e^{-Δt/τ_s*} + α_s · φ(G_s) + β_s · σ · w(p) · M )
G   ← 0.6·G_f + 0.4·G_s

• σ ∈ {−1,+1} is the sign (sell/buy), w(p) is a saturating weight of trade fraction.
• φ(·) (e.g., 1 − e^{-cG}) models saturation; small heteroscedastic noise scales with √G.
• τ_s* is liquidity-scaled (monotone), τ_f* is short to reject noise.

Short inter-spike intervals apply an STDP-like gain bounded within a fixed window, emphasizing consistent sequences and attenuating flicker.

Multi-Timeframe Blend

Our architecture integrates signals across multiple timeframes, from microsecond trade data to monthly trends. Each timeframe contributes weighted information to create a comprehensive market signal.

3) Timeframe Selection Methodology

Momentum is a convex blend of tanh-normalized deltas over multiple horizons (e.g., 5m / 15m / 1h / 1d). We overweight recency for reactivity while retaining longer context for regime stability:

M_i = 1 + tanh( Δ_i / s_i )     // per-horizon scaling
M   = Σ λ_i · M_i,  Σ λ_i = 1    // e.g., 0.40/0.25/0.20/0.15

Normalization constants s_i are set so that ordinary moves map to compact ranges, preventing gain spikes during transient turbulence.

Scoring & Thresholds

The final trading signal emerges from a weighted combination of synaptic state, momentum indicators, and risk metrics. Dynamic thresholds adapt to market conditions and volatility regimes.

4) Scoring & Regime Logic

The score is a monotone transformation of G, the momentum-modulated gain, and regime flags; it is explicitly bounded, with hysteresis to suppress oscillation near thresholds:

M'     = M · (1 − R)              // risk damping, R ∈ [0,1]
Score  = H( ψ(G), M', Regime )    // H applies clipping & hysteresis

R aggregates integrity features (e.g., concentration, bundling, turnover, new-holder velocity) through smoothstep/tanh mappings to avoid discontinuities. ψ is a gently curved, Lipschitz-bounded map of G to preserve ordering while compressing tails.

UI Bindings

The Signal Engine provides real-time data bindings for our visualization components, enabling live updates of synaptic states, momentum indicators, and trading recommendations.

5) UI Architecture (rendering & state)

• Rendering: device-pixel-aware canvases (HUD ring, raster, synapse plot) with deterministic sampling from the engine's compact state vector.
• State discipline: ring buffers for price, momentum, and spike rasters; cross-session continuity with expiry.
• Reactivity: UI reads the engine's derived state only; the engine never depends on UI cadence.

Limits & Next

Current Alpha limitations include single-token focus and simplified risk modeling. Future developments will expand to multi-asset portfolios and advanced risk management.

6) Technical Limitations & Scalability

• Cadence sensitivity: inner-loop jitter can bias timing gains; we isolate the loop and use bounded STDP windows.
• Data gaps: missing ticks are imputed conservatively; confidence is surfaced in the HUD.
• Throughput: multi-asset tracking scales linearly with compact state export; heavy features (backtests/drift) run off-path.
• Planned: formal convergence checks, synthetic adversarial scenarios, reliability scoring, and hardware-in-the-loop experiments with NOMFET-class devices.