Not a chat window bolted onto a cloud API. The analyst is a local GGUF model: weights on your disk, inference on your hardware. It reads the tape, signals, and flow the terminal just computed and writes a desk note in which every claim traces to a real number. When it doesn't have the data, it says so and abstains.
No. The difference is architectural, not a policy promise.
Cloud chatbots put your positions, sizes, and thesis into a prompt and send it to someone else's server, where a model you don't control generates confident prose whether or not the numbers behind it exist. QuantSuite inverts both halves: inference happens on your machine (there is no QuantSuite inference server to send anything to), and output is grounded: the model writes from a context of real values the terminal just computed, and abstains rather than invent a figure it wasn't given.
| Typical cloud chatbot | QuantSuite analyst | |
|---|---|---|
| Where inference runs | Provider's servers | Your GPU / CPU |
| Where your positions go | Into the prompt, off your machine | Nowhere — they never leave the box |
| Claims cite a source | Optional, often invented | Required — cite a real number or abstain |
| When data is missing | Fills the gap plausibly | Says "I don't have that" |
| Per-query cost | Metered tokens | Your electricity |
"Typical cloud chatbot" describes the general architecture of hosted conversational AI services, not any specific product. Offerings vary; verify any provider's data handling independently.
The terminal assembles what it just computed: price and volume action, the multi-horizon brain's signals and confidence bands, options flow, and dark-pool prints. Actual numbers with sources. The model is never asked to "know" the market from its training data.
A Qwen-class open-weight model in GGUF format runs via llama.cpp on your own hardware. The weights sit on your disk; you can swap models from the built-in manager. No API key to an AI vendor, no round-trip, no prompt logging anywhere but your machine.
The output is a short desk note and a vote with a rationale. The grounding rule is strict: every quantitative claim must cite a value present in the context it was given. If the context doesn't contain it, the model abstains on that point instead of improvising.
Prompts, positions, and market context are assembled and inferred on-device. There is no QuantSuite cloud that could hold a copy of your book, because none of this ever transits a QuantSuite server.
The analyst reports nothing back to us — no usage analytics, no prompt samples, no "quality improvement" pipeline. If our servers went dark, your analyst keeps working.
Market data is pulled with your own provider keys, which live in local configuration on your disk. Your machine talks directly to your providers; we never receive, proxy, or store your keys or your data.
The full local-first architecture — what the app touches, what the commerce site stores, and what we have and haven't audited — is laid out on the Security & Trust page.
A small local model is genuinely good at some jobs and genuinely bad at others. We built around that instead of pretending otherwise.
The analyst’s seat in the bot ensemble is earned, never granted: its weight is measured against resolved outcomes, and while it fails to beat the base rate that weight is zero and its ballot moves nothing. Measured on 2026-09-05 over 200 resolved votes: weight 0.00 (Brier 0.2364 against a base rate of 0.2379). Today it is a reasoner whose votes are recorded and scored, not a voter with influence. It reasons over supplied context well; that's the job it's given, and the only one.
It never writes or edits strategy code, and no generated code is ever executed. Strategies are authored by you and run in the sandboxed backtester. An LLM that rewires your trading logic is a hazard, not a feature.
Small local models are unreliable at filling large structured outputs — so we never ask for one. The model handles a vote, a confidence, a rationale; structured plumbing stays deterministic. If the model fails or its output can't be parsed, a deterministic fallback takes over. Nothing critical depends on it behaving.
When its calls resolve against real outcomes, its errors are mined for patterns and its influence in the ensemble is re-weighted accordingly. That is the entire self-improvement loop: evidence in, weight adjusted. It does not generate code, grow new abilities, or modify the platform.
Grounding stops fabricated numbers; it does not make the reasoning correct. A cited, sourced desk note can still draw the wrong conclusion. Treat it as one input from a junior analyst who shows their work — not a signal to follow blindly.
The analyst makes no return predictions and we make none for it. It exists to keep your reasoning honest and grounded — whether the resulting trades make money is exactly the question the rest of the platform refuses to answer dishonestly.
A desk note is a few grounded paragraphs plus a vote, not an essay. Two things to notice: every figure names its source, and when the model lacks data for a claim, it abstains on that point instead of filling the gap.
The example is hand-written to show the format. It is not output from a live account, and none of its figures are real market data or a recommendation.
Off-exchange share printed 43.1% of weekly volume vs a 12-week mean of 31.4% — z ≈ +2.1 [FINRA ATS · most recent weekly file].
Short-horizon brain signal +0.34 with a wide conformal band [−0.18, +0.71] — conviction is limited [brain.short_horizon].
Options flow leans to calls: call/put premium 1.8× [chain · 14:32 ET · 6 min old].
No borrow-cost data in context, so I won't speculate on squeeze mechanics — abstaining on that point.
There's no cloud bill because there's no cloud. The only question is how quickly your own hardware turns a context into a note.
Any reasonably modern x64 machine can run the analyst with no GPU at all. Votes and notes take on the order of tens of seconds each: fine for swing-horizon work and desk notes you read, slow if you want a vote on every scan.
A consumer NVIDIA card with around 8 GB of VRAM is enough to move inference onto the GPU, taking a vote from tens of seconds down to a few seconds. No datacenter card required, and no per-token meter running either way.
Local weights, grounded claims, honest abstention, bounded influence. The way a junior analyst should behave, in software that never phones home.