GPU model training
NVIDIA GPUs with CUDA and cuDNN for training and low-latency inference, the compute under the ML layer.
NVIDIACUDAcuDNNLow-latency trading infrastructure
A trading platform with a closed research-to-live loop.
One engine for backtest and live, proven identical by a parity gate, not a promise.
Stack
Built with a serious stack.
What the platform runs on, and the ML layer being built into it.
Languages
C++
Python
Comms
gRPC
ZeroMQ
Redpanda
Data
ClickHouse
PostgreSQL
NumPy
pandas
Compute
Ray
Spark
Dask
ML
TensorFlow
scikit-learn
Hugging Face
MLOps
MLflow
DVC
ONNX
Infrastructure
Docker
Google Cloud
Caddy
Envoy
Interfaces & viz
React
Next.js
Svelte
Bun
Leaflet
Plotly
On-prem hardwareplanned
NVIDIACUDAcuDNNDistributed compute
Ray across a multi-node cluster, orchestrated on Kubernetes and wired with high-bandwidth NVLink / InfiniBand.
Ray
KubernetesNVLinkData & model storage
NVMe-backed ClickHouse for time-series, plus an object store for datasets, features, and model artifacts.
NVMeClickHouse
MinIO
ClickHouseMinIOML operations
Experiment tracking, data + model versioning, and a registry, reproducible from raw data to a served model.
MLflowDVCONNX- 17Services
- 91Strategies
- 21Indicators
- 40Integration Suites
- 5Position Sizers
- 4Cost Models
Research at scale
ML that fans out across a cluster.
A warehouse of market history, fetched over gRPC and bridged into Python, then fanned across a Ray cluster on GCP. The same study on a laptop or on hundreds of cores.
Huge dataset, ELT'd
Collectors extract, load, and transform market, macro, and alt-data into one store.
Columnar warehouse
A local ClickHouse store, microsecond-stamped, multi-asset, pre-aggregated, built for billions of rows.
gRPC fetch
Services pull exactly the slices they need, straight from the warehouse over a binary wire.
ZenoBridge
Carries data and compute across the C++ ↔ Python boundary, capability-agnostic.
Ray · GCPOne study across the whole cluster, in parallel. Pin it to your laptop or a GCP Ray cluster with no code change — a scripted deploy stands the cluster up, and studies are listed and cancelled over the same gRPC API.
Methodology
Determinism is tested, not asserted.
Seven guarantees the platform enforces, each a gate, contract, or test, not a slogan.
Backtest can't drift from live
A parity gate forces research to reproduce the live run bit-for-bit, or the build fails.
No job is lost on a crash
A hard kill, then restart, proves jobs re-drain and terminals persist atomically.
No look-ahead bias
Walk-forward folds are tested, and reading past the current index is structurally forbidden.
No false-green tests
Suites probe their dependencies and skip honestly rather than faking a pass.
Claims stay falsifiable
Failure conditions are pre-committed, with a predicate on every causal-graph edge.
Bad numbers get withdrawn
A reading traced to era-contamination was pulled. Failures are kept as findings.
Disconnect and bad input can't take it down
Every long-lived stream reaps clients that drop, and malformed input is rejected before it can fault a worker thread — swept across the fleet by two robustness audits.
Infrastructure
One wire contract, research to live.
Seventeen services, one wire contract, the same from backtest to live.
Columnar Tick Store
A columnar tick store at five resolutions. The same surface drives backtest, paper, and live.
Service Mesh
17 services on one low-latency RPC mesh, each on a shared base class.
Execution Gateway
A single, clean broker-agnostic boundary. Paper trading by default.
Observable Wire
Real p50 / p95 / p99 per RPC, with correlation IDs that follow a call across services.
Typed Instrument Model
Eight security types, fixed-precision decimal money, closed enums at the boundary.
Broker Reconciliation
Positions, cash, and margin reconciled to the cent against the broker of record.
Architecture
Why it's built this way.
A handful of deliberate decisions, each a tradeoff we can point at.
split completion queues
Accepting an RPC never blocks I/O.
Each service runs separate accept and IO completion queues, so taking a new connection can't head-of-line-block work already in flight.
alarm-driven streaming
No thread per subscriber.
Server streaming is driven by event alarms, not a thread per client, so fan-out doesn't grow threads with subscribers.
two transports, on purpose
Reliable where it matters, lossy where it should be.
A reliable transport carries mutations, control, and reliable streams; a lossy pub/sub transport carries high-rate market data where dropping the stalest frame is the correct behaviour. A documented rule decides which.
producer-owned time
The store never re-stamps.
Timestamps are owned by the producer and preserved end-to-end. Persistence records what happened when it happened, not when it was written.
decimal money
Never float.
Prices, P&L, and cash are fixed-precision decimal throughout, so rounding error can't quietly accumulate into the books.
columnar persistence
A columnar store, async-buffered.
A columnar store with async buffered writes keeps the hot path clear, while pre-aggregated views answer second, minute, and hour scans.
An internal, in-process messaging benchmark measured ~17µs p99 over 100k frames, a design datapoint, not a production SLO. No live latency numbers are committed yet.
Distributed by design
One mesh per exchange. One replicated core.
Local where speed matters, central where truth matters, and no single box anything depends on.
Scale out by exchange
NASDAQ
NYSE
CME
+ any venue
Replicated core
Control plane
Network services
ClickHousesharded · replicated
survives any node or region, quorum holds
Architecture: the design Zeno scales into. Today it runs as one local stack, not live multi-region.
The closed loop
Prototype in research. Run in production.
One engine crosses from notebook to live book, proven identical by a parity gate.
Closed Loop
Research reads the live store, fits, and writes back: one substrate, not two that drift.
Parity Gate
Research must reproduce the live golden run bit-for-bit, or the build fails.
Walk-Forward Validation
Rolling out-of-sample folds, first-class and tested. Lookahead-freedom is a typed contract.
Research Bridge
Regime fits, sweeps, and scenarios fanned across a cluster, each study durable and idempotent.
One Engine, Research to Live
The strategy you backtested runs in paper and live unchanged. Promotion is config, not a rewrite.
Operator Control
Drain, shut down, tail logs, and watch tail latency: the whole mesh from one console.
Integrations
Plug into your trading stack.
At the center of the loop: ingest, route, observe, persist. One wire contract.
zenoα
Low-latency trading platform
Service meshClosed loop
BacktestWalk-forwardTear-sheets
Market data
- Live feeds
- Recorded replay
- Tick to bar
Ingest
Brokers & venues
- Broker-agnostic gateway
- Paper & live
- Order lifecycle
Route
Observe
Dashboards & ops
- Operator console
- Live telemetry
- Tail latency
Study
Research & models
- Regime studies
- Parameter sweeps
- Walk-forward
Persist
Persistence
- Columnar store
- Relational store
- Pre-aggregated views
Operate & verify
Run it by hand.
The mesh is operated from one console: drain, shutdown, stream logs, dispatch research studies. The commands below are illustrative of the capability surface, not a shipped CLI.
# Drain + stop a service through the operator console
$ zeno service stop execution
drain execution ok
shutdown execution ok
status execution down ✓
# Aggregate status across the fleet
$ zeno status
17 services · all up
# Dispatch a research study over the research bridge
$ zeno study start regime-fit
study=regime-fit-3f9a state=running
# The parity gate: research must reproduce the live run
assert research_run.final_equity == decimal("217831.09") # 43 trades, 364 points
Capability map
What is built.
Seventeen services, traced as one pipeline: sources to output, control plane on top.
Control planeorchestrates the fleet
01Network HubControl plane
02Session EngineOrchestrator
12Research WorkerResearch bridge
Sources
03Broker GatewayBroker-agnostic
04Historical ReplayRecorded to live
Stream processing
05Tick ConsolidationTick to bar
06Time-Slice SyncCross-symbol batching
07IndicatorsTwenty-one, streaming
08Securities RegistryTyped instruments
Decision
09Execution LoopNinety-one strategies
10SchedulingSessions & timers
11Backtest EngineEvent-driven
Order lifecycle
13Order LifecycleOCA + brackets
14Positions & P&LMargin-aware
15Cash & FX LedgerMulti-currency
Output
16Performance StreamLive tear-sheet
17Persistence StoreColumnar + relational
Macro Regime Intelligence Engine
A separate research engine. Not a trading system.
A falsifiable, US-only macro-regime engine for risk monitoring, not a trading system.
3 of 6 phases built · conditional inference only · not a trading systemk=4
Regime states
selected by model fit
0.761
NBER recession ROC-AUC
in-sample · gate was 0.70
7 / 10
Causal-graph nodes / edges
a falsification predicate per edge
57 / 57
Unit tests passing
phases 1–3 of 6
A dual regime-model stack keeps labels from drifting across retrains. When the two models disagree, it reports the range: a hard-landing reading between 12% and 75% in early 2026. The disagreement is the finding.
FAQ
Questions a skeptic asks first.
Is this live with real money?
No. ZenoAlpha is pre-1.0 and development-stage. Paper trading is the default path; there is no live track record, AUM, or production deployment to claim.
Which brokers does it support?
A single broker integration today, by design. One clean gateway boundary is the only place to reason about connectivity and fills, and the adapter itself is broker-agnostic, and additional gateways attach through the same interface.
Is MRIE part of the trading platform?
No. MRIE is a separate research and risk-monitoring engine in its own repository. It detects macro regimes and reasons about scenarios; it does not generate trade signals or execute orders.
What asset classes does it trade?
The verified path today is equities, via the broker gateway and recorded market data. The instrument type system spans eight security types, but live multi-asset trading is not claimed.
Is it secure for a multi-tenant deployment?
Not yet, and we won't dress it up. Services run on a single host with insecure channels today; transport security and multi-tenancy are on the roadmap, not shipped.
How can I trust the backtest?
A parity gateforces the research engine to reproduce the live engine's golden run bit-for-bit. Backtest and live share one engine, and the test fails the build if they ever diverge.
Etymology
Reductio ad absurdum, applied to alpha.
We treat every strategy and every model as a proposition that has to survive. Parity gates, walk-forward validation, closed catalogs, and a documented adversarial-review trail stand between a hypothesis and live capital, and when a result doesn't hold up, we withdraw it rather than dress it up.
A philosopher, and a benchmark.
Zeno honours Zeno of Elea (c. 490–430 BCE), the pre-Socratic philosopher whose paradoxes pioneered proof by contradiction (reductio ad absurdum) and whose doctrine of ontological pluralism held that reality admits many coexisting truths. Both ideas sit at the core of how we reason about markets.
Alpha (α) is the Greek letter that finance adopted as the benchmark for outperformance: the excess return that cannot be explained by the market itself.
See whether it holds up.
Read the methodology, trace the topology, and judge the rigor yourself.