Everything between first launch
and reading a deflated Sharpe.

Install & activate

QuantSuite Pro installs as a native Windows application and runs as a local web terminal: the engine serves the interface to your browser from your own machine. There is nothing to pip install and no Python to set up — the installer bundles its own runtime.

1. Download the installer from the Download page and run QuantSuite-Setup.exe. Builds are not yet code-signed, so Windows SmartScreen will warn on first run — choose More info → Run anyway. (Code signing is planned; we'd rather tell you that than pretend.)
2. Complete the wizard. The default install location works for most users; the app writes all of your data to your per-user folder (%LOCALAPPDATA%\QuantSuite), never to the install directory.
3. Launch and activate. On first launch you'll be asked for your license key — the HMAC-signed key emailed to you after purchase. Paste it into the activation screen. Activation is offline: the key is verified on your machine, no account-server call required.
4. You're in. The app opens pre-loaded with a shipped, read-only baseline of trained state so it's useful from the first second — not an empty shell.

Your first run

Give the terminal a minute on first launch — it fetches live quotes and builds every tab. A few things to do right away:

• Follow the Setup Wizard. On a fresh install it opens automatically: for each provider it shows exactly where to get the key (with a one-click portal link), you paste it, and Test & Save verifies it against the live API. Everything is optional — Yahoo Finance works with no key at all. Re-run it anytime from Settings.
• Manage your providers in Data Center and Settings. Alpaca (paper) and Finnhub are the two that unlock the most; both have free tiers.
• Walk the core workflow — data keys, the dashboard, the brain, the bot, backtesting, risk, and the Control Tower. The Setup Guide screen covers the same ground in the terminal.
• Set your default symbol in Settings so the terminal opens on the ticker you watch.
• Skim the Dashboard — indices, MAG7, commodities, bonds, crypto, forex and world markets are all one click apart along the top strip.

Web terminal

The web terminal is the app: launching QuantSuite starts the engine on your machine and opens the terminal in your browser. A native desktop window that wraps the same terminal is built but not yet in the installer; the earlier Tkinter desktop app no longer ships.

• Activation. Paste your HMAC-signed key once into the first-run license dialog — it's verified offline.
• Open in your browser. The web terminal serves at 127.0.0.1:8000 (local-only; nothing leaves your machine).
• Provider keys. Add your data keys under Settings → API Keys, then use Test connections to verify each one against its live API.

The module map

Eight modules group every screen — the same grouping as the terminal's left rail, so the map you read here is the map you will navigate. Each entry names what the module is for, every screen in it, what it needs to be useful, and what it honestly shows when that is missing. The same content ships in-app as the searchable Setup Guide.

Terminal

The what-is-the-market-doing-now board. Multi-asset price strips (indices, Mag 7, commodities, bonds, crypto, forex, world), an editable watchlist, movers, sectors, an economic calendar, candlestick charts with indicators, a screener with a treemap, a market-breadth engine that grades its own coverage, and a notify-only rule alert engine.

DashboardScreenerChartsMarket BreadthAlerts

• Requires: Nothing. The quote and bar cascade is Alpaca then Finnhub then yfinance, and yfinance is keyless, so an unkeyed install still gets prices, charts and the screener. Watchlist add and remove write to your config.
• When missing: Nothing goes blank without keys — the freshness dot turns grey or amber instead of green, and a failed fetch renders an em-dash rather than a fabricated 0.00. Market Breadth can still refuse on its own coverage floor, independent of keys.

Options & Flow

Chain work. Read a real chain with per-row quote age, build multi-leg strategies priced off live two-sided quotes, see dealer gamma exposure, scan roughly 64 options-liquid names for unusual activity with a calibrated (or explicitly uncalibrated) p_event, work the same-day expiry on a dedicated 0DTE board (chain slice, single-expiry dealer map and today-expiry prints for one underlying), and run an options paper lane with take-profit, stop-loss and trailing exits.

Options LabFlow ScannerGEX Analysis0DTEOptions Bot

• Requires: Keyless-capable: the chain cascade is yfinance (free NBBO and IV, no greeks), then Alpaca OPRA snapshots (Alpaca keys), then Tradier (Tradier token, greeks via ORATS). Alpaca keys promote you to the merged fresh-quote tier where quote ages are seconds instead of hours.
• When missing: The chain still loads, but the staleness gate bites and the strategy builder refuses leg by leg rather than pricing off a last print. Alpaca or Tradier keys are what move a new install past that gate.

Quant & Strategies

Where a strategy earns the right to be believed: a strategy registry, tearsheet, equity and drawdown backtests, walk-forward, paired A/B experiments with HAC (Newey-West) inference, Monte Carlo, correlation, cross-strategy performance, pairs trading, Pine or Python export of a scaffold, and a Validation Center that walks the deflation gates in order — the trial ledger behind N, then raw SR, PSR, MinTRL and DSR(N) — on your own numbers.

StrategiesStrategy RegistryTearsheetEquity CurveDrawdownWalk-ForwardExperimentsValidation CenterMonte CarloCorrelationPerformancePairs TradingPine Script exportPython export

• Requires: No API keys — backtests run on yfinance history. What this module needs is history and trials, not credentials. A longer default chart period gets the MinTRL gate open sooner.
• When missing: Short series refuse rather than plot, Experiments refuses below 20 paired days and fabricates no p-value, and every Sharpe is subject to the track-record gate.

Portfolio & Risk

Position-level book management and the risk kernel: holdings with institutional metrics (CVaR, HHI), mean-variance, Black-Litterman and ERC optimization, VaR, ES and Cornish-Fisher, a Basel-zone backtest exception rate, historical and option-aware stress scenarios, benchmark parity, per-trade analysis, transaction-cost attribution, and a microstructure lab for the spread, tick-size and outlier structure of one symbol plus its leakage audit.

PortfolioPortfolio OptimizerRisk EngineStress TesterBenchmarkTrade AnalyzerTCA & AttributionMicrostructure LabExecution Algos

• Requires: The risk math is local and keyless. Broker-synced holdings need Alpaca keys; otherwise the portfolio is whatever your config file holds (the web Settings screen shows it read-only).
• When missing: Rows with insufficient history render n/a, explicitly never 0.0%. Portfolio refuses outright rather than average one priced holding, and a window with too few resolved observations says so instead of printing zeros.

Execution & Prop

Running bots and watching them: pre-trade confirm and preview against the risk kernel, the equities Algo Bot paper loop, the TPT prop-firm dashboard, the futures brain scanner, the Control Tower (killed / lockout / section-health board), and Slide Doctrine sessions.

Trade ConfirmAlgo BotTPT DashboardFutures BrainControl TowerSlide Doctrine

• Requires: The paper loop runs keyless on cascade quotes. Alpaca paper keys give better fills and quotes plus a real broker portfolio read. There is no live-order path in the web client at all — the only modes are signal_only and paper.
• When missing: Performance refuses until there are enough closed trades. Control Tower sections degrade one at a time, each showing its own reason. A stopped bot shows an em-dash for equity with the sub-label 'bot stopped' rather than a stale number.

Research & Alt Data

The filing and alt-data desk: 13F fund books, SEC filings with quarter-over-quarter change, an Insider Desk over real Form 3/4/5 with a dropped-rows tray, FINRA dark-pool data (ATS weekly and TRF daily kept strictly separate), earnings, an event-study browser that answers 'last time this happened' as a measured distribution with N beside every statistic, supply-chain tier-N maps with HHI and geographic concentration, a news feed, and PDF report generation.

13F HoldingsSEC FilingsInsider DeskDark PoolEarningsEvent StudiesSupply ChainNews CenterReport MakerPersona Reports

• Requires: SEC EDGAR (13F, filings, insiders) is keyless. The FINRA TRF daily off-exchange proxy is keyless at T+1. News works keyless via yfinance; Finnhub adds company and market news. Per-venue ATS dark-pool volume needs free FINRA developer credentials. Supply-chain node enrichment uses Financial Modeling Prep.
• When missing: Insider Desk is the sharpest case: with no ingest run the store does not exist and every view reports the typed state never_ingested rather than an empty table. Dark Pool without FINRA credentials falls back to the keyless TRF proxy and says so — it never blends the two series.

AI / Brain

The model layer, all of it gated: a unified neural signal with a champion gate and calibration, ML feature predictions with a backtest, the multi-agent trading brain signal, the on-device LLM analyst that cites sources and abstains, a morning brief assembled only from this platform's own producers (regime, dealer positioning, breadth, the risk kernel, yesterday's flow tide) whose LLM prose appears only if it survives the no-invention gate, regime detection, a knowledge store, an LLM monitor, a read-only Model Lab scoreboard of local-model gate verdicts and trends (activation stays on Settings), and an Edge Report that turns the same deflation machinery on a track record you supply — raw SR, PSR, DSR against the number of variants you declare having tried, and a signed verdict that says where the edge stops surviving, and a Refusal Ledger listing every model this platform trained with the verdict it got and the reason it was refused — overwhelmingly refused, with the deflated numbers behind each verdict and the counts computed live from the registry rather than quoted here, because the weekly retrain appends to it.

