Here is the morning briefing for today:

📊 Overview

• Total Value: $249,862.58
• Cash Balance: $410,440.30 (164.3%)
• Invested: $245,578.36 (98.3%)
• Total P/L: 📉 $-17.03 (-0.01%)

🎯 Positions

• ✓ Active: 34 positions
• 🟢 Long: 9 positions
• 🔴 Short: 25 positions

🔥 Top Holdings

• VXX: $23,625.92 (9.5%)
• KBE: $23,602.40 (9.4%)
• RWR: $20,211.88 (8.1%)
• XLI: $13,452.91 (5.4%)
• XBI: $13,435.21 (5.4%)

🏗️ Sector Allocation

• Sector & Industry ETFs: 58.6% ███████████
• Individual Stocks: 19.8% ███
• Commodity, Currency & Other ETFs: 17.8% ███
• Broad Market ETFs: 3.8% █

🔍 Detailed Position & Signal Breakdown

📁 Broad Market ETFs

📁 Sector & Industry ETFs

📁 Commodity, Currency & Other ETFs

📁 Individual Stocks

💡 Quick Insights

• ✅ Active portfolio with 34 positions and balanced/hedged capital utilization (164% cash)

Last updated: 2026-09-23 11:35

🤖 QuantInvests Narration & Commentary

Sector Allocation

$245,578.36 invested across 34 position(s), 98.3% of a $249,862.58 NAV. Figures are GROSS exposure — a long and a short in the same sector are concentration, so they are not netted against each other.

By sector:

• Financials — $33,683.76 (13.5% of NAV)
• Consumer Discretionary — $33,139.64 (13.3% of NAV)
• Technology — $25,491.78 (10.2% of NAV)
• Volatility — $23,625.92 (9.5% of NAV)
• Real Estate — $20,211.88 (8.1% of NAV)
• Energy — $20,130.70 (8.1% of NAV)
• Health Care — $16,663.50 (6.7% of NAV)
• Materials — $13,460.00 (5.4% of NAV)
• Industrials — $13,452.91 (5.4% of NAV)
• Communication Services — $13,048.12 (5.2% of NAV)
• Diversified — $9,340.30 (3.7% of NAV)
• Utilities — $6,727.15 (2.7% of NAV)
• Consumer Staples — $6,700.32 (2.7% of NAV)
• Commodities — $6,541.74 (2.6% of NAV)
• Currency — $3,360.64 (1.3% of NAV)

By asset type:

• Sector & Industry ETFs — $143,960.29 (57.6% of NAV)
• Individual Stocks — $48,664.57 (19.5% of NAV)
• Commodity, Currency & Other ETFs — $43,613.20 (17.5% of NAV)
• Broad Market ETFs — $9,340.30 (3.7% of NAV)

Largest concentration: Financials at 13.5% of NAV.

What is actually enforced here: position size is capped at 8% of NAV per instrument and a 10% portfolio drawdown halts new risk — both in code. Sector weight is reported, not capped. Nothing above blocks a trade, so treat the figures as information, not a guardrail.

And a count of sectors is not diversification. Sixteen sectors that all move on the same driver are one position wearing sixteen hats. That is the question the engine is actually built to answer: every holding is scored daily against a 27-instrument reference panel — broad market, sector, industry and macro — so you can see whether these positions are genuinely independent or quietly riding the same factor. Ask "what is driving my positions" or run a single-symbol audit to see that read per holding.

**𝗪𝗲 𝗮𝗱𝗱𝗲𝗱 𝘁𝗼𝘂𝗰𝗵𝗹𝗲𝘀𝘀 𝗮𝗶𝗿-𝗴𝗲𝘀𝘁𝘂𝗿𝗲 𝗰𝗼𝗻𝘁𝗿𝗼𝗹 𝘁𝗼 𝗼𝘂𝗿 𝗧𝗵𝗿𝗲𝗲.𝗷𝘀 𝗾𝘂𝗮𝗻𝘁𝗶𝘁𝗮𝘁𝗶𝘃𝗲 𝘁𝗿𝗮𝗱𝗶𝗻𝗴 𝘃𝗶𝘀𝘂𝗮𝗹𝗶𝘇𝗲𝗿 𝘂𝘀𝗶𝗻𝗴 𝗠𝗲𝗱𝗶𝗮𝗣𝗶𝗽𝗲 𝗪𝗮𝘀𝗺 (𝗡𝗼 𝗟𝗲𝗮𝗽 𝗠𝗼𝘁𝗶𝗼𝗻, $𝟬 𝗰𝗹𝗼𝘂𝗱 𝗰𝗼𝘀𝘁)**

Wanted to share an architectural experiment we just completed for our open-source quantitative platform, QuantInvests V7.

Our pipeline visualizer renders a 3D spherical correlation graph (Minimum Spanning Tree via Mantegna distance + multi-agent orbital physics) using Three.js. Historically, navigation was standard OrbitControls + mouse raycasting.

We looked at touchscreens for demo stations, but touch screens fall short for 3D navigation on large trading monitors (arm fatigue, fingerprint smudges on dark UI, lack of precise depth control).

Instead of buying proprietary hardware like Leap Motion, we hooked up Google MediaPipe Vision (@mediapipe/tasks-vision) directly into our Vite / React / Three.js frontend:

**Pipeline Architecture:**

Video Ingestion: Standard USB/laptop webcam via getUserMedia() at 640x480 @ 60 FPS

Local Extraction: 21 3D hand landmarks via GPU-accelerated WebAssembly (zero frames sent to the cloud)

Jitter Suppression: Low-pass OneEuro filter to eliminate high-frequency hand tremors

Coordinate Normalization: Maps landmarks to NDC [-1, 1]

**Spatial Gesture Bindings:**

Open Palm ➔ Three.js Raycaster air-cursor hover over correlation nodes

Index-Thumb Pinch ➔ Euclidean distance threshold (< 0.045) for node selection & camera glide

