trade-prediction-markets

Trade Prediction Markets

Quick Start

This skill enables trading on Polymarket prediction markets (YES/NO tokens) for real-world events.

Load the tools first:

Use MCPSearch to select: mcp__workbench__get_all_prediction_events
Use MCPSearch to select: mcp__workbench__get_prediction_market_data
Use MCPSearch to select: mcp__workbench__create_prediction_market_strategy

Basic workflow:

1. Browse markets:
   get_all_prediction_events(market_category="crypto_rolling")
   → See BTC/ETH price prediction markets

1. Analyze market data: get_prediction_market_data(condition_id="0x123...") → Study YES/NO token price history

2. Create strategy: create_prediction_market_strategy( strategy_name="PolymarketArb_M", description="Buy YES when price <40%, sell at 55%" )

3. Test strategy: run_prediction_market_backtest( strategy_name="PolymarketArb_M", ... )

**When to use this skill**:
- Trading on real-world events (elections, Fed decisions, sports)
- Want binary outcome exposure (YES/NO)
- Interested in probability-based trading
- Exploring prediction market opportunities

## Available Tools (6)

### get_all_prediction_events

**Purpose**: Browse available Polymarket prediction markets

**Parameters**:
- `active_only` (optional, boolean): Only active events (default: true)
- `market_category` (optional, string): Filter by category

**Categories**:
- `crypto_rolling`: Crypto price predictions (BTC >$100k in next hour?)
- `politics`: Elections, policy decisions
- `economics`: GDP, inflation, Fed decisions
- `sports`: Game outcomes, championships
- `entertainment`: Awards, box office results

**Returns**: List of events with names, categories, markets, condition IDs, resolution status

**Pricing**: $0.001

**Use when**: Discovering trading opportunities, browsing available markets

### get_prediction_market_data

**Purpose**: Analyze YES/NO token price history for specific market

**Parameters**:
- `condition_id` (required): Polymarket condition ID
- `start_date` (optional): Filter from date (YYYY-MM-DD)
- `end_date` (optional): Filter to date (YYYY-MM-DD)
- `timeframe` (optional): Candle timeframe (1m, 5m, 15m, 30m, 1h, 4h, default: 1m)
- `limit` (optional, 1-10000): Max candles per token (default: 1000)

**Returns**: Market metadata, YES token price timeseries, NO token price timeseries

**Pricing**: $0.001

**Use when**: Analyzing market price history, researching token behavior, validating strategy concepts

### create_prediction_market_strategy

**Purpose**: Generate Polymarket strategy code with YES/NO trading logic

**Parameters**:
- `strategy_name` (required): Strategy name (follow pattern: Name_RiskLevel)
- `description` (required): Detailed requirements for YES/NO logic, exit criteria, position sizing

**Returns**: Complete Python PolymarketStrategy code

**Pricing**: Real LLM cost + margin (max $4.50)

**Execution Time**: ~30-60 seconds

**Use when**: Building new Polymarket strategies

### run_prediction_market_backtest

**Purpose**: Test prediction market strategy on historical data

**Parameters**:
- `strategy_name` (required): PolymarketStrategy to test
- `start_date` (required): Start date (YYYY-MM-DD)
- `end_date` (required): End date (YYYY-MM-DD)
- `condition_id` (for single market): Specific condition ID
- `asset` (for rolling markets): Asset symbol ("BTC", "ETH")
- `interval` (for rolling markets): Market interval ("15m", "1h")
- `initial_balance` (optional): Starting USDC (default: 10000)
- `timeframe` (optional): Execution timeframe (default: 1m)

**Returns**: Backtest metrics (profit/loss, win rate, position history)

**Pricing**: $0.001

**Execution Time**: ~20-60 seconds

**Use when**: Validating prediction market strategies

### get_data_availability

**Purpose**: Check available data ranges for Polymarket markets

**Parameters**:
- `data_type`: "polymarket" or "all"
- `asset` (optional): Filter by asset
- `include_resolved` (optional): Include resolved markets

**Returns**: Data availability with date ranges

**Pricing**: $0.001

**Use when**: Before backtesting (verify sufficient data)

### get_latest_backtest_results

**Purpose**: View recent prediction market backtest results

**Parameters**:
- `strategy_name` (optional): Filter by strategy
- `limit` (optional): Number of results

