27Build: an Agent-Based Market

An exchange simulator with nobody on it is an empty room. Put a few kinds of simple traders in it, some who know nothing, some who know the value, some who follow trends and one who makes markets, and it starts to look like a market; which of them it needs in order to look like one is itself a finding. This chapter describes the agent library this book has used since chapter 11, firm.agentmkt, adds the two agent types it lacked (chartists and an inventory-skewing market maker), calibrates the population to a target market by the method of simulated moments, and then takes it apart one agent type at a time to see which fact each one carries.

27.1 Agents and their information

Agent-based markets come in two traditions. The first gives agents strategies and asks what dynamics follow: Lux and Marchesi (1999) built a market of fundamentalists and chartists whose news process had neither fat tails nor any time dependence in volatility, and found that the interactions of the agents produced both. The second removes strategy almost entirely: Farmer, Patelli and Zovko (2005) let agents place and cancel orders at random (chapter 1’s zero-intelligence model) and, on eleven London Stock Exchange stocks, explained 96% of the cross-sectional variance of the spread and 76% of that of the price diffusion rate with one free parameter. Chiarella and Iori (2002) put heterogeneous rule-based traders into an order-driven market with a central matching mechanism and studied how their strategies, the tick and the lifetime of orders shape spreads, volume and volatility. The population here takes a little from each: most of its order flow is random, and a few rules give it direction.

Population runs its traders as clocks whose rates are recomputed after every event (Figure 27.1). Liquidity providers add one-lot limit orders on each side, half of them one tick from the opposite best quote and the rest up to ten ticks behind it, and every resting order is cancelled at a constant rate. Noise takers send market orders whose signs come in runs (next section). Fundamentalists send market orders toward a hidden value $V$, a random walk of one-tick jumps, at a rate proportional to the distance between $V$ and the mid: they are also this market’s informed traders (chapter 4), since nobody else sees $V$. Chartists send market orders in the direction of the mid’s change over the last 30 seconds, at a rate proportional to its size. The noise orders and the jumps of $V$ are drawn in advance from the seed, so two runs that differ by one agent share them (common random numbers).

    def on_timer(self, ctx, tag):
        c = self.cfg
        if tag != "tick":
            _, kind, x = self.exo[tag[1]]
            if kind == "noise":
                ctx.send(Order(side="B" if x > 0 else "S", qty=abs(x), price=0, tif="I"))
            else:
                self.v += x * c.tick
                self.v_path.append((ctx.now_ns, self.v))
            return
        r = self._r
        k = int(self.rng.choice(len(r), p=r / r.sum()))
        if k == 0:
            side = "B" if self.rng.random() < 0.5 else "S"
            b, _, a, _ = ctx.top(1)
            ref = a if side == "B" else b
            if ref is None:
                ref = int(round(self._mid(ctx) / c.tick)) * c.tick + (c.tick if side == "B" else -c.tick)
            d = 1 if self.rng.random() < c.near else 1 + int(self.rng.choice(c.depth, p=self.w))
            self._add(ctx, side, ref - d * c.tick if side == "B" else ref + d * c.tick)
        elif k == 1 and self.live:
            cl = self.live[int(self.rng.integers(len(self.live)))]
            ctx.cancel(cl)
            self._drop(cl)
        elif k == 2:
            ctx.send(Order(side="B" if self.v > self._mid(ctx) else "S", qty=100, price=0, tif="I"))
        elif k == 3:                                                  # a chartist follows the trend
            ctx.send(Order(side="B" if self.trend > 0 else "S", qty=100, price=0, tif="I"))
        self._next(ctx)

27.2 Liquidity providers and their inventory