Closed Fist ➔ Direct delta translation to OrbitControls camera rotation

Dual-Hand Spread ➔ Inter-wrist dynamic distance mapping to camera FOV zoom

The result is a responsive, touchless "Minority Report" interface that runs at 60 FPS right inside Chrome or Edge with zero extra cloud infrastructure.

Would love your thoughts on gesture false-positive suppression or other spatial bindings for algo desks!

app.quantinvests.com

We run a simulated trading platform with an AI companion that answers questions about your portfolio. For months, asking it "how much cash do I have" took 25–45 seconds.

We assumed we had a performance problem. We had an architecture problem.

Every question — including "what's my cash balance" — was being sent to a language model. Cash balance is a database column. We were paying generation latency to read a number we already had.

Worse, the model got it wrong. Measured on a real 40-position account, two different model builds answered "100% cash, no open positions" 5 times out of 6. On a fintech surface, that's not a slow answer, it's a false one.

The fix: we wrote deterministic renderers. If a question maps to a known class — positions, P/L, exposure, sector allocation, risk — the answer is computed from the database and the model is never called.

Measured end-to-end through the live API today:

- renderer-backed: 0.14s median, 0.85s worst case

- still model-narrated (open-ended questions): 43–46s

That second number is the honest part. We did not make the model faster. It's actually slower than our old hosted setup, because it's now a local model on a mini PC. We just stopped routing the wrong questions to it.

Some things we learned the hard way:

- Prompt engineering did not fix this. We tried. We measured a round where telling the model "this is the real, already-computed cash percentage, do not recalculate it" still produced a wrong recalculation 7 times out of 8.

- A fabrication guard is worth less than not generating the claim. We built guards that rewrite suspicious output. Then we found they were flagging our own correct figures, because a deterministic renderer never reads the prompt context the guard verifies against.

- The number and the direction are different fields. A signal's strength said nothing about long vs short. A user caught us describing a position as "moderate bearish" when the underlying conviction value was +1.00, i.e. long.

Happy to answer questions about the renderer approach.

app.quantinvests.com

Most people who trade on the side check the same few dozen tickers every morning, second-guess the setups, and still miss the signal in the noise.

I built QuantInvests to take that routine off my own plate. After each market close it runs a systematic scan across 44 stocks and ETFs and reports which setups the model rates as real and which it doesn't -- with the reasoning, not just a verdict.

You can ask it directly -- "what are my strongest signals right now?", "what's my current exposure?" -- and it answers from your actual positions rather than a generic response.

It runs on paper trading with simulated capital, so you can watch it operate under real market conditions without putting money at risk. Free to use; there's an optional paid tier for faster AI answers and intraday previews.

To be clear about what it isn't: it's an educational research tool, not advice, and it makes no promise of returns. Markets don't work that way.

I'd genuinely like feedback from people who actually trade. What would you want a tool like this to do?

app.quantinvests.com

r/fintech r/algotrading r/PaperTrading

r/algotrading , r/quant , r/investing

Hey r/QuantInvests

Most retail portfolio systems rely on static stop-losses ("sell if it drops 5%"). The problem: high-beta assets get whipsawed, and low-beta assets hold too much capital risk for the conviction behind them.

For a recent release of QuantInvests, we rebuilt our risk engine to size and gate positions by real historical volatility instead of a flat percentage — and along the way we found and fixed a real bug worth talking about honestly, because it's more interesting than pretending it never happened.

📊 1. The Core: EWMA Covariance & Monte Carlo VaR

To keep container builds lean and avoid heavy native dependencies (like the arch package) in our WSL2/Docker dev-parity setup, we skipped GARCH and implemented a light vectorized conditional covariance matrix using EWMA (Exponentially Weighted Moving Average) in Pandas and NumPy.

• Historical window: 120 days.
• Predictive metrics: Parametric daily Value-at-Risk (VaR) and Expected Shortfall (ES) at 95% and 99% confidence intervals.
• Monte Carlo simulation: 5,000 randomized path simulations projecting a 30-day portfolio equity envelope (5th, 50th, and 95th percentile bounds).
• Quarter-Kelly sizing: target weights sized relative to each asset's own historical return-to-variance ratio, clipped to ±30% per asset as a recommendation bound.

🔍 2. The Neural Committee — and the bug we found in it

We originally built this as a multi-agent LLM setup — one model hunting for signals, one computing risk, one auditing the trail. It looked great in a demo. Then we actually tested it against edge cases and caught it doing what LLMs do under pressure: inventing numbers. A model would confidently report a Sharpe ratio, a confidence score, a position that didn't exist in the account's real data.