Neural AnalysisBrain LabML PredictionsTrading BrainAI Analyst (LLM)Morning BriefEdge ReportRefusal LedgerSenate (model ensemble)Regime DetectKnowledge StoreLLM MonitorModel LabDoctrine

• Requires: Everything runs on-device. The analyst is llama-cpp plus a local GGUF model file; no prompt is ever sent to a cloud model. Optional: a NewsAPI key feeds the brain's news-sentiment feature and an FMP key feeds fundamentals features.
• When missing: With no model file loaded the analyst reports itself offline or abstained and fabricates no analysis. The AI seat badge reads SEAT UNEARNED and the confidence gauge draws a hollow dashed grey ring with an em-dash instead of a number. Neural Analysis is a separate subsystem: the TNN registry ships with the install, so its panel shows the one promoted champion and its gate record — with the edge gauge hollow, because the deflated Sharpe bar has never been cleared.

System

Setup and self-inspection: the Data Center SQLite console, live provider health with a manual authentication probe, session and license state, Settings (API keys, preferences, risk defaults, local AI models), and an append-only secret-scrubbed history of every config change with two-click restore.

Data CenterProvider HealthAccount & SessionSettingsVersion History

• Requires: Works offline. Provider Health's probe makes real network round-trips (roughly 8 seconds per provider) only when you press Test connections; the cascade counters beside it are local process counters.
• When missing: A Provider Health section that cannot be built reports its reason instead of zeros, and source cards read 'no requests recorded yet'. If the prober itself fails it says so and invites a retry rather than inventing a result.

