Execution: 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 total size Q filled in pieces q_i at prices p_i:

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: more time lowers impact and raises exposure to the market.

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 is the economically honest measure, and the one 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 daily volatility, 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 drive everything below: 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 forty per cent, not a hundred.

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 from the previous child plus the median gap seen so far times 100% of an unjittered TWAP’s children (20 children over two hours) to within thirty seconds; at 50% jitter the figure falls to 27%, and at full jitter to 14%. The price is small but not zero: 0.4 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, a fraction of a basis point), 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 and is chosen so that a full-day order lands near the square-root law above; γ = 0.3. Both are illustrative, not a calibration: the shapes of the results are the point, not their levels.

The reference grid computed by the Python simulator (4,000 paths per cell, 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 simulator gives:

Stretching the window from 6 minutes to the full day cuts the expected cost from 35 bp to 5 bp and raises the timing risk from 0 bp to 87 bp, the risk growing roughly with the square root of the window. No point is better on both axes. That is the Almgren–Chriss frontier, and choosing a point on it is a statement about how much price risk a strategy is willing to carry to save impact.

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, x, 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

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,351 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 alternating the two algorithms on comparable orders, 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. Field note 04 (QuantConnect and LEAN) describes how the backtesting engine models fills, and the gap between the two is where most live underperformance starts.

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

    side = +1 for a buy, -1 for a sell; positive is a cost. 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)
    avg = (fill_prices * fill_sizes).sum() / fill_sizes.sum()
    return side * (avg - arrival_mid)