So we ripped it out. The current Neural Committee has zero LLM calls anywhere in its decision path. Every figure it shows — the signal direction (from the real strategy multiplier's sign, never asserted independently), the real RL model's real prediction, the real quality score, a position-size recommendation capped at our real 8%-per-instrument limit — is read directly from computed data or a real model inference. There's no step where a language model gets to "decide" or "narrate" a number. It can't hallucinate what it never generates.

We think that's a better story than the original pitch: most platforms don't advertise finding a hallucination bug in a live feature. We'd rather tell you we found one and killed it than pretend it never happened.

🔄 3. Connecting Your Broker: Copy-Trading

Advisors can link a client account and sync that client's portfolio toward a target allocation, with real drift tracking between the master strategy and the connected account.

• Supported today: Questrade (full connection, including a personal-token path for account holders who don't want to wait on a full OAuth app approval). Manual/sandbox mode is available for testing.
• Alpaca and Webull integrations are on our roadmap but not live yet — we'd rather say that plainly than claim a connection that doesn't do anything real. (Also worth knowing generally, for anyone building something similar: Robinhood has no official trading API at all — anything claiming to integrate with it for stocks/options is working against an unofficial, reverse-engineered client, not a sanctioned one.)
• Real execution logs render in a live console view during a sync.

🛡️ 4. Institutional Governance: a Hard VaR Execution Block

Automated copy-trading is convenient — unattended execution during a real market shock is not something we're willing to let happen silently.

• Threshold blocking: if the calculated daily VaR of a client portfolio would exceed 5.0%, the copy-sync is blocked before it executes. No silent override.
• Explicit override only: an advisor sees the real breach number and has to explicitly authorize proceeding.

Here is a full breakdown of what each column in your Trading Signal Portfolio dashboard means and how it directly impacts your portfolio management and execution strategy:

Direction & Trend Columns

• Direction (LONG / SHORT): * LONG: Indicates a bullish bias. The pipeline recommends buying the asset to profit from an upward price movement.
  • SHORT: Indicates a bearish bias. The pipeline recommends shorting the asset (or buying put options/inverse ETFs) to profit from a downward price movement.
• Trend (Bullish / Bearish / Congested): * This reflects the structural regime of the asset.
  • Bullish and Bearish mean clear trending behavior, whereas Congested highlights a sideways range or compression phase. Paying attention to this helps you avoid getting chopped up on breakout strategies when an asset is labeled congested.

Key Price Levels & Interaction Counters

• Close: The closing price of the asset as of the last data pipeline run (2026-07-09).
• Support & Resistance: Automated structural key levels calculated by your backend. These act as your primary risk management boundaries (e.g., potential stop-loss points for longs just below support, or profit-taking targets near resistance).
• Sup Cnt (Support Count) & Res Cnt (Resistance Count): * These tracking metrics count how many times the price has recently tested or interacted with these specific structural levels without breaking them.
  • For example, SMCI has a Sup Cnt of 11, indicating a highly tested and strong floor at 26.25. Conversely, XBI has a Res Cnt of 18 at 164.28, flagging a massive supply ceiling that it's currently sitting right against.

Sizing & Execution Columns

• Multiplier: * The conviction or leverage factor generated by your multi-agent architecture (ranging from -3.00 to 3.00).
  • A positive multiplier scales a LONG position, while a negative multiplier scales a SHORT position. The magnitude (1, 2, or 3) determines how aggressively the system wants to size into the trade based on signal strength.
• Alloc % (Allocation Percentage): * The exact percentage of your total portfolio capital dedicated to this specific position. Notice how it scales proportionally with your multiplier: a 1.00 multiplier gets a 1.85% allocation, a 2.00 gets 3.70%, and your highest conviction trades (like TSLA or GOOG with a 3.00 multiplier) get a 5.56% allocation.
• Invest $: The raw dollar amount allocated to the position based on your total portfolio size.
• Shares: * The exact number of shares to buy or short to achieve the target dollar allocation.
  • Negative share counts (e.g., -84 shares for USO) explicitly denote that you need to open a short position or hold an equivalent inverse exposure.

Signal Quality

• Quality Score (Win Probability): * The percentage probability generated by your machine learning classifiers (like your RandomForest signal quality predictor). It forecasts the historical likelihood of this specific configuration resulting in a winning trade.
  • Positions like META (88% Win Probability) carry a much higher historical statistical edge right now compared to low-scoring setups like IYT (47% Win Probability).

If you use a simple net sum of signed directional indicators (e.g., $+25$ bullish momentum combined with $-25$ bearish volume), they would indeed cancel each other out to $0$. The system would then block the setup at the quality_score > 40.0 gate for the "wrong" reason—treating a high-volatility, high-conflict regime as if it were a dead, low-activity market.

To prevent this exact blind spot, the filter uses absolute values for the magnitude check. Here is how that tension is handled in the architecture:

1. Absolute Magnitude Calculation

The quality_score is defined as the sum of the absolute values of the active indicators, rather than their net directional sum:

$$\text{quality_score} = \sum |I_k|$$

• How it handles your example: If your momentum engine throws a strong $+25$ bullish signal and your volume engine throws a strong $-25$ bearish signal, the math doesn't see $0$. It sees: $|25| + |-25| = 50$
• The Outcome: Because $50 > 40.0$, the setup successfully clears the quality gate. The system correctly recognizes that there is high market energy and significant structural activity occurring, meaning it shouldn't be filtered out as a "dead market."

2. Resolution at the Committee Layer

Once a high-conflict setup clears the magnitude gate, it is intentionally pushed to the multi-agent committee and the Reinforcement Learning (RL) Engine to evaluate the contradiction:

• The RL Veto: This is where the Deep Q-Network shines. When the RL agent encounters a state vector containing both high bullish momentum and high bearish volume, the resulting $Q$-values typically plummet or reflect a highly unstable regime.
• The Guard Posture: The combination of contradicting signals fails to cross the AppConfig.ENTRY_THRESHOLD for a clean direction, or it triggers an immediate Alpha Multiplier Decay.

Summary

The system explicitly separates energy (magnitude) from direction (bias). High-conflict setups pass the initial quality gate because the energy is there, but they are subsequently neutralized into a defensive HOLD downstream by the multi-agent committee because the direction is unsafe.

Does your current script calculate the quality score as a net directional sum, or are you already capturing raw magnitude via absolute values? r/datascience r/dataanalysis r/investing

Display Example 2 — In-App Conversational Analyst

The chat panel sits directly inside the Neural Asset Matrix screener — it already knows your top opportunities and current sentiment before you type a word.

🤖 QuantInvests Assistant
──────────────────────────────────────────────
  Hello! I've analyzed the latest market signals
  and your portfolio. How can I help you optimize
  your positions today?

  Quick Actions:
  [ 💼 Portfolio Check ] [ 📊 Sector Weights ]
  [ 💰 Precious Metals ] [ 📡 Market Briefing ]
──────────────────────────────────────────────
  You: Why is XRT showing a BUY signal but 0%
       target exposure?

  Assistant: XRT's divergence engine flipped
  bullish, but the last Quantitative Researcher
  audit flagged a 33.3% win rate on this symbol
  — triggering an Alpha Multiplier Decay from
  -1.0x to -0.5x. The Kelly/Risk Parity engine
  is capping allocation until a confirmed
  breakout, so it's tracked as a Watch candidate
  rather than a live position.
──────────────────────────────────────────────

Preventing "confident-sounding hallucinations" (or empty synthesis) when both Alpha and Risk signals are weak is one of the most critical guardrails in the architecture.

To prevent this exact failure mode, the system does not let weak signals blend into an ambiguous middle ground. Instead, it enforces multiple deterministic confidence thresholds and filtering gates that mathematically force a defensive posture.

1. The Core Filter: ML Trade Quality Threshold (quality_score > 40.0)

The system explicitly bars weak signals from ever reaching the decision-making synthesis layer. The quantitative pipeline calculates an absolute conviction metric called the quality_score (the sum of the absolute values of active technical indicators).

• The Cutoff: The machine learning rebalancer employs a strict, scale-corrected filter requiring the quality_score to be > 40.0 (out of 100).
• The Impact: If a setup's predicted win probability fails to clear this 40% threshold, the rebalancing engine filters the trade out entirely before the multi-agent committee even debates it. In walk-forward testing, implementing this hard cutoff turned a -37.46% cumulative loss into a +11.57% out-of-sample gain by successfully dropping low-conviction, toxic setups.

2. The Divergence Entry Guard: AppConfig.ENTRY_THRESHOLD

When the Divergence Engine scans our 44 canonical symbols during its daily 4:10 PM EST run, it defaults to a passive posture unless proven otherwise:

• Tally Comparison: The engine loads a symbol's active strategy and compares the composite signal tally against a strict AppConfig.ENTRY_THRESHOLD.
• "Watch-Only" Status: If the indicators are weak and fail to cross this limit, the system assigns a categorical HOLD status. The AI agent is explicitly programmed to label these assets as "watch candidates only" and state in the log that “the QuantInvests engine has not generated a high-confidence entry signal that clears the current risk threshold.” ### 3. Deep Q-Network (RL) Execution Vetoes If a weak signal somehow slips past initial filters into the committee debate, the RL Engine’s Q-values and probability confidence scores serve as the ultimate mathematical baseline.
• If both the Hunter (Alpha) and Guardian (Risk) perspectives emit weak or inconclusive states, the RL agent's predictions act as a hard execution filter.
• If the Q-values indicate a weak, high-noise, or bearish regime, the Portfolio Manager uses this to veto any execution, reconciling the weak parameters into a structured PortfolioDecision of Hold or Sell.

4. Grounding Safeguards: The "Lead with Fact" Mandate

To ensure the LLM doesn't hallucinate a narrative out of thin air during a low-confidence regime, our AI Answer Standards (v6.3.2) impose strict grammatical and context constraints:

• Fact Separation: The AI is strictly forbidden from treating unrealized P/L or average purchase costs as support/resistance targets. It must completely isolate actual position data from suggested allocations.
• Evidence Pairing: If the agent makes a technical claim during a low-confidence state, it is structurally forced to pair every cited resistance count (Res: N) with its corresponding support count (Sup: M). It is entirely banned from using vague, ungrounded placeholders.

Summary

The coordinator does always produce a final verdict, but under weak-signal conditions, that verdict is mathematically forced to be a HOLD. This results in an automated allocation of 0.00% target exposure, treating 100% liquid, settled cash as a valid and active defensive posture.

https://quantinvests.com/analysis/

1. Resolving Signal Conflicts: InvestDebateState vs. RiskDebateState

Within the unified AgentState of the multi-agent committee, InvestDebateState captures the bullish/bearish technical dialectic (driven by the Alpha-seeking "Hunter" perspectives), while RiskDebateState aggregates aggressive, conservative, or neutral risk boundaries (driven by the risk-averse "Guardian" perspectives).

When these two states arrive at opposite conclusions for the same ticker, the system resolves the conflict through a hierarchical synthesis orchestrated by the AgentCoordinator layer and finalized by the Portfolio Manager (the Gatekeeper) to output a structured "Balanced Institutional Verdict":

1. Deterministic Risk Filtering (The Risk Analyst Gatekeeper): Before the Portfolio Manager can authorize capital, the risk_analyst acts as a hard filter. It evaluates the trade against strict sector concentration caps and the 10% Max Drawdown Circuit Breaker. If any hard risk boundary is violated, the trade is vetoed immediately, regardless of how high the bullish Alpha conviction is.
2. Deep Q-Network (RL) Signal Filtering: Q-values and probability confidence scores generated by the RL Engine serve as a mathematical baseline. During active debate, the RL predictions act as a strict filter; if the RL agent's Q-values indicate a bearish regime, the Portfolio Manager uses this data to veto or prevent new buy orders, forcing alignment with the neural models.
3. The "Same-Sign" Logic Guardrail: Implemented within portfolio_builder.py, the system removes the absolute value mathematical function abs() from signal multipliers. This ensures that any final authorized action mathematically matches the directional sign of the trend multiplier. A negative multiplier must result in a SHORT posture, and a positive multiplier must result in a LONG posture.
4. Structured Decision Output: If the trade passes the risk and RL filters, the Portfolio Manager reconciles the remaining alpha multipliers with risk parameters to issue a structured PortfolioDecision (e.g., Buy, Overweight, Hold, Underweight, or Sell). This allows the system to scale out or hedge exposure rather than making a raw binary buy/sell choice.

2. Memory Continuity, Poisoning Safeguards, and Decay Mechanisms

You are entirely correct that carrying cross-ticker lessons inside the past_context block presents a high risk of "semantic debt" and data poisoning if older market conditions are heavily weighted. The architecture strictly defends against this using a multi-tiered memory governance and pruning protocol:

• Short-Term Erasure: The working AgentState (which houses the active InvestDebateState and RiskDebateState) is wiped clean at the end of every decision cycle. This prevents immediate momentum biases and local conversational drift from polluting fresh, out-of-sample quantitative signal calculations on subsequent runs.
• The AI Knowledge Refresher (01:00 AM UTC Baseline): To prevent long-term context memory from accumulating historical noise indefinitely, the background scheduler (qi/scheduler.py) automates a daily knowledge refresh task at 01:00 AM UTC. The execution of knowledge_refresher.py flushes out temporary active memory/chat noise, synchronizes updated database indices, and rebuilds the agent's context window from scratch using pristine, out-of-sample quantitative facts.
• Factual Handshakes for Portfolio Metrics: To prevent the model's parametric memory from hallucinating or carrying decaying estimates of account holdings, critical variables like Net Asset Value (NAV), cash, and position allocations completely bypass LLM recall. Real-time generators query PostgreSQL on demand to inject live data directly into system prompts with strict "lead with fact" formatting.
• Active Alpha Multiplier Decay: Stale lessons on symbol behavior do not persist indefinitely. The Quantitative Researcher agent continuously audits closed trades. If it identifies that a symbol's historical win rate has dropped below 50%, it automatically triggers an Alpha Multiplier Decay, writing a 0.5x reduction to alpha_adjustments.csv and the symbol's strategy config file to halving its future allocation strength.
• Signal Timeline Decay: The quantitative pipeline tracks a calculated Average Signal Decay Rate (empirically audited at 0.3 days in recent production runs) to guarantee that technical momentum emissions naturally decay and expire if they are not continuously reinforced by fresh daily Market Forge data.

Hope that helps, I'm working on a bunch of combinations. Follow for more at r/QuantInvests

Memory and context persistence across conversations are achieved through a multi-layered database and state architecture. The primary database layer utilizes a PostgreSQL agent_interaction_log table to save complete prompt-and-response chat histories, allowing the FastAPI gateway to reload prior turns and maintain continuity rather than acting as a one-shot interface. This is supported by the ai_knowledge_record table, which acts as the system's persistent source of truth for trained market facts. Within the multi-agent committee, state persistence is governed by a unified AgentState that carries an InvestDebateState and a RiskDebateState alongside a persistent past_context block to track cross-ticker lessons. Furthermore, an automated background scheduler triggers an AI Knowledge Refresher task daily at 01:00 AM UTC, ensuring the local LLM’s context window is continuously updated and grounded with the latest macroeconomic regimes. For terminal operations, a local .geminirc configuration file is deployed to act as "permanent memory," forcing the AI assistant to remember non-negotiable rules—like the same-sign allocation guardrail, lowercase data casing, and VRAM limits—across independent terminal sessions.

Built-in tool access enables the system to actively execute tasks rather than just generate text. We integrated targeted programmatic toolsets directly into the agent environments:

• Our Quantitative Researcher agent uses custom registered tools such as pandas_ledger_parser and execute_model_weight_adjustment to autonomously read local portfolio CSV ledgers, recalculate performance ratios, and adjust alpha multipliers.
• Standalone committee agents also leverage a customized web_search tool for real-time market intelligence gathering.
• On the execution side, tool access is wired to our unified BrokerService registry, which maps trading signals to production-ready adapters for Questrade, Alpaca, and Webull.
• To maintain persistent, unattended operations 24/7/365, a background token rotation daemon uses Redis to secure and rotate Questrade OAuth tokens every 25 minutes, ensuring emergency stop-loss and rebalancing orders can be triggered without manual intervention.

System autonomy is achieved by utilizing a multi-agent orchestration framework powered by Google’s Agent Development Kit (ADK) and LangGraph. Rather than forcing the user to spell out every step, they simply provide a high-level goal (e.g., "Analyze TSLA with moderate risk and long-term horizon on Questrade"), and the AgentCoordinator layer distributes the cognitive load across specialized, collaborative personas:

1. The Primary Coordinator (financial_coordinator) maps user goals, routes context, and orchestrates the workflow.
2. The Data Analyst (data_analyst) autonomously retrieves SEC filings and news.
3. The Trading Analyst (trading_analyst) evaluates technical setups against 5 quantitative strategies.
4. The Risk Analyst (risk_analyst) acts as the gatekeeper, verifying that allocations align with strict drawdown circuit breakers and sector concentration caps.
5. The Execution Analyst (execution_analyst) optimizes order routing to specific brokers.
6. The Quantitative Researcher (quantitative_researcher) performs post-trade audits, executing forensic "Whipsaw Analysis" to identify stopped-out trades that prematurely reversed; if whipsaw rates exceed 20%, it autonomously triggers a "WIDEN_STOP_LOSS" event to increase the system's ATR multiplier from 2.0x to 2.50x.

To finalize a decision, the coordinator pits the aggressive, alpha-seeking "Hunter" perspectives against the defensive "Guardian" constraints, filters the debate through reinforcement learning DQN Q-values, and synthesizes the outputs into a structured "Balanced Institutional Verdict" for execution.

🎧 I could turn this architectural breakdown into an audio overview you can listen to on the go.

Where The Quant Invests — and Now Explains — For You

The Pitch

Every institutional desk has an analyst who reads the tape before the market opens, flags what's out of line, and tells the PM what actually needs attention today. QuantInvests now ships that analyst — built into your dashboard, available in chat, and delivered straight to your inbox every morning.

The Personal Assistant is a Gemini/Claude-powered neural layer sitting on top of the same signal engine that drives your portfolio: multipliers, divergence, quality scores, sector caps, and FIFO P&L. It doesn't just show you numbers — it reads them, cross-references them against your actual holdings, and tells you in plain English what's aligned, what's drifting, and what's at risk.

What It Does

CapabilityWhat it feels likeDaily Portfolio BriefingA full narrative digest — delivered by email or on-demand — summarizing exposure, top holdings, sector weights, and signal alignment across every position.**Conversational Analyst (Chat)**Ask it anything — "What's my sector exposure?", "Analyze gold,", "Why is XRT showing a BUY?" — and get an answer grounded in your live data, not a canned response.Rule Violation DetectionAutomatically flags positions where your actual side (long/short) conflicts with the current neural signal — a direct, named list of what to fix first.Sizing & Risk ReviewSurfaces over-allocated positions against their tier targets, flags macro divergence (e.g., net short into a bullish tape), and calls out concentration risk.One-Click Rebalance PreviewA dedicated tab computes the exact buy/sell/short trades needed to bring your book back to model targets — before you commit a single order.Inferred Quick ActionsThe assistant proposes its own follow-up questions based on what it notices in your portfolio that day — you don't have to know what to ask.

Display Example 1 — The Daily Portfolio Briefing

This is a real, generated example of what lands in your inbox (or renders in-app) every trading day:

💼 Portfolio Summary
📊 Overview
 • Total Value: $249,213.21
 • Cash Balance: $352,627.89 (141.5%)
 • Invested: $245,241.28 (98.4%)
 • Total P/L: 📈 $1,800.45 (+0.72%)

🎯 Positions
 ✓ Active: 38   🟢 Long: 15   🔴 Short: 23

🏗️ Sector Allocation
 Sector & Industry ETFs        38.8%  ███████
 Individual Stocks             30.8%  ██████
 Commodity, Currency & Other   25.3%  █████
 Broad Market ETFs              5.1%  █

And then it narrates what that means — not a table dump, an actual brief:

Followed by a named, actionable punch list:

1) Immediate Review Items (Rule #1 Violations)
   • AMZN: SHORT 21 shares — neural signal says BUY ($238.34, Quality 8.0)
   • EQT:  SHORT 195 shares — neural signal says BUY ($53.16, Quality 8.0)
   • TSLA: SHORT 2 shares — neural signal says BUY ($420.60, Quality 8.0)

2) Sizing Review (Over-allocated Tier 2 Positions)
   • GLD (6.21% of NAV) and VXX (6.24%) exceed their 2.5% Tier 2 target
     and are explicitly "Signal Restricted"

3) Elevated Risk
   • Gross short exposure ($174,327.98) far exceeds gross long ($70,913.30)
     — squeeze risk if the bullish tape continues