**Returns**: Recent backtest records

**Pricing**: Free

**Use when**: Checking existing backtest results

## Core Concepts

### Prediction Market Mechanics

**YES/NO Token Structure**:

Event: "Will BTC exceed $100,000 by end of hour?"

YES Token:

• Pays $1.00 if event occurs
• Pays $0.00 if event doesn't occur
• Current price = Market's implied probability
• Example: YES token at $0.65 = 65% implied probability

NO Token:

• Pays $1.00 if event DOESN'T occur
• Pays $0.00 if event occurs
• Current price = 1 - YES price
• Example: NO token at $0.35 = 35% implied probability

Total: YES price + NO price ≈ $1.00 (arbitrage if not)

**How trading works**:

Scenario: YES token at $0.40

Buy YES token:

• Pay $0.40 now
• If event occurs: Receive $1.00 (profit $0.60 = 150% return)
• If event doesn't occur: Lose $0.40 (-100% return)

Risk/Reward:

• Risking $0.40 to make $0.60
• 1.5:1 reward:risk ratio
• Need >40% win rate to break even

### Market Categories

**Crypto Rolling Markets** (high frequency):

Type: Continuous prediction markets Frequency: Every 15m, 1h, 4h, etc. Question: "Will BTC price increase next [interval]?"

Example:

• 1h BTC rolling market
• New market every hour
• Predict if BTC closes higher than current price

Use case: Short-term price speculation Trading style: Active, high frequency

**Politics** (event-driven):

Type: One-time events Frequency: Varies (elections, policy decisions) Timeline: Days to months until resolution

Examples:

• "Will candidate X win election?"
• "Will bill Y pass Congress by date Z?"
• "Will Fed cut rates in next meeting?"

Use case: Event speculation Trading style: Position trading, hold until resolution

**Economics** (data release):

Type: Scheduled data releases Frequency: Monthly, quarterly Timeline: Fixed resolution dates

Examples:

• "Will CPI exceed 3.5% next month?"
• "Will GDP growth exceed 2% this quarter?"
• "Will unemployment rate decrease?"

Use case: Economic data predictions Trading style: Position before release, exit at resolution

**Sports** (scheduled events):

Type: Game outcomes, championships Frequency: Varies by sport Timeline: Hours to months

Examples:

• "Will Team X win game tonight?"
• "Will Player Y score >25 points?"
• "Will Team Z win championship?"

Use case: Sports betting alternative Trading style: Event-based positions

### Strategy Types

**Probability Arbitrage** (mean reversion):

Concept: Buy underpriced probabilities, sell when corrected

Example:

• Event has ~60% true probability
• YES token priced at $0.45 (implies 45%)
• Buy YES (underpriced)
• Sell when price reaches $0.60 (fair value)

Advantages: Mathematical edge if probability estimation accurate Disadvantages: Requires good probability estimation

**Trend Following** (momentum):

Concept: Follow YES/NO token price momentum

Example:

• YES token price rising from $0.30 → $0.45
• Buy YES (momentum continuing)
• Exit when momentum fades

Advantages: Captures strong moves Disadvantages: Late entries, whipsaws

**Mean Reversion** (range trading):

Concept: Fade extreme probability movements

Example:

• YES token spikes to $0.85 (85% implied)
• Seems too high, buy NO token ($0.15)
• Exit when reverts toward mean

Advantages: Profits from overreactions Disadvantages: Catching falling knives (sometimes market is right)

**Event-Driven** (catalyst trading):

Concept: Trade based on news/catalysts

Example:

• Positive news for candidate X
• Buy YES token before market fully reacts
• Exit after market prices in news

Advantages: Early mover advantage Disadvantages: Requires fast news reaction

### Rolling Markets

**How rolling markets work**:

BTC 1h Rolling Market:

Hour 1 (12:00-13:00):

• Market created at 12:00
• Question: "Will BTC close higher at 13:00 than 12:00?"
• YES/NO tokens trade 12:00-13:00
• Resolves at 13:00 based on price change

Hour 2 (13:00-14:00):

• New market created at 13:00
• Previous market resolved
• Profits/losses settled
• Process repeats

Strategy rolls from market to market automatically

**Advantages of rolling markets**:
- Continuous trading opportunities
- More data for backtesting (many markets)
- Predictable resolution times
- Suitable for algorithmic trading

