TWAP, slicing and jitter

01Parent orders and implementation shortfall

Call the order the trader wants filled the parent, and the pieces actually sent to the market its children. The cost of a parent order is best measured against the price at the moment the decision was made, the arrival price, usually the mid-quote. For a buy of intended size Q, filled in pieces q_i at prices p_i, with m_end the mid when the order ends:

Perold introduced implementation shortfall as the gap between a paper portfolio, traded instantly at decision prices, and the real one.¹ In practice it is split into four parts: the half-spread paid to cross the quote, the market impact of the trader’s own demand, the timing risk of prices moving while the order is worked, and the opportunity cost of any part left unfilled. Splitting an order trades the second against the third: smaller children each pay less impact, but sending them takes time, and the part not yet filled is exposed to the market meanwhile.

02Arrival, TWAP and VWAP

Three benchmarks are in common use, and each rewards different behaviour. Choosing one is choosing what the execution is judged on.

VWAP became popular because it is simple to compute and hard to miss by much: an algorithm that follows the market’s volume curve will land close to it.² That is also its weakness. A large order moves VWAP towards its own fills, so beating VWAP says little about whether the trade was cheap. Arrival-price cost measures what the trade actually cost, and it is the measure this note uses; TWAP and VWAP are best treated as descriptions of how an order was worked.

03Market impact and the cost of waiting

The square-root law

How much does demand move the price? Kyle’s model gives a linear answer: price moves in proportion to net order flow, with a slope that rises with the uncertainty about the asset’s value and falls with the volume of uninformed trading that hides informed orders.³ Empirically, the total impact of a large order grows more slowly than its size. Across markets and decades, a good approximation is

where σ is volatility (daily here, unlike the annualised σ of the series notation), V daily volume and Y a constant of order one. Almgren, Thum, Hauptmann and Li estimated impact from large US equity orders and found temporary impact growing with the rate of trading raised to a power of about 0.6, close to the square root;⁴ Tóth and co-authors found the square root across many markets and argued that it reflects how thin liquidity is close to the current price.^5,6 Two consequences follow: the cost of an order depends on its size relative to volume more than on its size in shares, and doubling an order raises its cost per share by about 41%, where a linear model would say 100%.

The cost of waiting

Spreading an order over time lowers impact but leaves the unfilled part exposed to price moves. Bertsimas and Lo showed that, with linear impact and no concern for risk, splitting the order evenly over the available time minimises expected cost: that even split is a TWAP.⁷ Almgren and Chriss added the variance of cost: a risk-averse trader trades faster at the start, and the set of schedules that minimise variance for each level of expected cost forms an efficient frontier, from TWAP at one end to immediate execution at the other.⁸ Obizhaeva and Wang showed that when the order book refills gradually after each trade, the optimal schedule combines discrete trades at the start and end with continuous trading in between.⁹

04Schedules

A TWAP schedule divides a parent of size Q into N children of size Q/N, one every W/N minutes across a window W. Three numbers describe it. The participation rate, the child’s share of the market volume trading while it works, drives impact. The window drives timing risk. The child size relative to the quoted size decides whether a child can cross the spread without walking the book.

05Why schedules are randomised

A perfectly regular schedule, the same size at the same interval, is a signal. Anyone watching the tape who sees clips of the same size print every few minutes can infer that a larger order is being worked, estimate its direction and remaining size, and trade ahead of it. Brunnermeier and Pedersen formalised the incentive: when a trader is known to need to buy or sell, others profit by trading in the same direction first and reversing later.¹⁰ The defence is to make the schedule harder to read. Jitter randomises each child’s time within its slot and scales its size by a random factor, while still completing the parent within the window.

def schedule(slices: int, window: int, jitter: float, rng: np.random.Generator):
    """Child times (minutes after the window opens) and sizes (fractions of the parent).

    jitter = 0 is a plain TWAP: equal sizes at the start of equal intervals, so one slice is an
    immediate order. jitter in (0, 1] delays each child by up to jitter x its interval and scales
    each size by 1 + jitter * U(-0.5, 0.5), renormalised so the parent is filled exactly.
    """
    dt = window / slices
    times = (np.arange(slices) + jitter * rng.uniform(0.0, 1.0, slices)) * dt
    sizes = 1.0 + jitter * rng.uniform(-0.5, 0.5, slices)
    return np.sort(times), sizes / sizes.sum()

In the simulator, an observer who predicts each child’s time as the previous child’s time plus the median gap seen so far gets 100% of an unjittered TWAP’s children after the second (20 children over two hours) right to within 30 seconds; at 50% jitter the figure falls to 27%, and at full jitter to 14%. The price is small but not zero: 0.36 bp of expected cost at full jitter in this model, against a timing risk of 46 bp. It arises because a child’s total impact cost grows with its size to the power 1.5, so uneven sizes cost more than even ones, and because delayed children move along the intraday volume curve. The measure is deliberately narrow: it only watches the clock. Jitter does not hide one-sided flow, which a careful observer sees in the tape whatever the timing, and it helps little when children are about a minute apart. Randomising order types and venues, and never trading the same size at the same second of the minute, follow from the same logic.

