28Build: an Execution Algorithm

A trader hands the algorithm an order to buy 200 000 shares by three o’clock with a limit price. Everything this book has built, the schedule, the placement, the routing, the measurement, has to run at once, and keep running when the market does something the design did not expect: a halt, a spike, a kill from the desk. This chapter assembles firm.execalgo, an implementation-shortfall algorithm, from chapters 14, 17, 18 and 25, runs 200 parent orders through chapter 27’s agent market against a TWAP baseline on the same order flow, and measures both with chapter 19’s toolkit. The answer to the question every desk asks, “how much does it beat TWAP by?”, turns out to depend on the order.

28.1 The algorithm as a state machine

An execution algorithm (chapter 16) is a program that holds a parent order and decides, again and again, what child orders to have in the market. Written as a state machine it has few states and many events (Figure 28.1): a new order starts working at its start time and records the arrival mid; it is paused while its stock is halted or paused and resumes when trading does; it ends done when filled, expired when its deadline passes with shares left, or killed when the desk or a risk control stops it. Every transition and every refusal is written to an audit log with its time, the state and the reason: the log is how the desk, compliance and the developer reconstruct what the algorithm did and why.

28.2 Schedule, placement and routing together

The schedule is chapter 14’s: the Almgren–Chriss trajectory of holdings $x(t) = X \sinh(\kappa(T - t))/\sinh(\kappa T)$, with the urgency given as $\kappa T$ (zero for a straight line) through firm.acexec’s scheduler interface (Almgren and Chriss 2001; Kissell’s textbook describes the same family of implementation-shortfall algorithms). Every second the algorithm computes what the schedule says should be done by now and what it says should be done a little later (20 seconds), and bounds both by the participation band.

