SmartQuant Platform

SmartQuant Platform Architecture

The platform is structured as a set of coordinated layers, each responsible for a specific role:

• QuantController - lifecycle management of applications and strategies, the central control point of the infrastructure.
• QuantRouter - transport and routing of market data and trading events between system components.
• QuantBase - persistent storage of events and objects, the history of strategies and infrastructure.
• Strategy SDK (SmartQuant.dll, SmartQuant.Trading.dll) - the layer for strategy development in C#/.NET 10.
• QuantLauncher - controlled strategy execution from a repository, allowing the same strategy to run with multiple settings.
• QuantMonitor, QuantWeb, QuantVSIX - monitoring and development tools (desktop, web, IDE).
• QuantMCP - the AI interface of the platform for MCP clients and AI agents.

This structure allows the platform to support both local development environments and distributed server infrastructures.

Core Principles of the Platform

Strategy SDK and Strategy Development

SmartQuant Platform includes core libraries for developing trading strategies in C#/.NET: SmartQuant.dll and SmartQuant.Trading.dll.

A strategy in SmartQuant is not a script or a plugin. It is a standalone .NET application (exe): a regular C# net10.0 project that uses SmartQuant libraries and runs as an independent process inside the infrastructure.

The typical development model:

• • a strategy inherits from the base classes Strategy or InstrumentStrategy;
• • the strategy works in an event-driven model and reacts to market and trading events (bars and ticks, executions, order and account changes, custom and system events);
• • the strategy is configured through appsettings.json;
• • the infrastructure supports the concept of AppKey = AppName + AppSettings, allowing the same strategy to run with different parameter sets.

Strategies can be launched:

• • directly from Visual Studio for development and debugging;
• • through QuantLauncher from the strategy repository for managed execution in the infrastructure.

Strategy logs and events are visible in QuantMonitor and QuantWeb and are stored in QuantBase for analysis and replay.

Configuration-Driven Strategy Execution (AppSettings & AppKey)

In SmartQuant, a strategy does not need to be recompiled to trade new instruments or use new parameters.

All runtime behavior is defined in appsettings.json.

A developer builds the strategy once and publishes the binary to the strategy repository. From that point on, an operator can configure, copy, edit, and launch multiple instances of the same strategy with different settings directly from QuantMonitor / QuantLauncher, without touching the code or rebuilding the application.

This is possible because SmartQuant uses the concept:

AppKey = AppName + AppSettings

The same strategy executable can run simultaneously in multiple copies, each with its own configuration file, instruments, and parameters.

This creates a clean separation of responsibilities:

• • the developer writes and compiles the strategy;
• • the operator configures and runs it.

QuantRouter - the Transport Layer of the Platform

QuantRouter serves as the transport layer of SmartQuant Platform. It is a server that routes market data, trading commands, and events between all system components.

Why this matters in real infrastructure:

• a single connection point to providers (broker/exchange connections are established once on the router side);
• fan-out replication of data streams: one incoming market data stream can be delivered to multiple strategies and monitoring tools;
• centralized subscription management: the router knows who is subscribed to what and can optimize external subscriptions;
• decoupling of components: strategies and services act as clients of the event bus and can run in separate processes and on different machines.

QuantRouter enables a true server architecture where strategies, QuantBase, monitoring tools, and other services operate as clients of a unified event bus.

Products Inside the Platform

The key components of the ecosystem:

• • QuantController - management of applications and strategies.
• • QuantRouter - transport of events and commands.
• • QuantBase - storage of events and objects, history of runs and logs.
• • QuantLauncher - strategy execution from a repository with multiple settings.
• • QuantMonitor - desktop monitoring and analysis tool.
• • QuantWeb - web interface for remote access and operational control.
• • QuantVSIX - integration of monitoring and logs into Visual Studio.
• • QuantMCP - access to platform data and infrastructure for AI agents (MCP).

Typical Use Cases