rsi-reversal-regime-dependency

name	rsi-reversal-regime-dependency
description	Use when evaluating any RSI-based reversal or mean-reversion signal on HyperLiquid perpetuals. RSI reversals have strong regime dependency — they work in ranging/mean-reverting conditions and fail catastrophically in trending conditions. This skill documents the full regime filter stack, divergence confirmation requirements, failure modes specific to RSI reversals in perpetuals, and how RSI signals coordinate with EMA cross signals in mixed-regime conditions.
category	agentic

RSI Reversal Regime Dependency

When This Skill Activates

Apply this skill:

• Before acting on any RSI overbought (> 70) or oversold (< 30) reversal signal on HyperLiquid perpetuals
• When RSI divergence (price makes new high/low but RSI does not) is observed and a reversal entry is being considered
• When a mean-reversion or fade strategy is being evaluated for a trending asset — RSI is the most common source of premature fade entries in trending markets
• When coordinating RSI signals with EMA cross signals in the same session — the two strategy types have opposing regime requirements and must not generate conflicting simultaneous positions
• When classifying a post-trade loss from a reversal strategy to determine whether regime filters should be tightened

---

Core Principle: RSI Is a Regime-Conditional Indicator

RSI does not measure absolute overbought or oversold conditions. It measures the speed and magnitude of recent price changes relative to the lookback period. In a strong trend, RSI can remain above 70 for extended periods — this is not an error, it is the expected output of a fast-moving trending market.

The fundamental regime split:

Regime	RSI Behavior	RSI Signal Validity	Strategy Action
Ranging / mean-reverting	RSI oscillates 30-70, reverts quickly	High — oversold/overbought are actionable	RSI reversals valid
Trending (established)	RSI holds 60-85 (bull) or 15-40 (bear)	Low — readings are regime artifacts	RSI reversals invalid; use EMA cross
Trending (mature/exhaustion)	RSI diverges from price at extremes	Medium — divergence only, not level	RSI divergence entries valid with confirmation
Post-cascade / high fragility	RSI collapses then bounces rapidly	Very low — cascade-driven distortion	No RSI entries during cascade

Rule: Never fade an RSI extreme in a trending market. An RSI reading of 78 in an established uptrend is not overbought — it is confirmation the trend is strong. The same reading in a ranging market is a valid short setup.

---

Regime Classification for RSI Signals

def classify_rsi_regime(
    adx_14: float,
    bb_width_pct: float,
    bb_width_20p_median: float,
    hh_hl_count: int,             # from trending-bull-entry-timing
    atr_current: float,
    atr_20p_median: float,
    cascade_score: int,           # from liquidation-cascade-risk
) -> dict:
    """
    Classify the current regime for RSI signal validity.
    Returns regime class and whether RSI reversal signals are
    permitted, divergence-only, or fully blocked.
    """
    # Cascade override: always block during cascade
    if cascade_score >= 5:
        return {
            "regime": "CASCADE",
            "rsi_reversal_permitted": False,
            "divergence_permitted": False,
            "reason": f"Cascade score={cascade_score} >= 5. No RSI entries during cascade.",
        }

    trending     = adx_14 >= 25.0
    strong_trend = adx_14 >= 35.0
    mature_trend = hh_hl_count >= 7
    ranging      = adx_14 < 20.0 and bb_width_pct <= bb_width_20p_median * 1.10
    compressed   = bb_width_pct < bb_width_20p_median * 0.75  # pre-breakout

    if strong_trend and not mature_trend:
        return {
            "regime": "STRONG_TREND",
            "rsi_reversal_permitted": ,
            : ,
            : 
                      ,
        }

     trending  mature_trend:
         {
            : ,
            : ,
            : ,   
            : 
                      ,
        }

     trending   mature_trend:
         {
            : ,
            : ,
            : ,
            : 
                      ,
        }

     compressed:
         {
            : ,
            : ,
            : ,
            : 
                      ,
        }

     ranging:
         {
            : ,
            : ,
            : ,
            : 
                      ,
        }

    
     {
        : ,
        : ,
        : ,
        : 
                  ,
    }

---

RSI Signal Types and Requirements

Type 1: Level-Based Reversal (Ranging Regime Only)

A simple RSI overbought (> 70) or oversold (< 30) entry. Valid only in a confirmed ranging regime (ADX < 20).