The top strip is always-live market data; the Dashboard's status strip shows session, regime and live risk (VaR / drawdown / Sortino).

Five flows, step by step

Five journeys end to end. Each step is one action and the one thing you should see if it worked — so you can tell the difference between a step that did nothing and a step whose result you have not found yet. The same walkthroughs ship in-app under Setup Guide.

Install and activate

Get from a downloaded installer to a running terminal. about 5 minutes

1. Run the installer and launch QuantSuite from the Start menu.
   The terminal opens on the activation screen — not the dashboard. Nothing is unlocked yet.
2. Open your purchase email and copy the licence key. It is one unbroken line, roughly 126 characters.
   Your mail client may show it wrapped across two or three lines. Copy all of it anyway.
3. Paste the key into the activation box and confirm.
   The terminal unlocks and the dashboard loads. Activation is checked on this machine — it does not phone home.
4. If it refuses instead, read the sentence it printed rather than retyping the key.
   One of five specific sentences, each naming a different cause. 'Not a typo' means exactly that — retyping cannot fix a signature mismatch.
5. Open Account & Session and read its License panel.
   Your plan and expiry, read from the key itself, plus the signing fingerprint this build carries. A refused key shows the same sentence the activation screen printed, so you never have to guess which of the five it was.

Worth knowing: Line breaks a mail client inserted into the key are stripped for you before it is checked, so a wrapped copy still activates. That cleanup can never make an invalid key pass — the signature still has to match.

Connect your data

Move from the keyless tier to live, fresh quotes. about 10 minutes, most of it on the providers' own sites

1. Open the terminal before entering any key at all.
   Prices, charts and the screener already work. The keyless tier is real, not a demo — yfinance needs no credentials.
2. Open Settings and find the API keys section.
   One row per provider, each naming what it unlocks.
3. Paste a key and save it.
   The key is stored on this machine only. It is never sent anywhere except to the provider it belongs to.
4. Press Test connections.
   A real authenticated round-trip per provider — roughly 8 seconds each, so give it a moment. The result is the provider's actual answer, not a format check.
