trade-prediction-markets

仓库: robonet-tech/skills
安装量: 149
排名: #5782

安装

npx skills add https://github.com/robonet-tech/skills --skill 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
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)
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 : 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).
← 返回排行榜