**Disadvantages**:
- Higher frequency = more fees
- Requires active monitoring
- Shorter time to resolution (less time to be right)

### Polymarket Strategy Framework

**Required methods**:
```python
class MyPolymarketStrategy(PolymarketStrategy):
    def should_buy_yes(self) -> bool:
        """Check if conditions met for YES token purchase"""
        # Return True to buy YES token

    def should_buy_no(self) -> bool:
        """Check if conditions met for NO token purchase"""
        # Return True to buy NO token

    def go_yes(self):
        """Execute YES token purchase with position sizing"""
        # Calculate position size
        # Buy YES token

    def go_no(self):
        """Execute NO token purchase with position sizing"""
        # Calculate position size
        # Buy NO token

Optional methods:

    def should_sell_yes(self) -> bool:
        """Exit YES position"""
        # Return True to sell YES tokens

    def should_sell_no(self) -> bool:
        """Exit NO position"""
        # Return True to sell NO tokens

    def on_market_resolution(self):
        """Handle market settlement"""
        # Called when market resolves
        # Settle P&L

Best Practices

Market Selection

Choose liquid markets:

High liquidity: >$50k volume
- Tight spreads
- Easy entry/exit
- Reliable pricing

Low liquidity: <$10k volume
- Wide spreads
- Difficult exits
- Slippage risk

Recommendation: Start with high-volume markets

Prefer clear resolution criteria:

GOOD: "Will BTC close above $100k at 5pm EST on Jan 1, 2025?"
- Objective resolution source (price data)
- Specific date and time
- No ambiguity

BAD: "Will crypto have a good year in 2025?"
- Subjective ("good" is undefined)
- Ambiguous resolution criteria
- Dispute risk

Avoid ambiguous outcomes:

Check resolution source:
- Data-driven (prices, scores, votes) → Good
- Subjective judgment → Bad
- "Community decides" → High dispute risk

Research past market resolutions:
- Were resolutions fair?
- Any disputed outcomes?
- Market maker credibility

Strategy Development

Define clear probability thresholds:

Example: Probability arbitrage strategy

Entry logic:
- Buy YES if price <40% (undervalued)
- Buy NO if price <40% (YES >60%, overvalued)

Exit logic:
- Sell YES at 55% (15% profit target)
- Sell NO at 55% (symmetric)
- Stop loss at 25% (37.5% loss, preserve capital)

Include position sizing:

Fixed percentage:
- 5% of capital per market
- Max 10 simultaneous positions = 50% deployed
- Conservative, predictable

Kelly Criterion:
- Size based on edge and odds
- More aggressive, optimal growth
- Requires accurate probability estimation

Set exit criteria:

Profit targets:
- Sell at X% gain (e.g., 15% above entry)

Time-based exits:
- Close position Y hours before resolution
- Avoid last-minute volatility

Stop losses:
- Sell if price drops below Z% (e.g., 60% of entry)
- Preserve capital on wrong predictions

Risk Management

Position limits:

Per market: 5-10% of capital
- Limits single-market exposure
- Diversifies risk

Total exposure: 50-70% of capital
- Leaves cash buffer
- Allows for new opportunities
- Prevents overtrading

Market diversification:

Don't concentrate in one category:
- 3 crypto markets
- 2 politics markets
- 2 sports markets
→ Diversified across event types

Avoid:
- 10 BTC rolling markets
→ All correlated, high concentration risk

Liquidity monitoring:

Check before entry:
- Current volume
- Bid/ask spread
- Order book depth

If liquidity drops:
- May be unable to exit
- Accept mark-to-market loss
- Or hold until resolution

Common Workflows

Workflow 1: Exploring Rolling Markets

Goal: Find BTC rolling market trading opportunities

1. Browse crypto rolling markets:
   get_all_prediction_events(market_category="crypto_rolling")
   → Lists BTC, ETH rolling markets with intervals

2. Check data availability:
   get_data_availability(data_type="polymarket", asset="BTC")
   → Verify sufficient history for backtesting

3. Analyze specific market:
   get_prediction_market_data(
       condition_id="0x123...",
       timeframe="1m",
       limit=5000
   )
   → Study YES/NO token price patterns

4. Identify strategy:
   - YES token often overshoots (>60%)
   - Mean reversion opportunity
   - Buy NO when YES >65%, exit at 55%

5. Create strategy:
   create_prediction_market_strategy(
       strategy_name="BTCRollingMeanRev_M",
       description="Buy NO token when YES >65%, exit at 55%..."
   )

6. Backtest strategy:
   run_prediction_market_backtest(
       strategy_name="BTCRollingMeanRev_M",
       asset="BTC",
       interval="1h",
       start_date="2024-01-01",
       end_date="2024-12-31"
   )

Cost: ~$2.50 ($0.003 data + $2.50 strategy creation)

Workflow 2: Event-Driven Politics Trading

Goal: Trade on election prediction market

1. Browse politics markets:
   get_all_prediction_events(market_category="politics")
   → Find election markets

2. Analyze candidate X market:
   get_prediction_market_data(condition_id="election_123")
   → Study YES token price leading up to election

3. Identify pattern:
   - YES token very volatile
   - Spikes on good news, drops on bad news
   - Opportunities to buy dips, sell spikes

4. Create strategy:
   create_prediction_market_strategy(
       strategy_name="ElectionDipBuy_M",
       description="Buy YES when price drops >15% in 24h,
                   sell when recovers to pre-drop level..."
   )

5. Backtest (limited data for one-time events):
   - May have insufficient data for thorough backtest
   - Analyze manually or use similar past events

6. Trade carefully:
   - Event markets have less data
   - Higher uncertainty
   - Start with smaller position sizes

Cost: ~$2.50

Workflow 3: Multi-Market Portfolio

Goal: Build diversified prediction market portfolio

1. Identify multiple opportunities:
   - BTC 1h rolling (crypto)
   - Fed decision (economics)
   - Championship game (sports)

2. Create strategies for each:
   - Strategy 1: BTC rolling mean reversion
   - Strategy 2: Fed decision probability arbitrage
   - Strategy 3: Sports underdog value

3. Backtest all strategies:
   run_prediction_market_backtest(...) for each

4. Allocate capital:
   - BTC rolling: 15% (more data, higher confidence)
   - Fed decision: 10% (one-time event, moderate confidence)
   - Sports: 5% (less data, lower confidence)
   Total: 30% deployed, 70% cash

5. Monitor performance:
   - Track each strategy independently
   - Rebalance based on results
   - Stop underperformers

Cost: ~$7.50 (3 strategies)

Troubleshooting

"No Prediction Events Found"

Issue: get_all_prediction_events returns empty

Solutions:

• Try active_only=False to see resolved markets
• Check different market_category
• Markets may be temporarily unavailable

"Insufficient Market Data"

Issue: Not enough history for backtesting

Solutions:

• Prediction markets have shorter history than crypto
• Use shorter backtest periods (1-3 months)
• Focus on rolling markets (more data points)
• Some events are one-time (limited data)

"Strategy Performs Poorly"

Issue: Backtest shows losses

Solutions:

• Prediction markets are efficient (hard to beat)
• Check if probability estimation is accurate
• Verify strategy logic makes sense
• Consider fees and slippage
• May need more sophisticated approach

Next Steps

After creating prediction market strategies:

Test thoroughly:

• Use test-trading-strategies for backtesting
• Validate on multiple markets
• Check win rate and profit factor

Refine strategies:

• Use improve-trading-strategies to refine
• Optimize thresholds and parameters
• Test improvements

Live deployment (when supported):

• Currently simulation only
• Live Polymarket deployment coming soon
• Will use deploy-live-trading when available

Summary

This skill provides Polymarket prediction market trading:

• 6 tools: Events browsing, data analysis, strategy creation, backtesting
• Cost: $0.001 for data, $1-$4.50 for strategy creation
• Markets: Politics, economics, sports, crypto rolling
• Status: Simulation only (live deployment coming)

Core principle: Prediction markets trade YES/NO tokens on real-world events. Success requires accurate probability estimation and disciplined risk management.

Best practices: Choose liquid markets with clear resolution criteria, diversify across event types, use proper position sizing (5-10% per market), set profit targets and stop losses.

Current limitation: Live deployment not yet supported. Use for backtesting and strategy development. Live trading will be available in future updates.

Note: Prediction markets are efficient. Beating them consistently is difficult. Start with simulation, validate edge thoroughly before risking capital (when live deployment available).