Skip to content

Multi-Strategy Channel Architecture

Date: 2025-10-31 Status: Specification Author: Bert Frichot (with Claude Code) Context: Phase 3 of Agentic Trading Roadmap - Multi-Strategy Portfolio Optimization

1. Overview

Build a multi-strategy portfolio manager with independent strategy channels - each asset class (large-caps, micro-caps, options, crypto) runs its own optimized strategy simultaneously without interference.

1.1 Core Principle

"Each asset class has different behavior → Each needs different strategy"

  • Large-caps (TSLA, NVDA): Mean reversion during volatility
  • Micro-caps (<$300M): Momentum on low-float breakouts
  • Options: Theta decay strategies (spreads, condors)
  • Crypto: Trend-following with high volatility tolerance

1.2 Architecture Philosophy

Independent Channels (not switching strategies): - Each channel runs 24/7 with its own rules - Capital allocated per channel (not reallocated dynamically) - Strategies don't interfere with each other - Risk managed at portfolio level (aggregate exposure)

2. Strategy Channels

Channel 1: Large-Cap Volatility (Mean Reversion)

Asset Universe: - TSLA, GME, PLTR, RIOT, AMC, NIO, SOFI, COIN, MARA, NVDA (10 symbols) - Market cap: >$1B - Volatility: >30% annualized

Strategy: Mean Reversion (already optimized) - Entry: Price < BB lower AND RSI < 27 - Exit: Price > SMA OR RSI > 63 OR 5-day profit target - Stop Loss: 12% - Position Size: $673 per trade - Max Positions: 3

Capital Allocation: 25% of portfolio ($24,750 if $99k total)

Expected Performance (from genetic optimization): - Sharpe: 0.09-0.16 - Win Rate: 60-75% - Trades/month: 2-3 (with 10 symbols)

Channel 2: Micro-Cap Momentum

Asset Universe: - Market cap: $50M - $300M - Float: <20M shares (low float = high volatility) - Volume: >500k shares/day (tradeable liquidity) - Sector: Healthcare (biotech catalysts), Tech (AI hype), EV (infrastructure plays)

Strategy: Momentum Breakout (to be optimized) - Entry: - Price breaks above 20-day high - Volume > 2x average (confirmation) - RSI > 50 (strength, not oversold) - Exit: - Trailing stop: 15% from highest price - Time stop: 10 days (ride the momentum, then exit) - Position Size: $500 per trade (smaller due to illiquidity) - Max Positions: 5

Capital Allocation: 20% of portfolio ($19,800)

Expected Performance (to be validated): - Sharpe: 0.3-0.5 (higher risk/reward) - Win Rate: 40-50% (fewer wins, bigger wins) - Trades/month: 5-8 (more opportunities in micro-caps)

Data Source: - Alpaca supports down to ~$100M market cap - Screen for micro-caps daily via Alpaca screener API

Channel 3: Options Strategies

Asset Universe: - SPY, QQQ (high liquidity, tight spreads) - Individual stocks: AAPL, TSLA, NVDA (30+ DTE options)