The population’s providers never hold anything: their orders are independent of what they have filled. The new MarketMaker does: every half second it quotes two lots at the other traders’ best bid and ask (one tick inside when their spread is wider than two ticks), both moved against its inventory by a skew in ticks per lot held, and it stops adding to a position beyond 20 lots. Its reference excludes its own quotes; an early version that did not walked its own bid down, refresh after refresh, whenever it was long, since each new quote was set below the previous one.

    def on_timer(self, ctx, tag):
        live = ctx.working()
        mine = {o["ref"] for o in live}
        bk = ctx.book(1).book
        b, a = self._best(bk, 1, mine), self._best(bk, -1, mine)
        want = {}
        if b is not None and a is not None:
            inside = self.tick if a - b > 2 * self.tick else 0
            inv = ctx.position(1) / 100
            shift = int(round(self.skew * inv)) * self.tick
            if inv < self.max:
                want["B"] = min(b + inside - shift, a - self.tick)
            if inv > -self.max:
                want["S"] = max(a - inside - shift, b + self.tick)
        for o in live:
            if want.get(o["side"]) == o["price"]:
                del want[o["side"]]
            else:
                ctx.cancel(o["cl"])
        for side, px in want.items():
            ctx.send(Order(side=side, qty=100 * self.lots, price=int(px)))
        ctx.set_timer(int(self.refresh * SEC), 0)

Without skew the maker’s inventory wanders (Figure 27.2) and it loses money: its fills follow the fundamentalists, who know the value, so the inventory it accumulates is the wrong way round when $V$ moves (chapter 4’s adverse selection). With a skew of 0.3 ticks per lot its inventory stays within a few lots and its hourly profit is positive and steadier (Table 27.1); the skew is the practical form of the inventory models of chapter 4 (and of Book 2, chapter 30). The market’s spread hardly changes: the providers keep it near one tick whatever the maker does.

27.3 Execution agents and metaorders

A metaorder (Book 7, chapter 9) cut into children sends many market orders of one sign; this is the mechanism Lillo, Mike and Farmer (2005) proposed for the long memory of order signs: if the sizes of large orders have a power-law tail, $P(V > v) \propto v^{-\alpha}$, and they are executed in children of constant size, the autocorrelation of order signs decays as $\tau^{-(\alpha - 1)}$, which is long memory (not summable) when $\alpha < 2$. The noise takers of firm.agentmkt are that mechanism in a line: their signs come in runs whose lengths are Pareto with tail $\alpha$ (the parameter run_tail), each run a metaorder. Execution agents proper, Metaorder for a schedule of market-order children and the algorithms of chapters 16 to 22, are added to the same simulator as separate agents; chapter 11 measured their impact against the same session without them.

The calibrated market has $\alpha = 2.5$, so its runs predict an excess autocorrelation falling as $\tau^{-1.5}$: short memory. Measured over lags 1 to 7 the excess falls with a log-log slope of $-1.15$ (Figure 27.3), a little flatter than the asymptotic law, and is gone by lag 10. What remains without the runs, about 0.07 to 0.09 out to lag 20, is the fundamentalists’ doing: while $V$ is away from the mid they send order after order in the same direction.

27.4 Calibrating to stylised facts

Franke and Westerhoff (2012) estimated small fundamentalist-chartist models this way, with moments chosen from the stylised facts (Book 7, chapter 5) of daily index returns. Here the target is one hour of Book 7’s synthetic market, firm.tape without its news window, measured on eight hours: it has Hawkes-clustered noise flow, metaorders, informed traders and a random activity level, none of which the agent population has as such. The seven facts are the excess kurtosis of 30-second mid returns, their lag-1 autocorrelation, volatility clustering (the mean autocorrelation of absolute returns at lags 1 to 5), the autocorrelation of the signs of aggressive orders at lags 1 and 10 (the prints of one order counted once), the time-weighted mean spread and the mean depth at the best. The distance is the sum of squared differences between simulated and target means, each scaled by the target’s standard deviation across its eight hours.

def distance(sim: dict, target: dict, scale: dict) -> float:
    """Sum over facts of ((simulated - target) / scale)^2."""
    return float(sum(((sim[k] - target[k]) / scale[k]) ** 2 for k in target))


