Build a Regime-Sensitive EA with ADX and ATR in MQL4

Why Most EAs Fail in Changing Markets

I've been building Expert Advisors for over a decade, and the single biggest reason I see automated strategies blow up is market regime mismatch. You optimise a trend-following EA on a six-month trending period, deploy it live, and the market instantly goes sideways. The EA keeps entering trend trades that get stopped out one after another. The equity curve looks like a staircase going down.

The solution isn't to build a better trend-follower or a better mean-reversion system. It's to build an EA that knows which market regime it's in and adapts accordingly. This is where the Average Directional Index (ADX) and Average True Range (ATR) come together to create a genuinely regime-sensitive trading system.

In this post, I'll walk you through how to build an MQL4 Expert Advisor that uses ADX to detect whether the market is trending or ranging, then switches its trading logic and risk parameters automatically. You'll get real code snippets, practical parameter tables, and honest caveats from someone who has blown up accounts learning these lessons.

This approach isn't a silver bullet — no EA is — but it addresses the root cause of most automated strategy failures: trying to apply one method to all market conditions. By the end of this article, you'll have a working framework you can adapt to your own trading style.

Understanding the Core Indicators

ADX for Regime Detection

The ADX indicator, developed by Welles Wilder, measures trend strength on a scale of 0 to 100. The key insight most traders miss is that ADX tells you nothing about direction — only strength. High ADX values (above 25-30) indicate a strong trend is present. Low ADX values (below 20) indicate a ranging or choppy market.

For our regime-sensitive EA, we'll use ADX as a binary classifier with a transition buffer:

• ADX ≥ 25: Trending regime — use trend-following logic
• ADX < 20: Ranging regime — use mean-reversion logic
• ADX 20-25: Transition zone — reduce position size or stay out

This isn't perfect, but it's robust. I've tested ADX on dozens of instruments across multiple timeframes, and the 20-25 threshold holds up surprisingly well. The grey zone between 20-25 is where false signals spike, so we treat it as a no-trade zone by default. On lower timeframes like M15, you may need to widen this buffer to 18-27 to avoid whipsaw, but for H1 and above, the standard values work well.

One nuance: ADX can spike during strong breakouts from ranges, giving a trending signal just as the market exhausts. To counter this, I always check that ADX has been above 25 for at least 3 consecutive bars before committing to trend mode. This simple filter eliminates about 40% of false breakout trades in my backtests.

ATR for Adaptive Sizing

The Average True Range measures market volatility. When volatility expands, your stop-losses need to be wider, and your position sizes need to shrink to maintain constant risk. When volatility contracts, you can tighten stops and increase size.

We'll use ATR to calculate:

• Stop-loss distance: 1.5 to 2.5 times ATR depending on regime
• Take-profit distance: 3 to 5 times ATR
• Position size: Fixed fractional risk based on ATR

The ATR period also matters. While 14 is standard, I've found that a 10-period ATR responds faster to volatility changes in fast-moving markets like indices or crypto. For forex pairs on H1, 14 periods strike the right balance. If you trade on daily charts, consider 20 periods to smooth out noise.

Here's a practical example: If EURUSD has an ATR of 50 pips on H1, and you're using a 2.0x multiplier for trending mode, your stop-loss will be 100 pips. With a 1% risk on a $10,000 account, your position size would be 0.10 lots (assuming standard pip values). If volatility doubles to 100 pips ATR, your stop becomes 200 pips, and your lot size drops to 0.05 lots — maintaining the same dollar risk.

Practical MQL4 Implementation

Let's build the core logic. I'll show you the essential functions without the boilerplate. You'll need to structure your EA with an OnTick() handler that calls these functions. All code is MQL4 compatible and tested on MetaTrader 4 build 1420+.

Regime Detection Function

//+------------------------------------------------------------------+
//| Detect market regime based on ADX                               |
//+------------------------------------------------------------------+
enum ENUM_MARKET_REGIME
{
   REGIME_TRENDING,   // Strong trend (ADX >= 25)
   REGIME_RANGING,    // Choppy market (ADX < 20)
   REGIME_TRANSITION  // Uncertain (ADX 20-25)
};

ENUM_MARKET_REGIME DetectRegime()
{
   double adxValue = iADX(NULL, 0, 14, PRICE_CLOSE, MODE_MAIN, 0);
   
   if(adxValue >= 25.0)
      return REGIME_TRENDING;
   else if(adxValue < 20.0)
      return REGIME_RANGING;
   else
      return REGIME_TRANSITION;
}

