Strategy Prioritization

Quick Start

When prioritizing strategies:

Inventory all available strategies across codebase
Score each strategy on 4 factors (Performance, Risk, Operations, Business)
Rank strategies by composite score
Generate deployment recommendations
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

bash

# 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:

python

# 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

python

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

python

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

markdown

# 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

Be Conservative: When data is missing, score low and mark as gap
Prioritize Data: Strategies with documented performance rank higher
Actionable Output: Provide specific next steps, not just scores
Regular Updates: Re-prioritize as strategies are tested/deployed
Document Gaps: Clearly identify blockers to enable promotion
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

strategy-prioritization

NPX Install

Tags

SKILL.md Content

Strategy Prioritization

Quick Start

Scoring Framework

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

1. Performance (25%)

2. Risk Readiness (25%)

3. Operational Readiness (25%)

4. Business Importance (25%)

Prioritization Process

Step 1: Strategy Discovery

Step 2: Data Collection

Step 3: Scoring

Step 4: Ranking and Categorization

Step 5: Generate Report

Key Metrics Reference

Performance Metrics

Risk Controls Checklist

Operational Checklist

Integration Points

With Backtesting

With Strategy Management

With Risk Management

Common Patterns

High-Priority Strategies

Strategies Needing Work

Archived Strategies

Report Template

Best Practices

Troubleshooting

Missing Performance Data

Incomplete Risk Controls

Configuration Issues

Related Resources