Three Production Failures in AI-Generated MQL Code That the Strategy Tester Never Catches
Trading Systems

Three Production Failures in AI-Generated MQL Code That the Strategy Tester Never Catches

18 July 2026, 17:56
Boris Armenteros
Boris Armenteros
2
168

Three failure patterns recur in AI-generated EAs. The code compiles clean and backtests well. It fails in production because it misses the conditions that only exist when real money is on the line.

No State Persistence After Terminal Restart

AI-generated EAs store trade state in RAM — static variables, global scope counters. When the terminal restarts, everything resets. The EA forgets its open positions and opens duplicates.

A common AI pattern:

static int openTradeCount = 0;

void OnTick()
{
   if(openTradeCount < 1 && entryCondition)
   {
      OrderSend(...);
      openTradeCount++;
   }
}

In the Strategy Tester, this works perfectly — the tester never restarts mid-run. In live trading, after a VPS reboot, openTradeCount resets to 0. The EA opens a new position while the previous one is still running.

The fix requires scanning the order pool on every init:

int OnInit()
{
   openTradeCount = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderMagicNumber() == magicNumber && OrderSymbol() == Symbol())
         {
            openTradeCount++;
         }
      }
   }
   printf("%s: Init | Recovered %d open positions", __FUNCTION__, openTradeCount);
   return(INIT_SUCCEEDED);
}

The counter is never the source of truth. The broker's order pool is.

Missing Order Context Validation

AI treats the order pool as a static list. It selects an order by position index, reads its properties, runs trailing logic, then calls OrderModify() — assuming the pool stayed frozen between operations.

Two things break this assumption in live trading. First, the order can close between OrderSelect() and OrderModify() . Second, if the trailing logic contains any intervening OrderSelect() call — checking a hedge position, scanning for a related order — the internal selection shifts. The subsequent OrderOpenPrice() and OrderTakeProfit() calls return values from whatever order was last selected, not the intended target.

The production-ready pattern re-selects by ticket before every modification:

for(int i = OrdersTotal() - 1; i >= 0; i--)
{
   if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
   {
      int ticket = OrderTicket();
      double newSL = CalculateTrailingStop(ticket);

      if(OrderSelect(ticket, SELECT_BY_TICKET))
      {
         if(OrderCloseTime() == 0)
         {
            if(!OrderModify(ticket, OrderOpenPrice(), newSL, OrderTakeProfit(), 0))
            {
               printf("%s: OrderModify failed | Ticket=%d Error=%d",
                      __FUNCTION__, ticket, GetLastError());
            }
         }
      }
   }
}

Three extra lines. One concept: the order pool is live, and any operation that changes it invalidates previous selections.

Broker Constraint Blindness

AI generates order operations that ignore runtime constraints enforced by the broker's trade server.

Stop level violation. Every broker defines MODE_STOPLEVEL — the minimum distance between price and any stop loss or take profit. AI generates OrderModify() without checking this. The trade server rejects the call with error 130 (invalid stops), and an EA that does not check the return value never notices.

Lot step mismatch. AI sends raw calculated lot sizes to OrderSend(), such as 0.0847 lots, and what happens next depends on the platform. In MT4 the order opens at 0.08 lots with no error: in our tests on a demo account and in the Strategy Tester, the terminal cut the volume to two decimals before sending it, so the actual risk is lower than intended and the EA never knows. In MT5 the same request fails with retcode 10014 (invalid volume), live and in the Strategy Tester, and an EA that does not check the result never opens the trade.

Trade context busy. In MT4, one trade operation at a time per terminal. AI never checks IsTradeAllowed() . The EA gets error 146 and proceeds as if the order was never attempted.

A composite production-ready pattern. It measures the buy's stop from Bid, as MT4 does, sizes the lot from the stop it will actually send, rounds the lot down to the broker's step, and skips the trade rather than raising the lot to the minimum:

double stopsLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
double requestedSl = NormalizeDouble(Ask - stopLossPoints * Point, Digits);
double sl = requestedSl;
if(Bid - sl < stopsLevel) // MT4 measures a buy's stop loss from Bid
{
   sl = NormalizeDouble(Bid - stopsLevel, Digits);
   printf("%s: SL adjusted to stop level | Requested=%.5f Effective=%.5f",
          __FUNCTION__, requestedSl, sl);
}

// Size the lot from the stop that will actually be sent
double tickSize = MarketInfo(Symbol(), MODE_TICKSIZE);
if(tickSize <= 0 || tickValue <= 0)
{
   printf("%s: No tick size or tick value yet, skipping entry", __FUNCTION__);
   return;
}
double rawLots = AccountBalance() * 0.02 / ((Ask - sl) / tickSize * tickValue);
double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
double lots = MathFloor(rawLots / lotStep) * lotStep;
if(lots < MarketInfo(Symbol(), MODE_MINLOT))
{
   printf("%s: Risk budget below the minimum lot, skipping entry", __FUNCTION__);
   return;
}
lots = MathMin(lots, MarketInfo(Symbol(), MODE_MAXLOT));

if(!IsTradeAllowed())
{
   printf("%s: Trade context busy, skipping entry", __FUNCTION__);
   return;
}

double tp = NormalizeDouble(Ask + tpPoints * Point, Digits);
int ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3, sl, tp);
if(ticket < 0)
{
   printf("%s: OrderSend failed | Error=%d", __FUNCTION__, GetLastError());
}

Why the Strategy Tester Misses All of This

The tester never restarts mid-run. Orders do not close between operations within the same tick. Stop levels are often not enforced or set to zero. Trade context is always available. AI learns from code that works in this controlled environment because production failures are posted as forum complaints — not as code samples.

The code is not broken. It is incomplete. It handles the strategy logic and nothing else.

Quick Diagnostic Checklist

Before running any AI-generated EA live, search the source for:

  1. GlobalVariableSet or FileWrite in OnInit() — state persistence
  2. OrdersTotal() or PositionsTotal() in OnInit() — position reconciliation
  3. OrderSelect(ticket, SELECT_BY_TICKET) before every OrderModify() — re-selection
  4. MODE_STOPLEVEL or SYMBOL_TRADE_STOPS_LEVEL — stop level validation
  5. MODE_LOTSTEP or SYMBOL_VOLUME_STEP — lot normalization
  6. IsTradeAllowed() before OrderSend() — trade context guard

If any of these is missing, the code is not production-ready.

Correction, 9 October 2026: the lot step paragraph said the broker rounds an off-step volume to the nearest step. Tests on MT4 and MT5 demo accounts and in the Strategy Tester showed otherwise, and the paragraph now says what each platform does. The stop level sentence no longer says the broker may silently adjust a stop. The composite example now measures a buy's stop loss from Bid, as MT4 does, and sizes the lot from the stop it actually sends.

#Risk Management, expert advisors, Live Trading, MQL4, MQL5, Strategy Tester, AI code generation