Design Trading Strategies

Quick Start

This skill generates AI-powered trading strategy concepts before you commit to expensive development. It's the cheapest AI tool in Robonet ($0.05-$1.00 vs $1-$4.50 for full strategy creation).

Load the tool first:

code

Use MCPSearch to select: mcp__workbench__generate_ideas

Basic usage:

code

generate_ideas(strategy_count=3)

Returns 3 creative strategy concepts with descriptions of market conditions, entry/exit logic, and rationale.

When to use this skill:

•Exploring new markets or timeframes
•Stuck for strategy ideas
•Want to validate approach before expensive development
•Need inspiration from current market data
•Brainstorming session before building

When to skip this skill:

•You already know exactly what you want to build → Go directly to build-trading-strategies
•Iterating on existing strategy → Use improve-trading-strategies

The generate_ideas Tool

Purpose: Creates innovative strategy concepts based on current Hyperliquid market data

Parameters:

•strategy_count (optional, integer, 1-10): Number of ideas to generate (default: 1)

Returns: List of strategy concepts including:

•Strategy name: Descriptive name for the concept
•Market conditions: What market regime it's designed for (trending, ranging, volatile, etc.)
•Entry logic: When to enter positions
•Exit logic: When to exit positions
•Risk management: Stop loss and position sizing approach
•Indicators: Which technical indicators to use
•Rationale: Why this strategy might work

Pricing: Real LLM cost + margin (max $1.00)

•Typical cost: $0.05-$0.50 depending on number of ideas
•Significantly cheaper than create_strategy ($1-$4.50)

Execution Time: ~20-40 seconds

Example output:

code

Strategy 1: "Bollinger Band Mean Reversion"
Market conditions: Ranging market with clear support/resistance
Entry logic: Enter long when price touches lower band and RSI <30
Exit logic: Exit at middle band or when RSI >70
Risk management: 2% position size, stop loss at 1.5× ATR below entry
Indicators: Bollinger Bands (20, 2), RSI (14), ATR (14)
Rationale: Markets tend to revert to the mean in ranging conditions.
           Bollinger Bands identify extremes, RSI confirms oversold/overbought.

Core Concepts

Strategy Archetypes

Understanding common patterns helps evaluate AI-generated ideas:

1. Trend Following

•Market: Trending markets (strong directional movement)
•Logic: Enter in direction of trend, ride momentum
•Indicators: Moving averages (EMA, SMA), ADX, MACD
•Risk: False breakouts, whipsaws in ranging markets
•Example: "Buy when price crosses above 50 EMA and ADX >25"

2. Mean Reversion

•Market: Ranging markets (price oscillates around mean)
•Logic: Buy oversold, sell overbought, profit from reversion
•Indicators: RSI, Bollinger Bands, Stochastic
•Risk: Trending markets (price may not revert)
•Example: "Buy when RSI <30 and at lower Bollinger Band"

3. Breakout

•Market: Consolidation followed by expansion
•Logic: Enter when price breaks support/resistance with volume
•Indicators: Bollinger Bands, ATR, Volume, Donchian Channels
•Risk: False breakouts, low win rate (requires large profit factor)
•Example: "Buy on breakout above 20-day high with volume >1.5× average"

4. Momentum

•Market: Strong directional moves
•Logic: Enter when momentum accelerates, exit when it fades
•Indicators: MACD, Stochastic, Rate of Change (ROC), Williams %R
•Risk: Late entries, momentum reversals
•Example: "Buy when MACD crosses above signal line and price makes new high"

5. Arbitrage/Market Making

•Market: Any (exploits inefficiencies or spreads)
•Logic: Profit from price discrepancies or spread capture
•Indicators: Spread analysis, correlation, volume
•Risk: Low margins, requires high frequency, execution risk
•Example: "Capture spread between related assets or maker/taker fees"

Realistic Performance Expectations

Set realistic expectations to evaluate generated ideas:

Sharpe Ratio (risk-adjusted return):

•>2.0: Exceptional (rare for algorithmic strategies)
•1.0-2.0: Good (achievable with solid strategy)
•0.5-1.0: Acceptable (worth testing)
•<0.5: Poor (likely not profitable after costs)

