Build, Backtest & Deploy Quant Strategies with Natural Language
QuantCell is an AI-native quantitative trading system powered by the axon-quant Rust engine, with FastAPI and React/TypeScript. Describe strategies in natural language — AI generates the code, passes safety checks, and completes backtest verification, from idea to live deployment.
$ quantcell strategy generate \ --requirement "Golden cross buy, death cross sell" \ --name dual_ma
Everything for AI-Native Quant Trading
From natural-language strategy ideas to Rust-powered backtesting and live deployment
🤖AI Intelligence
Natural-Language Strategy Generation
Describe a trading idea in plain language and get executable strategy code automatically. Thinking-chain reasoning is explainable and traceable, with built-in code quality and safety checks.
AI Agent
An AI agent with long-term memory, tool calling, and built-in skills (news analysis, technical analysis) for multi-turn conversations and operation orchestration.
Custom Indicators with AI
Write indicator code in the browser; the LLM diagnoses errors in the code and fixes them automatically.
⚡Rust Engine & Backtesting
Event-Driven Backtesting
Powered by the axon-quant Rust core, with K-line, Tick, OrderBook, and Deriv data adapters. Backtests and live trading share identical matching semantics, guarded by conformance contract tests.
Walk-Forward & Hyperparameter Optimization
Rolling-window validation prevents overfitting. Built-in Optuna HPO with TPE sampling and median pruning.
Reinforcement Learning
Gymnasium trading environments with Stable-Baselines3 (PPO / SAC / DQN), covering the full train → backtest → evaluate → retrain lifecycle.
🌐Trading & Data Ecosystem
Unified Exchange Access
Binance (live / paper / archive) and OKX adapters, with WebSocket real-time streaming, automatic reconnection, and persistence.
DuckDB + Parquet Data Stack
Columnar storage for efficient reads and writes, plus data quality checks, automatic gap recovery, and archive repair for corrupted files.
Worker Live Execution
Strategy live loops, paper trading, and engine deployment with full lifecycle management.
🛡️Platform Engineering
Plugin System
Inter-plugin communication through a unified event bus and isolation in a security sandbox. Package and install plugins with one quantcell plugin command.
Risk Control & Credential Security
Exchange API keys are encrypted at rest and managed via quantcell account, with a risk engine for monitoring and unified JWT authentication.
Modern Frontend & Visualization
React 18 + TypeScript + Vite 7 + Ant Design 6, KLineCharts/ECharts, the Monaco editor, backtest replay, and built-in zh/en i18n.
System Architecture
React/TypeScript on the frontend, FastAPI services, and the axon-quant Rust trading core — decoupled through axon_bridge, covering strategy development, backtest validation, and live deployment.
Rust Core Engine
Identical matching semantics in backtest and live trading; conformance contract tests protect every engine upgrade.
AI-Native Loop
Natural language → code generation → safety checks → backtest verification → deployment.
axon_bridge Decoupling
The Python business layer and the Rust engine stay decoupled — one strategy codebase runs in both backtests and live trading.
Get Running in Minutes
Three steps from clone to your first AI-generated, backtested strategy
Install with one command
Clone the repo and run the installer. It provisions the uv and bun toolchains plus the frontend and backend environments (--minimal / --full / --extra).
git clone https://github.com/pengwow/quantcell.git
cd quantcell
bash install.sh # --minimal / --full / --extra, auto-configures uv + bun
Generate and backtest via CLI
Turn a natural-language requirement into a strategy, then run an event-driven backtest with a single command.
quantcell strategy generate --requirement "golden cross buy" --name dual_ma
quantcell backtest run --symbols BTCUSDT --timeframes 1h --initial-capital 100000
Write strategies in Python
Receive bars in on_bar and return a unified axon_quant Action. The same code runs in backtests and live trading.
from axon_quant import Action, ActionType class DualMA: def __init__(self, fast=10, slow=30): self.fast, self.slow = fast, slow self.closes = [] def on_bar(self, bar: dict) -> Action: self.closes.append(bar["close"]) if len(self.closes) < self.slow: return Action(ActionType.Hold, 0.0, 0.0, "dual_ma", 0) fast_ma = sum(self.closes[-self.fast:]) / self.fast slow_ma = sum(self.closes[-self.slow:]) / self.slow if fast_ma > slow_ma: return Action(ActionType.Buy, 0.8, 0.1, "dual_ma", 0) return Action(ActionType.Hold, 0.0, 0.0, "dual_ma", 0)
Open Source & Community
QuantCell is open source under Apache 2.0. Explore the code, try the live demo, or reach out directly.