How the engine plans & learns.
Most systematic strategies classify the present with frozen indicators. Ours plans the future. Modeled on the MuZero paradigm — learn the dynamics, imagine the consequences, act on the plan — the swarm evaluates market dynamics without relying on rigid static rules, and it does this on live capital every market day.
Model-based decisions, learned from raw data.
The engine does not start from "RSI crossed 70." It learns the underlying dynamic state space directly from raw multi-asset tick and candle data — price paths, volume, order-flow imbalance, cross-asset correlations — the way MuZero learns a game's rules by watching moves rather than reading a rulebook.
Raw inputs, not hand-crafted crutches
Multi-asset tick and candle streams are the substrate. Classical indicators (the eight strategies in our library) still exist — but as genomes whose parameters breathe, scored and re-weighted by the evolution engine rather than trusted as law.
A latent state that means something
Learned representations compress the tape into a hidden state capturing what actually drives forward dynamics: trend persistence, liquidity conditions, volatility carry, flow pressure. The HMM regime classifier (Bull / Bear / Neutral / Macro Volatility) runs alongside as an interpretable cross-check.
Dynamics, not labels
The model is trained to predict how the state evolves — not to fit a static classifier on yesterday's snapshots. That's what makes it adaptive: when the market's character shifts, the learned dynamics shift with it, and the regime model catches the macro breaks.
Internal state & latent simulation.
Before a single live order is dispatched, the agent models hidden market dynamics to simulate potential future trajectories — including its own market impact.
Roll the tape forward
From the current latent state, the internal model unrolls candidate futures: what price, volume, and flow plausibly do over the strategy's horizon, conditional on what the swarm does or doesn't do.
Model our own footprint
Market impact is simulated as part of the future, not discovered in the fill: expected slippage per child order, queue position, and venue behavior are priced into the plan before the first slice of a TWAP/VWAP schedule is routed.
Stress the branch points
Trajectories that brush the risk envelope — drawdown thresholds, exposure caps, gap risk — are surfaced to the Risk Warden as pre-trade context, so circuit breakers evaluate a plan, not just a number.
// every bar, per candidate genome state_t = encode(ticks, candles, flow, cross_asset) # learned latent state regime_t = hmm_posterior(state_t) # bull | bear | neutral | macro-vol for action in {ENTRY, EXIT, REBALANCE, STAND_DOWN}: r_1..r_h = dynamics_model(state_t, action) # latent roll-out, no live orders impact = impact_model(r_i, child_orders) # slippage + queue + venue model Q(action) = value_head(r_1..r_h) - λ · tail_risk(r_1..r_h) action* = argmax Q # gated by the Warden before routing
Policy & value heads.
Candidate actions are scored explicitly, balancing real-time return expectation against downside tail risk. The action set is deliberately small and auditable.
| Policy head | Intent | Value head weighs | Guarded by |
|---|---|---|---|
| ENTRY | Open or add exposure in a ranked genome | expected return per unit of tail risk | 7-gate warden · sizing caps |
| EXIT | Flatten or reduce; harvest or cut | drawdown containment vs. reversal probability | dynamic stop ladder |
| REBALANCE | Re-weight the book across regimes | correlation shift vs. turnover cost | gross-exposure cap |
| STAND_DOWN | Risk-off: no new risk, protect capital | regime posterior × drawdown headroom | kill-switch fail-safe |
STAND_DOWN is a first-class action, not an absence of signal. In Macro Volatility posterior states the value head makes protecting capital the highest-Q action — which is precisely how the system behaves in the regimes that kill static strategies.
Search & tactical pathing.
Strategy picks what; search picks when and how. Monte-Carlo tactical rollout trees evaluate risk-adjusted return paths across multiple bars to select optimal order timing and minimize slippage.
Branch on tactics, not on hopes
Each rollout branches over realistic tactical choices: enter now vs. stagger, TWAP vs. VWAP schedule, participation rate, passive vs. crossing legs.
Score whole paths
A path is scored on its full risk-adjusted trajectory — not its first fill. Drawdown along the way costs as much as the terminal P&L earns.
Commit through the Warden
The best path becomes an order plan, and the order plan faces the seven pre-trade checks before the execution layer routes it to broker gateways.
The swarm around the engine.
The planning loop is one agent in a distributed multi-agent swarm — a hybrid C# (.NET 8/9) and Python microservice ecosystem on Google Cloud, engineered so that no single failure can turn a bad model into a worse account.
ELO-rated genome pools
Genomes compete in tournaments on identical market paths. Surrogate models pre-score candidates so expensive full simulations are spent only where they matter; genetic mutation pipelines breed the winners. ELO rank — not a researcher's hunch — allocates capital.
Seven checks between signal and order
Pre-trade validation of symbol, side, notional, position cap, gross exposure, drawdown headroom, and regime consistency — with dynamic drawdown thresholds, real-time position sizing, and an automated kill-switch that cancels and flattens without waiting for a human.
Optimal TWAP/VWAP & routing
High-throughput order routing integrates broker gateways behind idempotent asynchronous ingestion queues. Schedules are generated from the search layer's plans; fills are reconciled against broker state continuously.
Multi-state HMM in real time
Gaussian-emission Hidden Markov Models classify Bull, Bear, Neutral, and Macro Volatility states from live returns. Posterior probabilities gate strategy weighting, sizing multipliers, and the STAND_DOWN policy.
DATA PLANE async ingestion queues ──▶ Memorystore Redis (sub-ms hot tier) ──▶ versioned GCS cold storage (immutable research & evidence lake) COMPUTE Cloud Run microservices (stateless, autoscaled) Spot VM Batch fleets for parallel tournament & simulation workloads RUNTIMES C# .NET 8/9 : risk engine · execution router (deterministic order path) Python : evolution · HMM regime · LightGBM ensembles · research CONTROL Pub/Sub choreography · idempotency keys · dead-letter topics Cloud Monitoring ──▶ alerting ──▶ kill-switch fail-safes
What we publish — and what we don't.
Everything above is architecture, not algorithm. We market outcomes and operational robustness: how the system is engineered, what it measures, and how it fails safely. The moat stays in the vault.
Engineering doctrine
- System topology, agent responsibilities, and failure handling
- Methodology: purged walk-forward validation, deflated Sharpe, regime segmentation
- Risk philosophy: seven-gate pre-trade checks, drawdown containment, kill-switch design
- Operational telemetry shapes: latency, uptime, gate verdicts
Alpha & parameters
- Genome parameter files, mutation operators, and fitness landscapes
- Learned model weights, feature transformations, and ensemble configurations
- Tournament ELO tables, capital allocation state, and live P&L attribution
- Verified performance metrics — released as verified figures under NDA, never marketing numbers
See the loop run on live capital.
Allocators and institutional counterparties can request gated access to verified regime matrices, deflated-Sharpe tracking, and the live dashboards. Engineering teams can book a free working session and get the same architecture applied to their stack.