5. Open Provider Health to see the standing picture.
   Per-provider status and the local cascade counters. A section that cannot be built states its reason instead of showing zeros.

Worth knowing: Adding Alpaca keys is what moves options chains past the staleness gate: quote ages go from hours to seconds. Without them the chain still loads, and the strategy builder refuses leg by leg rather than pricing off a stale last print.

Run a backtest and read the number

Get a performance figure you can actually defend. about 10 minutes

1. Open Strategies and pick one to test.
   Each strategy states what it trades and on what timeframe.
2. Run it, then open the Tearsheet.
   The performance block leads with raw SR, then PSR, then DSR with its trial count N in brackets.
3. Read the three numbers as one sentence, not three.
   Raw SR is what the curve did. PSR is the chance it beats zero. DSR is what survives after correcting for how many strategies were tried to find it.
4. If a figure is withheld instead, read the reason.
   A named refusal — usually too short a track record for the gate to say anything honest. That is the gate working, not a failure.
5. Open Validation Center to walk the gates in order on your own numbers.
   The trial ledger behind N, then raw SR, PSR, MinTRL and DSR(N), each with its own verdict.

Worth knowing: A high raw Sharpe with a low DSR is the normal result, not a bug. It is the platform telling you the number came from searching rather than from an edge — which is exactly the thing most tools hide.

Start the paper bot — and stop it

Run the automated lane, and know exactly how to halt it. about 10 minutes

1. Open Algo Bot and review the configuration before starting anything.
   Mode is signal_only or paper. There is no live-order mode in this product — the option does not exist to be clicked by accident.
2. Set your stop, target and trailing rules, then start the lane.
   The decisions feed begins filling: one row per scan, including the ones where it decided not to trade, with the reason.
3. Let a position open and watch the fill.
   The fill pays a modelled half-spread rather than the mid price, so the P&L is not flattered by a fill nobody would get.
4. Now engage the kill switch from Control Tower.
   New entries stop across all three lanes — equity, futures and options — each refusal named in the feed.
5. Watch your open position while the switch is on.
   Stops, targets and trailing exits still run. The switch stops new risk; it never freezes the exits that reduce it.
6. Clear the switch when you want entries back.
   It is one-way by design: nothing re-arms it automatically, so it takes an operator to resume.

Worth knowing: Every fill here lands in a paper ledger kept separate from the desktop trade history, on purpose: simulated results can never leak into the statistics the models are graded on.

Check what the model actually claims

Find out how much the AI is really asserting before you lean on it. about 5 minutes

1. Open Neural Analysis and enter a ticker.
   A directional call with its confidence — and a confidence gauge drawn hollow, with a dash where a number would be.
2. Read the line under the gauge before the call above it.
   It states that no promoted champion has cleared the deflated Sharpe gate, so the gauge will not draw a confident arc for an edge that has not been proven.
3. Scroll to the TNN registry panel.
   The one promoted champion, its balanced accuracy, and the gate record behind the promotion.
4. Open the promotion history beneath it.
   Every attempt, promoted or rejected, with the reason. One promotion, dozens of refusals.
5. Cross-check in Validation Center.
   The same gates applied step by step, so the verdict is reproducible rather than asserted.

Worth knowing: Promotion and proven edge are two different bars. This model cleared the first — it beat its challengers on balanced accuracy — and not the second. Both facts are on the screen at the same time, on purpose.

Your platform, honestly

What you get on your machine, stated before you buy - including what is missing. Every row is the current state of this build, not a roadmap.

Windows 10/11 (x64) supported

• How you get it: Installer (.exe) - not yet code-signed, so SmartScreen warns on first run; Start-menu entry, per-user install
• Interfaces: The web terminal, served locally by the engine and opened in your browser — this is the app. A native desktop window that wraps the same terminal is built but not yet bundled.
• On-device AI: GPU-accelerated when a CUDA card is present; CPU otherwise
• Where your keys live: Brokerage-link secrets: Windows Credential Manager, with an encrypted 0600 file fallback. Provider API keys: written to a gitignored .env on this machine, plain text unless you run scripts/maintenance/encrypt_dotenv.py (Windows DPAPI).
• Worth knowing: None. This is the reference platform and the most tested.

macOS (Apple silicon and Intel) not yet signed

