18Smart Order Routing

A router splits an order across five venues. Sent at once, the pieces arrive microseconds apart, and quotes on the later venues vanish in between: the first fill told fast traders what was coming. This chapter builds a router on the multi-venue simulator, measures what the order loses when its pieces arrive one after another and what it keeps when they are timed to arrive together, ranks venues by what they deliver rather than what they show, allocates a passive order across venues by Cont and Kukanov’s programme, and ends with the fees and the rules that protect an order from being read.

18.1 What a router decides

Chapter 17 decided whether to rest or cross; the router decides where. Its inputs are the venues’ books (chapter 8’s fragmented market, protected quotes and the order protection rule of One Quant Book 1, chapter 9), their fees (chapter 7’s fee-adjusted price), its own latency to each venue (One Quant Book 7, chapter 18’s order-entry latency) and statistics of what past orders got. Foucault and Menkveld (2008) studied the entry of the London Stock Exchange against Euronext in Dutch stocks: the consolidated book was deeper after entry, and where more trades went through the entrant’s better quotes, it supplied less liquidity, which is why routers that actually reach every protected quote matter.

The experiment of this chapter uses five venues, A to E, in firm.exchsim. The router sits next to A and reaches the venues in 50, 120, 200, 280 and 360 microseconds. Each venue shows 500 shares at the ask of 100.01: 200 from slow providers and 300 from one fast provider, whose machine sits at A and reaches the other venues over faster links (45, 95, 145 and 195 microseconds). Behind them each venue has 1 000 shares at 100.02. The fast provider follows one rule: when one of its orders fills, it cancels its orders on every other venue. Take fees differ: 0.30 cents a share at A, B and D, 0.10 at C, and a rebate of 0.10 to the taker at E (an inverted venue, chapter 7).

18.2 Venue ranking and fill probabilities

A router that believes displayed quotes ranks venues by fee-adjusted price. One that keeps statistics learns what the display is worth. After 100 sprays (below) with a latency jitter of 10%, the router’s own orders filled 100% of the shares sent to A and 44%, 41%, 40% and 40% of those sent to B, C, D and E. With an unfilled share costing a tick later, the expected cost of a share sent to each venue ranks A first (0.30 cents), then E (0.56), C (0.63), B (0.69) and D (0.72): the displayed rebate of E is worth less than the certainty of A. Timed to arrive together, the same orders filled everywhere, and the ranking reverts to the fees: E ($-0.10$), C (0.10), then A, B and D (0.30). A venue ranking is a statement about the router’s own routing as much as about the venues.

    def on_start(self, ctx):
        self.names = {s.venue: s.name.split("@")[-1] for s in ctx.sessions}
        d = send_delays([self.venues[v] for v, _, _ in self.legs], self.sync, self.margin)
        for i, (v, _, _) in enumerate(self.legs):
            ctx.set_timer(self.t0 + d[v] - ctx.now_ns, ("leg", i))

    def on_timer(self, ctx, tag):
        v, px, q = self.legs[tag[1]] if tag[0] == "leg" else tag[1:]
        self.next_cl += 1                  # ids are per session: unique across venues
        cl = ctx.send(Order(side="B", qty=int(q), price=int(px), tif="I", venue=v,
                            cl_ord_id=self.next_cl))
        self.cl_venue[cl] = v
        if tag[0] == "leg":
            self.pending.add(cl)

18.3 Aggressive routing and quote fade

Figure 18.1 is the race. The spray reaches A at 50 microseconds and fills there; the fast provider learns of its fill 5 microseconds later and its cancels reach B at 100, C at 150, D at 200 and E at 250, each before the router’s piece. The router gets A’s 500 shares and the slow 200 on each other venue: 1 300 of 2 500, a fill ratio of 52%. The 1 200 shares left go to the next level in a clean-up sweep, and the whole order costs 0.73 cents a share above the displayed ask, fees included. Synchronised, every piece arrives at 360 microseconds: the fill ratio is 100% and the cost 0.18 cents, the average take fee.

    def on_report(self, ctx, rep):
        if type(rep).__name__ != "Out_E" or self.faded:
            return
        self.faded = True
        for o in ctx.working():
            if o["cl"] != rep.cl_ord_id:
                ctx.cancel(o["cl"], venue=o["venue"])

