Algorithmic Trading Strategy Lifespan: How Long Edges Last

How long does an algorithmic trading strategy last?

There is no single half-life. The honest answer is a range that depends on four things: capacity (how much capital the edge absorbs before its own impact eats it), capital and infrastructure required to exploit it, turnover and holding horizon, and how many other participants hold the same signal.

Quoted figures such as 'edges last 3 to 5 years' are summaries of heterogeneous strategies, not constants. A latency-sensitive arbitrage and a value factor share a word, 'alpha', but not a decay mechanism.

The useful question is therefore not 'how long' but 'what is the decay rate of my signal, and can I measure it faster than it costs me?'

What does the academic evidence say about alpha decay?

McLean and Pontiff (2016) studied 97 published cross-sectional return predictors. They found returns about 26% lower out-of-sample (the period after each predictor's original sample ends and before publication) and about 58% lower after publication. The gap between 26% and 58% is read as roughly 32 points of publication-informed trading, and the 26% as a mix of statistical bias and data mining.

Chordia, Subrahmanyam and Tong examined anomaly profitability over time and found it weakened substantially after decimalization and the rise of liquidity and arbitrage activity. Cheaper, faster trading made known anomalies easier to arbitrage, so the mechanism there is market structure, not only discovery.

Two engineering lessons follow. First, haircut any published backtest heavily before allocating research time. Second, a signal that survives only in the pre-publication or pre-decimalization sample is a candidate for being already dead, not a bargain.

Why do trading strategies stop working?

Most failures trace to a small set of mechanisms. Knowing which one applies tells you whether to retire, resize or repair.

Importantly, several of these are not alpha decay at all: cost increases and capacity limits reduce net returns while the gross signal is intact.

How do HFT and slower strategies decay differently?

High-frequency edges are often based on speed or market structure: queue priority, rebate capture, cross-venue latency. They can vanish within days to months when a competitor upgrades hardware or an exchange alters fees, tick size or matching rules. The edge is binary with respect to your position in the speed ranking.

HFT firms also recalibrate continuously, so decay tends to appear as a shrinking margin per trade (lower capture per fill, higher adverse selection) rather than a clean stop. Monitoring should therefore track per-fill economics daily, not monthly return.

Slower factor and macro strategies can persist for years because they rely on risk premia or behavioural patterns that are hard to arbitrage at scale. They decay by dilution: more capital, lower returns, higher correlation with other holders. A years-long gradual slope is statistically harder to distinguish from noise than an abrupt break, which is why slow strategies need longer evaluation windows.

How do I separate alpha decay from overfitting?

Much 'decay' is a backtest that never had edge. Selection from many trials, multiple testing and look-ahead bias inflate the in-sample Sharpe; live results then regress toward zero and look like decay.

Bailey and López de Prado's deflated Sharpe ratio (DSR) adjusts the observed Sharpe for the number of trials, non-normality (skew, kurtosis) and sample length. Probability of backtest overfitting (PBO) uses combinatorially symmetric cross-validation to estimate how often the in-sample best configuration ranks below median out-of-sample.

Record the number of configurations you tried. Without it, DSR cannot be computed honestly.

import numpy as np
from scipy.stats import norm, skew, kurtosis

def expected_max_sr(n_trials, sr_var):
    g = 0.5772156649
    return np.sqrt(sr_var) * ((1 - g) * norm.ppf(1 - 1.0 / n_trials)
                              + g * norm.ppf(1 - 1.0 / (n_trials * np.e)))

def deflated_sharpe(returns, n_trials, sr_var_across_trials):
    # returns: periodic strategy returns; Sharpe is per-period (not annualized)
    T = len(returns)
    sr = returns.mean() / returns.std(ddof=1)
    sk, ku = skew(returns), kurtosis(returns, fisher=False)
    sr0 = expected_max_sr(n_trials, sr_var_across_trials)
    denom = np.sqrt(1 - sk * sr + (ku - 1) / 4 * sr ** 2)
    z = (sr - sr0) * np.sqrt(T - 1) / denom
    return norm.cdf(z)  # probability true SR > 0 after deflation

How do I measure alpha decay quantitatively?

Use several lenses together. Rolling Sharpe and rolling information coefficient (IC, the rank correlation between signal and forward return) show drift. An IC term structure, IC computed at horizons h = 1, 2, 5, 10, 20 bars, shows how fast the signal's information is absorbed; the horizon where IC falls to half of its peak is a practical signal half-life.

To estimate decay in time, fit an exponential to cumulative or rolling alpha: alpha(t) = a0 * exp(-lambda * t), with half-life ln(2)/lambda. Report the confidence interval; with noisy data it will be wide, and that width is itself information.

Finally, compare live fills to backtest assumptions. If gross signal return is intact but net return is falling, you have a cost or capacity problem, not decay.

import numpy as np, pandas as pd
from scipy.optimize import curve_fit

def rolling_ic(signal, fwd_ret, window=63):
    # signal, fwd_ret: wide DataFrames (dates x assets); fwd_ret must be
    # strictly AFTER signal timestamp (shift to avoid look-ahead)
    ic = signal.rank(axis=1).corrwith(fwd_ret.rank(axis=1), axis=1)
    return ic.rolling(window).mean()

def ic_term_structure(signal, prices, horizons=(1, 2, 5, 10, 20)):
    out = {}
    for h in horizons:
        fwd = prices.pct_change(h).shift(-h)
        out[h] = signal.rank(axis=1).corrwith(fwd.rank(axis=1), axis=1).mean()
    return pd.Series(out)

def fit_half_life(alpha_series):
    t = np.arange(len(alpha_series))
    f = lambda t, a0, lam: a0 * np.exp(-lam * t)
    (a0, lam), cov = curve_fit(f, t, alpha_series.values, p0=(alpha_series.iloc[0], 0.01), maxfev=10000)
    return np.log(2) / lam if lam > 0 else np.inf

How do I detect decay statistically and monitor live performance?

The central constraint is sample size. The standard error of an annualised Sharpe estimate is roughly sqrt((1 + 0.5 * SR^2) / years). For SR near 1 that is about 1.2 / sqrt(years), so you need roughly 5 to 6 years of data for a 95% interval that excludes zero, and far more to distinguish SR 1.0 from SR 0.7. A single drawdown, even a deep one, is usually within what the backtest distribution allows.

Sequential tests help because they use data as it arrives. CUSUM accumulates standardised shortfall against the expected mean and alarms at a threshold; a sequential probability ratio test compares 'edge as backtested' against 'edge halved or zero'. Change-point methods (for example PELT) locate breaks retrospectively, which suits post-mortems.

1. Pre-register kill criteria before going live: max drawdown beyond a percentile (for example the 99th) of the backtest drawdown distribution, live slippage above a multiple of modelled slippage, hit-rate drift beyond a band.
2. Run a paper or shadow stage that records signals, intended and simulated fills, and compare them with live fills.
3. Alert on input feature distribution drift (population stability index or Kolmogorov-Smirnov statistic against a reference window).
4. Size down in stages when CUSUM or SPRT alarms, then retire if the kill rules trip, without discretionary exceptions.

def cusum(returns, mu0, sigma, k=0.5, h=5.0):
    # one-sided CUSUM for a downward shift in mean; k, h in units of sigma
    s, alarms = 0.0, []
    for i, r in enumerate(returns):
        z = (mu0 - r) / sigma
        s = max(0.0, s + z - k)
        if s > h:
            alarms.append(i); s = 0.0
    return alarms

What engineering practices extend a strategy's lifespan, and what mistakes shorten it?

Walk-forward validation and a genuinely untouched out-of-sample holdout reduce the chance of deploying noise. Model transaction costs with realistic impact (for example a square-root impact term scaled by participation) and estimate capacity as the size at which net Sharpe halves. Keep research pipelines versioned, with data snapshots, so a result can be reproduced and a decay investigation compares like with like.

Treat the portfolio as a pipeline: expect to research replacements continuously, diversify across uncorrelated strategies, size down as decay is detected, and retire on predefined rules rather than hope.