def evaluate_rsi_level_signal(
    rsi_14: float,
    direction: str,              # "long" (from oversold) or "short" (from overbought)
    regime: dict,                # from classify_rsi_regime()
    price: float,
    range_high: float,           # resistance level of current range
    range_low: float,            # support level of current range
    funding_1h_pct: float,       # from high-funding-carry-avoidance
) -> dict:
    if not regime["rsi_reversal_permitted"]:
        return {
            "signal_valid": False,
            "reason": f"Regime blocks RSI reversal: {regime['reason']}",
        }

    # RSI threshold check
    oversold_ok  = direction == "long"  and rsi_14 <= 30.0
    overbought_ok = direction == "short" and rsi_14 >= 70.0
    rsi_level_ok = oversold_ok or overbought_ok

    # Price at range boundary confirmation
    if direction == "long":
        at_range_boundary = price <= range_low * 1.005   # within 0.5% of support
    else:
        at_range_boundary = price >= range_high * 0.995  # within 0.5% of resistance

    # Funding check for longs (crowded long at range low is fragile)
    funding_ok =  (direction ==   funding_1h_pct > )

    signal_valid = rsi_level_ok  at_range_boundary  funding_ok
     {
        :      signal_valid,
        :       ,
        :            rsi_14,
        : at_range_boundary,
        :        funding_ok,
        : (
              signal_valid 
            .join((, [
                   rsi_level_ok  ,
                           at_range_boundary  ,
                   funding_ok  ,
            ]))
        ),
    }

Type 2: RSI Divergence (Mature Trend or Ranging)

Bullish divergence: price makes a lower low but RSI makes a higher low. Bearish divergence: price makes a higher high but RSI makes a lower high. More reliable than level-based entries; valid in mature trends as a potential exhaustion signal.

def evaluate_rsi_divergence(
    price_swing_1: float,        # older swing high/low
    price_swing_2: float,        # newer swing high/low
    rsi_swing_1: float,          # RSI at older swing
    rsi_swing_2: float,          # RSI at newer swing
    divergence_type: str,        # "bullish" or "bearish"
    regime: dict,
    candles_between_swings: int, # time between swings (validity window)
    volume_at_swing_2: float,
    volume_20p_avg: float,
) -> dict:
    if not regime["divergence_permitted"]:
        return {
            "divergence_valid": False,
            "reason": f"Regime does not permit divergence entries: {regime['reason']}",
        }

    # Validate divergence structure
    if divergence_type == "bullish":
        price_diverges = price_swing_2 < price_swing_1   # lower low in price
        rsi_diverges   = rsi_swing_2   > rsi_swing_1     # higher low in RSI
    else:
        price_diverges = price_swing_2 > price_swing_1   # higher high in price
        rsi_diverges   = rsi_swing_2   < rsi_swing_1     # lower high in RSI

    structure_ok = price_diverges and rsi_diverges

    # Time validity: swings too close = noise; too far = stale divergence
    time_ok = 5 <= candles_between_swings <= 50

    
    
    volume_declining = volume_at_swing_2 < volume_20p_avg * 

    divergence_valid = structure_ok  time_ok  volume_declining
     {
        :    divergence_valid,
        :         ,
        :     divergence_type,
        :      price_diverges,
        :        rsi_diverges,
        :             time_ok,
        :    volume_declining,
        :     candles_between_swings,
        : (
              divergence_valid 
            .join((, [
                            structure_ok  ,
                   time_ok  ,
                    volume_declining  ,
            ]))
        ),
    }

---

RSI Failure Modes Specific to Perpetuals

RFM-1: Trend Fade Loss

Description: RSI overbought/oversold signal taken in a trending market. The trend continues, RSI remains elevated/depressed for extended periods, and the position is stopped out multiple times as the trader repeatedly fades the trend.

Identification: ADX ≥ 25 at entry. Loss came from repeated stop-outs on the same direction (e.g., three short entries on high RSI in an uptrend).

Prevention: classify_rsi_regime() returns STRONG_TREND or EARLY_TREND → block all RSI reversal entries.

---

RFM-2: Divergence in Continuation

Description: Bearish/bullish RSI divergence fires in a strong trend as a "normal" consolidation pause rather than a genuine exhaustion. Price pauses, RSI pulls back slightly (creating divergence structure), then the trend resumes with a large move against the divergence trade.

Identification: Divergence was valid structurally but the ADX remained above 30 throughout, or HH/HL count was below 6 (trend not yet mature). The divergence was a mid-trend pause, not an exhaustion signal.

Prevention: Only permit divergence entries when hh_hl_count >= 7 AND adx_14 < 40 (strong but not acceleration phase). ADX > 40 indicates active acceleration — no divergence is reliable at acceleration phase.

MAX_ADX_FOR_DIVERGENCE = 40.0   # above this, trend is accelerating; divergence unreliable
MIN_HH_HL_FOR_DIVERGENCE = 7    # below this, trend not mature enough for exhaustion signal

---

RFM-3: Cascade Reversal Trap

Description: A liquidation cascade drives RSI to extreme oversold (< 20) levels rapidly. The extreme RSI reading looks like a textbook reversal setup. An entry is taken, but price continues down as the cascade proceeds through further liquidation levels.

