Build, test, run, and understand algorithmic trading strategies
SmartQuant brings strategy development, backtesting, paper and live trading, analysis, monitoring, and control into one AI-assisted platform.
- Strategy development
- C#, IDE, and AI
- Research
- Backtests and analysis
- Trading
- Paper and live
- Monitoring and control
- Desktop, web, and IDE
One platform for the complete strategy lifecycle
Move from a trading concept to research, execution, and ongoing analysis without assembling separate tools.
-
Develop and research strategies
Write SmartQuant C# strategies directly or use OpenQuant and Codex to define, implement, and investigate them.
-
Backtest and understand results
Inspect charts, orders, accounts, logs, and recorded events to understand strategy behavior.
-
Move into paper or live trading
Connect strategies to market data and execution providers through the same SmartQuant platform.
-
Monitor and control strategies
Follow strategy activity, trading results, and applications from desktop, web, or Visual Studio.
A cohesive platform built around events
Market data, execution, account updates, and strategy logic flow through one unified event pipeline that can be recorded, replayed, analyzed, and distributed.
Event-driven core
Unified pipeline for market data, orders, and strategy logic.
- • Full replay capability
- • Works across network boundaries
- • Enables time travel debugging
QuantController hub
Central orchestration server for all SmartQuant applications.
- • Universal registry of apps
- • Centralized monitoring & control
- • Remote strategy deployment
Dependable strategy operation
Architecture designed to keep strategy execution observable and independent.
- • Process isolation per strategy
- • Stateful recovery from logs
- • UI never slows strategy processing
SmartQuant solution components
From AI-assisted strategy development to data distribution, execution, persistent storage, and monitoring, SmartQuant provides a complete end-to-end stack.
SmartQuant Platform
A full-featured, event-driven stack for strategy development, trading, monitoring, and analysis.
- • Strategy SDK + infrastructure for trading operations
- • Persistent event history for replay and analysis
- • Control, transport, storage, execution, observation
OpenQuant
A SmartQuant strategy IDE that uses Codex to turn trading ideas into C# strategies, backtests, and research conclusions.
- • Convert a plain-English concept into a detailed strategy specification
- • Generate and build SmartQuant C# strategy code using dedicated guides and templates
- • Backtest the strategy and let Codex investigate results, explain findings, and suggest improvements
QuantRouter
Routes market data, orders, commands, and messages between trading strategies, data providers, brokers, and SmartQuant applications.
- • Distribute market data and subscriptions
- • Route orders and execution reports
- • Deliver commands and generic messages
QuantBase
Persistent event logs for replay, auditing, analysis, and recovery.
- • Post-run diagnostics
- • Compliance audit trails
- • Stateful recovery
QuantController
Unified control plane that connects your trading world.
- • Universal registry
- • Centralized management
- • Multi-client access
QuantWeb
Modern Blazor web UI for monitoring and control from anywhere.
- • Browser access
- • Real-time dashboards
- • Operate on any device
QuantMonitor
Full-featured Windows desktop monitoring with charting and dashboards.
- • Real-time charting
- • Order management
- • Multi-strategy view
QuantVsix
IDE integration to debug, monitor, and control without leaving Visual Studio.
- • Integrated workflow
- • Fast iteration
- • Production visibility
QuantLauncher
Remote lifecycle management for SmartQuant applications and strategies.
- • Start/stop strategies and services
- • Manage multiple instances and configurations
- • Track status and process lifecycle
QuantMCP
MCP server that exposes SmartQuant infrastructure, data, and logs to AI agents.
- • Standard tool interface for AI assistants
- • Data and state inspection
- • Integrates with Copilot and other MCP clients
Key differentiators
SmartQuant combines strategy development and research with the infrastructure needed to run, inspect, and control trading strategies.
| Capability | SmartQuant | Traditional platforms |
|---|---|---|
| Strategy isolation and fault containment | Each strategy is a standalone .NET application (separate process), so crashes and leaks are isolated per strategy instance | Often a single host process with many strategies/plugins, so failures can cascade across the system |
| Event-first architecture | Market/trading/account/log events are first-class, flow through the infrastructure, are stored, and can be replayed | Event handling is commonly ad-hoc, with limited or fragmented persistence |
| Full history persistence and replay | Records complete history of strategies, infrastructure, trading activity, and logs; supports reproducibility and “time-travel” debugging | Limited retention, partial logs, or no consistent replay path |
| State recovery from recorded events | Infrastructure is designed so state can be rebuilt from stored event history (operational recovery becomes deterministic) | Recovery often means manual reconciliation and guesswork from partial logs |
| Clear separation of roles (control/transport/storage/execution/observation/AI) | Dedicated components per role: QuantController (control), QuantRouter (transport), QuantBase (storage), QuantLauncher (execution), QuantMonitor/QuantWeb/VSIX (observation), QuantMCP (AI interface) | Responsibilities are frequently blended into a monolith, making scaling and operations harder |
| Central control plane for a distributed stack | QuantController provides a universal registry, real-time monitoring view, and event/command routing between apps and clients | Decentralized management; point-to-point wiring and brittle operational procedures |
| Transport layer with fan-out and subscription control | QuantRouter centralizes subscriptions, replicates streams, routes by instrument, and supports multi-client distributed setups | Each consumer often connects directly to providers; duplication of connections and inconsistent routing |
| Configuration-driven multi-instance execution (AppKey) | Same executable can run simultaneously with multiple appsettings; operators can clone/edit settings and run without rebuilding | Multi-instance setups usually require rebuilds, manual copies, or bespoke orchestration |
| Remote lifecycle and config operations | QuantLauncher builds an app catalog from a repository, starts/stops processes remotely, manages and copies settings, and persists state across restarts | Manual SSH/RDP/service scripts; configuration drift and inconsistent instance management |
| Multi-client operational UX (desktop + web + IDE) | QuantMonitor (desktop), QuantWeb (browser), QuantVSIX (inside Visual Studio) all connect to QuantController for a consistent system view | Usually a single UI surface; switching contexts is expensive and remote ops are limited |
| IDE-native observability and faster dev loop | QuantVSIX embeds monitoring in Visual Studio and routes strategy output into the IDE Output window (usable by Copilot workflows) | Debugging and operations typically happen outside the IDE with slow context switching |
| AI-assisted strategy development with full user control | OpenQuant helps define trading rules, generate and build SmartQuant C# code, investigate backtest results, compare strategy versions, and move the strategy into operation | AI assistance is often limited to code generation or chat, leaving strategy definition, research evidence, decisions, and operation disconnected |
| Built-in AI agent interface (MCP) | QuantMCP exposes infrastructure, data, and logs via standard MCP tools; supports Copilot/ChatGPT-style agent loops (inspect - analyze - act) | AI integration is usually external, custom, or limited to "chat over docs" |
| Cross-platform operations story | Explicit Windows + Linux server components and a web UI path (QuantWeb) for Linux-first teams | Often platform-locked (or "runs" cross-platform but operational tooling is not) |
Build and operate with SmartQuant
See how SmartQuant's event-driven platform supports strategy development, research, execution, monitoring, and control, with AI assistance through OpenQuant and QuantMCP.