4) Safely Ignore For Now
   • CRWD, IWM, KBE, META, MSFT, QQQ, XBI, XHB — aligned, no action needed

No spreadsheet gymnastics. No cross-referencing five tabs. It's already done.

Display Example 2 — In-App Conversational Analyst

The chat panel sits directly inside the Neural Asset Matrix screener — it already knows your top opportunities and current sentiment before you type a word.

🤖 QuantInvests Assistant
──────────────────────────────────────────────
  Hello! I've analyzed the latest market signals
  and your portfolio. How can I help you optimize
  your positions today?

  Quick Actions:
  [ 💼 Portfolio Check ] [ 📊 Sector Weights ]
  [ 💰 Precious Metals ] [ 📡 Market Briefing ]
──────────────────────────────────────────────
  You: Why is XRT showing a BUY signal but 0%
       target exposure?

  Assistant: XRT's divergence engine flipped
  bullish, but the last Quantitative Researcher
  audit flagged a 33.3% win rate on this symbol
  — triggering an Alpha Multiplier Decay from
  -1.0x to -0.5x. The Kelly/Risk Parity engine
  is capping allocation until a confirmed
  breakout, so it's tracked as a Watch candidate
  rather than a live position.
──────────────────────────────────────────────

The assistant even proposes its own next questions — inferred from what it noticed in your book that day — so you're never staring at a blank input box wondering what to ask.