Identification: RSI dropped from > 50 to < 25 within 3-5 candles (cascade speed, not organic selling). OI dropped simultaneously (liquidations, not shorts being established). Cascade score ≥ 5 at or before entry.

Prevention: cascade_score >= 5 → block all RSI entries in classify_rsi_regime(). Wait for cascade score to fall below 3 and OI to stabilise before re-evaluating RSI signals.

---

RFM-4: Funding Bleed on Range Longs

Description: RSI oversold range long taken with elevated funding. The trade is directionally correct (price does bounce from range low) but the carry cost on the long side erodes the net profit, converting a nominal win into a breakeven or small loss. Repeated applications cumulatively destroy edge even when price prediction is accurate.

Identification: Post-trade review shows positive price move but negative or zero net PnL. Funding rate was > 0.020% per hour at entry and sustained throughout.

Prevention: funding_ok check in evaluate_rsi_level_signal() blocks long entries when funding_1h_pct > 0.020%. RSI range longs in elevated funding are not valid setups regardless of price action.

---

Coordination with EMA Cross Signals

RSI reversals and EMA cross signals have opposing regime requirements. Conflicts must be resolved before any position is sized:

def coordinate_rsi_ema_signals(
    rsi_signal: dict,    # from evaluate_rsi_level_signal() or evaluate_rsi_divergence()
    ema_signal: dict,    # from ema-cross-failure-modes pre-entry filter
    regime: dict,        # from classify_rsi_regime()
) -> dict:
    """
    Resolve conflicts between RSI reversal and EMA cross signals.
    Returns the permitted signal type (if any) and the resolution.
    """
    rsi_valid = rsi_signal.get("signal_valid") or rsi_signal.get("divergence_valid", False)
    ema_valid = ema_signal.get("entry_permitted", False)

    # Both valid simultaneously: regime conflict
    if rsi_valid and ema_valid:
        # Prefer EMA cross in transitional regimes (trend taking over)
        # Prefer RSI in confirmed ranging (ADX < 20)
        if regime["regime"] == "RANGING":
            return {
                "permitted_signal": "RSI",
                "resolution": "Confirmed ranging: RSI reversal preferred over EMA cross.",
            }
        else:
            return {
                "permitted_signal": "EMA",
                "resolution": "Non-ranging regime: EMA cross preferred; RSI signal suppressed.",
            }

    if rsi_valid and not ema_valid:
        return {"permitted_signal": , : }

     ema_valid   rsi_valid:
         {: , : }

     {: , : }

Conflict resolution rule: In a ranging market, RSI wins. In any non-ranging market (ADX ≥ 20), EMA wins. Never hold simultaneous RSI reversal and EMA trend positions on the same asset.

---

RSI Period and Threshold Calibration

Default RSI-14 with 70/30 thresholds is a starting point, not a universal truth. Calibrate to the asset and timeframe:

Asset Volatility	Timeframe	Recommended RSI Period	OB/OS Thresholds	Rationale
High (BTC, ETH)	15m	RSI-9	75 / 25	Faster signals needed; tight thresholds reduce false signals on volatile candles
High (BTC, ETH)	1H	RSI-14	70 / 30	Standard; well-validated
High (BTC, ETH)	4H	RSI-21	68 / 32	Slower timeframe: wider thresholds reduce whipsaw
High-beta alts	1H	RSI-14	75 / 25	High-beta assets reach extreme RSI more easily; raise thresholds
High-beta alts	4H	RSI-21	72 / 28	Same rationale; slower period

---

Position Sizing Override for RSI Reversals

RSI reversal trades in ranging markets carry a specific sizing constraint distinct from Kelly-optimal sizing:

RSI_REVERSAL_KELLY_MULTIPLIER_CAP = 0.25   # never exceed quarter Kelly
# Rationale: RSI reversals have lower average RR ratio (typically 1.5:1)
# than trend-following entries (typically 2:1 or better).
# Lower RR means Kelly optimal fraction is lower; quarter Kelly cap
# prevents oversizing on trades with structurally lower edge.

RSI_REVERSAL_MAX_CONCURRENT = 2   # max simultaneous RSI reversal positions
# Rationale: RSI reversal trades on different assets in the same
# ranging regime are often correlated (broad market ranging). Two
# simultaneous RSI reversal positions is the practical maximum before
# correlated stop-out risk becomes unacceptable.

---

Worked Example — Divergence Entry in Mature Trend

Asset: BTC-PERP, 4H timeframe
Signal: Bearish RSI divergence (price new high, RSI lower high)
Timestamp: 2026-04-07T12:00Z

Regime classification inputs:
  ADX_14:         32.1    (trending but not strong_trend > 35)
  BB_width:       2.3%    (median 1.9%, ratio 1.21 — expanded)
  HH_HL_count:    8       (mature trend >= 7: MATURE_TREND)
  Cascade score:  1       (normal)