Synchronisation works only as well as the router knows its latencies. Figure 18.2 adds a random factor to each piece’s latency (lognormal, mean one), 100 trials per level. Up to 10% the synchronised sweep still fills everything; at 20% it fills 99.3% of the shares on average and the whole level on 94% of trials; at 40%, 90.3% and 37%. The spray gains from the noise, since it reshuffles the arrivals, but only to 68.6%. Royal Bank of Canada patented the method, in claims that describe timing parameters determined from latencies “so as to cause synchronized arrival” of the pieces at the venues (US patent 8 489 747, granted in 2013); its description names the problem as orders arriving at faster exchanges before slower ones, where others can detect them.

An order smaller than the displayed liquidity makes the router choose venues. For 1 000 shares (with 10% jitter), a router that picks the cheapest fees goes to E and C, the two farthest venues, and loses almost nothing even when it sprays (99.8%, 0.004 cents a share), because its first fill lands where the fast provider’s cancels are slow to reach. A router that picks the nearest venues goes to A and B and, spraying, fills 71.2% at 0.59 cents; synchronised, 100% at 0.30. Which piece arrives first matters more than which venue is cheapest.

18.4 Passive allocation across venues

A passive order faces the opposite problem: where to rest so as to be filled. Cont and Kukanov (2017) wrote it as a convex programme. With $X$ shares to buy, a market order $M$ and limit orders $L_k$ behind queues $Q_k$, and $\xi_k$ the shares that will leave the front of queue $k$ during the horizon (market orders and cancellations, random), the limit order at $k$ fills $\min(L_k,(\xi_k-Q_k)^+)$ and the cost against the mid is

with $h$ the half-spread, $f$ the take fee, $r_k$ the rebate, $A$ the shares executed, and penalties $\lambda_u$, $\lambda_o$ for executing too few or too many. Its expectation is convex when the penalties exceed the spread and fees; firm_sor.ck_allocate minimises the sample average over simulated outflows.

    xi = np.atleast_2d(np.asarray(xi, float))
    q, lim = np.asarray(queues, float), np.asarray(limits, float)
    r = np.asarray(rebates, float)
    g = np.zeros_like(r) if improve is None else np.asarray(improve, float)
    fill = np.minimum(lim, np.maximum(xi - q, 0.0))
    got = m + fill.sum(axis=1)
    cost = ((h + take) * m - fill @ (h + r + g) + lam_u * np.maximum(x_total - got, 0)
            + lam_o * np.maximum(got - x_total, 0))
    return cost, got

Take four lit venues and a dark one for a 1 000-share buy over a minute: queues of 1 500, 2 500, 300 and 800 shares at the lit bids and none in the dark pool; outflows with means of 2 000, 2 200, 900, 1 000 and 400 shares (lognormal, with a common factor); rebates of 0.20, 0.25, $-0.05$ and 0.20 cents (the third venue is inverted); the dark venue fills at the mid, half a spread (0.5 cents) worse than a fill at the bid, without fee; a take fee of 0.30 cents, and penalties of 1.2 cents a share either way. The optimum is fitted on 400 scenarios and every rule is scored on 20 000 fresh ones (Table 18.1).

The optimum posts 1 778 shares for 1 000 wanted: it overbooks, because each venue fills only part of its order and the penalty for too many is paid only on the scenarios where most venues fill. It sends nothing at the market. Chasing the highest rebate puts the whole order behind the longest queue and fills 22%; Battalio, Corwin and Jennings (2016) found in real data that limit orders routed to venues paying the largest rebates execute worse, and that brokers who route for rebates cannot have it all. The dark venue is worth 0.03 cents a share here: its fills are worse than a passive fill at the bid but come without a queue. Maglaras, Moallemi and Zheng (2021) showed that when many traders route this way, the queues of the venues move together, and the market behaves like one aggregate queue.

18.5 Fee-aware routing and anti-gaming

A fee-aware router compares prices net of fees (chapter 7): at equal displayed prices it takes the inverted venue first and rests on the venue with the best rebate. The two lessons above temper both: the cheapest venue to take from is worth nothing if its quote has faded by the time the order arrives, and the best rebate is worth nothing behind a queue that will not clear.

Chapter 9 measured how pinging orders find a large dark order and what the leak costs. A router answers with a dark-first leg that carries a minimum fill quantity, so that a 100-share ping cannot trade with it, and with child sizes drawn around their target instead of repeated (firm_sor.dark_first, child_sizes); it answers quote fade with synchronised arrivals; and it keeps, per venue, the markouts of its fills (One Quant Book 7, chapter 23) to stop routing to venues where they are consistently bad. Latency arbitrage, the business of the fast provider of this chapter, is One Quant Book 11’s subject.

18.6 Tutorial: a router on five venues

18.7 Build: smart order router

18.8 Exercises

18.9 Problem: The Order That Arrived After the Quotes Had Gone

18.10 Interview questions