def detectability(slices: int, window: int, jitter: float, rng: np.random.Generator,
                  tolerance: float = 0.5) -> float:
    """Share of child orders whose time an observer predicts to within `tolerance` minutes by
    adding the median of the gaps seen SO FAR to the previous child's time. 1.0 for an exact
    TWAP. The observer only watches the clock; size and direction are other giveaways."""
    t, _ = schedule(slices, window, jitter, rng)
    gaps = np.diff(t)
    if len(gaps) < 2:
        return 0.0
    guess = np.array([t[i - 1] + np.median(gaps[: i - 1]) for i in range(2, len(t))])
    return float(np.mean(np.abs(guess - t[2:]) <= tolerance))

06An execution laboratory

The laboratory below simulates a buy order under the model in the code listing: a random-walk mid with the chosen daily volatility, a half-spread of 1 bp, temporary impact following the square-root law in each child’s share of the volume while it works (one minute, or its slot if shorter), linear permanent impact (small at this size, under 1 bp), and a U-shaped intraday volume curve. Each child starts its slot, so a single child is an immediate order; jitter delays children within their slots. The impact coefficient η = 0.15 applies to one minute’s participation. With it, a full-day order worked as 390 one-minute children pays 3.55 bp in all, a temporary impact of about 0.15 · σ√(Q/V): roughly a sixth of the square-root law’s constant of order one, so the model sits at the cheap end of published estimates. The permanent-impact coefficient γ is 0.3. The two are close to the values Almgren and co-authors fitted, though their temporary impact grows with the trading rate to the power 0.6.⁴ They are illustrative: the shapes of the results matter here, and their levels do not. Expected costs and timing risks below are exact under the model (the random-walk mid is integrated out); only the spread of outcomes comes from simulated days.

The reference grid computed by the Python model (an order of 1% of daily volume, 1.5% daily volatility) shows the two forces separately. Holding the window fixed, more children cut the cost; the timing risk depends mainly on the window:

The trade-off appears when the pace is held and the window stretched. At one child every six minutes, the Python model gives:

Stretching the window from 6 minutes to the full day cuts the expected cost from 35 bp to 7 bp and raises the timing risk from 0 bp to 86 bp, the risk growing roughly with the square root of the window. In this toy the saving comes from the number of children, not from the time: each child’s impact is gone within its minute, so the same 65 children sent one a minute would cost 6 bp with a timing risk of 35 bp, better on both axes than spreading them over the day. In real markets impact decays over minutes to hours, so trading the same amount faster costs more; that is the trade-off the Almgren–Chriss frontier prices, and choosing a point on it is a statement about how much price risk a strategy is willing to carry to save impact. The toy has no such memory, so this table shows what more children buy, and the frontier itself needs a model in which impact decays.

def volume_profile(minutes: int = MINUTES) -> np.ndarray:
    """A U-shaped intraday volume profile: busier at the open and the close. Sums to one."""
    t = np.arange(minutes) + 0.5
    f = 1.0 + 1.5 * ((t - minutes / 2) / (minutes / 2)) ** 2
    return f / f.sum()


def _volume(prof: np.ndarray, a: float, b: float) -> float:
    """Market volume (fraction of the day) between minutes a and b, pro rata within a minute."""
    i, j = int(np.floor(a)), int(np.floor(b))
    if i == j:
        return prof[min(i, MINUTES - 1)] * (b - a)
    total = prof[i] * (i + 1 - a) + prof[i + 1:j].sum()
    return total + (prof[j] * (b - j) if j < MINUTES else 0.0)


def expected_cost(size=0.01, sigma=150.0, slices=10, window=120, jitter=0.0, spread=2.0,
                  eta=0.15, gamma=0.3, child_minutes=1.0, start=0, schedules=400, seed=7) -> dict:
    """Expected implementation shortfall and timing risk, with the price path integrated out.

    The mid is a driftless random walk, so its expected contribution to the cost is zero and
    the expected shortfall is the expected impact plus half the spread. The timing risk is
    exact too: child i fills after m_i one-minute steps, so the price part of the cost has
    variance  vol_min^2 * sum_ij q_i q_j min(m_i, m_j). Only the schedule is random (jitter),
    and it is averaged over `schedules` draws from a fixed seed, so neighbouring settings share
    their draws and the numbers move smoothly. With no jitter one schedule is exact.
    """
    window = min(window, MINUTES - start)
    rng = np.random.default_rng(seed)
    prof = volume_profile()
    vol_min = sigma / np.sqrt(MINUTES)
    work = min(child_minutes, window / slices)
    n = 1 if jitter == 0 else schedules
    impact, var_price = np.empty(n), np.empty(n)
    for k in range(n):
        t, q = schedule(slices, window, jitter, rng)
        m = np.minimum(start + t.astype(int), MINUTES - 1) - start    # price steps before each fill
        v = np.array([_volume(prof, *_working(x, work)) for x in start + t])
        child = q * size
        temp = eta * sigma * np.sqrt(child / v)
        perm = gamma * sigma * np.concatenate([[0.0], np.cumsum(child)[:-1]])
        impact[k] = (q * (perm + temp + spread / 2)).sum()
        later = q[::-1].cumsum()[::-1] - q                         # weight filled after child i
        var_price[k] = vol_min ** 2 * (m * (q * q + 2 * q * later)).sum()
    sd = np.sqrt(var_price.mean() + (impact.var() if n > 1 else 0.0))
    return {"expected": impact.mean(), "sd": sd}


