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
0
21

I review AI-generated MQL code regularly in rescue projects. Since 2024, the same three failure patterns appear in the majority of 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.

I see this in roughly 40% of AI-generated EA rescue projects. 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 broker either rejects with error 130 or silently adjusts.

Lot step mismatch. AI sends raw calculated lot sizes to OrderSend() . The broker rounds to the nearest MODE_LOTSTEP . The actual risk differs from the intended risk, and the EA never knows.

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:

double rawLots = AccountBalance() * 0.02 / (stopLossPips * tickValue);
double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
double lots = MathFloor(rawLots / lotStep) * lotStep;
lots = MathMax(lots, MarketInfo(Symbol(), MODE_MINLOT));
lots = MathMin(lots, MarketInfo(Symbol(), MODE_MAXLOT));

double sl = Ask - stopLossPips * Point;
double stopsLevel = MarketInfo(Symbol(), MODE_STOPLEVEL) * Point;
if(Ask - sl < stopsLevel)
{
   sl = Ask - stopsLevel;
   printf("%s: SL adjusted to stop level | Requested=%.5f Effective=%.5f",
          __FUNCTION__, Ask - stopLossPips * Point, sl);
}

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

int ticket = OrderSend(Symbol(), OP_BUY, lots, Ask, 3, sl, Ask + tpPips * Point);
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. Broker constraints 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.

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