Placement is chapter 17’s lesson made operational: rest passively at the near touch for the schedule a little ahead, and cross the spread only for what the order is behind by more than a tolerance (20 seconds of schedule), so that the passive order has time to fill before it is overtaken. Crossing goes through chapter 18’s sweep when the stock trades on several venues: the displayed quotes at the far touch, best price first, each leg an immediate-or-cancel child. A limit price caps every child; an I-would price switches the algorithm to its band’s upper edge while the far touch is at or better than it.

    def check(self, ctx):
        p, sgn = self.p, self.sign
        tau = self._t(ctx) - self.paused_s
        left = p.qty - self.filled
        if left <= 0:
            self._cancel_all(ctx)
            self.state = "done"
            self._note(ctx, "done", f"{self.filled} filled")
            return
        b, a = self._touch(ctx)
        if b is None or a is None:
            return
        far, near = (a, b) if sgn > 0 else (b, a)
        if tau >= p.horizon_s:                                      # the deadline
            self._cancel_all(ctx)
            if p.finish and tau < p.horizon_s + p.check_s:
                self._cross(ctx, left, far)
                self._note(ctx, "finish", f"crossing the last {left}")
            else:
                self.state = "expired"
                self._note(ctx, "expire", f"{left} left unfilled")
            return
        now = self._band(p.qty - float(self.sched.targets([tau])[0]))
        if p.i_would is not None and sgn * (p.i_would - far) >= 0:
            now = max(now, min(p.qty, self._band(math.inf)))
            if not self.wanting:
                self._note(ctx, "i-would", f"far touch {far} at or better than {p.i_would}")
            self.wanting = True
        else:
            self.wanting = False
        tol = p.tol_s / p.horizon_s * p.qty if p.passive else 0.0
        behind = int((now - self.filled - tol) // 100) * 100
        if behind >= 100:
            if self.passive_cl is not None:                          # the resting order is re-sized below
                self._cancel(ctx, self.passive_cl)
                self.passive_cl = None
            self._cross(ctx, behind, far)
        if p.passive:
            ahead = self._band(p.qty - float(self.sched.targets([tau + p.look_s])[0]))
            self._rest(ctx, int((min(ahead, p.qty) - self.filled - max(behind, 0)) // 100) * 100, near)

28.3 Limits, pauses and exceptions

Every child passes pre-trade controls before it is sent: no child above a maximum size, no price further than a collar from the mid, never more working and filled than the order. They are the algorithm’s own share of the controls a broker must have in front of the market.

    def _send(self, ctx, qty: int, price: int, tif: str, venue: str = "") -> int | None:
        """Pre-trade controls (child size, price collar around the mid, never more than the order), then send."""
        mid = self._mid(ctx)
        working = sum(o["leaves"] for o in ctx.working() if o["cl"] not in self.cancelled)
        why = None
        if qty > self.p.max_child:
            why = f"child {qty} > {self.p.max_child}"
        elif mid is not None and abs(price - mid) > self.p.collar_ticks * TICK:
            why = f"price {price} outside the collar"
        elif self.filled + working + qty > self.p.qty:
            why = "would exceed the order"
        if why:
            self._note(ctx, "reject", why)
            return None
        return ctx.send(Order(side=self.p.side, qty=qty, price=int(price), tif=tif, venue=venue))

The exceptions are driven by the feed and the desk. A trading-action message that leaves the trading state (chapter 25’s halts and pauses) cancels every working child and stops the schedule’s clock; when trading resumes, the schedule is shifted by the pause, so the order neither rushes to catch up nor loses its deadline. A kill, sent by the desk or by a risk monitor through the simulator’s scheduled calls, cancels everything and ends the order. Three runs of the same buy of 16 000 shares show them (Figure 28.2, Table 28.1).

The halted order finished a minute late, as designed, and paid 2.62 basis points against 2.31 on the normal day. In the spike, another buyer’s 60 000 shares took the far touch past the limit within twelve seconds; the algorithm stopped crossing for 213 seconds and kept its passive order at the limit, and paid 3.79 basis points, against 4.31 for the same order without a limit. The killed order stopped at 8 500 shares and ended at 8 700: a kill cancels what is resting, not what has already been sent, which is why the desk’s position after a kill is read from the fills, never from the order.

28.4 Measuring it

The measure is chapter 19’s: the implementation shortfall (Perold 1988) against the arrival mid, all-in (fees and rebates included), attributed by firm.tca into spread, impact (the order’s own push, from a copy of the session without it), timing (the market’s own move) and fees. The experiment is an A/B test with common random numbers: 200 parent orders, four sizes (4 000 to 32 000 shares over ten minutes, 2.4% to 15.9% of the market’s volume) by two urgencies ($\kappa T$ of 0.5 and 3) by 25 seeds, each run with the full algorithm and with a TWAP baseline of the same size on the same seed (a straight line, a market order every ten seconds for what is due).

Over the 200 orders the algorithm saves $-0.15$ basis points against TWAP, with a 95% interval of $[-0.44, 0.14]$ clustered by seed: no saving on average. The average hides a slope (Figure 28.3). A regression of the saving on the size’s doubling and a high-urgency dummy gives $1.25 - 0.70\,\log_2(Q/4000) - 0.69\,h$, where $h$ is 1 at high urgency (standard errors 0.08, 0.04 and 0.22): the algorithm saves 1.06 basis points on the smallest orders at low urgency and loses 1.96 on the largest at high urgency, and breaks even near 13 700 shares, about 8% of the volume, at low urgency.

The attribution says why (Figure 28.4). Resting passively earns the algorithm what TWAP pays: $-0.15$ ticks of spread against $+0.51$, and rebates against fees, $-0.02$ against $+0.30$. It pays it back in impact, 1.73 ticks against 0.93: a resting buy absorbs the sell orders that would have pushed the price down, the catch-up crosses come in bursts, and urgency front-loads the order into the market’s memory. The spread and the fees scale with the shares, the impact with the order’s size too, so the passive design wins on small orders and loses on large ones. This is not a failure of the build: it is the measurement that tells the desk which orders to give it, and which parameters to change for the others (a lower urgency, a smaller tolerance, a wider band).

28.5 Rolling it out

A new algorithm reaches clients the way any model does (Book 7, chapter 21): first in simulation (this chapter), then on a canary, a small share of the desk’s own flow, with a kill criterion written in advance, then in a randomised A/B test against the incumbent, and only then as the default. The test’s size follows from the paired dispersion: the difference between the arms has a standard deviation of 1.33 basis points per order even with common random numbers, so detecting an average saving of 0.15 with 80% power at the 5% level needs $(1.96 + 0.84)^2 \times 1.33^2 / 0.15^2 \approx 620$ orders, and live orders, which do not share their market with a counterfactual, need many more. A per-order effect that depends on size is easier: stratify by size and test within the stratum where the algorithm is meant to win.

28.6 Tutorial: beat TWAP

28.7 Build: execalgo

28.8 Exercises

28.9 Problem: Beat TWAP by How Much?

28.10 Interview questions