def simulate(size=0.01, sigma=150.0, slices=10, window=120, jitter=0.0, spread=2.0,
             eta=0.15, gamma=0.3, child_minutes=1.0, start=0, paths=2000, seed=7) -> dict:
    """Implementation shortfall (vs the arrival mid) of many paths, and its parts."""
    window = min(window, MINUTES - start)
    rng = np.random.default_rng(seed)
    prof = volume_profile()
    vol_min = sigma / np.sqrt(MINUTES)
    cost = np.empty(paths)
    impact = np.empty(paths)
    for k in range(paths):
        t, q = schedule(slices, window, jitter, rng)
        minute = np.minimum(start + t.astype(int), MINUTES - 1)
        steps = rng.normal(0.0, vol_min, MINUTES)
        path = np.concatenate([[0.0], np.cumsum(steps)])
        mid = path[minute] - path[start]                              # random walk from arrival
        work = min(child_minutes, window / slices)
        a = start + t
        v = np.array([_volume(prof, *_working(x, work)) for x in a])
        child = q * size
        temp = eta * sigma * np.sqrt(child / v)
        perm = gamma * sigma * np.concatenate([[0.0], np.cumsum(child)[:-1]])
        fills = mid + perm + temp + spread / 2
        cost[k] = implementation_shortfall(fills, q, 0.0)
        impact[k] = (q * (perm + temp + spread / 2)).sum()
    return {"mean": cost.mean(), "sd": cost.std(ddof=1), "p05": np.percentile(cost, 5),
            "p95": np.percentile(cost, 95), "expected_impact": impact.mean()}

07Measuring execution quality

The tables give each schedule’s expected cost and its timing risk. A single order delivers one number, its measured shortfall, and that number mixes the two, as one simulated order from the reference case shows.

Execution quality can only be judged in aggregate. With a timing risk of about 46 bp per order in the example above, telling apart two algorithms whose true costs differ by 5 bp needs roughly 1,300 orders for each algorithm to detect the difference reliably (a two-sided 5% test with 80% power). Removing the market’s move from each order’s cost, or splitting the same parent orders between the two algorithms, so that both face the same market move, cuts that number considerably.

The practical consequences:

1. Record everything at the child level: decision time, arrival mid, each child’s send time, fill price, size and venue, and the quote at the time.
2. Measure against arrival first, then decompose: spread paid, temporary impact (the drift during the order that reverses afterwards), permanent impact (the part that persists), and timing (the market’s own moves while the order was worked, which a benchmark such as the index or the sector over the same minutes estimates).
3. Normalise by volatility and participation before comparing orders: cost divided by σ√(Q/V) is comparable across days and instruments; raw basis points are not.
4. Reconcile against the backtest. The backtest’s cost assumption is a hypothesis; live fills test it. QuantConnect and LEAN describes how a backtesting engine models fills; the gap between modelled and live fills is a common source of live underperformance, and Live versus backtest reconciliation measures it fill by fill against the cost model.

def implementation_shortfall(fill_prices, fill_sizes, arrival_mid, side=1, intended=None, end_mid=None):
    """Cost of a parent order against the mid at the moment it arrived, per unit of the size the
    trader intended, in the price's units.

    side = +1 for a buy, -1 for a sell; positive is a cost. `intended` is the parent's size Q
    (default: everything filled). If less than Q was filled, the unfilled part is charged its
    opportunity cost, the move from the arrival mid to `end_mid`, the mid when the order ended:

        IS = [ sum q_i (p_i - m_arrival) + (Q - sum q_i) (m_end - m_arrival) ] / Q

    Divide by the arrival mid (and multiply by 1e4) for basis points when prices are levels
    rather than bp offsets.
    """
    fill_prices, fill_sizes = np.asarray(fill_prices, float), np.asarray(fill_sizes, float)
    filled = fill_sizes.sum()
    q = filled if intended is None else float(intended)
    paid = (fill_sizes * (fill_prices - arrival_mid)).sum()
    missed = q - filled
    if missed > 1e-12 * q:
        if end_mid is None:
            raise ValueError("a partly filled order needs end_mid to price what was not filled")
        paid += missed * (end_mid - arrival_mid)
    return side * paid / q