• How you get it: Disk image (.dmg)
• Interfaces: The web terminal, served locally by the engine and opened in your browser — this is the app. A native desktop window that wraps the same terminal is built but not yet bundled.
• On-device AI: CPU / Metal via llama-cpp. No CUDA on any Mac.
• Where your keys live: Brokerage-link secrets: the macOS Keychain, with an encrypted 0600 file fallback. Provider API keys: written to a gitignored .env on this machine in plain text — scripts/maintenance/encrypt_dotenv.py is Windows DPAPI only and refuses here, so file permissions are the protection.
• Worth knowing: The .dmg is NOT yet signed or notarized, so macOS refuses to open it and reports that the app is damaged. Until that is in place, the supported way to run on a Mac is the container lane below. This is a certificate we do not have yet, not a defect in the build.

Linux (x86_64) supported

• How you get it: Tarball (.tar.gz) and AppImage
• Interfaces: The web terminal, served locally — runs headless; no display toolkit is required
• On-device AI: GPU-accelerated when a CUDA card and driver are present
• Where your keys live: Brokerage-link secrets: Secret Service (GNOME Keyring / KWallet) where a session bus exists; a headless box has none and falls back to the encrypted 0600 file, which the app says out loud. Provider API keys: written to a gitignored .env on this machine in plain text — scripts/maintenance/encrypt_dotenv.py is Windows DPAPI only and refuses here.
• Worth knowing: Desktop-environment integration (file associations, menu entries) is not installed for you outside the AppImage.

Container (Docker) web terminal only

• How you get it: Dockerfile in the repository; one image, one port
• Interfaces: The web terminal — the same single interface as every platform, on the container's one port
• On-device AI: CPU by default; GPU only with an explicit NVIDIA runtime
• Where your keys live: Brokerage-link secrets: whatever the host provides — no OS keyring inside the container, so the encrypted file fallback is the normal path. Provider API keys: written to a gitignored .env on the container's filesystem, in plain text.
• Worth knowing: This is the supported way to run on a Mac until the signed .dmg ships. It is a real lane, built and health-checked in CI on every release.

Markets & Dashboard

The Dashboard top strip cycles through INDICES, MAG7, COMMODITIES, BONDS, CRYPTO, FOREX and WORLD. Index cards are honestly labeled with the ETF they price (NASDAQ · QQQ) and world cards with their major index (GERMANY · DAX). Outside regular hours, US-equity cards show the after-hours price tagged · AH; if there's no extended tape, they honestly show the last close.

• Screener screens any ticker list you give it on live technicals — RSI, trend, signal — with sortable columns and double-click straight into Charts. (The named universes — DIVERSIFIED to BROAD, crypto/forex/world — belong to the Algo Bot scanner.)
• Charts gives interactive candlesticks with indicator overlays and TradingView deep-links for anything it doesn't draw natively.
• No fabricated quotes: a card that missed its fetch cycle says stale rather than inventing a number.

Algo Bot

The Algo Bot is the autonomous engine. It scans a universe, blends an ensemble of technical, smart-money, ML and (optionally) on-device-LLM signals into a consensus, and — when you enable execution — routes paper trades through Alpaca.

• Universe: pick from DIVERSIFIED, MARKET_150, BROAD (183 names), plus CRYPTO / FOREX / world-ETF sets. Scanning is parallelized, so a 150-name scan finishes in seconds.
• The evidence gate: the bot will not auto-trade a symbol that hasn't demonstrated an edge. Every candidate is backtested to its maximum honest depth and must clear a deflated-Sharpe bar (see the honesty model). A thin-but-real edge can still trade at half size on pooled evidence; a net-losing symbol is blocked.
• Dual-lane: a swing lane and an intraday lane run concurrently — the intraday lane trades regular hours only and flattens at the close, and each lane owns its own exits.
• Paper shorting is enabled by default on paper accounts; live trading, shorting included, is not part of this version.

Backtesting & Experiments

The Backtesting tab is the equity strategy backtester: pick a preset strategy or write your own (a Pine-script subset or restricted Python, both sandboxed), choose ticker / period / capital, and get a leak-safe walk-forward result — with the raw SR | PSR | DSR(N) triplet on every performance figure.

The tastytrade-grade mechanical options backtester lives on the Options Bot tab, next to the recommendations it validates:

