How the system plans & learns.
Most systematic strategies classify the present with frozen indicators. Ours plans the future. The swarm builds a working model of market dynamics straight from raw data — learn the dynamics, imagine the consequences, act on the plan — then evaluates live markets 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 — instead of trusting a fixed indicator 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 interpretable regime model (Bull / Bear / Neutral / Macro Volatility) runs alongside as a 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 = regime_model(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
Why this is hard — and why the system is built around verification.
Markets are non-stationary, adversarial, and noisy. No single model "solves" them, and any system that claims one is selling something. The hard part is not dreaming up a clever model — it is keeping a live system honest when the tape keeps changing.
Learning from a moving target
Relationships that held last year decay, invert, or vanish. A learned model must be re-scored against new regimes continuously — and the moment it is treated as law, it becomes a liability. That is why genomes are re-ranked by tournament outcome rather than trusted as fixed strategies.
Overfitting is the default
With enough parameters, any historical curve can be fit beautifully — and fail forward. The engine fights this with purged walk-forward validation, no-lookahead guards on every feature, and deflated-Sharpe statistics that price in how many hypotheses were tried.
Costs and impact are the edge
An edge that survives gross math is usually consumed by spread, slippage, and adverse selection. Every plan is priced against a pessimistic fill model before it routes — if it does not survive the pessimist, it does not trade.
Failure must be boring
The interesting failure modes are the quiet ones: a stale feature, a gate that silently loosened, a regime that no strategy anticipated. The swarm is engineered so a bad model becomes a flagged event, not a blown account — seven pre-trade checks, an automated kill-switch, and a kill-switch that does not wait for a human.
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.
Regime adaptation in real time
An interpretable multi-state regime model classifies 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 ──▶ in-memory 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 · regime engine · 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: pre-trade checks, drawdown containment, kill-switch design
- Data policy: the public surface is derived-only — raw provider values are never re-exposed
- 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.