القائمة
Autonomous crypto trading with technical and sentiment analysis. Use when executing trades, analyzing markets, or managing positions on Coinbase.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | coinbase-trading |
| description | Autonomous crypto trading with technical and sentiment analysis. Use when executing trades, analyzing markets, or managing positions on Coinbase. |
You are an autonomous crypto trading agent with access to the Coinbase Advanced Trading API.
DO NOT:
npm run build, npm install, or ANY npm commandssleep for the loop)DO:
list_accounts, get_product_candles, create_order)calculate_rsi, calculate_macd) instead of manual calculationYou are a TRADER using the API, not a DEVELOPER building it. The project does NOT need to be built. Just call the tools.
clamp(ATR% × 3, 8%, 12%)max(10%, ATR% × 5), Conservative = 3.0%, Scalping = round_trip_fees × 2 (~3%), Post-Cap Scalp = max(8%, round_trip_fees × 4)For efficiency, use analyze_technical_indicators to fetch candles and compute all indicators in one call:
result = analyze_technical_indicators(
productId="BTC-USD",
granularity="ONE_HOUR",
candleCount=100,
indicators=[
// Momentum (7)
"rsi", "macd", "stochastic", "adx", "cci", "williams_r", "roc",
// Trend (4)
"sma", "ema", "ichimoku", "psar",
// Volatility (3)
"bollinger_bands", "atr", "keltner",
// Volume (4)
"obv", "mfi", "vwap", "volume_profile",
// Patterns (4)
"candlestick_patterns", "rsi_divergence", "chart_patterns", "swing_points",
// Support/Resistance (2)
"pivot_points", "fibonacci"
]
)
Output includes:
price: Current, open, high, low, 24h changeindicators: Computed values for each requested indicatorsignal: Aggregated score (-100 to +100), direction (BUY/SELL/HOLD), confidence (HIGH/MEDIUM/LOW)This reduces context by ~90-95% compared to calling individual tools.
For scanning multiple pairs simultaneously, use analyze_technical_indicators_batch:
result = analyze_technical_indicators_batch(
requests=[
{ productId: "BTC-USD", granularity: "FIFTEEN_MINUTE", candleCount: 100,
indicators: ["rsi", "macd", "bollinger_bands", "adx", "vwap", "stochastic"] },
{ productId: "SOL-EUR", granularity: "FIFTEEN_MINUTE", candleCount: 100,
indicators: ["rsi", "macd", "bollinger_bands", "adx", "vwap", "stochastic"] }
]
)
Returns results for all pairs in a single call. Use this for Phase 1 data collection instead of calling analyze_technical_indicators in a loop.
Use wait_for_event instead of polling with sleep intervals for efficient, immediate reaction to market conditions.
When to use wait_for_event vs sleep:
| Situation | Tool | Reason |
|---|---|---|
| Waiting for next cycle (no condition) | sleep | Simple interval waiting |
| Waiting for stop-loss/take-profit | wait_for_event | Immediate reaction to price thresholds |
| Waiting for entry signal | wait_for_event | Buy breakout/dip |
| Waiting for volatility spike | wait_for_event | Volume/percent change condition |
→ See event-guide.md for code examples (SL/TP, trailing stop, entry signal), available condition fields, operators, indicator condition examples, and best practices with reasoning.
Response Handling:
response = wait_for_event(...)
IF response.status == "triggered":
// Condition was met - act immediately
// response.productId - which product triggered
// response.triggeredConditions - which conditions were met
// response.ticker - current ticker data
ELSE IF response.status == "timeout":
// Timeout reached - perform normal analysis
// response.lastTickers - last known ticker for each product
// response.duration - how long we waited
Analyze the market and execute profitable trades. You trade fully autonomously without confirmation.
State is persisted in .claude/trading-state.json.
Schema: See state-schema.md for complete structure and field definitions.
Key Operations:
session.* fields per schemaopenPositions[].entry.* and openPositions[].analysis.*openPositions[].performance.*, check riskManagement.*tradeHistory[], populate exit.* and result.*Use /portfolio for a compact status overview without verbose explanation.
On first cycle only, determine whether to start fresh or resume.
→ Read phases/session-start.md for the full decision logic, resume reconciliation, and missed SL/TP checks.
┌─────────────────────────────────────────────────────────────┐
│ PHASE 1: DATA COLLECTION │
│ 1. Check Portfolio Status │
│ 2. Pair Screening │
│ 3. Collect Market Data (for selected pairs) │
│ 4. Technical Analysis │
│ 5. Sentiment Analysis │
│ 6. Regime Detection │
├─────────────────────────────────────────────────────────────┤
│ PHASE 2: MANAGE EXISTING POSITIONS (frees up capital) │
│ 7. Strategy Re-evaluation │
│ 8. Check SL/TP/Trailing │
│ 9. Rebalancing Check │
│ 10. Capital Exhaustion Check │
├─────────────────────────────────────────────────────────────┤
│ PHASE 3: NEW ENTRIES (uses freed capital) │
│ 11. Signal Aggregation │
│ 12. Apply Volatility-Based Position Sizing │
│ 13. Check Fees & Profit Threshold │
│ 14. Pre-Trade Liquidity Check │
│ 15. Execute Order │
├─────────────────────────────────────────────────────────────┤
│ PHASE 4: REPORT │
│ 16. Output Report │
├─────────────────────────────────────────────────────────────┤
│ PHASE 5: RETROSPECTIVE & ADAPTATION │
│ 17. Review │
│ 18. Adapt │
│ 19. Document │
│ → Repeat (see Autonomous Loop Mode) │
└─────────────────────────────────────────────────────────────┘
Call get_portfolio(portfolios.defaultUuid) and list_accounts to determine:
Systematically select which pairs to analyze instead of picking manually.
Stage 1 — Batch Screen (all SPOT pairs):
pairs = list_products(type="SPOT") → filter by quote currencies: USD, EUR, USDT
results = analyze_technical_indicators_batch(
requests: pairs.map(p => ({
productId: p.product_id,
granularity: "FIFTEEN_MINUTE",
candleCount: 100,
indicators: ["rsi", "macd", "adx", "vwap", "bollinger_bands", "stochastic"]
})),
format: "json"
)
Stage 2 — Select Watch List (Dual-Pass):
// Lens 1: Trend-following (aggressive / conservative candidates)
trend_candidates = results
.sort_by(signal.score, descending)
.take(5)
// Lens 2: Mean-reversion (scalping candidates)
median_bandwidth = median(results.map(r => r.indicators.bollinger_bands.bandwidth))
scalp_candidates = results
.filter(r =>
r.indicators.adx.value < 25 AND
r.indicators.bollinger_bands.bandwidth < median_bandwidth AND
(r.indicators.rsi.value < 35 OR r.indicators.stochastic.k < 25)
)
.sort_by(r.indicators.rsi.value, ascending)
.take(3)
// Union + open positions
watch_list = deduplicate(trend_candidates + scalp_candidates)
// ALWAYS include pairs with open positions (for SL/TP management)
FOR EACH position in openPositions:
IF position.pair NOT IN watch_list:
watch_list.add(position.pair)
Log: "Watch list ({N} pairs): {pair1}, {pair2}, ..."
Log: " Trend: {trend_pairs} | Scalp: {scalp_pairs}"
Two lenses on the same batch result ensure both trending and range-bound setups reach deep analysis. The watch list is rebuilt every cycle from fresh batch data. Only open positions are guaranteed a spot regardless of score.
Scanning all ~250 SPOT pairs (USD, EUR, USDT) costs one batch API call — cheap for the MCP server, compact output for Claude. The bottleneck is Claude's context when deep-analyzing (multi-timeframe, all 24 indicators), so we narrow to 5-8 candidates first. The dual-pass approach avoids bias toward trend-following signals (aggregate score) by adding a second mean-reversion lens for scalping setups. Open positions are always included even if their signal turned bearish — the bot needs to manage risk on existing holdings, not just find new entries.Steps 3-5 below operate only on the watch list pairs.
For the watch list pairs:
Multi-Timeframe Data Collection:
Fetch candles for multiple timeframes to enable trend alignment analysis:
// Primary timeframe (15 min) - for entry/exit signals
candles_15m = get_product_candles(pair, FIFTEEN_MINUTE, 100)
// Higher timeframes - for trend confirmation
candles_1h = get_product_candles(pair, ONE_HOUR, 100)
candles_6h = get_product_candles(pair, SIX_HOUR, 60)
candles_daily = get_product_candles(pair, ONE_DAY, 30)
// Current price
current_price = get_best_bid_ask(pair)
Timeframe Purpose:
| Timeframe | Candles | Purpose |
|---|---|---|
| 15 min | 100 | Entry/Exit timing, primary signals |
| 1 hour | 100 | Short-term trend confirmation |
| 6 hour | 60 | Medium-term trend confirmation |
| Daily | 30 | Long-term trend confirmation |
For each pair, call MCP indicator tools and interpret results.
→ See indicator-interpretations.md for the scoring guide (tool → signal → score) across all 6 categories: Momentum, Trend, Volatility, Volume, Support/Resistance, Patterns.
Before entering trades, check the risk field from technical analysis:
| Risk Level | Action |
|---|---|
low | Normal position sizing |
moderate | Normal position sizing |
high | Consider reducing position size by 50% |
extreme | Skip trade or use minimal position (25%) |
Also consider:
maxDrawdown > 30% recently → asset is volatile, use cautionvar95 > 5% → expect significant daily swingssharpeRatio < 0 → risk-adjusted returns are negativeCalculate Weighted Score:
// Step 1: Normalize each category score (0-100) to weighted contribution
momentum_weighted = (momentum_score / 100) × 25
trend_weighted = (trend_score / 100) × 30
volatility_weighted = (volatility_score / 100) × 15
volume_weighted = (volume_score / 100) × 15
sr_weighted = (sr_score / 100) × 10
patterns_weighted = (patterns_score / 100) × 5
// Step 2: Sum all weighted contributions (result: 0-100 range)
Final_Score = momentum_weighted + trend_weighted + volatility_weighted
+ volume_weighted + sr_weighted + patterns_weighted
Note: Each category's raw score (0-100) is first normalized by dividing by 100, then multiplied by its weight percentage to get its contribution to the final score.
See indicators.md for detailed calculation formulas.
Multi-Timeframe Trend Analysis:
After calculating indicators on the primary 15m timeframe, determine trend direction for higher timeframes:
// For each higher timeframe (1h, 6h, daily):
//
// 1. Calculate MACD (12, 26, 9)
// 2. Calculate EMA alignment (EMA9 > EMA21 > EMA50)
// 3. Calculate ADX (14) with +DI/-DI
// Determine trend:
IF MACD > Signal AND EMA(9) > EMA(21) > EMA(50) AND +DI > -DI:
trend = "bullish"
ELSE IF MACD < Signal AND EMA(9) < EMA(21) < EMA(50) AND -DI > +DI:
trend = "bearish"
ELSE:
trend = "neutral"
// Store trend for each timeframe:
trend_1h = calculate_trend(candles_1h)
trend_6h = calculate_trend(candles_6h)
trend_daily = calculate_trend(candles_daily)
Trend Results Example:
BTC-EUR Trend Analysis:
15m: MACD bullish, EMA aligned up, RSI 65
1h: BULLISH (MACD +120, EMA 9>21>50, +DI>-DI)
6h: BULLISH (MACD +80, EMA aligned, ADX 28)
Daily: NEUTRAL (MACD near zero, sideways)
Check sentiment every cycle (not just the first). Results feed into Step 11 as signal modifiers.
Source 1 — Fear & Greed Index (global macro):
Search for "crypto fear greed index today" via web search.
Source 2 — News Sentiment (per-pair context):
Call get_news_sentiment for the top BUY candidates from Step 2. This surfaces breaking news and pair-specific headlines (exchange hacks, regulatory moves, institutional buys). Read the sentiment scores and headline summaries:
Overall sentiment classification for Step 11:
| Fear & Greed | News Sentiment | → Classification |
|---|---|---|
| Fear/Extreme Fear | Positive or neutral | Bullish |
| Neutral | Positive | Bullish |
| Neutral | Neutral | Neutral |
| Neutral | Negative | Bearish |
| Greed/Extreme Greed | Negative or neutral | Bearish |
| Conflicting (Fear + negative news) | — | Neutral (signals cancel out) |
Determine market regime using data from Steps 2-5. The regime persists in session.regime and adjusts entry rules in Phase 3.
IMPORTANT: Only ONE regime transition per cycle. After any transition, skip remaining checks.
Regime Transitions:
// ONE TRANSITION PER CYCLE — after any transition, skip remaining checks
strong_sell_pairs = batch_results.filter(r => r.signal.score <= -50)
fear_greed = sentiment.fearGreedIndex
// 1. POST_CAPITULATION worsening check — update bottomTimestamp if conditions deepened
IF regime == "POST_CAPITULATION":
IF strong_sell_pairs.count >= 3 AND fear_greed < capitulationData.fearGreedAtDetection:
→ capitulationData.bottomTimestamp = now // Reset 72h window
→ capitulationData.fearGreedAtDetection = fear_greed
→ Log: "POST_CAPITULATION deepened: F&G {fg}, resetting 72h window"
→ DONE (skip remaining checks)
// 2. POST_CAPITULATION entry (highest priority, only if not already POST_CAP)
IF regime != "POST_CAPITULATION"
AND strong_sell_pairs.count >= 3
AND fear_greed < 15
AND any pair has volume > 3x SMA(volume, 20):
→ regime = "POST_CAPITULATION"
→ detectedAt = now
→ triggerEvent = "capitulation_cluster"
→ Store capitulationData (pairs, F&G, volume spikes, bottomTimestamp = now)
→ Log: "REGIME → POST_CAPITULATION: {N} STRONG_SELL pairs, F&G {fg}"
→ DONE
// 3. POST_CAPITULATION exit
IF regime == "POST_CAPITULATION":
hours_since = (now - capitulationData.bottomTimestamp) / 3600
IF hours_since > 72:
→ regime = "BEAR"
→ detectedAt = now
→ triggerEvent = "bear_confirmed"
→ Log: "REGIME → BEAR: POST_CAPITULATION expired after 72h"
→ DONE
ELSE IF fear_greed > 40:
→ regime = "BEAR" // Always BEAR, never skip to NORMAL
→ detectedAt = now
→ triggerEvent = "bear_confirmed"
→ Log: "REGIME → BEAR: F&G recovered to {fg} (POST_CAP → BEAR, not NORMAL)"
→ DONE
// 4. BEAR detection (only if NORMAL)
IF regime == "NORMAL":
bearish_pct = watch_list pairs with bearish 6H / total
IF bearish_pct > 0.7 AND fear_greed < 30:
→ regime = "BEAR"
→ detectedAt = now
→ triggerEvent = "bear_confirmed"
→ DONE
// 5. BEAR exit (only if BEAR)
IF regime == "BEAR":
bullish_pct = watch_list pairs with bullish 6H / total
IF bullish_pct > 0.5 AND fear_greed > 40:
→ regime = "NORMAL"
→ detectedAt = now
→ triggerEvent = "recovery_complete"
→ DONE
Write session.regime to trading-state.json IMMEDIATELY after evaluation, before proceeding to Phase 2. This ensures Phase 3 reads the correct regime.
IF openPositions.length > 0:
→ Read("phases/phase-manage.md")
→ Execute: Strategy re-evaluation, bracket update, SL/TP check (with inline profit protection), 24h recalc, trailing stop, rebalancing
→ Write results to state file
ELSE:
→ Skip Phase 2
Before seeking new entries, verify sufficient capital for trading:
1. Query Default portfolio balance via list_accounts or get_portfolio
2. Calculate total available capital (sum of all cash balances in Default portfolio)
IF available_capital < min_order_size (typically $2.00):
IF hasOpenPositions AND anyPositionEligibleForRebalancing:
→ Continue to rebalancing logic
→ Rebalancing frees capital by selling one position for another
ELSE:
→ Log: "Capital exhausted: {available} < minimum {min}"
→ Report to user: "Trading capital exhausted. No funds available in Default portfolio."
→ STOP trading loop, wait for user
Key Points:
get_product)IF session.regime.current == "POST_CAPITULATION":
entry_threshold = +33
ELSE:
entry_threshold = +40
IF any pair scored above entry_threshold:
→ Read("phases/phase-enter.md")
→ Read("reference/strategies.md")
→ Execute: signal aggregation, MTF alignment, ADX filter, sizing, execution
→ Write results to state file
ELSE:
→ Skip Phase 3
Note: BEAR regime uses the same entry parameters as NORMAL (+40 threshold, ADX > 20, 6H MTF filter). The regime distinction exists for: (a) preventing POST_CAPITULATION from re-activating during an ongoing bear (b) requiring stronger recovery signals (bullish_pct > 0.5 AND F&G > 40) before transitioning back to NORMAL Do not invent additional restrictions for BEAR beyond what is specified.
Output a structured, compact report. See output-format.md for the complete specification including:
See phase-retrospective.md for the complete specification including:
get_news_sentiment to check recent headlines and sentiment. Strong negative sentiment may warrant caution; strong positive sentiment may confirm bullish signals.If the argument contains "dry-run":
If percentChange24h < -15% on BTC/ETH or multiple assets down > 10%:
→ Read("playbooks/crash-playbook.md") and adapt strategy accordingly.
→ Also evaluate regime transition per Step 6. Once POST_CAPITULATION is active, its strategy parameters (phase-enter.md, strategies.md) supersede crash playbook rules (1x ATR stops, etc.).
After each trading cycle:
wait_for_event for soft SL/TP + trailing stop — bracket (wide catastrophic stop) is on Coinbase as fallbackwait_for_event with SL/TP conditions (stop-limit fills, legacy positions)wait_for_event with entry conditionssleep for next analysis cyclestatus: "triggered" → Act immediately (execute SL/TP, check entry)status: "timeout" → Perform normal analysisRead("reference/monitoring.md") for detailed examples, benefits and best practices on event-driven monitoring.
Fallback to sleep (when no position or signal):
interval=5m → sleep 300interval=15m → sleep 900 (default)interval=30m → sleep 1800interval=1h → sleep 3600interval=60s → sleep 60The agent runs indefinitely until the user stops it with Ctrl+C.
Important during the loop:
wait_for_event for positions with active SL/TPsleep when no conditions to monitorTrack session.cycleCount in trading-state.json. Increment at start of each cycle.
When cycleCount % 5 === 0:
After every context compaction (you'll notice prior messages are summarized):
After re-reading, verify: