918 Experiments, Zero Directional Edge: What TCNs Actually Detect

The most uncomfortable result in deep-learning forex this year is not that temporal convolutional networks fail — it is that they succeed and fail at the same time. In a controlled benchmark of 918 experiments published February 2026 (arXiv 2603.16886), the modern TCN variant ModernTCN swept the field on level-forecast accuracy, posting a mean rank of 1.333 and winning 16 of 16 forex and equity tests at the 24-hour horizon. And yet, on the one metric a long/short EA actually trades — directional accuracy — every architecture in the study, ModernTCN included, was statistically indistinguishable from a coin flip.

The Architecture That Promised Too Much

The TCN's appeal to EA developers was always architectural, not empirical. Where an LSTM processes a sequence step by step and bleeds gradient signal across long dependencies, a TCN stacks dilated causal convolutions that read the whole window in parallel. The standard block is five components — a dilated causal convolutional layer, weight normalization, an activation, dropout, and a residual connection — and the dilation factors expand exponentially, typically d = 1, 2, 4 with a kernel size of k = 3.

That exponential dilation is the headline feature. A 3-layer TCN with those parameters sees 24 time steps of history; extend it to 6 layers and the receptive field jumps to 192 steps — all without the vanishing-gradient tax that punishes deep recurrent stacks. Bai et al.'s original 2018 paper showed this simple convolutional design outperforming canonical LSTMs and GRUs across most sequence-modeling benchmarks, and the finance community took the hint. No vanishing gradients, parallelizable training, explicit temporal ordering: on paper, the ideal price-prediction engine.

The trouble is that "sequence modeling benchmark performance" and "tradeable directional edge" are different objects, and the gap between them is exactly where a forward-test account goes to die.

What 918 Experiments Actually Found

The February 2026 benchmark is the most statistically rigorous attempt yet to settle the question. It pitted nine architectures — Autoformer, DLinear, iTransformer, LSTM, ModernTCN, N-HiTS, PatchTST, TimesNet, and TimeXer — against cryptocurrency, forex, and equity-index data at 4-hour and 24-hour horizons, with hyperparameter optimization and multi-seed retraining to strip out luck.

On magnitude accuracy, the TCN lineage dominated. ModernTCN took first place 75% of the time across 24 evaluation points and beat every Transformer variant, the LSTM, and the classic CNN baselines on RMSE. At the other end, the FFT-based TimesNet — architecturally the most novel entrant — landed in the bottom tier with a rank of 7.708, a clean reminder that novelty is not performance.

Then comes the sentence that should reframe how EA developers use these models:

Directional accuracy is indistinguishable from 50% across all 54 model-category-horizon combinations.

Not the weak models. Not the crypto subset. All of them, across every category and both horizons. The benchmark's explanation is mechanical rather than mystical: models trained to minimize MSE or RMSE optimize for level proximity, and "directional forecasting requires explicit loss-function redesign." You cannot ask a network to minimize squared error and expect a sign-prediction edge to fall out for free.

Why a 0.998 R-Squared Tells You Nothing About P&L

The level-versus-direction divergence is easy to miss because the level metrics look spectacular. A Frontiers in Physics study (2022) trained a TCN on nine years of data — January 2012 to December 2021 — across EUR/RMB, RUB/RMB, AUD/RMB, and GBP/RMB, and reported an in-sample R-squared of 0.99814 on AUD/RMB. That number is real, and it is also nearly useless for trading: it confirms the network tracks the price series tightly, while saying nothing about whether it calls the next bar up or down.

This is the trap. A curve that hugs the historical close looks like prophecy on a backtest chart and behaves like noise on a forward test. The independent Hecatus Research study made the failure explicit, applying a TCN to S&P 500 SPY 5-day forward returns under strict train/validation/test splits and multiple robustness diagnostics. Its verdict: it could not reject the null that AUC ≤ 0.50, and performance "does not reliably exceed that of a random classifier," with the authors concluding the "exploitable signal appears weak or absent at short horizons."

Visualizing the gap is the fastest cure for the illusion. Traders can monitor these levels in real time using TradingView, which lets you overlay a smooth model-fitted level curve against the raw bar-by-bar direction it is supposed to predict — and see directly how a forecast that looks near-perfect on magnitude scatters into randomness the moment you score it on sign. The hybrid-model literature underlines how thin the magnitude edge is anyway: on EUR/USD, AUD/USD, and GBP/USD, an LSTM-TCN configuration posted an average RMSE of 0.003911 versus 0.004181 for TCN-LSTM — a 6.5% difference small enough to vanish under spread costs.

Where TCN Genuinely Earns Its Place: Event and Regime Detection

None of this makes the TCN useless. It makes it misassigned. The architecture's real strength is detecting that something unusual is happening — not predicting which way price resolves it. Reframed as an event and volatility detector, the same model that flunks direction starts adding value.

The evidence is in the anomaly-detection literature. The DTAAD framework (Dual TCN-Attention Networks) for multivariate time-series anomaly detection improved true-positive rate by 6.43%, overall accuracy by 7.63%, and cut the false-positive rate by 11.96% against prior methods. That is precisely the job the TCN's exponential receptive field is suited for: recognizing when the current window has departed from its learned baseline.

Practitioners are already routing the architecture this way. Documented quant pipelines pair a TCN with a Random Forest for XAUUSD regime classification under walk-forward validation — labeling trending versus ranging environments rather than betting on up or down. This is the architecturally honest application: the benchmark itself found that "architecture explains nearly all performance variance, while seed randomness is negligible," which both validates the TCN as a structural choice and quietly demolishes the common EA habit of re-running a backtest until a lucky seed prints a pretty equity curve.

Even the Right Use Case Decays Without Retraining

Deploying a TCN as a regime filter is necessary but not sufficient, because a static model is a snapshot of a market that keeps moving. A 2025 study on deploying TCN-based models for real-time risk monitoring in automated trading systems found that static TCNs degrade under regime shifts and require a dynamic model-updating mechanism to keep adapting to evolving market behavior.

For an MT5 developer, the operational consequence is concrete: a TCN volatility classifier that scored well on 2024 data is, by 2026, classifying against conditions it was never shown. The receptive field that makes the architecture powerful is also a lookback window, and a lookback window carries an expiry date the moment the regime composition behind it changes.

The Constructive Takeaway: A Gate, Not an Oracle

The synthesis the 2026 benchmark and the 2025 practitioner literature both point to is a hybrid one, well summarized by an April 2026 mql5.com note:

AI does not need to replace classic trading logic; in many cases, the strongest approach is hybrid, where traditional rules define what the strategy is allowed to do, while machine learning or statistical scoring helps decide whether the current environment resembles conditions where that strategy historically performed well.

In an EA, that means demoting the TCN from signal generator to environment gate. The rules-based logic — your moving-average cross, your breakout, your mean-reversion trigger — decides the trade. The TCN only decides whether the current volatility state is one in which that rule has historically earned its keep.

// TCN as a regime gate, not a direction oracle
double tcn_state = TCN_VolatilityScore();   // 0..1, NOT a buy/sell signal

bool regimeOK = (tcn_state > LOW_VOL_FLOOR && tcn_state < HIGH_VOL_CEIL);

if (regimeOK && ClassicEntrySignal())
    OpenTrade();          // direction comes from the rules, not the net
// else: stand aside — wrong environment for this strategy

The distinction is the whole article. A TCN pointed at the directional question is, on the best available evidence, a 50/50 generator dressed in convincing in-sample R-squared. The same network pointed at the event-detection question — is the market entering an unusual or off-baseline state? — is doing the job its architecture was built for. The 918 experiments did not prove deep learning has no place in forex. They proved that placing it correctly is the entire game, and that the metric you optimize decides whether you get a regime filter or an expensive coin flip.

None of this guarantees an edge. Regime filters can be wrong, retraining can lag the break, and a well-gated bad strategy is still a bad strategy. But the framing dissolves a costly illusion: that a model which tracks price beautifully must also predict it. On the evidence, those are separate claims — and only one of them survives an out-of-sample test.