Backtesting Arena

Reviewed 1d ago.

• tools: 49 tools scanned
• metadata: scanned

No findings.

Tools (49)

• arena_get_pulse

  How hot is the Bitcoin market today? Daily 0-100 heat score for the Bitcoin market, aggregated from 8 components (BTC-Cycle, F&G, Altcoin-Season, Bullmarket-Ampel, Funding-Rate, Hash-Ribbons, Mayer-Multiple, MVRV-Z). Returns score, band label, color, 7d/30d delta, verdict, components breakdown, plus score_percentile ranking today’s score against its own history (e.g. 42 = 44th percentile — how hot/cold vs history, not just the raw number). score_semantics says which value you hold: the daily snapshot frozen once a day by the cron, or — before that cron has run for today — a live preliminary that still moves and whose percentile/deltas compare against frozen snapshots. [Free tier]

• arena_get_cycle

  Crypto cycle position — where are we in the cycle? Default BTC: point-in-time 9-indicator aggregation (Pi-Cycle Top & Bottom, Mayer Multiple, weekly RSI, 200-week-MA distance, halving position, Fear & Greed, BTC-dominance trend, mining-difficulty trend — weights in indicator_scores; components without input are excluded and weights renormalized, see indicator_coverage). Includes an `ath` block (E32): ATH on UTC daily-close basis with ath_date, days_since_ath and drawdown_from_ath_pct vs BOTH the scoring price and the live spot. Pass asset=ETH or asset=SOL for a per-coin cycle read built from the transferable price-derived indicators (Mayer, weekly-RSI, 200-week-MA distance) with renormalized weights; BTC-native indicators (halving, dominance, mining, F&G, Pi-Cycle) are returned as `not_applicable` rather than faked. All return raw + Z-Score, signal enum, and a `percentiles` block ranking each indicator against that asset’s own history. The `signal` enum is a FIXED SCORE-BAND LABEL (<25

• arena_get_spot_price

  Current BTC, ETH and SOL spot price — what is Bitcoin (or ETH/SOL) worth right now? Live USDT-quoted last price plus 24h change %, high and low from Binance. Use this to anchor the connector’s own analytics (cycle, historical-analog, gem scores) with the current market price instead of switching to web search mid-analysis. [Free tier]

• arena_get_stablecoin_supply

  Aggregate stablecoin supply (crypto-liquidity proxy) — is the liquidity impulse turning or accelerating? macro_regime only gives the 30d delta; this exposes the trend: current supply, 30d/90d change (USD + %) plus a daily time series (`days`, default 365; `resolution` states points and spacing) so direction and speed are visible, not just a single delta. Read `impulse` for what the supply change is doing — four states (accelerating / decelerating / reversal / flat). The neighbouring `acceleration_usd` is the signed difference last-30d minus prior-30d and gets LARGE exactly when the trend reverses, while the older boolean `accelerating` requires the same direction AND a bigger magnitude; a reversal therefore shows a big `acceleration_usd` next to `accelerating: false`. Source DefiLlama peggedUSD. [Free tier]

• arena_get_etf_flows

  Spot-ETF net flows (USD millions) — is the flow impulse turning or accelerating? The summary only gives point-in-time deltas; this exposes the trend: 30d/90d net flow, a direction label (inflows/outflows/flat) and a daily series (every US trading day: cumulative inflow + that day's net flow; `resolution` states points and spacing) so direction and speed are visible, not just a single delta. Read `impulse` for what the flow is doing — it has four states (accelerating / decelerating / reversal / flat) and is the field to quote. Two neighbouring fields measure different things and are easy to confuse: `acceleration_usd_m` is the signed difference last-30d minus prior-30d and gets LARGE precisely when the flow reverses, while the older boolean `accelerating` requires the same direction AND a bigger magnitude — so a swing from outflows to inflows shows a big positive `acceleration_usd_m` together with `accelerating: false`, which is correct and reads like a contradiction. `impulse` reports

• arena_get_altcoin_season

  Is it altcoin season? Daily Altcoin-Season indicator (v7 Native-Filter methodology). Returns BTC-Dominance, Alt-Dominance, 4 Layer-1 signals (USDT.D, USDC.D, BTC-DOM, ETH-DOM), overall color (red/amber/green) + Top-50 CoinGecko snapshot. [Free tier]

• arena_get_fear_greed

  How fearful or greedy is the market right now? Crypto Fear & Greed Index (alternative.me). Returns the current `value` (0-100) and `classification` (extreme fear / fear / neutral / greed / extreme greed) as their own fields, plus `history` — the last 90 daily readings by default, so you can see whether today is a move or a plateau. The window is capped in SIZE but free in POSITION: `end_date` moves it anywhere in the history since 2018 (e.g. end_date=2025-10-06 reads the sentiment around the October 2025 top), and the `range` block states requested / granted / available days with the reason — a short series here is a window, not a young index. On Pro and Elite two Arena-derived blocks add what the upstream index does not publish: `cadence` (how far smoothed sentiment has travelled versus ~90 days ago) and `tempo` (how FAST the index is moving — 7d and 30d change ranked as a rolling percentile against three years of same-direction moves, not a fixed threshold; rank compares with its own

• arena_get_bullmarket_ampel

  Is this still a bull market? Bitcoin Bullmarket-Ampel current state (0-5 active stages). Returns active_count, a stages[] breakdown (each stage with key, label, active and `since` = first day of its current state; null when the state predates the 400-day lookup) and stage_history — per day active_count PLUS all five per-stage booleans, so which stage flipped when is readable directly (history_days 1-365, default 30). Higher count = more bull-market signals firing. Stages evaluate weekly 20W/50W-MA conditions. [Free tier]

• arena_get_funding_rate

  Are longs or shorts paying right now? Latest BTC perpetual funding rate, averaged across up to 4 exchanges (Binance, Bybit, OKX, Deribit; 8h settlement cadence). Returns value, 30d moving average and Z-Score. Positive = longs pay shorts (bullish bias), negative = shorts pay longs (bearish bias). Read `coverage` before comparing values across dates: it says how many exchanges stand behind that day (4 = full average, 1 = a single exchange), and a day-over-day move can be a change in composition rather than in the market; `venues_present`/`venues_missing` name the exchanges. A value of exactly 0.0001 (0.01 % per 8h) on many days is the exchanges' base-rate clamp on USDT perpetuals, not a cap in our pipeline: it means "no premium beyond the base rate", and values above it are real market readings. [Free tier]

• arena_get_macro_regime

  What is the macro backdrop doing? Daily Macro Regime snapshot from 18 components in 6 tiers (Liquidity 30%, Financial Conditions 20%, Risk Appetite 15%, Crypto Liquidity 10%, Business Cycle 15%, Inflation/Real Rates 10%). FRED-sourced. Returns composite_score (0-100), regime_label (risk_off/neutral/risk_on_leaning/risk_on), cycle_phase_label (contraction/early_expansion/mid_expansion/late_expansion), matrix_quadrant (sweet_spot/late_cycle_warning/crisis/recovery), tier_scores (6 sub-scores), components (flat key/value of all 18), plus stale_components_detail dating each stale input (last_good_date + age_days + discontinued flag for series the upstream has retired for good) so freshness is quantified, not a vague caveat. Two component keys mean something narrower than their name suggests, so read them carefully: `vix_score` is the derived 0-100 score (a value of 71 means VIX around 18.6), NOT the VIX index level — the raw Cboe level is not redistributed over this channel; and `broad_dol

• arena_get_btc_market_structure

  Is the trend up or down, and how fresh is the flip? Daily Bitcoin market structure from 1000-bar Phantomflow adaptation (BTCUSDT 1d). Returns current_trend (up/down/sideways), last trend change timestamp, counts of waves + fractals, last-5 fractals on each side (up = pivot highs, down = pivot lows), and trend_context: previous trend + its duration, flip_age_days, and a descriptive historical flip base rate over the SAME 1000 bars (total flips, share reverted within 5 bars, median trend duration) — a fresh same-day flip is the least settled observation — the base rate tells you how often such flips reverted historically, so you can weight the current one yourself. Educational analysis of price action. [Free tier]

• arena_get_key_levels

  Which price levels matter above and below spot? Reproducible Bitcoin structural levels on BOTH sides of spot, in TWO distinct provenance classes. (1) resistance/support: swing-pivot clusters — where past pivot highs+lows cluster into price zones (touch-count, band, last-touch date, signed distance), resistance above spot, support below, nearest-first. (2) indicator_levels.above / .below: named indicator STANDS as marks — 200-day & 200-week simple moving averages, short-term-holder cost basis, Pi-Cycle legs — each carrying its source, formula and as_of date. The two classes are kept separate on purpose: pivots are where price REACTED before, indicator levels are where an indicator STANDS now. Both are measured price clusters: they say where trading has concentrated, not where anyone defends a level. [Free tier]

• arena_get_iv_snapshot

  What is the options market pricing in? Latest Deribit volatility snapshot for BTC or ETH. Returns DVOL (30d vol index), constant-maturity ATM implied vol (30/60/90/180d via options chain), 30d realized vol, and `vol_risk_premium_30d`, which is the TRAILING spread: ATM implied vol (30d, from the options chain — not DVOL) minus the realised volatility of the PAST 30 days. It answers "are options priced expensively right now?". Set include_implied=true to additionally get the FORWARD premium in an `implied` block: DVOL(t) minus the realised volatility of the FOLLOWING 30 days, which answers the different question "did the expectation actually materialise?". These two are NOT interchangeable — measured 2026-08 they carried OPPOSITE signs on 17.3% (BTC) / 30.5% (ETH) of paired days. The forward field is spelled out as `vol_risk_premium_forward_30d` so the two cannot be confused. The most recent 30 days carry premium_complete=false and no premium value at all, because their forward window ha

• arena_list_onchain_series

  Which on-chain series are available? Lists all 69 available Bitcoin Research Kit (BRK) on-chain series across the groups pilot, sentiment, mining, supply, cointime, activity, liquidity (e.g. MVRV, NUPL, SOPR, Realized-Price, Mayer, Puell, STH/LTH SOPR, Hash-Ribbons). Returns id + label + group. Use the id with arena_get_onchain_latest / _history. [Free tier]

• arena_get_onchain_latest

  What does this on-chain metric read right now? Returns the most recent value of ONE on-chain series from the Bitcoin Research Kit as { series_id, metric_name, date, value }. Cheapest way to answer "what is X right now" (MVRV, SOPR, realized price, hash rate, …). Discover valid series_ids with arena_list_onchain_series; for the history behind the number use arena_get_onchain_history. A single reading has no context — pair it with the series percentile before calling any level high or low. [Free tier]

• arena_get_sth_cost_basis

  What did recent buyers pay on average — and how far is spot from that? Latest BTC short-term-holder cost basis (realized price of coins younger than ~155 days, BRK brk_sth_realized_price), derived STH-MVRV (spot ÷ STH cost basis), an in_loss flag, plus ±1σ/±2σ bands: basis × exp(±k·σ), σ of ln(price ÷ basis) over a 730-day ROLLING window (sigma_method/sigma_window_days travel in the payload; similar construction to public STH band charts, own convention — not a rebuild). band_zone names the state (above/below basis, beyond ±2σ); sth_mvrv_percentile is the rolling 730d rank. Measured band coverage (2026-08-25, full history): 32.1% of days outside ±1σ (near the Gaussian 31.7%), 7.4% outside ±2σ (wider than the Gaussian 4.6% — fat tails); the bands are descriptive geometry (the measured coverage above tells you how literally to take them). On-chain context you weigh with the percentile field. [Free tier]

• arena_get_onchain_history

  How has this on-chain metric moved over time? Returns the full TIME SERIES of one on-chain metric from the Bitcoin Research Kit — date/value pairs in ascending order, with history back to 2009 for most series. Use it for trend and percentile work; for the single current reading call arena_get_onchain_latest, and to discover valid series_ids call arena_list_onchain_series. Values are as-reported: on-chain metrics can be revised retroactively, so this is not a point-in-time vintage. Range capped by tier — the response carries a `range` block (requested_days, granted_days, clamped, clamp_reason, tier), so a clamped window announces itself instead of silently looking like the full history. [Free 30d / Pro 365d / Power unlimited]

• arena_get_max_pain

  What happened at the last Deribit expiry? Max pain and how spot settled against it: max_pain_strike, spot_at_expiry, %-diff, put_call_ratio, notional. Plus up to 10 upcoming expiries, each with current live max-pain level, days_to_expiry, open_interest_contracts and open_notional_usd. Field semantics: days_to_expiry is floored at 0 and cannot separate "expires later today" from "already settled" — settles_at (full ISO timestamp) and hours_to_settlement (SIGNED; negative = settled but not yet finalized) carry that distinction. settlement_time_utc names the settlement time where evidenced against the exchange (08:00:00Z for DERIBIT_BTC); where not evidenced, all three timing fields are null. open_interest_contracts (upcoming: latest daily snapshot) and total_contracts (settled: last snapshot BEFORE expiry) are the SAME measurement at different observation times; contracts_as_of names the snapshot. total_notional_usd is computed against the SETTLEMENT spot and never changes; open_notional

• arena_get_max_pain_history

  Does max pain actually pull price to the strike? Settled Deribit BTC options expiries with the max-pain level we compute per expiry, for measuring the convergence question: does spot drift toward the max-pain level as expiry approaches? Each row: expiry_date, max_pain_strike, spot_at_expiry, %-diff, P/C ratio, notional, expiry-type flags. The mandatory base_rates block answers the convergence question PER expiry class (n, median |diff|, shares within 1%/2%, max, sample_adequate at n>=30) — the pooled median mixes tiny daily expiries with large quarterlies, which is what the per-class split separates. Filter with expiry_type / min_contracts / snapshot_expiry_date instead of post-processing the full row set. With include_open_snapshots=true it adds the daily observation series of still-open expiries — that series starts 2026-05-28, is not backfillable, and its per-expiry depth is thin, so check open_snapshot_coverage before computing anything from it. Days auto-capped by tier: Pro 365d,

• arena_status

  Am I connected, and what can this key do? Returns auth status (key kind: oauth connector or bearer API key, tier), server version, current UTC time, and the rate-limit state (hour/day used, remaining, reset) WITHOUT consuming extra quota beyond this call itself. Call this first when other tools fail: it separates auth problems (reconnect), tier problems (upgrade) and rate limits (wait) from real outages. [Free tier]

• arena_list_strategies

  Which strategies can I backtest here? Lists all backtest strategies (key, label, plan, supported asset classes, primary indicators). Filterable by asset class and plan. Use this before calling arena_run_backtest to discover valid strategy names. Entries deprecated for an asset class stay listed (historical results depend on them) and carry deprecated_for + deprecation {since, reason} — do NOT call arena_run_backtest or validate_strategy for those combinations, they return 400. [Free tier]

• arena_list_universes

  Which asset universes can I test against? Lists all crypto asset universes (BTC, top-10 crypto, top-50 crypto, etc.) — the underlying pair-sets used by custom-report and universe-backtest endpoints. [Free tier]

• arena_get_universe

  Which pairs are in this universe? Returns one pair universe in full: its id, label, selection rule and the complete list of pairs it currently contains. Use it to see what you are about to test BEFORE handing a universe_id to arena_run_universe_backtest, or to resolve a universe into explicit pairs. For the list of available universes call arena_list_universes. Without as_of the universe reflects the CURRENT membership (CoinGecko market-cap rank) — a backtest over it carries survivorship bias for the earlier years; the `pit` block in the payload says so. With as_of (YYYY-MM-DD, >= 2026-07-14) it returns the membership as MEASURED on that day from our own daily record of Binance USDT spot, ranked by 24h quote volume (not market cap) — coins delisted since are included, coins listed later are not. Point-in-time universes are recorded forward-only; earlier dates are refused, not reconstructed. [Free tier]

• arena_get_strategy_insights

  Which strategy and interval combinations actually performed? Aggregated backtest performance per (strategy × interval) cell. If `strategy` AND `interval` provided, returns detail with per-asset breakdown + param variants. Otherwise returns the matrix. Free tier is limited to the same strategies that are free in the backtester itself (rsi_sma, golden_cross, rsi_ob_os, bnh_fixed, dca_reference, dca_reference_v2); the response then carries `plan_capped: true` plus `plan_cap_note`, so a short matrix is never mistaken for a thin database. Detail mode on a Pro-only strategy returns 403 rather than a silently empty answer. API Pro and Power receive every cell. Counts: `runCount` = deduplicated runs above the trade floor that carry the averages, `inertRuns` = 0-trade runs of the same cell counted IN ADDITION, `runs_total` = both. `avgWinRate` averages only runs with a rated trade (0-trade runs and open single positions store 0, which is not a hit rate); `avgBuyholdCagr`/`beatsBuyhold` are show

• arena_get_strategy_performance

  How did this exact strategy, asset and interval perform? Aggregated backtest performance for ONE specific (strategy, asset, interval) combination. Returns run_count, avg_cagr, avg_win_rate, avg_drawdown, effective_years, vs_buy_hold comparison (beats_buy_hold, cagr_delta) and an `evidence` block declaring the gate machine-readably (gate_applies_to: stats.run_count, threshold 5 runs, benchmark value, aggregation data window). For multi-strategy overview use arena_get_strategy_insights. Use this to answer 'How does strategy X perform on asset Y?'. [Free tier]

• arena_get_strategy_filter_effect

  What would each entry filter have changed for this strategy? Per-(strategy, asset, interval) filter-effect analysis. Returns baseline-stats (no filters) + each observed filter-variant's stats with cagr_delta / drawdown_delta / win_rate_delta vs the time-overlap-matched baseline + best_by_cagr pick (null with best_by_cagr_reason when every variant is low_data or none beats the baseline — no pick below the data gate) + not_applicable_filters list (e.g. altcoin_season excluded on BTC-pair). Baseline and each variant carry their aggregation `window` (from/to + avg_run_years) — CAGR is time-normalized, so identical trade sets over different windows legitimately produce different CAGR. Based on REAL backtest aggregations — not theoretical 2^5 permutations. Use this to answer 'Which filters would improve my backtest for X on Y?'. [Free tier]

• arena_get_strategy_performance_by_regime

  In which macro regime has this strategy worked? Historical backtest performance for ONE (strategy, asset, interval) combination SPLIT BY macro market regime (sweet_spot / late_cycle_warning / crisis / recovery — classified at each trade's entry date), PLUS the CURRENT live regime so you can align the buckets yourself. You get the per-regime numbers to weigh directly (per-bucket verdicts live in the per-cell tools, where the pool is stable). Each regime bucket returns trades, trades_per_config (trade counts pool ALL parameter-variant configs — see config_count), win_rate, avg_pnl_pct (per-trade return, not annualized), reward_risk_ratio (per-trade mean/stddev, NOT annualized Sharpe), share_of_time_pct (calendar-day-weighted — each regime observation counts the days until the next one, so the mixed weekly/daily cadence of the regime history does not skew the share) and a rating. The `benchmark` block anchors the payload with the combination's buy-and-hold CAGR (identical to arena_get_str

• arena_get_edge_reports

  Which entry filter carries a real edge? Platform-wide aggregated analysis: how each Pro+ entry filter (200 WMA, ATR low/high/expansion, Altcoin Season, Bullmarket confirm/strict) affects strategy CAGR — baseline vs. filtered, asset-equal-weighted (per-asset medians over param-deduplicated runs, then the median across assets — no single asset's run grid can dominate an arm). delta_cagr is the median of PER-ASSET deltas over MATCHED assets only (present in both arms) — so it usually differs from filtered_cagr − baseline_cagr; pairs_matched/pairs_filtered and the baseline pairs count declare the basis. Verdicts come from the effect's 90% paired-bootstrap interval (delta_ci_low/delta_ci_high), not the point estimate: helps (whole interval > +1pp) / hurts (< −1pp) / neutral (inside ±1pp) / insufficient_evidence (runs disagree) / insufficient_data (fewer than 30 runs per arm or fewer than 10 matched assets). Below the gate, derived fields (delta_*, dsr, dsr_pass) are null; every gated null c

• arena_list_backtests

  Which backtests have I run? Lists the backtest runs belonging to the authenticated user — newest first, with id, strategy, pair, interval, date range and headline metrics per run. Use it to find a run_id, then call arena_get_backtest for its detail or arena_get_backtest_trades for the individual trades. Only your OWN runs; for the public cross-user leaderboard use arena_get_winners. Paginated via limit + offset. [API Pro tier]

• arena_get_backtest

  What exactly did that backtest do? Returns the full record of ONE backtest run by id: strategy, pair, interval, date range, parameters, filters and the aggregate metrics (CAGR, total return, win-rate, max drawdown, trade count, Buy & Hold comparison, net-of-fees figures). Only your own runs (admins may read others). Get ids from arena_list_backtests; for the individual trades add arena_get_backtest_trades; to create a new run use arena_run_backtest. [API Pro tier]

• validate_strategy

  Does this strategy survive an honest test? Backtest a trading strategy honestly — look-ahead-aware validation with Deflated-Sharpe-Ratio / multiple-testing correction (Bailey & López de Prado). Returns an EVIDENCE verdict (insufficient_evidence | anecdote | failed_oos | passed_oos) plus metrics, flags and caveats — NOT a buy/sell recommendation. Call this before acting on a strategy or signal list. Accepts a named catalog strategy (type=rules), a timestamped BUY/SELL signal list (signal_list), or a timestamped trade list (trade_list). Checks: realistic next-bar fills (look-ahead/optimism), net of cost, out-of-sample split, and a hard 30-round-trip sample gate (under 30 is always "anecdote"). Not reproducible via generic backtest tools that ignore overfitting. [API Pro tier]

• arena_run_backtest

  How would this strategy have performed? Run ONE strategy on ONE pair over a date range and get the full result: CAGR, total return, max drawdown, win-rate, trade count, Buy & Hold comparison, net-of-fees figures, and a run_id for later retrieval. Synchronous, typically 3–10s. Use this when the user wants a concrete result for a specific setup. For several strategies side by side use arena_compare_strategies; for many pairs at once use arena_run_universe_backtest; to judge whether an EXISTING result is trustworthy rather than produce a new one, use validate_strategy or arena_get_robustness_field. Filters are optional and only remove entries; run once without them for the baseline. Read result.benchmark before comparing cagr to buyhold_cagr: warmup or a late listing can shorten the strategy window, and matches_strategy_window:false means the two figures are annualized over DIFFERENT periods — in that case benchmark.strategy_window carries the like-for-like buy-and-hold (its cagr_delta_pp

• arena_compare_strategies

  Which of these strategies performed best on the same data? Run 2–5 strategies against the SAME pair, interval and date range and return per-strategy metrics plus a comparison summary (best by CAGR, best by win-rate, worst by drawdown). Use this when the user asks which of several strategies fits a market — it holds the pair, interval and requested date range fixed, which a series of separate arena_run_backtest calls does not guarantee. What it does NOT equalize is the EVALUATION window: a strategy with a long warmup starts trading later, so compare actual_date_from across the runs and check result.benchmark before ranking by CAGR. For one strategy across many pairs use arena_run_universe_backtest instead. Caveat worth passing on: comparing N strategies and reporting the winner IS multiple testing — the winner’s edge is upward-biased. arena_get_robustness_field puts a counted N on that. Sequential, expect 10–50s. Per-day quota: Pro=20, Power=200. [API Pro tier]

• arena_run_universe_backtest

  Does this strategy hold up across a whole universe? Runs it against every pair in the universe. Pair cap depends on your API tier: Pro 50, Power 250 — Power covers crypto-top-250 in ONE job, and a single job keeps the ranking on one pair set (merging results across different pair sets measures pair selection, not strategy quality). THIS CALL IS ASYNCHRONOUS AND RETURNS NOTHING BUT A job_id: the result is NOT in this response. You MUST poll arena_get_job_status until status is 'completed'; estimated_seconds in the create-response says how long to budget. Provide either universe_id (call arena_list_universes) OR explicit pairs[]. Benchmarks bnh_fixed and dca_reference_v2 are accepted here — run one of them over the SAME universe and interval alongside: an excess over buy-and-hold is only readable next to the buy-and-hold value itself, which can be negative. beats_bh_count compares each pair's cagr against the LIKE-FOR-LIKE buy-and-hold — the benchmark measured over the window the strateg

• arena_get_job_status

  Is my universe backtest finished? Polls an async job by job_id (created via arena_run_universe_backtest). Returns status (pending/running/completed/failed), progress_pct, pairs_completed, and once completed: the full result (summary + per-pair results). [Free tier]

• arena_run_grid_backtest

  Would a grid bot have made money here? Simulate a GRID BOT (buy-low / sell-high ladder inside a fixed price range) on historical candles. Returns final value, return %, CAGR, trade count, fees paid and a Buy & Hold comparison — plus `zerlegung` (spot runs): `decomposition` splits the result into ladder P&L from completed buy→sell cycles, allocation P&L of the starting coins, open grid buys and fees (identity_check_usd must be ~0); `benchmarks` anchors buy-and-hold, the never-touched starting split (static_allocation, with coin_share_start) and an arithmetic 50/50 at the entry price — grid_vs_static_pp is the number that says whether the ladder added anything over just holding the split; `fee_economics` gives the break-even spacing (2 × fee) and flags below_breakeven. Note: buyhold_return/outperformance keep their legacy anchor (first→last candle close); benchmarks anchor at entry. This is a different machine from the strategy backtester: grid bots earn from oscillation inside a range,

• arena_get_gem_scores

  Altcoin screener ranking — which altcoins look strong right now? Today's CoinGecko Top-200 minus stablecoins and tokenized fiat, scored by a composite of 3 factor groups: Mean-Reversion (A), Tokenomics (B), Market-Structure (C). Each score carries `plain` (one sentence: rank with its base `scored_total`, composite, factor groups) and the response carries `scored_total`. Backtest-validated factors, not a hype list. Limit gated by tier: Free top-10, Pro top-50, Power up to 200 (the full scored set). [Free tier, daily refresh]

• arena_get_volatility_history

  How volatile has Bitcoin been? Daily Bitcoin volatility time series: realized volatility (30d & 90d, √365-annualized — calendar days, the same basis as DVOL — close-to-close) and ATR% (Wilder EMA-14, captures intraday range + gaps), on the same scale. Ranks come in two flavours answering different questions: `rvRank`/`atrPctAnnRank` expand from the start of history and are look-ahead-free, but they include BTC's structural volatility decline; `rvRankRolling`/`atrPctAnnRankRolling` rank against a trailing 2-year window, which removes that trend from the comparison. History reaches back to 2009 via a stitched pre-Binance close series; ATR is null before the Binance era because no daily high/low exists that far back (see meta.coverage). Use `from`/`to` for a specific window instead of pulling everything and discarding it, and `granularity`/`fields` to keep long ranges affordable. For long ranges pass `format: "columns"` (one array per field — the largest saving) together with `schema_vers

• arena_list_knowledge

  What knowledge objects exist here? Discover what Knowledge Objects exist: lists all published types + their subjects (with min_tier, api_path, seo_slug, latest as_of). Use this BEFORE arena_get_knowledge to learn valid type/subject pairs instead of guessing. New types appear automatically. [Free tier]

• arena_get_knowledge

  What does the platform know about this subject? Fetch a versioned, explainable Knowledge Object by type + subject (e.g. type='market_regime', subject='GLOBAL'). Returns the current published envelope: payload, explanation (factors + weights + confidence), provenance (inputs + params), ontology binding, compute version. ONE tool covers ALL knowledge types. Set include_graph=true to also walk the knowledge graph: resolved outbound edges (what this object is derived_from / references) + inbound edges (what derives from / references it), each with api_path + seo_slug so you can follow them. [Free tier; per-object access additionally gated by min_tier]

• arena_dip_decision

  Buy now or wait for the dip? Decision-math over the user's OWN assumptions (target/dip prices, probabilities, capital). Two modes: "compare" = expected value of Buy-Now vs Wait vs Split + the breakeven dip probability (prices as MULTIPLES of today); "allocate" = the risk-adjusted (Kelly / risk-aversion γ) optimal fraction to deploy now vs reserve for the dip (ABSOLUTE prices). Ask the user for the missing inputs, then call. Returns scenario numbers and which option wins on expected value — NOT a buy/sell recommendation. For the full interactive version (incl. leverage & Elliott-wave planning) point the user to https://tradingstrategies.work/analyse/dip-decision. [Free tier]

• arena_get_historical_analog

  What happened historically after the Bitcoin cycle looked like this? Conditional forward-return distribution for a named preset cycle state — over N DISTINCT historical episodes matching that state (matched_episodes), returns median/IQR/positive-share forward returns (30/90/180/365d) with per-horizon n, small-n warnings, point-in-time integrity and an `evidence` block that names which field its sample-size gate checked (gate_applies_to), against which threshold, over which data window. A distribution with its sample size. Not obtainable from web search or public market-data APIs — requires point-in-time indicator history and look-ahead-free episode matching. Presets: cycle_bottom_cluster (Cycle bottom cluster), cycle_top_cluster (Cycle top cluster), deep_fear (Deep fear), euphoria (Euphoria), quiet_volatility (Quiet volatility regime). The response opens with "preset_definition" (machine-readable condition set) plus current_state_matches (does the state hold TODAY?) and last_matching_d

• arena_get_robustness_field

  Is this backtest result real, or a lucky cell? Assess one backtest result against its neighborhood instead of trusting a single "+X% CAGR" cell. Given a (strategy, interval, pair) and YOUR result (user_cagr, optional user_sharpe), returns: the cross-asset distribution of the SAME strategy+interval across every pair the backtest factory ran it on (median, IQR, positive-share, your percentile), a plateau/spike/fragile/mixed verdict, and — where Sharpe coverage allows — a Deflated Sharpe threshold whose N is COUNTED (the number of neighbor assets IS the testing family), not guessed. Honest small-n handling: fewer than 15 neighbors → "insufficient", no DSR-N claimed. Set axis="parameter" for the secondary, always-anecdotal view (the few parameter settings tested on this exact pair). Read-only over result aggregates, look-ahead free. [API Pro tier]

• arena_is_distinguishable

  Do these two backtest figures actually differ? Check before ranking them. Pass the two values as `a` and `b` (same metric, same basis) plus `axes` — which arbitrary choices went into them — and the tool returns whether their gap clears the MEASURED noise floor of those choices, along with the floor itself, the dominant axis, and the probe + date it was measured on. `axes` accepts: grid_phase (how a multi-day candle grid is aligned to the Unix epoch; exists only on 2d/3d), parameter_choice (neighbouring parameter settings — by far the largest axis), window_edges (shifting the start date), pair_selection (which pairs made it into the universe). Pass ALL axes that genuinely varied; the floor is their maximum, not their sum. Optionally set `interval` to the candle interval so the floor can be sharpened where an axis was measured per interval — passing grid_phase together with a non-multi-day `interval` is a hard error, because that axis does not exist there. `label_a` and `label_b` are opt

• arena_get_indicator_snapshot

  What do the classic indicators read right now? Current RSI(14), MACD(12/26/9), Bollinger(20,2), ATR(14) and OBV for a pair — each with a PERCENTILE RANK against that indicator's own history on that pair, plus the observation count — the rank turns a raw reading into a placement. ATR comes as a percentage of price so it is comparable across time, and OBV as a 30-bar slope normalised by that window's volume (raw cumulative OBV would mostly rank how long the series has existed). Where the reading sits in an extreme AND a study on this platform has tested that exact state, the payload carries the study verdict — including a null result: a Bollinger squeeze returns the `quiet_volatility` finding that tight bands did NOT carry an edge. Below 500 bars (1d) / 150 (1w) the raw values still come but `percentile` is null with a reason, rather than a rounded number from too small a sample. Set `interval` to '1w' for the weekly view. On the 1d view the payload also carries `rsi_14_weekly` (weekly R

• arena_get_signal_context

  Should I take this entry? Answers it for one (strategy, pair, interval) in ONE call instead of seven. Aligns what each entry filter historically did to this strategy (arena_get_strategy_filter_effect) with where that filter stands TODAY (bull-market gauge, altcoin-season signal, volatility phase, 200-week trend for BTC): `filters[].blocks_this_entry` says which filter would sit this entry out, with the measured worst-loss / return deltas next to it. Adds the current signal state (anticipated is always false — before candle close there is no signal), an `edge_vs_benchmark` block gated by the MEASURED noise floor (a gap below the floor is a measurement artifact, not a finding), a `contradictions` block (e.g. Pulse risk-off while the macro regime reads risk-on — reported, never resolved), and measured invalidation zones (pivot clusters, 200-week SMA; BTC only). `detail`: 'headline' (default) returns the statement, three key numbers and only the decisive filters; 'full' adds every variant,

• arena_get_asset_snapshot

  Where does this coin stand? ONE call per Binance USDT pair instead of six: last daily close, 7/30/90/365-day returns, relative strength vs BTC and vs ETH on the same horizons (with the MEASURED base rate next to it — the median altcoin loses against Bitcoin, so a positive number is a description, not an edge), the F6 trend state vs BTC, ATH/drawdown/days-since-ATH on the available exchange history (`ath_scope` says which), SMA200 distance, a `parabolic` state (in a parabolic run now? last run? plus what followed such runs per exit rule, from knowledge object parabolic_base_rate), realized 30d volatility and ATR%, liquidity from our own daily Binance universe measurement (24h-volume rank today vs 30 days ago, 30d mean/median volume, band), tokenomics ratios from the gem screener (Pro+, CoinGecko ratios only), derivatives (BTC only so far) and a `data_quality` block: history span, candle count, missing days, coverage %, source/stitch, listing status (delisted pairs are flagged) and a mec

• arena_batch

  Several market snapshots in ONE call instead of one roundtrip per read. Batchable reads (14): spot_price, pulse, cycle, fear_greed, funding_rate, macro_regime, iv_snapshot, etf_flows, stablecoin_supply, mayer_multiple, onchain_latest, max_pain, altcoin_season, bullmarket_ampel. Pass 1-6 queries; each returns its result OR a structured error (partial success — one failing query does not abort the rest). Each query consumes one rate-limit unit: the batch saves roundtrips, not quota. Payloads, tier gates and source attribution are identical to the single tools; per-query args match the single tool's parameters (e.g. {tool: "iv_snapshot", args: {currency: "BTC"}}). For history tools, backtests or anything not in the list, call the single tool. [Free tier]

• arena_call_extended

  Gateway to the EXTENDED tools of this server — listed here in one line each instead of individually, to keep the tool list short. Use it when no listed tool fits: per-metric daily history series, subscriptions, chart images, niche primitives. mode="call" runs the tool with `arguments` (same result, auth, tier and rate limits as calling it directly); mode="describe" returns its full description and parameters first, if the arguments are unclear. - arena_cancel_subscription: Stop this alert? - arena_check_subscription_updates: Has anything I subscribed to fired? - arena_cross_series: Did two market series move together, and what did BTC do next when they agreed or diverged? - arena_dca_scenario: Should I invest all at once or spread it out (DCA)? - arena_dip_scenario: Where would I add on a dip, and when is the thesis wrong? - arena_get_altcoin_season_history: Has capital been rotating into or out of altcoins? - arena_get_backtest_trades: Which trades did that backtest actually take? - a