• Custom window (start/end dates), target DTE, entry cadence.
• Mechanical exits: take-profit % of premium, stop as a multiple of premium, manage-at-DTE, or a fixed hold — plus a max-open-trades cap.
• tastytrade metrics: occurrences, POP, P50, average days-in-trade, CVaR, total P/L, return on used capital, and a buy & hold comparison over the same window.
• Honest IV: options IV through time is a clearly-labeled trailing-realized-vol proxy (no historical option chains are stored), so results are honest rather than flattering.

The Quant Platform → Experiments lab runs true A/B tests: two strategy arms on the same tape, compared with a paired t-test — a real p-value, "significant" only below 0.05. Monte Carlo simulates path distributions and Correlation maps cross-asset structure over your chosen window.

Options suite

Portfolio & Pairs

The Portfolio tab is institutional-grade risk. Add your holdings and Analyze for:

• Return-based risk: annualized return & vol, Sharpe (with the triplet), Sortino, Calmar, Beta, Alpha, max drawdown.
• Tail risk: VaR and CVaR / Expected Shortfall (the coherent tail measure).
• Concentration: effective number of names, top-position weight (flagged when heavy), a diversification ratio.
• Risk budgeting: each holding's share of portfolio risk vs its weight — the "where your risk actually lives" decomposition. A hedge shows negative contribution.
• Rebalance drift toward an HRP risk-parity target.

Pairs Trading researches co-moving pairs — spread construction and mean-reversion diagnostics on real price history.

Neural AI & the local LLM

The AI Analyst (LLM) runs an on-device model (Qwen3-4B by default) that stands for one seat in the ensemble — with a veto, and a 5% floor that applies only while it is UNPROVEN — and writes grounded analysis. It cannot cite a number that isn't in its evidence: ungrounded figures are hard-rejected. Its weight is earned — measured against realized outcomes, it can climb toward the neural tier or fall below the floor if it's wrong.

• Model manager: models install as GGUF files into a local registry; you can switch or roll back at any time, and a larger opt-in tier exists for stronger GPUs. The bundled Local AI Models guide covers install, activation and rollback step by step.
• No model, no theater: with no model installed the LLM seat abstains and every AI surface says so — nothing pretends to think.
• The deeper stack: Neural Analysis, ML Predictions, Regime Detect and Trading Brain expose the transformer and classical-ML models. Nothing here is promoted to a "champion" without clearing the promotion gate — and promotion is a separate, weaker bar than a proven deflated edge, which no model here has cleared.

News & X Intelligence

X (Twitter) is a first-class intel source. Open News Center and find the Catalyst Radar card: click ⚡ Connect X, paste your X bearer token, and it saves + verifies in one step — no config-file editing. (The token also appears as a key row in API Connect if you prefer managing it there.)

• Watched profiles: the ⚙ Profiles dialog lets you choose which handles to follow, map each to the tickers it moves, set a category (wire / official / analyst / insider / whale / macro) and a weight, and tune X's share of your social-sentiment blend.
• Sentiment: a transparent, auditable lexical scorer — the numbers are deterministic, never an LLM guess. Each post is tagged ▲/▼ and rolled up into per-ticker, X-weighted sentiment.
• AI digest: the on-device model writes a short desk brief; with no model installed it falls back to a deterministic top-lines summary — it never invents catalysts.
• News Center itself aggregates dated headlines per symbol alongside the radar — one tab for the whole information edge.

Research: 13F to Supply Chain

Prop Firm: the futures desk

The PROP FIRM family is for traders running (or preparing for) a funded-account evaluation. TPT Dashboard tracks the evaluation bot's session — P&L against daily-loss and trailing-drawdown limits, prop-firm style. Futures Brain is the futures model cockpit.

The quant desk

The QUANT family is the workbench around every trade decision:

• Quant Platform — the strategy laboratory: build, test and compare strategies, and run the Experiments A/B lab.
• Trade Confirm — a rule-based pre-trade checklist with optional ML confidence. It grades a setup against your rules before you take it, and is explicit that a passing grade is not a guaranteed edge.
• Benchmark — the benchmark engine: compare your strategies and portfolio against index benchmarks across modes.
• Risk Engine — position-level and account-level risk: sizing, exposure, and the kill-switch limits the bot obeys.
• Slide Doctrine — the ML compliance module: audits model-driven trading sessions against a doctrine checklist and grades their compliance. (Live gating belongs to the Risk Engine.)
• Report Maker (REPORTS family) — persona-lens investment research reports (Buffett, Simons, Lynch…) with presentation-ready HTML export. Performance figures in these reports are descriptive and labeled as such — the validated SR | PSR | DSR tearsheets live in the backtesters and the Control Tower.