Regime: MATURE_TREND
  rsi_reversal_permitted: False
  divergence_permitted:   True

Divergence evaluation:
  price_swing_1:  $87,200  (previous high)
  price_swing_2:  $88,500  (new price high — higher high)
  rsi_swing_1:    74.2     (RSI at previous high)
  rsi_swing_2:    68.8     (RSI at new price high — lower RSI high)
  divergence_type: bearish
  candles_between: 18      (within 5-50 range)
  volume_swing_2:  $1.2B   (20p avg $1.6B — declining: 0.75x)

  price_diverges:    True  ($88,500 > $87,200: higher high)
  rsi_diverges:      True  (68.8 < 74.2: lower RSI high)
  time_ok:           True  (18 candles)
  volume_declining:  True  ($1.2B < $1.6B * 0.85 = $1.36B)

Divergence result: VALID

ADX check: 32.1 < MAX_ADX_FOR_DIVERGENCE=40 ✔
HH/HL check: 8 >= MIN_HH_HL=7 ✔

Additional checks:
  Cascade score:  1   (< 5) ✔
  Funding 1h:     -0.005% (slightly negative — no carry concern for short) ✔

Decision: DIVERGENCE ENTRY PERMITTED (BTC short, 4H)
Sizing: Kelly quarter (0.25 multiplier cap for RSI/divergence entries)
SL: Above swing_2 high + 0.5× ATR
TP: Previous swing high minus ATR (1.5:1 RR minimum)

---

Audit JSONL Schema

{
  "event": "rsi_signal_evaluation",
  "timestamp_utc": "2026-04-07T12:00:00Z",
  "asset": "BTC",
  "timeframe": "4H",
  "signal_type": "RSI_DIVERGENCE",
  "direction": "short",
  "signal_valid": true,
  "regime": "MATURE_TREND",
  "rsi_reversal_permitted": false,
  "divergence_permitted": true,
  "adx_14": 32.1,
  "hh_hl_count": 8,
  "cascade_score": 1,
  "rsi_swing_1": 
   
   
   
   
   
   
   
   

---

Integration with Other Skills

• ema-cross-failure-modes (strategy/): coordinate_rsi_ema_signals() resolves conflicts when both strategy systems produce signals simultaneously. RSI wins in confirmed ranging (ADX < 20); EMA wins in all other regimes. The two skills share ADX and RSI inputs — compute once and pass to both.
• trending-bull-entry-timing (regime-detection/): Provides hh_hl_count used in classify_rsi_regime() (mature trend gate) and evaluate_rsi_divergence() (minimum leg count for valid divergence).
• liquidation-cascade-risk (regime-detection/): cascade_score is a hard block in classify_rsi_regime(). Any cascade score

  = 5 prevents all RSI entries regardless of other regime conditions.

• high-funding-carry-avoidance (regime-detection/): funding_1h_pct used in evaluate_rsi_level_signal() to block crowded long range entries. Also feeds RFM-4 prevention.
• kelly-position-sizing-perps (risk/): RSI reversal entries are capped at RSI_REVERSAL_KELLY_MULTIPLIER_CAP = 0.25 regardless of the Kelly formula output. Pass this as the kelly_multiplier ceiling when sizing RSI reversal trades.
• max-concurrent-positions (risk/): RSI reversal trades are subject to RSI_REVERSAL_MAX_CONCURRENT = 2. Track active RSI reversal positions separately from trend positions.

---

Quick Decision Tree

RSI signal fires (overbought, oversold, or divergence observed):
│
├── 1. Classify regime (run in parallel with regime inputs):
│     trending-bull-entry-timing  → hh_hl_count
│     liquidation-cascade-risk    → cascade_score
│     regime = classify_rsi_regime(adx, bb_width, hh_hl_count,
│                                    atr, cascade_score)
│
├── 2. Route by signal type:
│   ├── Level signal (RSI < 30 or > 70):
│   │     regime.rsi_reversal_permitted? → No → SKIP signal
│   │     evaluate_rsi_level_signal()
│   │     signal_valid? → No → SKIP signal
│   └── Divergence signal:
│         regime.divergence_permitted? → No → SKIP signal
│         adx < 40 AND hh_hl_count >= 7? → No → SKIP signal
│         evaluate_rsi_divergence()
│         divergence_valid? → No → SKIP signal
│
├── 3. Coordinate with EMA signals:
│     Any active EMA cross signal on same asset?
│     coordinate_rsi_ema_signals() → resolve conflict
│
├── 4. Signal valid and no conflict:
│     Kelly sizing with multiplier capped at 0.25
│     → max-concurrent-positions (RSI reversal count ≤ 2)
│     → slippage-budget-enforcement → order submission
│
└── 5. On position close (if loss):
      Classify failure mode: RFM-1, RFM-2, RFM-3, or RFM-4
      Log to audit. Update rolling failure frequency.