Production Pitfalls for Ten-Q Capital

Mitigation Strategies

A. Regime Detection

def detect_market_regime():
    """Detect if market regime changed"""
    vix = get_vix()
    pe_ratio = get_sp500_pe()
    market_return_3m = get_market_return()

    if vix > 30:
        regime = 'HIGH_VOLATILITY'  # Crisis mode
    elif pe_ratio > 25:
        regime = 'OVERVALUED'  # Bubble territory
    elif market_return_3m < -10:
        regime = 'BEAR_MARKET'
    else:
        regime = 'NORMAL'

    return regime

# Adjust Q-learning behavior
if detect_market_regime() != 'NORMAL':
    # Reduce position sizes
    # Increase cash holdings
    # Only trade highest-confidence predictions
    action = conservative_action(state)

B. Market-Adjusted Returns

# Instead of:
reward = stock_return_3m  # Absolute return

# Use:
reward = stock_return_3m - sp500_return_3m  # Market-adjusted (alpha)

# This teaches Q-learning to beat the market, not just make money
# Works in both bull and bear markets

C. VIX-Based Position Sizing

vix = get_vix()

if vix < 15:
    position_size = 100  # Normal
elif vix < 25:
    position_size = 50   # Cautious
elif vix < 35:
    position_size = 25   # Very cautious
else:
    position_size = 0    # Cash only

Mitigation Strategies

A. Keyword Penalty During Bubble Phases

def adjust_prediction_for_bubble(prediction, filing_text):
    """Reduce prediction if suspicious AI hype"""

    # Count AI mentions
    ai_mentions = filing_text.lower().count('artificial intelligence')
    ai_mentions += filing_text.lower().count(' ai ')

    # Check for substance
    has_ai_revenue = 'ai revenue' in filing_text.lower()
    has_ai_product = 'ai product' in filing_text.lower()

    # If lots of mentions but no substance = AI washing
    if ai_mentions > 10 and not (has_ai_revenue or has_ai_product):
        bubble_discount = 0.5  # 50% haircut
        adjusted_prediction = prediction * bubble_discount
        print(f"⚠️ AI washing detected, discounting prediction")
        return adjusted_prediction

    return prediction

B. Sector Rotation Detection

def check_sector_bubble(sector):
    """Check if sector is overheated"""

    sector_pe = get_sector_pe(sector)
    historical_pe = get_historical_pe(sector, years=10)

    # If 2+ standard deviations above historical = bubble
    if sector_pe > historical_pe + 2 * std(historical_pe):
        return True, 'BUBBLE_RISK'

    return False, 'NORMAL'

# Usage
is_bubble, _ = check_sector_bubble('Technology')
if is_bubble:
    # Reduce tech exposure
    # Increase defensive sectors (healthcare, utilities)

Mitigation: Look for Substance, Not Buzzwords

def biotech_substance_check(filing):
    """Check if biotech filing has real substance"""

    has_phase_data = any(p in filing for p in ['Phase 1', 'Phase 2', 'Phase 3'])
    has_fda_action = any(f in filing for f in ['FDA approved', 'FDA granted', 'Breakthrough'])
    has_revenue_projection = 'peak sales' in filing.lower()

    substance_score = sum([has_phase_data, has_fda_action, has_revenue_projection])

    if substance_score >= 2:
        return 'REAL'
    else:
        return 'HYPE'

# Adjust prediction
if sector == 'Biotech':
    substance = biotech_substance_check(filing)
    if substance == 'HYPE':
        prediction *= 0.5  # 50% discount

Mitigation: Add Macro Features

state = (
    prediction_bucket,
    price_bucket,
    interest_rate_bucket,  # NEW: Fed funds rate
    inflation_bucket,       # NEW: CPI
    vix_bucket,            # NEW: Volatility
    has_position
)

# Now Q-learning can learn:
# "Buybacks good when rates low, bad when rates high"

Mitigation: Include Costs in Training

def execute_action_with_costs(filing, action):
    """Realistic reward function with costs"""

    if action == BUY:
        entry_cost = 0.003  # 0.3% (bid-ask + slippage)
        exit_cost = 0.003   # 0.3%
        reward = filing.actual_return - entry_cost - exit_cost

        # Tax on gains (if < 1 year)
        if reward > 0:
            tax = reward * 0.37  # Short-term cap gains
            reward -= tax

    return reward

Mitigation: Liquidity Filter

def check_liquidity(ticker, position_size):
    """Only trade if liquid enough"""

    daily_volume = get_daily_volume(ticker)
    daily_dollar_volume = daily_volume * get_price(ticker)

    # Our position should be < 5% of daily volume
    if position_size < daily_dollar_volume * 0.05:
        return True  # OK to trade
    else:
        return False  # Skip (too illiquid)

Mitigation: Filing Timestamp Checks

def get_filing_age(filing):
    """Check how old filing is when we see it"""

    filed_time = filing.filing_datetime
    our_time = datetime.now()
    age_hours = (our_time - filed_time).total_seconds() / 3600

    return age_hours

# Skip if stale
age = get_filing_age(filing)
if age > 4:  # More than 4 hours old
    print("Filing too old, price already moved")
    action = HOLD

Mitigation: Use Public Info Only

# ONLY use data available to everyone
sources = [
    'EDGAR filings (public)',
    'Stock prices (public)',
    'Form 3/4/5 (public)',
]

# DO NOT use:
bad_sources = [
    'Expert networks',
    'Non-public company calls',
    'Leaked documents',
]