For quant developers
Institutional infra. One declarative SDK.
Stop stitching together feature stores, experiment trackers, registries, schedulers, and compute. Declare your strategy in one Python SDK. Commit it. The platform compiles, backfills, trains, and ships — server-side, reproducible to the byte — and pays you 70% of the performance fee when it goes live.
The Promethean Editor
Your whole quant stack, in the browser.
A collaborative dev environment on a managed Kubernetes workspace with the SDK preinstalled. CM6 editor, pyright LSP, an integrated terminal wired straight to remote execution, real-time CRDT collaboration with presence, and a git panel. Nothing to install; nothing to configure.
# features.py — declare features as expressions, not jobs
from promethean import Featureset, Feature, feature
from .datasets import SpotBars, OrderFlow
@featureset
class Momentum(Featureset):
"""Cross-sectional momentum over the spot tape."""
ret_5m: float = Feature(
expr=SpotBars.close / SpotBars.close.shift(5) - 1,
)
rv_30m: float = Feature(
expr=SpotBars.ret.rolling(30).std() * 1440 ** 0.5,
)
@feature
def ofi_imbalance(self) -> float:
bid, ask = OrderFlow.bid_vol, OrderFlow.ask_vol
return (bid - ask) / (bid + ask)
momentum-alpha ❯ promethean commit ./strategy
✓ resolved 2 datasets · 1 featureset · 1 pipeline
✓ compiled Momentum → SurrealQL (3 expressions)
→ backfill SpotBars@v12 ████████████░░ 84% 2.1M rows/s
→ submit RayJob train.momentum (8 CPU · 1 A10G)
▸ run a4f1c2 epoch 12/40 sharpe 1.94 loss 0.0271
momentum-alpha ❯
Code, not config
Write @dataset, @featureset, and @pipeline definitions with full type-checking. Pyright runs against the real SDK surface.
Terminal on the cluster
promethean commit streams compile, backfill, and training logs back into the editor. The Ray job runs remotely; the output lands here.
Collaborate live
CRDT-backed multiplayer editing with presence and a shared git panel. Pair on a feature without screen-sharing or merge anxiety.
The stack
Nine systems, one SDK.
Each of these is what another team would sell as a standalone product. On Promethean they compose, share lineage, and live behind a single declarative API.
Ember — Feature Store
Server-side materialization, reactive pipelines, hybrid search, Arrow Flight tensors, git-style branching. Your features live here; nothing computes client-side.
Forge — Pipelines
@pipeline / @step DAG with depends_on, ClickHouse-backed metrics, RayJob remote execution, and per-job resource tracking.
Sweeps
Grid, random, and Bayesian hyperparameter search. Backend-agnostic — annotate @hyperparameter, never see a Ray address.
Model Registry
Immutable versioned artifacts, dev → staging → prod → archived, full lineage to Forge run and Ember datasets, chunked dedup + compression on upload.
Auth & Tenancy
IdP-agnostic OIDC and passkeys, per-org namespaces and DB isolation, org/team/user chargeback, shared Ray cluster with quotas.
Promethean Editor
Managed Kubernetes workspaces, CM6 editor, pyright LSP, integrated terminal, CRDT collaboration with presence, and a git panel. Idle → auto-pause.
MCP Servers
ember-mcp and forge-mcp let LLM agents discover features, query pipelines, and inspect runs. First-class AI copilot surface.
CLI + Admin
promethean-cli for org/team/user management, deploy ops, and billing — scriptable, whitelabel-ready.
Backtesting
Point-in-time-correct slippage, realistic fills, paper trading with competitive leaderboards. Roadmap — before marketplace GA.
Ember · Feature Store
Features as expressions. Versioned like code.
Declare a featureset and the platform compiles each expression to SurrealQL, materializes it server-side, and serves it over Arrow Flight as tensors. Discovery is hybrid BM25 + vector search. Experiment safely on a data branch and merge when it works.
Momentum
Cross-sectional momentum over the spot tape. Joined point-in-time to SpotBars.
close / close.shift(5) - 1ret.rolling(30).std() * 1440 ** 0.5(bid_vol - ask_vol) / (bid_vol + ask_vol)Hybrid search
Find features by keyword and by meaning at once — BM25 lexical recall fused with vector similarity over feature descriptions and lineage.
Git-style data branches
Fork a dataset, reshape features, validate point-in-time correctness, then merge. Production reads stay untouched until you promote.
Tensors over Arrow Flight
Training reads stream as columnar Arrow batches — zero client-side recompute, no CSV round-trips, no silent type drift.
Forge · Pipelines
A DAG you declare. A cluster you never touch.
Compose @step functions into a @pipeline with depends_on, then commit. Forge submits a RayJob, runs the graph remotely, streams metrics into ClickHouse, and sweeps hyperparameters — all behind the SDK. You read results; you never write infra.
| trial | lr | depth | sharpe | max_dd |
|---|---|---|---|---|
t-19best | 1.2e-3 | 6 | 2.14 | -6.8% |
t-22 | 8.0e-4 | 7 | 1.97 | -7.1% |
t-11 | 2.5e-3 | 5 | 1.81 | -9.4% |
t-04 | 5.0e-3 | 8 | 1.42 | -12.6% |
Remote execution on Ray
load → featurize → train → evaluate → register runs as a RayJob on the shared cluster with per-node resource requests and live state.
Backend-agnostic sweeps
Annotate @hyperparameter and pick grid, random, or Bayesian. Trials fan out across the cluster; the best one surfaces automatically.
Metrics in ClickHouse
Every trial's sharpe, drawdown, and loss curve lands in a columnar store you can slice — not a directory of JSON you grep.
Model Registry
Promote with confidence. Trace it forever.
Winning models become immutable, versioned artifacts. Promote dev → staging → prod with a single call, and every version carries a lineage thread back to the exact Forge run, hyperparameters, seed, and Ember data branch it was trained on.
v0.9.0prod1.86-7.4%12d agov0.10.0staging2.02-6.9%3d agov0.11.0dev2.14-6.8%just nowv0.8.2archived1.61-9.1%31d agoStage promotion
dev → staging → prod → archived, gated by policy. Roll back to any prior version instantly; nothing is ever overwritten.
End-to-end lineage
Click a version and walk the chain: model → run → featureset → dataset branch. Reproduce or audit any production result.
Efficient artifacts
Chunked dedup and compression on upload — iterate on hundreds of model versions without paying for hundreds of full copies.
Reproducibility contract
Every run is a byte-for-byte reproducible artifact.
Debugging a model that only misbehaves in production is a full-day problem. Not here. Every run locks pipeline version, dataset versions, hyperparameters, runtime env, and seeds into a single record. Re-run any historical result. Diff two runs. Audit the chain back to the raw source.
inspecting a run's lineage# every run records: pipeline version, data versions,
# hyperparams, runtime env, and random seeds
run = client.pipelines.run(
train,
hyperparams={"lr": 1e-3, "depth": 6},
branch="experiment/feature-v3",
)
run.lineage()
# → pipeline: train@sha.a1b2c3
# → datasets: SpotBars@v12 (branch: experiment/feature-v3)
# → features: Momentum@v4 (compiled: SurrealQL)
# → env: python 3.11.9, torch 2.2.0, promethean 0.3.2
# → seed: 42The whole loop
Declare. Commit. Ship.
Three verbs span the entire workflow — from an empty file to a published, audited strategy earning a performance fee.
Declare
Datasets, featuresets, and pipelines as typed Python. No YAML, no cluster config, no infra leaking into your strategy logic.
Commit
The platform compiles expressions to the execution engine, auto-backfills history, and schedules training — every step server-side and reproducible.
Ship
Promote the winning model to the registry and publish to the marketplace. Full lineage rides along for audit, iteration, and trust.
Revenue
Build once. Earn as long as it performs.
Publish a strategy to the Promethean marketplace and earn on two streams: a portion of each investor's monthly subscription, plus 70% of the performance fee — 25% of annual profit, split 70/30 in your favor.
A developer with $1M of subscribed AUM returning 10% earns ≈ $17,500/year on performance fees alone. The platform handles discovery, billing, execution, compliance, and risk controls. You handle the alpha.
Illustrative, not a guarantee
Unit economics above are for modeling purposes and assume a hypothetical subscribed AUM. Actual earnings depend on strategy performance, churn, fees, and market conditions. Promethean does not guarantee returns to investors or revenue to developers.
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.