Algorithmic trading, evolved.
The two-sided ML trading platform. Quant developers ship strategies on institutional-grade infrastructure. Retail investors subscribe to vetted, transparent algorithms — one curated marketplace.
Built in Rust · Ember · Forge · Registry · Marketplace · reproducible to the byte
# declare — what, not how
@featureset
class Momentum(Featureset):
m_1h: float = Feature(close / close.shift(60) - 1)
vol_z: float = Feature(ret.rolling(390).z())
@pipeline
def train():
feats = Momentum.join(SpotBars, XAsset)
model = LGBM(feats, target="fwd_ret_1h")
sweep(model, lr=[0.03, 0.1])
registry.publish(model, stage="staging")Strategy
Cross-Asset Momentum
Lineage
run train-8f2c1
→ LGBM fit ✓ auc 0.61
→ registry ✓ published
Who it's for
Two audiences. One platform.
A full ML platform underneath a consumer-grade trading product. Developers build the edge. Investors get access to it.
Quant developers
Institutional infra. One declarative SDK.
Feature store, reproducible pipelines, model registry, and managed compute. Publish your strategy to the marketplace and keep ~70% of the performance fee.
See the developer stack →Retail investors
Curated strategies. Transparent track records.
Subscribe to vetted algorithms with honest performance history. No code, no setup — institutional-grade models behind a consumer-grade app.
See how it works →What's inside
Four systems. One declaration.
Each piece is a platform other teams would ship as a product. Together, they're the shortest path from idea to deployed trading strategy.
Ember · Feature Store
Declarative datasets and featuresets, hybrid BM25 + vector search, tensor data over Arrow Flight, git-style branching for safe experimentation.
Forge · Pipelines
@pipeline / @step DAGs with a reproducibility contract, hyperparameter sweeps, ClickHouse-backed metrics, and remote execution on Ray.
Model Registry
Versioned artifacts, dev → staging → prod promotion, lineage back to the pipeline run and its data, gated access policies.
Marketplace
Publish a strategy, earn from subscriptions and performance. Discovery, track records, and profit share — built in.
The stack, up close
Institutional plumbing, made declarative.
The same primitives that power quant funds — search, reproducible training, gated promotion — exposed through one SDK and a managed runtime.
Find the signal. Branch the data. Train on tensors.
Declare datasets and featuresets as code; Ember materializes them server-side and serves point-in-time-correct features over Arrow Flight. Hybrid BM25 + vector search makes a sprawling feature catalog actually discoverable.
- Git-style branching for safe, reproducible experiments
- Tensor-native storage — embeddings and order-book snapshots, first class
- Online + offline parity by construction
Commit once. The platform trains everywhere.
@pipeline / @step DAGs compile to a remote execution engine on Ray. Forge backfills, schedules, sweeps hyperparameters, and streams every metric to ClickHouse — under a reproducibility contract that pins code, data, and environment.
- Hyperparameter sweeps with parallel fan-out
- Live metrics + logs streamed back over WebSocket
- Reproducible to the byte — re-run any historical job
Promote with provenance, not vibes.
Every artifact is versioned and immutable, with lineage that reaches all the way back to the run that produced it and the data it saw. Promotion from dev → staging → prod is gated, audited, and reversible.
- Immutable, content-addressed model versions
- Full lineage: model → run → featureset → dataset branch
- Policy-gated promotion with one-click rollback
Ship the strategy. Earn from the edge.
Publish a vetted strategy to a curated storefront with a transparent, audited track record. Investors subscribe; developers keep ~70% of the performance fee. Discovery, risk disclosure, and payouts handled by the platform.
- Transparent, point-in-time track records
- Subscriptions + performance fees, ~70% to the developer
- Curation and risk vetting before listing — every strategy reviewed
How it works
Declare. Commit. Ship.
Describe your datasets, features, and training pipeline in one SDK. The platform materializes, trains, and publishes — and keeps every run reproducible to the byte.
promethean — example strategy# declare — the SDK describes what, not how
@dataset
class SpotBars(Dataset):
symbol: str = Field(key="symbol")
close: float
ts: datetime = Field(timestamp=True)
@featureset
class Momentum(Featureset):
m_5m: float = Feature(expr=close / close.shift(5) - 1)
@pipeline
def train():
features = Momentum.join(SpotBars)
model = LGBM(features, target="fwd_ret_1h")
registry.publish(model)
# commit — the platform handles materialization, training, deploy
client.commit(SpotBars, Momentum, train)Declare
Datasets, featuresets, pipelines — all as code. No YAML, no cluster configs, no infra leakage into your strategy.
Commit
The platform compiles expressions to the execution engine, auto-backfills, and schedules training — all server-side.
Ship
Promote the winning model to the registry. Publish to the marketplace. Every run carries full lineage for audit and iteration.
Why now
Algorithmic trading is institutional-only. That's the bug.
Retail investors represent a large share of market volume but most of them lose money. Robo-advisors give passive exposure. Robinhood-class apps give options. Neither gives real edge. The tools that power institutional funds — feature stores, model registries, reproducibility contracts — have never been available to retail.
We built the infrastructure first. Feature store, pipelines, registry, sweeps, multi-tenancy, remote execution — all running. The marketplace ties it together: a curated store for strategies with transparent track records, where quant developers earn from what they build and investors get access to real, audited alpha.
If you write trading algorithms, join as a developer. If you invest, join the investor waitlist. We're onboarding in waves.
Join the waitlist
We're onboarding developers and early investors in waves. Tell us who you are and we'll reach out when your slot opens.
We'll only use your email to contact you about Promethean. No spam, no sharing.