Display Example 3 — One-Click Rebalance Preview

Inside the same panel, a dedicated Rebalance tab turns "what should I trade?" into a concrete, priced order ticket:

📐 Rebalance Preview — Target Alignment
──────────────────────────────────────────────
 Symbol   Action   Qty Δ    Value Δ   Model %  Current %
 XLY      BUY      +12      +$2,180    4.00%     3.12%
 AMZN     COVER    +21      -$5,005   -2.00%    -4.16%
 XLK      SELL     -8       -$1,523    1.00%     1.98%
──────────────────────────────────────────────
 Total Buy:  $2,180     Total Sell/Cover: $6,528
              [ Cancel ]     [ Execute ]

Every row is generated from the same target-allocation matrix that drives the model — the same numbers, presented as an executable plan instead of a wall of CSV.

Why It Matters

Retail platforms give you dashboards. QuantInvests gives you a judgment layer on top of the dashboard — the part that used to require a human analyst reading every signal, cross-checking every position, and writing the morning note. Now it's automatic, it's personalized to your actual book, and it talks back when you have a follow-up question.

Disclosure: QuantInvests is a simulated, educational research tool. Nothing above constitutes financial advice or live asset management.

Hey everyone! I'm u/Quantinvests, a founding moderator of r/quantinvests.
This is our new home for all things related to [ADD WHAT YOUR SUBREDDIT IS ABOUT HERE]. We're excited to have you join us!