def msm(run, grid, target: dict, scale: dict, seeds) -> dict:
    """The method of simulated moments on a grid: run(params, seed) -> facts; the average over seeds (the same seeds
    at every point: common random numbers) is compared with the target; returns the best point, its facts and every
    point's distance."""
    rows = []
    for params in grid:
        sims = [run(params, s) for s in seeds]
        mean = {k: float(np.mean([x[k] for x in sims])) for k in target}
        rows.append((distance(mean, target, scale), params, mean))
    rows.sort(key=lambda x: x[0])
    return {"best": rows[0][1], "distance": rows[0][0], "facts": rows[0][2], "all": rows}

Three parameters are calibrated, on a grid of three values each: the noise takers’ rate (0.9, 1.2, 1.5 a second), their run tail (none, 1.5, 2.5) and the chartists’ rate (0, 0.05, 0.1 a second per tick of trend); the providers, fundamentalists and market maker (skew 0.1) are fixed. Each point is run for three hours with the same three seeds.

The best point is a noise rate of 1.2, a run tail of 2.5 and a chartists’ rate of 0.05, at a distance of 10.1 over its three calibration hours; the starting point (noise 0.9, no runs, no chartists) was at 27.9 (Figure 27.4). On six fresh hours the calibrated population is at 5.4, and six fresh hours of the target market itself are at 1.7 from the target’s mean: what sampling noise alone gives. Figure 27.5 shows where the rest comes from: the calibrated market has too little volatility clustering and too little depth, and a little too much sign memory at lag 1.

The ablation takes the calibrated population and removes one agent type at a time on the six fresh hours, with the same seeds: the sign runs (the noise takers keep their rate but their signs become independent), the chartists, the fundamentalists, the market maker. Table 27.2 gives each fact’s move in target standard deviations.

Each type carries something (Table 27.2). The sign runs carry the lag-1 sign memory ($-2.77$, standard error 0.15 standard deviations). The fundamentalists carry the price’s movement: without them the mid is pinned between rare jumps, so the kurtosis of returns explodes ($+8.6$) and the long-lag sign memory falls ($-2.42$). The market maker carries the spread ($+9.4$): without it, the spread widens by 0.15 ticks. The chartists carry nothing this test can see: their largest move, on kurtosis, is $+1.11$ with a standard error of 0.55, two standard errors. Removing the noise takers altogether leaves a market in which only fundamentalists trade, with a sign autocorrelation near one; it is not in the table because every fact moves.

27.5 What agent-based markets can and cannot tell you

An agent-based market is a tool for questions about mechanisms: what happens to spreads if the tick halves (chapter 6), whether a band attracts the price (chapter 25), how an algorithm’s shortfall depends on the other traders’ reaction (chapter 28). Replaying a historical tape cannot answer them, because a replayed market does not react; Vyetrenko and coauthors (2020) compared market replay with interactive agent-based configurations on a list of realism metrics taken from the stylised facts, and found the interactive ones more realistic, and more so when the agents’ fundamental value came from historical data rather than a mean-reverting random walk. ABIDES (Byrd, Hybinette and Balch 2020), an open-source simulator of tens of thousands of agents with an exchange agent whose messages follow Nasdaq’s ITCH and OUCH, is built for exactly this.

What it cannot tell you is why real traders do what they do. Matching seven facts to within 5.4 does not identify the agents: other populations, with other rules, would match them as well (here the chartists could be removed at little cost), and the facts left unmatched, volatility clustering first, say that something in the target (its random activity level) is missing from the population. The calibration answers “is this population good enough for the question?”, not “is this how the market works?”; and the answer depends on the facts chosen and their weights. The fair use is comparative: the same population, with and without an algorithm, a rule or a trader, and the same seeds.

27.6 Tutorial: a market that looks like a market

27.7 Build: agentmkt

27.8 Exercises

27.9 Problem: A Market That Looks Like a Market

27.10 Interview questions