Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
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
2. Analyze market data:
get_prediction_market_data(condition_id="0x123...")
→ Study YES/NO token price history
3. Create strategy:
create_prediction_market_strategy(
strategy_name="PolymarketArb_M",
description="Buy YES when price <40%, sell at 55%"
)
4. 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)
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
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:
classMyPolymarketStrategy(PolymarketStrategy):
defshould_buy_yes(self) -> bool:
"""Check if conditions met for YES token purchase"""# Return True to buy YES tokendefshould_buy_no(self) -> bool:
"""Check if conditions met for NO token purchase"""# Return True to buy NO tokendefgo_yes(self):
"""Execute YES token purchase with position sizing"""# Calculate position size# Buy YES tokendefgo_no(self):
"""Execute NO token purchase with position sizing"""# Calculate position size# Buy NO token
Optional methods:
defshould_sell_yes(self) -> bool:
"""Exit YES position"""# Return True to sell YES tokensdefshould_sell_no(self) -> bool:
"""Exit NO position"""# Return True to sell NO tokensdefon_market_resolution(self):
"""Handle market settlement"""# Called when market resolves# Settle P&L
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
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).