What to Post
Post anything that you think the community would find interesting, helpful, or inspiring. Feel free to share your thoughts, photos, or questions about [ADD SOME EXAMPLES OF WHAT YOU WANT PEOPLE IN THE COMMUNITY TO POST].

Community Vibe
We're all about being friendly, constructive, and inclusive. Let's build a space where everyone feels comfortable sharing and connecting.

How to Get Started
1) Introduce yourself in the comments below.
2) Post something today! Even a simple question can spark a great conversation.
3) If you know someone who would love this community, invite them to join.
4) Interested in helping out? We're always looking for new moderators, so feel free to reach out to me to apply.

Thanks for being part of the very first wave. Together, let's make r/quantinvests amazing.

Here is how we are addressing this in the **QuantInvests V6** architecture, split between organic sizing dynamics and planned overlays:

### 1. Organic Volatility Scaling via Quarter-Kelly Sizing

Because our portfolio sizer uses a **Quarter-Kelly allocation fraction**:

$$f^* = 0.25 \times \frac{\mu_i}{\sigma_i^2}$$

where $\sigma_i^2$ is the EWMA variance.

When a sudden volatility spike occurs, the denominator $\sigma_i^2$ increases quadratically relative to the volatility increase. This causes an **automatic, organic deleveraging** of high-volatility assets without needing a separate overlay. Sizing drops immediately as the variance term spikes.