Strategy: Theta Decay (Credit Spreads) - Type: Bull Put Spreads (neutral to bullish bias) - Entry: - Sell put at 0.30 delta (~30% OTM) - Buy put at 0.15 delta (~15% further OTM) - Credit: $0.50-$1.00 per spread - DTE: 30-45 days - Exit: - Close at 50% profit (take profits early) - Stop loss: 200% of credit received (e.g., $1.00 credit → close at $2.00 loss) - Time stop: 21 DTE (don't hold to expiration) - Position Size: 1-2 contracts per trade - Max Positions: 3 spreads

Capital Allocation: 25% of portfolio ($24,750)

Expected Performance (typical for credit spreads): - Sharpe: 0.8-1.2 (theta decay is consistent) - Win Rate: 70-80% (most expire worthless) - Trades/month: 4-6 (monthly cycle)

Broker: - Alpaca supports options (paper + live) - Use alpaca.trading.OptionsOrderRequest

Channel 4: Crypto (Trend-Following)

Asset Universe: - BTC, ETH (via Alpaca crypto or Coinbase) - High liquidity, 24/7 trading

Strategy: Trend-Following (to be optimized) - Entry: - Price > 50-day SMA (uptrend) - MACD crossover (12/26/9) - Volume > average (confirmation) - Exit: - Price < 20-day SMA (trend reversal) - Trailing stop: 20% (crypto is volatile) - Position Size: $1,000 per trade - Max Positions: 2 (BTC + ETH)

Capital Allocation: 15% of portfolio ($14,850)

Expected Performance (to be validated): - Sharpe: 0.2-0.4 (high volatility) - Win Rate: 40-50% (trend-following = fewer wins, big wins) - Trades/month: 2-4 (crypto trends last weeks)

Broker: - Alpaca supports crypto (BTC, ETH, etc.) - 24/7 trading (weekend opportunities)

Channel 5: Cash Reserve (Safety Buffer)

Allocation: 15% of portfolio ($14,850)

Purpose: - Handle margin calls - Opportunistic deployment during market crashes - Cushion for drawdowns

3. Portfolio-Level Management

3.1 Capital Allocation (Fixed)

Channel Allocation Capital (on $99k) Max Positions Position Size
Large-Cap Mean Reversion 25% $24,750 3 $673
Micro-Cap Momentum 20% $19,800 5 $500
Options Theta Decay 25% $24,750 3 ~$2,500/spread
Crypto Trend-Following 15% $14,850 2 $1,000
Cash Reserve 15% $14,850 - -
Total 100% $99,000 - -

Note: Allocations are fixed at start, not dynamically rebalanced (simplicity).

3.2 Risk Management (Portfolio-Level)

Aggregate Exposure Limits: - Max 13 total positions across all channels (3+5+3+2) - Max 50% of portfolio in any single asset class - Max 10% of portfolio in any single position

Correlation Monitoring: - Track correlation between channels - If correlation > 0.7 (too similar), reduce allocations - Goal: Negative or low correlation (<0.3) for diversification

Drawdown Circuit Breaker: - If portfolio drawdown > 15%, halt all new positions - Review strategy performance by channel - Resume when drawdown < 10%

3.3 Performance Tracking

Per-Channel Metrics (independent): - Sharpe ratio - Total return - Max drawdown - Win rate - Profit factor (gross profit / gross loss)

Portfolio-Level Metrics (aggregate): - Portfolio Sharpe (risk-adjusted return) - Diversification ratio (portfolio volatility / sum of channel volatilities) - Correlation matrix (channel-to-channel)

4. Implementation Architecture

4.1 Code Structure

trading_agents/
├── strategies/
│   ├── base_strategy.py           # Abstract base class
│   ├── large_cap_mean_reversion.py  # Channel 1 (already exists)
│   ├── micro_cap_momentum.py      # Channel 2 (new)
│   ├── options_theta_decay.py     # Channel 3 (new)
│   └── crypto_trend_following.py  # Channel 4 (new)
├── orchestrator/
│   ├── portfolio_manager.py       # Runs all channels simultaneously
│   ├── capital_allocator.py       # Fixed allocation per channel
│   └── risk_monitor.py            # Portfolio-level risk checks
├── agents/
│   ├── market_data.py             # Existing (fetch data for all symbols)
│   ├── strategy.py                # Existing (route to correct channel)
│   ├── order_execution.py         # Existing (submit orders)
│   ├── risk_management.py         # Existing (check limits)
│   └── position_management.py     # Existing (track positions)
└── config/
    ├── portfolio_config.yaml      # Capital allocations, limits
    └── channel_configs/
        ├── large_cap.yaml
        ├── micro_cap.yaml
        ├── options.yaml
        └── crypto.yaml

4.2 Execution Flow

1. Portfolio Manager starts all channels (parallel threads)
2. Each channel:
   a. Market Data Agent fetches symbol data
   b. Strategy Agent evaluates entry/exit signals
   c. Risk Management Agent checks limits (channel + portfolio)
   d. Order Execution Agent submits orders (if approved)
   e. Position Management Agent tracks open positions
3. Risk Monitor aggregates exposure across channels
4. Repeat every 1 minute (during market hours)

4.3 Message Bus (Redis)

Channels (Redis Pub/Sub): - market_data - Price updates for all symbols - signals.large_cap - Entry/exit signals for Channel 1 - signals.micro_cap - Signals for Channel 2 - signals.options - Signals for Channel 3 - signals.crypto - Signals for Channel 4 - orders - Order execution requests - positions - Position updates - risk_alerts - Portfolio-level risk warnings

Key-Value Store (Redis): - portfolio:capital - Available capital per channel - portfolio:positions - Open positions across all channels - portfolio:metrics - Real-time performance metrics

5. Optimization Strategy

5.1 Per-Channel Optimization

Each channel runs genetic optimization independently:

  1. Large-Cap (already optimized):
  2. Parameters: RSI thresholds, BB std, stop loss, position size

  3. Objective: Balanced (Sharpe, Return, Drawdown)

  4. Micro-Cap (next to optimize):

  5. Parameters: Breakout period, volume filter, trailing stop, holding period

  6. Objective: Return-focused (accept higher volatility)

  7. Options (manual strategy):

  8. Parameters: Delta selection, DTE, spread width, profit target
  9. No genetic optimization (too complex for backtesting)

  10. Use historical IV data for validation

  11. Crypto (to optimize):

  12. Parameters: SMA periods, MACD settings, trailing stop
  13. Objective: Calmar ratio (return/max drawdown)

5.2 Portfolio-Level Optimization

After individual channels are optimized, run portfolio optimization:

  • Input: Channel performance distributions (from backtests)
  • Optimize: Capital allocation percentages (15-30% per channel)
  • Objective: Maximize portfolio Sharpe ratio
  • Constraint: Maintain diversification (correlation < 0.5)

6. Timeline & Milestones

Week 1: Foundation (This Week)

  • [x] Optimize large-cap mean reversion (DONE)
  • [ ] Design multi-channel architecture (THIS SPEC)
  • [ ] Implement portfolio manager skeleton
  • [ ] Create channel-specific config files

Week 2: Micro-Cap Channel

  • [ ] Build micro-cap screener (Alpaca API)
  • [ ] Implement momentum strategy
  • [ ] Genetic optimization (2020-2024)
  • [ ] Backtest validation

Week 3: Options Channel

  • [ ] Build options spread builder
  • [ ] Historical IV data integration
  • [ ] Paper trading validation (2 weeks required)

Week 4: Crypto Channel

  • [ ] Implement trend-following strategy
  • [ ] Genetic optimization (crypto data)
  • [ ] Backtest on 2020-2024 (includes 2022 bear market)

Week 5: Integration & Testing

  • [ ] Portfolio-level optimization
  • [ ] Multi-channel orchestrator testing
  • [ ] Paper trading (all channels simultaneously)

Week 6: Deployment Decision

  • [ ] Review 2-week paper trading results
  • [ ] User approval for live deployment
  • [ ] Go live with small capital allocation

7. Success Criteria

Per-Channel Success (Validation Period)

  • Large-Cap: Win rate >60%, Sharpe >0.08, <5% drawdown
  • Micro-Cap: Win rate >40%, Return >10%, <20% drawdown
  • Options: Win rate >70%, Sharpe >0.8, <10% drawdown
  • Crypto: Sharpe >0.2, Return >5%, <25% drawdown

Portfolio-Level Success

  • Portfolio Sharpe: >0.5 (better than any individual channel)
  • Diversification: Correlation between channels <0.5
  • Drawdown: Portfolio max drawdown <15% (better than worst channel)
  • Consistency: Positive returns in 4+ months out of 6

8. Open Questions (To Decide)

  1. Micro-Cap Data:
  2. Q: Can Alpaca screen for market cap <$300M reliably?

  3. A: Test screener API, fallback to manual universe if needed

  4. Options Backtesting:

  5. Q: How to backtest options strategies without historical IV data?

  6. A: Use paper trading only (2-week validation), skip genetic optimization

  7. Crypto 24/7 Trading:

  8. Q: Should crypto channel trade weekends (when stocks are closed)?

  9. A: Yes, but with tighter risk limits (no support team on weekends)

  10. Capital Rebalancing:

  11. Q: Should we rebalance allocations monthly based on performance?

  12. A: No (complexity), only rebalance if channel fails validation (manual decision)

  13. Correlation Hedging:

  14. Q: If all channels are correlated during market crash, should we hedge?
  15. A: Out of scope for MVP, revisit after 3 months of live data

9. Next Steps

Immediate (today): 1. Review this spec (user approval) 2. Create portfolio_config.yaml with allocations 3. Build portfolio_manager.py skeleton

This Week: 1. Implement micro-cap screener 2. Build momentum strategy 3. Run genetic optimization

Approval Required: - [ ] User approves overall architecture - [ ] User approves capital allocations (25/20/25/15/15%) - [ ] User approves micro-cap universe criteria - [ ] User approves options strategy (credit spreads vs iron condors) - [ ] User approves crypto exchanges (Alpaca vs Coinbase)

10. References

  • Agentic Trading Roadmap: docs/trading/AGENTIC_TRADING_ROADMAP_2025-10-30.md
  • Phase 1 Complete: docs/status/TRADING_MULTI_AGENT_PROGRESS_2025-10-28.md
  • Genetic Optimizer: tools/genetic_optimizer.py
  • Trading Agents: trading_agents/agents/
  • Large-Cap Optimization Results: reports/mean_reversion_5yr_robust.json

Status: Awaiting user approval to proceed with implementation.