Control Tower

The Control Tower is the feedback loop's cockpit — the one screen that answers "is any of this actually working?". Every prediction the platform makes (bot signals, options recs, LLM votes) is recorded, resolved against realized prices, and graded. The tower rolls those grades up by scope and shows the raw SR | PSR | DSR (N) triplet for each — the same deflated standard as everywhere else, with the trial count visible.

Expect it to say insufficient or no proven edge early on. That's not a bug; that's the product refusing to flatter you before the evidence exists.

Data Center console

QuantSuite records every prediction it makes and grades it against reality, all in plain SQLite files on your machine — yours to open with any SQLite tool, ever. The Data Center is the read-only database console built into the web terminal (its own family in the sidebar). In a source checkout it can also run as a separate standalone browser app at 127.0.0.1:8001. Use it to:

• Browse every table in every database — the feedback ledger, brain knowledge, trial ledger, trade history.
• Run SELECT-only SQL with tested example queries (writes are blocked at multiple layers).
• See the schema as an ER diagram, run integrity checks, and export any table to CSV / XLSX / Parquet.

The honesty model

This is the product's whole moat. Every performance statistic is shown as the triplet raw SR | PSR | DSR (N) with the trial count N visible. Here's why each stage exists — and what the same track record looks like at each one:

Illustrative example — not measured performance

N counts distinct configurations tried, not re-evaluations of the same one. The feedback loop resolves each prediction on realized price and labels it edge, luck or insufficient.

Multi-asset coverage

Beyond US equities and ETFs, QuantSuite covers crypto (BTC, ETH, SOL…), forex majors (EUR/USD, GBP/USD…), commodity futures (gold, oil, copper…) and world markets (Hong Kong, S. Korea, China, Germany, UK, Japan, India). The dashboard, scanner, backtester and the ML training set all understand these.

Trading routes honestly: crypto paper-trades on Alpaca's paper engine (fractional); forex / futures / indices are simulated in the local paper book (never a fake broker fill); world markets trade via their US-listed ETF proxies — and the dashboard labels every card with the instrument that's actually pricing it.

License & portal

Your customer portal is a magic-link sign-in (no password): enter your purchase email, click the link we send, and you can re-send your key, manage billing, and open support tickets. Billing runs through Stripe; your key is HMAC-signed and verified offline on your machine.

Data & privacy

Your trading data, ledgers, weights and config live only on your machine — QuantSuite has no cloud account holding your positions. The on-device LLM runs locally; nothing you analyze is sent to a third party for inference. See Security & Trust and the Privacy Policy for specifics.

Troubleshooting

• A data strip shows "stale": that's the honest state when a quote fetch missed this cycle — press Refresh. Foreign / forex strips fill in a few seconds.
• The Algo Bot won't trade a symbol: it hasn't cleared the evidence gate — that's by design. Check the Backtesting tab for that name's DSR.
• "No proven edge" everywhere: intended. The platform will only claim an edge it can defend statistically.
• AI features say "no model installed": the LLM ships separately from the installer to keep the download small. Follow the Local AI Models guide to install one; everything else works without it.
• GPU / local-LLM features show a status banner: your build may be the lite edition (no bundled GPU/LLM stack) — everything else works; the deep models degrade gracefully.
• Activation rejected: the app prints one of five exact refusal sentences — find yours in the table below. If the key itself is the problem, re-send it from the portal.

License refusals

The five refusal sentences the license gate can print, and what opens each.

Every surface that reports a license refusal — the desktop lock screen, Settings and the launcher — prints the same sentence for the same cause, so these sentences are exactly what you will see, word for word.

Pasting is deliberately forgiving: whitespace, line breaks and invisible characters are stripped from a pasted key before it is checked, because mail clients hard-wrap a long key mid-string. That cleanup can never make an invalid key pass — the signature still has to match.

FAQ

Deep-dive guides

Four focused manuals — the same files that ship in the installer under docs/user/. (They open as plain-text Markdown.)