Trade Polymarket BTC 5-minute and 15-minute fast markets using CEX price momentum signals via Simmer API. Default signal is Binance BTC/USDT klines. Use when user wants to trade sprint/fast markets, automate short-term crypto trading, or use CEX momentum as a Polymarket signal.
Instrucciones de origen · Vista previa de solo lectura
name
polymarket-fast-loop
description
Trade Polymarket BTC 5-minute and 15-minute fast markets using CEX price momentum signals via Simmer API. Default signal is Binance BTC/USDT klines. Use when user wants to trade sprint/fast markets, automate short-term crypto trading, or use CEX momentum as a Polymarket signal.
When the task matches this skill's domain expertise
When NOT to use:
For tasks outside this skill's scope
Trade Polymarket's 5-minute crypto fast markets using real-time price signals. Default: BTC momentum from Binance. Works with ETH and SOL too.
Polymarket only. All trades execute on Polymarket with real USDC. Use --live for real trades, dry-run is the default.
This is a template. The default signal (Binance momentum) gets you started — remix it with your own signals, data sources, or strategy. The skill handles all the plumbing (market discovery, import, trade execution). Your agent provides the alpha.
⚠️ Fast markets carry Polymarket's 10% fee (is_paid: true). Factor this into your edge calculations.
⚠️ Risk monitoring does not apply to sub-15-minute markets. Simmer's stop-loss and take-profit monitors check positions every 15 minutes — which means they will never fire on 5m or 15m markets before resolution. Any risk settings you configure in the Simmer dashboard have no effect on these positions. Size accordingly and do not rely on automated stop-losses for fast market trades.
When NOT to Use
When you cannot afford to lose the capital at risk
For instruments you do not understand
When emotional state impairs judgment (revenge trading, FOMO)
Overview
Polymarket Fast Loop provides market analysis capabilities with risk management.
Workflow
# Example: Position sizing (Kelly Criterion)defkelly_size(win_rate: float, avg_win: float, avg_loss: float) -> float:
if avg_loss == 0: return0
b = avg_win / abs(avg_loss)
kelly = (win_rate * b - ( - win_rate)) / b
(, (kelly * , ))
1
return
max
0
min
0.5
0.02
# Half-Kelly, max 2%
Research — Analyze market conditions and opportunities
Plan — Define entry, exit, and position sizing
Execute — Place trades with proper order types
Monitor — Track positions and market changes
Manage risk — Apply stop-losses and hedging
Review — Post-trade analysis and journaling
Risk Management
Never risk more than 1-2% of portfolio per trade
Set stop-loss before entering any position
Diversify across uncorrelated assets
Size positions based on volatility (ATR)
Have a maximum daily loss limit
Key Metrics
Win rate and profit factor
Sharpe ratio and max drawdown
Average risk-reward ratio
Expectancy per trade
Correlation to benchmark
Discipline Rules
Follow your trading plan — no impulsive trades
Cut losses short, let winners run
Review every trade in your journal
Never revenge trade after a loss
Take breaks after consecutive losses
Anti-Rationalization Table
Rationalization
Reality
"I will cut losses later"
Later never comes. Set stop-losses before entering any trade.
"This time is different"
It never is. Follow your strategy, not your emotions.
"I do not need to journal"
Journaling reveals patterns in your behavior. Track every trade.
Money-Making Overview
Run automated arbitrage between CEX BTC price momentum and Polymarket prediction markets. The core strategy: track Binance BTC/USDT 1-minute candles, detect short-term momentum shifts, and place opposing-direction positions on Polymarket's 5-minute and 15-minute crypto fast markets. These markets resolve based on whether BTC crosses certain price thresholds within the window — the same signal you can detect from CEX order flow seconds before the market closes.
Target 60-80% win rate on 5-minute signals with proper position sizing. Realistic daily earnings of $50-500 per account depending on bankroll size and signal quality. The 10% Polymarket fee is your biggest friction — it requires every edge estimate to include a fee_factor = 0.9 on gross payout. Small accounts ($100-1K) should use conservative 1-2% position sizing to survive variance.
Revenue Streams
Stream
Description
Estimated Income
Momentum Scalping
Trade 5-min/15-min fast markets using CEX momentum divergence signals. Each trade locked for 5-15 minutes.
$50-500/day per account
Multi-Account Scaling
Run 5-10 accounts in parallel (compliant with Polymarket ToS). Diversify signal parameters across accounts.
$500-5K/day
Copy-Trading / Signal Service
Sell access to your real-time signals via Telegram/API. Charge monthly subscription or profit-share.
$200-2K/month commissions
Fee Awareness
Polymarket fast markets carry a 10% platform fee (is_paid: true). This means a $100 win pays out $90. Factor this into every calculation:
Minimum viable edge = 11.2% (you need to beat the fee just to break even)
Position Sizing for Small Accounts
Small accounts ($100-1K bankroll) must be hyper-conservative:
Per-trade risk: 1-2% of bankroll ($2-20 on a $1K account)
Max concurrent trades: 2 (keep powder dry for the next signal)
Daily loss limit: 10% of bankroll — stop trading if hit
Recovery rule: After a 3-trade losing streak, step back for 2 hours
Half-Kelly: Use kelly_size() below with a 0.25 fractional factor instead of 0.5 for extra conservatism
defkelly_size_small(win_rate: float, avg_win: float, avg_loss: float) -> float:
fee_factor = 0.9# Polymarket takes 10%if avg_loss == 0: return0
b = (fee_factor * avg_win) / abs(avg_loss)
kelly = (win_rate * b - (1 - win_rate)) / b
returnmax(0, min(kelly * 0.25, 0.02)) # Quarter-Kelly, max 2%
First Action in 60 Minutes
This Python script generates your first live signal in under an hour. It fetches the latest Binance BTC/USDT 1m klines, calculates a simple momentum score, and prints a trade decision you can execute on Polymarket.
#!/usr/bin/env python3"""First Polymarket Fast Loop Signal Generator"""import time, hmac, hashlib, json, urllib.request
# --- Config ---
BINANCE_API = "https://api.binance.com/api/v3"
POLYMARKET_API = "https://clob.polymarket.com"# Polymarket fee is 10% on fast markets — factor into profit checks
FEE_FACTOR = 0.9deffetch_klines(symbol="BTCUSDT", interval="1m", limit=5):
"""Get latest 5 one-minute candles from Binance."""
url = f"{BINANCE_API}/klines?symbol={symbol}&interval={interval}&limit={limit}"with urllib.request.urlopen(url, timeout=10) as resp:
data = json.loads(resp.read().decode())
return [{
"open": float(k[1]), "high": float(k[2]), "low": float(k[3]),
"close": float(k[4]), "volume": float(k[5])
} for k in data]
defmomentum_score(klines):
"""Simple momentum: compare latest close vs avg of closes. Positive = bullish."""
closes = [k["close"] for k in klines]
latest = closes[-1]
avg = sum(closes) / len(closes)
return (latest - avg) / avg * 100# percent deviationdefsignal_decision(score):
"""Return a trade signal based on momentum divergence."""
threshold = 0.05# 0.05% deviation — adjust based on backtestingif score > threshold:
return {"action": "BUY", "direction": "UP",
"reason": f"CEX momentum bullish ({score:+.3f}%)"}
elif score < -threshold:
return {"action": "BUY", "direction": "DOWN",
"reason": f"CEX momentum bearish ({score:+.3f}%)"}
else:
return {"action": "HOLD", "direction": None,
"reason": f"No clear momentum signal ({score:+.3f}%)"}
if __name__ == "__main__":
print("=== Polymarket Fast Loop — First Signal ===\n")
klines = fetch_klines()
print(f"Binance BTC/USDT last 5 candles:")
for k in klines:
print(f" Close: ${k['close']:>7.1f} | Vol: {k['volume']:>8.2f}")
score = momentum_score(klines)
decision = signal_decision(score)
print(f"\nMomentum score: {score:+.3f}%")
print(f"Signal: {decision['action']} -> {decision['direction'] or'N/A'}")
print(f"Reason: {decision['reason']}")
print(f"\nPolymarket fee: 10% (factor = {FEE_FACTOR})")
if decision['action'] == 'BUY':
print("Next step: Find the active 5m/15m fast market on Polymarket ")
print("and place a USDC position matching your signal direction.")
else:
print("No trade. Wait for the next 1-minute candle and re-run.")
To run:
python3 first_signal.py
Next steps after the first signal:
Wire in the Simmer API for automated execution (see simmer-python examples)
Add a backtester using historical Binance klines vs Polymarket resolution data
Tune the momentum threshold parameter (0.05%) on at least 200 historical trades
Scale from 1 account to multiple independent strategies
Output Format
Every trade signal and execution result MUST follow this template:
{"timestamp":"2026-07-16T14:30:00Z","signal":{"source":"Binance BTC/USDT","score_pct":0.08,"direction":"UP","confidence":"medium"},"trade":{"market":"BTC > $60K at 14:35?","outcome":"YES","size_usdc":20.00,"fee_usdc":2.00,"potential_payout_usdc":18.00},"result":{"profit_loss_usdc":null,"win":null,"return_pct":null}}
Fill result after market resolution. Track every trade in a local CSV or SQLite for win-rate calculation and threshold tuning.
Process
Scope — Define research questions, identify data sources, set time boundaries
Gather — Collect data from primary sources, APIs, and public records
Synthesize — Analyze findings, identify patterns, produce actionable report