Max Drawdown (largest peak-to-trough decline):

•<10%: Conservative (lower returns, safer)
•10-20%: Moderate (balanced risk/reward)
•20-40%: Aggressive (higher returns, higher risk)
•>40%: Very risky (difficult to recover from)

Win Rate (percentage of profitable trades):

•45-65%: Realistic for most strategies
•>70%: Suspicious (likely overfitting or unrealistic assumptions)
•<40%: Needs improvement or higher profit factor

Typical characteristics of good strategies:

•Clear entry and exit rules (not ambiguous)
•Realistic indicator parameters (not over-optimized)
•Appropriate for market regime (trend-following in trending markets)
•Risk management included (stop loss, position sizing)
•Based on sound trading principles (not curve-fitted)

Market Regime Awareness

Different strategies work in different market conditions:

Trending Markets (strong directional movement):

•Best: Trend following, momentum strategies
•Worst: Mean reversion (buys dips that keep dipping)
•Current state: Check BTC/ETH price action (making new highs/lows?)

Ranging Markets (sideways price action):

•Best: Mean reversion, oscillator-based strategies
•Worst: Trend following (whipsawed by false signals)
•Current state: Price oscillating between clear support/resistance?

Volatile Markets (large price swings):

•Best: Breakout strategies, volatility-based position sizing
•Worst: Tight stop losses (get stopped out frequently)
•Current state: ATR elevated? Wide intraday ranges?

Low Volatility Markets (compressed ranges):

•Best: Range trading, spread capture
•Worst: Momentum strategies (insufficient movement)
•Current state: ATR compressed? Narrow ranges?

How generate_ideas uses market data:

•Analyzes current Hyperliquid market data
•Considers recent volatility, trends, and patterns
•Generates ideas appropriate for current conditions
•You should still validate ideas against your own market view

Best Practices

Cost Optimization

Why use generate_ideas before create_strategy:

code

Without generate_ideas:
1. create_strategy("vague idea") → $2.50
2. Code doesn't match expectations → Wasted
3. create_strategy("try again") → $2.50
4. Still not quite right → Wasted
Total cost: $5.00, no strategy yet

With generate_ideas:
1. generate_ideas(strategy_count=3) → $0.30
2. Review 3 concepts, pick best
3. create_strategy("refined concept from idea #2") → $2.50
4. Code matches expectations → Success
Total cost: $2.80, working strategy

Savings: $2.20 (44% reduction) + better outcome

Effective Idea Generation

Request multiple ideas to compare approaches:

code

generate_ideas(strategy_count=3-5)

Why 3-5 ideas:

•See multiple approaches to same problem
•Compare trade-offs (risk vs return, complexity vs simplicity)
•Identify common themes (e.g., all ideas use RSI → probably important)
•Cost is still minimal ($0.15-$0.50 total)

Avoid:

•strategy_count=1: Limited perspective, may miss better approaches
•strategy_count=10: Diminishing returns, most ideas will be variations

Critical Evaluation of AI Ideas

Not all AI-generated ideas are good. Evaluate critically:

Red flags (be skeptical of these):

•Unrealistic parameters: "Buy when RSI exactly equals 27.6" (over-optimized)
•Too many indicators: Uses 8+ indicators (overfitting risk)
•Vague logic: "Enter when conditions are favorable" (not actionable)
•No risk management: Doesn't mention stop loss or position sizing
•Ignores market regime: Mean reversion strategy for strongly trending market
•Contradictory logic: "Buy when RSI <30 AND RSI >70" (impossible)

Green flags (good ideas have these):

•Clear entry conditions: Specific, measurable criteria
•Clear exit conditions: Defined profit target and stop loss
•Appropriate indicators: 2-4 indicators that complement each other
•Market regime awareness: Strategy matches current conditions
•Risk management: Position sizing and stop loss defined
•Sound rationale: Based on trading principles, not curve-fitting

Example evaluation:

code