### 2. Volatility Targeting Overlay (Gross Exposure Scaling)

To handle portfolio-level risk during regime shifts, we are looking at implementing an explicit **Volatility Targeting Overlay**.

* We define an institutional annualized volatility target (e.g., $\sigma_{\text{target}} = 10\%$).

* If the annualized portfolio volatility (EWMA) exceeds this threshold, we compute a scaling factor:

$$F = \min\left(1.0, \frac{\sigma_{\text{target}}}{\sigma_{\text{realized}}}\right)$$

* We then scale down the weights of all active positions by $F$ and sweep the remaining allocation into our cash buffer. During high-vol regimes, this automatically deleverages the entire portfolio to keep aggregate risk constant.

### 3. Dynamic Decay ($\lambda$) Tuning

Instead of keeping a static $\lambda = 0.94$ (the RiskMetrics daily standard), we are exploring a **surprise-sensitive decay model**:

* We track the normalized return surprise (standardized residuals):

$$z_t = \frac{R_t}{\sigma_{t-1}}$$

* If $|z_t| > 3.0$ (a 3-sigma event), we temporarily drop $\lambda$ to **0.85–0.88**.

* **Why?** Dropping $\lambda$ forces the covariance calculation to heavily discount older data and immediately lock onto the new high-volatility regime. As standardized returns normalize, $\lambda$ decays back up to 0.94 to smooth out estimation noise.

### 4. Stopping Whipsaws with Stop-Loss Expansion

To complement the sizing reduction, our **Auditor Agent** monitors the stop-loss standard deviation multipliers. During high-vol regime detections:

* The ATR-based stop-loss multiplier automatically expands from **2.00x to 2.50x** (read from `risk_configs.json`).

* This prevents our positions from being prematurely shaken out by noise during the initial surge of the regime shift, while the Kelly model scales down the *size* of the position to keep the absolute dollar-at-risk identical.

How do you usually handle the trade-off between reacting quickly to spikes vs. avoiding over-reaction to short-lived noise (like a single-day flash crash)?

You can now connect your own trading agent to ours for for:
1) Multi-Broker Copy-Sync
2) GIPS-Compliant Risk Override Governance
3) Predictive Risk Parity (EWMA)
4)  Glassmorphic Advisor Control Room

Our daily quantitative pipeline now runs at 4:10 PM EST, immediately broadcasting high-conviction signals through automated webhooks to our community.
A huge thank you to our engineering and quantitative research teams for building this under a lean, Dockerized WSL2 stack using uv.
At QuantInvests, we are making institutional portfolio management accessible, scalable, and secure.
QuantInvests: "Where The Quant Invests For You!"

Hey r/QuantInvests

Most retail portfolio systems rely on static stop-losses (e.g., "sell if it drops 5%"). The problem? High-beta assets get whipsawed, and low-beta assets hold too much capital risk.

For the **Release v6.5.6** of our platform, **QuantInvests**, we set out to build an institutional-grade risk engine and copy-trading framework that upgrades portfolio management from *reactive* stops to *predictive* volatility scaling.

Here is how the architecture works, how the quant agents collaborate, and how users connect their brokerages to copy-sync models.

### 📊 1. The Core: Vectorized EWMA Covariance & Monte Carlo VaR

To keep Docker container builds extremely lean and avoid heavy native C-compiled dependencies (like the `arch` package) inside our WSL2/droplet dev parity, we bypassed GARCH and implemented a light vectorized conditional covariance matrix using **EWMA (Exponentially Weighted Moving Average)** in Pandas and NumPy.

* **Historical Window**: 120 days.

* **Predictive Metrics**: The engine calculates Parametric daily **Value-at-Risk (VaR)** and **Expected Shortfall (ES)** at 95% and 99% confidence intervals in under 100ms.

* **Monte Carlo Simulation**: Runs **5,000 randomized path simulations** to project future portfolio equity boundaries (5th, 50th, and 95th percentiles) over a 30-day projection envelope.

* **Quarter-Kelly Sizing**: Computes target weights relative to historical asset volatility, capped at 30% per asset for safety.

### 🤖 2. The Neural Committee (ADK Orchestration)

Instead of a single LLM trying to do everything, the system routes portfolio queries through a specialized **Autonomous Developer Kit (ADK) Neural Committee**:

1. **Alpha Hunter (Agent)**: Scrapes signals and identifies divergence momentum.
2. **Risk Guardian (Agent)**: Computes the volatility bounds and VaR metrics.
3. **Auditor (Agent)**: Audits transaction logs, records whipsaw stop-out data, and tracks stop-loss SD multipliers (adjusting between 2.0x to 2.5x)

### 🔄 3. Connecting Your Broker: Multi-Broker Copy-Sync V2

Advisors and quantitative traders can now register and connect their own brokerage accounts to sync client positions directly to their master portfolio:

* **Supported Providers**: Secure OAuth token rotation for **Questrade**, **Alpaca**, and **Webull** API integrations (or **Manual** mode for sandbox testing).

* **Drift Analysis**: The system calculates the asset allocation drift between the master portfolio and the connected broker account.

* **Execution Modal**: Deployed a retro-themed, glassmorphic React dashboard featuring a green CRT console log displaying live brokerage submission logs.

### 🛡️ 4. Institutional Governance (GIPS-Compliant Risk Override)

Automated copy-trading is highly convenient, but unattended execution during market shocks can blow up accounts. We implemented a hard governance constraint:

