Strategy Prioritization

Quick Start

When prioritizing strategies:

1. Inventory all available strategies across codebase
2. Score each strategy on 4 factors (Performance, Risk, Operations, Business)
3. Rank strategies by composite score
4. Generate deployment recommendations
5. Identify gaps blocking promotion

Scoring Framework

Four-Factor Scoring (1-5 scale, equal weights)

Composite Score = (Performance + Risk + Ops + Business) / 4

1. Performance (25%)

• 5: Strong metrics (Sharpe > 2.0, Win Rate > 70%, PF > 2.5)
• 4: Good metrics (Sharpe > 1.5, Win Rate > 65%, PF > 2.0)
• 3: Moderate or limited data
• 2: Weak metrics or no recent backtests
• 1: No performance data

2. Risk Readiness (25%)

• 5: Comprehensive controls (stops, sizing, limits, correlation)
• 4: Good controls (stops, sizing, basic limits)
• 3: Basic controls (stops only)
• 2: Minimal controls
• 1: No risk management

3. Operational Readiness (25%)

• 5: Fully configured, tested, documented, monitored
• 4: Configured and tested, minor doc gaps
• 3: Basic config, needs testing/docs
• 2: Code exists, not configured
• 1: Experimental/incomplete

4. Business Importance (25%)

• 5: Explicitly recommended, high priority, proven
• 4: Important, good business case
• 3: Moderate value
• 2: Low priority/experimental
• 1: Example/research only

Prioritization Process

Step 1: Strategy Discovery

# Find all strategies
find openalgo/strategies/scripts -name "*.py" -type f
find openalgo_backup_*/strategies/scripts -name "*.py" -type f  
find AITRAPP/AITRAPP/packages/core/strategies -name "*.py" -type f

# Check documentation
grep -r "strategy" *.md | grep -i "priorit\|rank\|recommend"

Step 2: Data Collection

For each strategy, gather:

Performance Data:

• Backtest results from openalgo/strategies/backtest_results/
• Metrics from ALL_STRATEGIES_COMPARISON.md
• Ranking reports and CSV files
• AITRAPP backtest engine results

Risk Assessment:

# Check for risk controls in code
grep -r "stop_loss\|max_drawdown\|position_size\|risk_per_trade" strategy_file.py
grep -r "daily_loss_limit\|weekly_loss_limit\|correlation" strategy_file.py

Operational Check:

• Config files: AITRAPP/AITRAPP/configs/app.yaml
• Deployment scripts: openalgo/strategies/scripts/
• Documentation: Strategy .md files
• Monitoring: Log files, status endpoints

Business Value:

• Check STRATEGY_PRIORITIZATION_REPORT.md
• Review ALL_STRATEGIES_COMPARISON.md recommendations
• Look for explicit deployment recommendations

Step 3: Scoring

def score_strategy(strategy_name, performance_data, risk_data, ops_data, business_data):
    """Score strategy on 4 factors"""
    perf_score = score_performance(performance_data)  # 1-5
    risk_score = score_risk(risk_data)  # 1-5
    ops_score = score_operations(ops_data)  # 1-5
    biz_score = score_business(business_data)  # 1-5
    
    composite = (perf_score + risk_score + ops_score + biz_score) / 4.0
    
    return {
        'name': strategy_name,
        'performance': perf_score,
        'risk': risk_score,
        'operations': ops_score,
        'business': biz_score,
        'composite': composite,
        'gaps': identify_gaps(perf_score, risk_score, ops_score, biz_score)
    }

Step 4: Ranking and Categorization

def categorize_strategy(composite_score):
    """Categorize by action needed"""
    if composite_score >= 4.0:
        return "Deploy", "Ready for live trading"
    elif composite_score >= 3.0:
        return "Paper Trade", "Needs validation"
    elif composite_score >= 2.5:
        return "Optimize", "Needs improvements"
    else:
        return "Hold", "Experimental or incomplete"

Step 5: Generate Report

Create prioritization report with:

• Ranked table (sorted by composite score)
• Detailed analysis per strategy
• Gap identification
• Deployment roadmap
• Action items

Key Metrics Reference