Idea: "Buy when price is above 200 EMA, RSI crosses above 50, and MACD crosses bullish"
✓ Clear entry conditions (3 specific criteria)
✓ Indicators complement each other (trend + momentum + momentum confirmation)
✓ Appropriate for trending markets
? Missing exit logic (need to ask for refinement)
? No position sizing mentioned (need to specify)

Verdict: Good foundation, needs exit logic and risk management details

Iterative Refinement

Use ideas as starting points, not final solutions:

code

1. generate_ideas(strategy_count=3) → Get initial concepts

2. Evaluate ideas:
   - Idea #1: Too complex (8 indicators)
   - Idea #2: Good concept, but missing exit logic
   - Idea #3: Too risky (no stop loss)

3. Pick best idea (#2) and refine:
   - Use browse-robonet-data to verify indicators available
   - Add missing details (exit logic, risk management)
   - Create refined concept description

4. Proceed to build-trading-strategies:
   - Use refined concept as input
   - Get working code on first try

Exploring Different Markets

Generate ideas for specific symbols or timeframes:

code

# First, check available symbols
(Use browse-robonet-data skill)
get_all_symbols()
get_data_availability(symbols=["BTC-USDT", "ETH-USDT"], only_with_data=true)

# Generate ideas (generate_ideas pulls current market data automatically)
generate_ideas(strategy_count=3)

# AI will analyze current market conditions and propose strategies

Note: generate_ideas automatically analyzes current Hyperliquid market data. You don't need to specify symbol or timeframe—it considers the current market environment.

Common Workflows

Workflow 1: Exploring New Market

Goal: Generate ideas for trading a new asset

code

1. Browse available assets (use browse-robonet-data skill):
   get_all_symbols() → See what's available
   get_data_availability(symbols=["SOL-USDT"]) → Check history

2. Generate ideas:
   generate_ideas(strategy_count=3) → Get 3 concepts

3. Evaluate ideas:
   - Which idea fits current market regime?
   - Which idea has clearest logic?
   - Which idea has best risk/reward?

4. Select best idea:
   - Pick idea with clearest logic and appropriate risk

5. Build strategy (use build-trading-strategies skill):
   - Use selected idea as description input
   - Get working code in one attempt

Cost: ~$0.20-$0.50

Workflow 2: Brainstorming Session

Goal: Explore multiple approaches before committing to development

code

1. Generate initial batch:
   generate_ideas(strategy_count=5) → Get 5 diverse concepts

2. Group ideas by type:
   - Trend following: Ideas #1, #3
   - Mean reversion: Ideas #2, #4
   - Breakout: Idea #5

3. Compare approaches:
   - Trend following: Higher win rate but slower trades
   - Mean reversion: More trades but lower win rate
   - Breakout: Highest risk/reward but lowest frequency

4. Choose based on goals:
   - Want frequent trades? → Mean reversion
   - Want high win rate? → Trend following
   - Want big winners? → Breakout

5. Proceed to development:
   - Build chosen strategy type
   - Test thoroughly before deployment

Cost: ~$0.30-$0.70

Workflow 3: Validating Your Own Idea

Goal: See if your strategy concept is viable before building

code

1. You have an idea:
   "I want to trade BTC mean reversion using RSI"

2. Generate AI ideas:
   generate_ideas(strategy_count=3) → See what AI suggests

3. Compare:
   - Do any AI ideas match your concept?
   - What do AI ideas do differently?
   - Are there obvious flaws in your idea that AI avoids?

4. Refine your idea:
   - Incorporate AI insights
   - Add missing details (exit logic, risk management)
   - Validate indicator selection

5. Build refined strategy:
   - Use your idea + AI insights as input
   - Proceed to build-trading-strategies skill

Cost: ~$0.15-$0.40

Workflow 4: Market Regime Analysis

Goal: Understand what strategies work in current market

code

1. Generate ideas (AI analyzes current market automatically):
   generate_ideas(strategy_count=5)

2. Identify patterns in generated ideas:
   - All ideas trend-following? → Market is trending
   - All ideas mean-reversion? → Market is ranging
   - Mix of approaches? → Mixed/transitional market

3. Use insights to guide strategy selection:
   - Build strategy aligned with current regime
   - Be aware of regime change risk
   - Consider multi-regime strategies

4. Proceed to development:
   - Build strategy appropriate for current market

Cost: ~$0.30-$0.70

Advanced Usage

Combining with Browse Data

Optimal workflow for thorough exploration:

code

1. Browse data first (use browse-robonet-data skill):
   get_all_symbols() → Available assets
   get_all_technical_indicators(category="momentum") → Indicators
   get_allora_topics() → ML predictions available

2. Generate ideas:
   generate_ideas(strategy_count=4) → AI concepts

3. Cross-reference:
   - Do generated ideas use available indicators?
   - Can I enhance with Allora ML (check topics)?
   - Do I have sufficient data history?

4. Select idea that aligns with:
   - Available data
   - Available indicators
   - ML prediction coverage

5. Build with confidence:
   - All resources verified
   - No surprises during development

Extracting Patterns Across Ideas

Learn from multiple idea generations:

code

Generate ideas multiple times and track patterns:
- Session 1: generate_ideas(strategy_count=3) → Uses EMA, RSI, MACD
- Session 2: generate_ideas(strategy_count=3) → Uses EMA, ATR, Bollinger
- Session 3: generate_ideas(strategy_count=3) → Uses EMA, Volume, ADX

Pattern identified: EMA appears in 9/9 ideas → Fundamental indicator
→ Include EMA in your custom strategy design

Troubleshooting

"Generated Ideas Are Too Generic"

Issue: Ideas lack specific details or actionable logic

Solutions:

•This is expected—ideas are concepts, not complete strategies
•Use ideas as starting points, not final solutions
•Refine the best idea and use it as input to build-trading-strategies
•Ideas are meant to inspire, not to be implemented directly

"Ideas Don't Match My Market View"

Issue: AI generates trend-following ideas but you think market is ranging

Solutions:

•AI analyzes current data, but markets change
•Use ideas for inspiration, not gospel
•Modify concept to match your view
•Generate new ideas and select one that aligns better
•Remember: You have final say, AI provides suggestions

"All Ideas Look Similar"

Issue: 5 ideas generated but they're all variations of same approach

Solutions:

•This can happen if market regime is very clear (strong trend → all trend-following)
•Try generating another batch (different ideas each time)
•If pattern persists, market may strongly favor one approach
•Consider building the repeated strategy type (market is telegraphing opportunity)

"Ideas Use Indicators I Don't Understand"

Issue: AI suggests indicators you're unfamiliar with

Solutions:

•Use browse-robonet-data skill: get_all_technical_indicators() to see all indicators
•Research indicator (Google "ADX indicator trading" for examples)
•Ask AI to explain indicator in strategy description when building
•Choose ideas with familiar indicators if uncomfortable

Next Steps

After generating and evaluating ideas:

Build the strategy:

•Use build-trading-strategies skill to transform concept into code
•Cost: $1.00-$4.50 per strategy
•Provide refined idea description as input
•Get complete Python strategy code

Test the strategy:

•Use test-trading-strategies skill to backtest generated ideas
•Cost: $0.001 per backtest
•Validate performance before committing to expensive development

Improve the strategy:

•If you already have a strategy and want to refine it
•Use improve-trading-strategies skill
•Cost: $0.50-$4.00 per operation

Deploy to production:

•After thorough testing shows strong performance
•Use deploy-live-trading skill (HIGH RISK)
•Cost: $0.50 deployment fee
•NEVER deploy without extensive backtesting

Summary

This skill provides cheap AI-powered strategy ideation before expensive development:

•1 tool: generate_ideas (1-10 concepts per call)
•Cost: $0.05-$1.00 (significantly cheaper than building $1-$4.50)
•Execution: 20-40 seconds
•Purpose: Explore concepts, validate ideas, get inspiration

Core principle: Spend $0.30 exploring 3 ideas before spending $3.00 building. This saves money and improves outcomes.

Best practice: Browse data first (browse-robonet-data), generate ideas (this skill), then build best idea (build-trading-strategies). This workflow minimizes waste and maximizes success rate.

Remember: AI-generated ideas are starting points, not final solutions. Evaluate critically, refine, and validate before building.