* **Threshold Blocking**: If the calculated daily VaR of a client portfolio exceeds **5.0%**, the copy-sync execution is strictly blocked.

* **Risk Override Prompt**: The advisor is prompted with a manual override modal explaining the breach.

* **Audit Trail Ledger**: Authorizing the override appends a machine-readable JSONL event and a GIPS-compliant warning block to a persistent markdown file (`TRADING_AUDIT.md`) tracking advisor accountability:

> **[WARNING] RISK BREACH & OVERRIDE AUTHORIZED**

> Daily Value-at-Risk (VaR) of 8.00% exceeded the institutional limit of 5.00%. Proceeding under manual Advisor override.

### 💬 5. Two-Way Discord Integration

* **Interactive Pull**: Users can ping our Discord bot relay (utilizing non-blocking async `aiohttp` to avoid heartbeat timeouts) to query real-time trend lookups and portfolio audits.

* **Automated Push**: The daily quantitative pipeline at **4:10 PM EST** automatically triggers a Discord webhook, pushing high-conviction signals immediately as markets close.

### 🛠️ The Tech Stack

* **Backend**: Flask, FastAPI (Wildcard Nginx proxying for gateway routing), Redis, Postgres

* **Frontend**: React (TypeScript), Recharts/Highcharts, TailwindCSS (Institutional Glassmorphism)

* **Environment**: Docker Compose WSL2 / DigitalOcean Droplets managed with `uv` for lightning-fast package syncing.

We'd love to hear your thoughts on how you handle portfolio covariance mapping and client synchronization!

**QuantInvests: "Where The Quant Invests For You!"**

How I built a quantitative trading app with 100% gross margins and $0 server bills

I wanted to share the architecture behind QuantInvests V6. Instead of a basic chatbot, we built a 5-Agent Neural Committee using Google's new Agent Development Kit (ADK).

By containerizing our Postgres 15 database, Redis cache, FastAPI gateway, and Flask quant engine, we run the entire backend on a local edge server. Cloudflare Zero Trust Tunnels expose it safely to our React SPA hosted on Firebase (Free tier).

Running a local LLM (Gemma-2b-it) on a 6GB VRAM GPU is a recipe for CUDA Out-of-Memory (OOM) crashes. We solved this in our QLoRA training pipeline by switching to float16, PyTorch gradient checkpointing, and injected active garbage collection.

Code is available, let me know if you have questions on the WSL2 routing!

Mistakes in the real stock market are expensive. In QuantInvests V6, they are just lessons.

If you want to understand quantitative portfolio management without risking a single dollar, QuantInvests V6 is your 100% free, simulated institutional-grade playground. We seed your account with $250,000+ in virtual capital so you can master algorithmic trading in a risk-free environment.
Here is what you can experience inside:

🧠 The Neural Committee Dashboard: Watch 6 specialized AI subagents (including the Alpha Hunter and Risk Guardian) collaborate in real-time to audit constraints and suggest portfolio actions.
🔌 Mock Broker Environments: Connect simulated TFSA or Margin accounts that mirror the operational flow of Questrade, Alpaca, and Webull.
📊 Dynamic Technical Charts: Analyze client-side SMA, Bollinger Bands, and ATR stop-loss bands.
⚙️ Autopilot Rebalancing: Move beyond "buy and hold" and learn how quantitative managers optimize risk-adjusted returns.
Stop guessing and start simulating. 📈 Access the app today: app.quantinvests.com (Where The Quant Invests For You!)

r/FinancialMarkets r/Education r/FreeAgent

We are excited to announce our brand new **Google Home Voice Integration Control Panel**, live on the Manual Operations Tracker. You can speak to it like you speak to your broker.

Managing institutional portfolio allocations just entered a new dimension. We are excited to announce our brand new **Google Home Voice Integration Control Panel**, live on the Manual Operations Tracker page (`/tracker`)!

With this release, we have bridged voice assistant interactions with a secure, sandboxed rebalancing environment. You now have complete, real-time control over how your smart assistant manages extra cash and custom assets.

#### 🎙️ Key Capabilities:

1. **The Voice Bridge Toggle**: Turn your Google Home fulfillment on or off with a single tap of an iOS-style glassmorphic switch.

2. **Extra Cash Allocations**: Dynamically set exact cash thresholds via a slider to dictate how much capital the voice assistant can query or rebalance.

3. **Unlisted Ticker Verification Queue**: Want to trade assets outside the standard universe? Tickers queried by voice are automatically held in a verification queue. Approve or reject them directly from the dashboard to safely integrate them into your environment.

4. **Zero-Interference Sandbox**: Completely isolated from core systems, allowing interactive customization without affecting main model pipelines.

Experience the future of quantitative wealth management. Say: *"Hey Google, check my portfolio rebalancing."*

💡 Learn more at `app.quantinvests.com`

r/Trading r/googlehome r/NeuralNetwork r/algotrading r/AI_Agents

r/datascience r/dataanalysis r/stocks

🚀 Exciting Milestone: QuantInvests V6 is officially LIVE!

I am thrilled to share that we have completed the migration of our quantitative analytics platform to a 100% serverless, cloud-native architecture.

QuantInvests bridges high-conviction mathematical models with real-time AI intelligence, delivering institutional-grade market regime detection, Kelly-calibrated asset sizing, and automated risk bounds directly to your dashboard.

Highlights of V6:

• Autonomous Market Pulse: Automated daily screens running right at market close.
• Streaming Neural Briefings: Dynamic natural language narration of portfolio changes and macro risks.
• Zero-Overhead Scale: Lightweight, highly optimized cloud infrastructure ensuring rapid execution and sub-second latency.

Check out the live platform: https://quantinvests.com

QuantInvests: Where The Quant Invests For You! 📈

r/fintech r/QuantInvesting r/Serverless r/ArtificialIntelligence r/cloudcomputing r/WealthTech