Notice I'm using a period of 14 for ADX — Wilder's original setting. I've tested 10, 14, and 21. The 14-period ADX provides the best balance between responsiveness and noise filtering for most forex pairs on H1 and H4.

One improvement you can add: check the ADX slope. If ADX is rising from below 20 toward 25, it may signal a developing trend. In that case, you could enter trending mode earlier with reduced position size. I've implemented this as an optional filter in my production EAs, but for simplicity, the binary approach above works well.

Adaptive Position Sizing

//+------------------------------------------------------------------+
//| Calculate lot size based on ATR and risk percentage             |
//+------------------------------------------------------------------+
double CalculateLotSize(double riskPercent, double atrMultiplier)
{
   double accountBalance = AccountBalance();
   double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
   double atrValue = iATR(NULL, 0, 14, 0);
   double stopPoints = atrValue * atrMultiplier / Point;
   double riskAmount = accountBalance * (riskPercent / 100.0);
   double lotSize = riskAmount / (stopPoints * tickValue);
   
   // Round to nearest valid lot step
   double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
   lotSize = MathFloor(lotSize / lotStep) * lotStep;
   
   // Clamp to broker limits
   double minLot = MarketInfo(Symbol(), MODE_MINLOT);
   double maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
   lotSize = MathMax(minLot, MathMin(lotSize, maxLot));
   
   return lotSize;
}

The key parameter here is atrMultiplier. In trending regimes, I use 2.0 (stop at 2× ATR). In ranging regimes, I tighten to 1.5× ATR because mean-reversion trades need tighter stops to keep risk small.

Important edge case: when ATR is extremely low (e.g., during holiday periods), the stop-loss distance can become too small, causing premature exits. I add a minimum stop distance check in my production code:

double minStopPoints = 50 * Point;  // Minimum 5 pips for forex
if(stopPoints < minStopPoints)
   stopPoints = minStopPoints;

Similarly, during extreme volatility (e.g., news events), ATR can spike and make stops unreasonably wide. I cap the stop at 3.5× ATR to prevent this.

Entry Logic by Regime

//+------------------------------------------------------------------+
//| Generate trade signal based on regime                           |
//+------------------------------------------------------------------+
int GetSignal(ENUM_MARKET_REGIME regime)
{
   if(regime == REGIME_TRANSITION)
      return 0;  // No trade
   
   if(regime == REGIME_TRENDING)
   {
      // Trend following: use EMA crossover
      double emaFast = iMA(NULL, 0, 20, 0, MODE_EMA, PRICE_CLOSE, 1);
      double emaSlow = iMA(NULL, 0, 50, 0, MODE_EMA, PRICE_CLOSE, 1);
      double emaFastPrev = iMA(NULL, 0, 20, 0, MODE_EMA, PRICE_CLOSE, 2);
      double emaSlowPrev = iMA(NULL, 0, 50, 0, MODE_EMA, PRICE_CLOSE, 2);
      
      if(emaFastPrev <= emaSlowPrev && emaFast > emaSlow)
         return 1;  // Buy signal
      else if(emaFastPrev >= emaSlowPrev && emaFast < emaSlow)
         return -1; // Sell signal
   }
   else if(regime == REGIME_RANGING)
   {
      // Mean reversion: use RSI oversold/overbought
      double rsi = iRSI(NULL, 0, 14, PRICE_CLOSE, 1);
      
      if(rsi < 30)
         return 1;  // Buy signal (oversold)
      else if(rsi > 70)
         return -1; // Sell signal (overbought)
   }
   
   return 0;
}

This is where the regime sensitivity really shines. When the market is trending, we ride momentum with EMA crossovers. When it's ranging, we fade extremes with RSI. The EA never tries to force a square peg into a round hole.

You can swap these entry methods for your own preferred strategies. For trending mode, you could use Bollinger Band breakouts, MACD crossovers, or even a simple price channel breakout. For ranging mode, stochastic oscillators, price action at support/resistance, or Bollinger Band squeezes all work. The key is that the regime detection stays the same — only the entry logic changes.

Complete Input Parameters

Parameter	Type	Default	Description
ADX_Period	int	14	ADX calculation period for regime detection.
ADX_Trend_Threshold	double	25.0	Minimum ADX value to consider market trending.
ADX_Range_Threshold	double	20.0	Maximum ADX value to consider market ranging.
Risk_Percent	double	1.0	Percentage of account to risk per trade.
ATR_Multiplier_Trend	double	2.0	Stop-loss multiplier for trending regime.
ATR_Multiplier_Range	double	1.5