Performance Metrics

Sharpe Ratio:

• Excellent: > 2.0
• Good: 1.5 – 2.0
• Acceptable: 1.0 – 1.5
• Poor: < 1.0

Win Rate:

• Excellent: > 70%
• Good: 60-70%
• Acceptable: 50-60%
• Poor: < 50%

Profit Factor:

• Excellent: > 2.5
• Good: 2.0 – 2.5
• Acceptable: 1.5 – 2.0
• Poor: < 1.5

Max Drawdown:

• Excellent: < 10%
• Good: 10-15%
• Acceptable: 15-20%
• Poor: > 20%

Risk Controls Checklist

• Stop loss implemented
• Position sizing based on risk
• Daily loss limit
• Weekly loss limit
• Max drawdown protection
• Correlation management
• Max positions limit
• Volatility-based sizing

Operational Checklist

• Configuration file exists
• Parameters documented
• Deployment script available
• Logging implemented
• Monitoring integrated
• Error handling robust
• Documentation complete
• Tested in sandbox

Integration Points

With Backtesting

• Use backtest results to score performance
• Reference backtesting-analysis skill for metrics
• Check openalgo/strategies/backtest_results/ for data

With Strategy Management

• Coordinate deployment with strategy-manager subagent
• Check current running strategies before prioritizing
• Verify strategy status via web UI

With Risk Management

• Align with risk-management skill requirements
• Verify risk controls meet standards
• Check portfolio-level constraints

Common Patterns

High-Priority Strategies

Look for:

• Documented backtests with strong metrics
• Comprehensive risk controls
• Fully configured and tested
• Explicitly recommended in docs

Strategies Needing Work

Identify:

• Missing backtest data → Run backtests
• Weak risk controls → Add risk management
• Configuration gaps → Create configs
• Documentation gaps → Write docs

Archived Strategies

• Check openalgo_backup_*/strategies/ for high-performing archived strategies
• Consider porting to current location if score is high
• Verify code compatibility before promotion

Report Template

# Strategy Prioritization Plan - [Date]

## Executive Summary
- Total strategies: X
- Top 3: [List]
- Ready to deploy: X
- Need work: X

## Ranked Strategies

| Rank | Strategy | Perf | Risk | Ops | Biz | Score | Action | Location |
|------|----------|------|------|-----|-----|-------|--------|----------|
| 1 | Strategy A | 5 | 5 | 4 | 5 | 4.75 | Deploy | openalgo/strategies/scripts/ |

## Detailed Analysis

### Strategy A
**Performance (5/5)**: [Details]
**Risk (5/5)**: [Details]
**Operations (4/5)**: [Details]
**Business (5/5)**: [Details]
**Gaps**: None
**Next Steps**: Deploy to live trading

## Gaps Blocking Promotion
- Strategy X: Missing backtest data
- Strategy Y: No risk controls

## Deployment Roadmap
1. Week 1: Deploy top 3 strategies
2. Week 2: Paper trade next tier
3. Month 1: Optimize remaining strategies

Best Practices

1. Be Conservative: When data is missing, score low and mark as gap
2. Prioritize Data: Strategies with documented performance rank higher
3. Actionable Output: Provide specific next steps, not just scores
4. Regular Updates: Re-prioritize as strategies are tested/deployed
5. Document Gaps: Clearly identify blockers to enable promotion
6. Consider Context: Market conditions and instrument types matter

Troubleshooting

Missing Performance Data

• Run backtests using backtesting-analysis skill
• Check archived backtest results
• Look for comparison reports

Incomplete Risk Controls

• Reference risk-management skill for requirements
• Add missing controls before promotion
• Test risk limits in sandbox

Configuration Issues

• Check existing configs in AITRAPP/AITRAPP/configs/
• Create config files following patterns
• Verify parameters are documented

Related Resources

• Subagent: strategy-prioritization-planner for detailed planning
• Skill: backtesting-analysis for performance metrics
• Skill: risk-management for risk control standards
• Skill: trading-strategy-development for strategy structure
• Reports: STRATEGY_PRIORITIZATION_REPORT.md, ALL_STRATEGIES_COMPARISON.md