Emergent Stylized Facts

This is the lesson the whole course has been walking toward. We spent three lessons assembling a zoo of agents — market makers quoting both sides, momentum traders chasing the tape, value traders leaning against it, and noise traders flipping coins — and stuffing them into a limit order book. Now we collect the prize.

The prize is this: you do not have to put the stylized facts into the model. You don’t hand-code “make the tails fat” or “cluster the volatility.” You write down a handful of dumb local rules, press play, and the facts fall out. Fat tails, volatility clustering, long memory — they emerge from the interaction, the way traffic jams emerge from drivers who only know “don’t hit the car in front.”

And there’s a sharper claim hiding inside the pretty one. A generative model (a GAN, a diffusion model, a fitted GARCH) can reproduce fat tails because it saw them in the training data and learned to mimic the shape. An agent-based model produces them because it contains the mechanism that makes them. Reproduce versus produce. Description versus explanation. That distinction is the soul of this lesson — and, as we’ll see at the end, also its biggest trap.

The rubric, one more time

Before we manufacture the stylized facts, let’s pin down the scoring rubric — the list of empirical regularities a believable market simulation has to hit. You met all six in earlier courses; here they are as a checklist, because for the rest of this lesson “did emergence work?” literally means “did we tick these boxes?”

Analogy. Think of the six stylized facts as a referee’s scorecard in figure skating. A Gaussian random walk is the contestant who shows up, glides in a straight line, and falls down on every jump. It nails exactly one element (returns are roughly uncorrelated) and flunks the rest. Our agent market is the contestant trying to land all six.

The six canonical facts (and how a plain Gaussian random walk does on each):

So the Gaussian walk scores roughly 1 out of 6, and even its one “pass” is a cheat: it’s Gaussian at every scale, so it never had a non-Gaussian shape to flatten. Our job is to build a market that earns the other five honestly.

Poke at each fact below — the scorecard contrasts a real market against the Gaussian null and tells you whether the null reproduces it. Keep this open as your reference rubric for the rest of the lesson.

Why a non-interacting market is Gaussian

Start with the null: a market where agents don’t interact. Each trader wakes up, forms a demand based only on their own private information or whim, and submits it. No one watches anyone else. What does the aggregate price do?

It does the most boring thing in all of statistics: it goes Gaussian.

Analogy. Imagine a stadium where every fan independently decides, on a coin flip, to lean left or right. With one fan, the stand tilts hard one way. With fifty thousand independent fans, the leans cancel and the stand barely quivers around vertical — and the size of that quiver follows a tidy bell curve. Independence plus aggregation is a smoothing machine. The Central Limit Theorem is the bouncer that throws out any interesting structure.

Precise definition. If the net order flow at each step is a sum of $N$ independent agent demands with finite variance, then by the Central Limit Theorem (CLT) the aggregate demand — and hence the price change — converges to a normal distribution as $N$ grows. Independent shocks each step also means today’s variance carries no information about tomorrow’s: the process is homoscedastic (constant variance) and the returns are serially uncorrelated. Thin tails, no clustering, no memory. The null nails one stylized fact (uncorrelated returns) and flunks the rest.

Worked example — summing independent demands. Let $N$ agents each submit a demand $d_i = \pm 1$, independently, with probability $\tfrac{1}{2}$ each. The net flow is $S = \sum_{i=1}^{N} d_i$.

• Each $d_i$ has mean $0$ and variance $\mathrm{Var}(d_i) = 1$.
• By independence, variances add: $\mathrm{Var}(S) = \sum_{i=1}^{N} 1 = N$. So the standard deviation grows like $\sqrt{N}$ — the familiar diffusive scaling.
• The excess kurtosis of a single $\pm 1$ flip is $-2$ (a sharply non-Gaussian, flat-tailed shape). But kurtosis of an independent sum shrinks: the excess kurtosis of $S$ is

As $N \to \infty$ this $\to 0$ — exactly the Gaussian value. With $N = 10{,}000$ agents, excess kurtosis is about $-0.0002$. Statistically indistinguishable from a bell curve.

That’s the punchline of the null: independence + aggregation = Gaussian, and Gaussian = stylized-fact failure. So whatever produces fat tails and clustering in a real market, it cannot be “lots of independent traders.” Emergence requires breaking independence. Interaction is not a nice-to-have; it’s the whole engine.

Open the demo below and drag the Agent interaction (feedback) slider all the way to the left (the Independent end). The same i.i.d. Gaussian shocks drive everything — but with zero feedback you get a flat, featureless |return| strip: excess kurtosis hugging 0, biggest shock a forgettable $\sim 3\sigma$, no bursts. This is the null staring back at you. Don’t turn it up yet.

When to use it

Reach for the non-interacting null whenever you need a baseline to beat. It’s the “did you fool yourself?” control from the modeling-discipline lesson: run your full ABM and an independent-agent version of it on the same shocks, and any stylized fact present in both was never emergent — it leaked in from your inputs (e.g., you fed the model fat-tailed shocks). Emergence only counts when the fact appears in the interacting model and vanishes in the independent null.

Volatility clustering from feedback

Now switch on interaction and watch the first fact appear. We’ll start with volatility clustering — the tendency of turbulent and calm periods to come in runs rather than sprinkling at random.

Analogy. Clustering is a crowd with momentum. One person starts running through a square; a few nervous bystanders run too because others are running; their running convinces still more. The panic feeds itself and persists — until it exhausts and the square goes quiet, and the quiet also persists because nothing is feeding it. You get loud regimes and quiet regimes, each sticky. The market’s loud regime is trend-dominated (momentum traders in control); the quiet regime is value-dominated (mean-reverters in control). The market drifts between them, and that stickiness is volatility clustering.

Precise definition. Volatility clustering is positive autocorrelation of absolute (or squared) returns: $\mathrm{Corr}(\lvert r_t \rvert, \lvert r_{t-k} \rvert) > 0$ for many lags $k$, even though the signed returns $r_t$ are basically uncorrelated. Momentum traders supply the positive feedback that creates it: a move up generates buying, which generates more up-move. That makes today’s volatility a predictor of tomorrow’s — precisely the ARCH/GARCH intuition you met in time-series, where $\sigma_t^2$ is an increasing function of recent squared returns. The ABM doesn’t assume a GARCH equation; the feedback loop manufactures GARCH-like behavior.

Worked example — a feedback trace. Let tomorrow’s volatility respond to today’s move via a toy ARCH-style rule:

Trace it with a quiet start $\sigma_0 = 0.01$ (1%), then hit it with one big innovation:

One 5% move at step 2 inflates $\sigma$ from ~1% to ~4.9%, and that elevated volatility persists into steps 3, 4, 5… decaying slowly because each step’s volatility is mostly inherited from the last. Calm begets calm; a shock begets a streak of big moves. That persistence, read off the absolute returns, is clustering — and its slow decay is the long-memory stylized fact (the slowly-decaying $\lvert r_t \rvert$ autocorrelation) showing up for free.

Now go back to the demo and drag interaction up. Same i.i.d. Gaussian shocks as the null — but the feedback reorganizes them: the |return| bars bunch into bursts, the tail moves (highlighted above ~2.2$\sigma$) arrive in clumps rather than alone, and the excess-kurtosis readout climbs off zero. Nothing about the input shocks changed. The structure is entirely emergent.

When to use it

Lean on the momentum-feedback mechanism whenever your simulated market looks too calm — flat volatility, no regimes. Adding or strengthening trend-followers introduces positive feedback and brings clustering to life. Conversely, if your market is a permanent rolling boil with no quiet stretches, you’ve got too much positive feedback and not enough mean-reverting value traders to damp it. Clustering is a tug-of-war; you tune it by tuning the balance.

Fat tails from herding and thresholds

Clustering is about when big moves happen. Fat tails are about how big the biggest move can get. And the engine here isn’t quite the same — it’s coordination.

Analogy. A single person leaving a crowded theater is a non-event. But put a “FIRE” shout in the room and everyone heads for the same door at the same instant — the correlation of their individual choices produces a crush no single person intended or wanted. Markets have fire alarms: stop-loss orders that all trigger near the same price, margin calls that all fire when the account hits the same threshold, trend signals that all flip at the same moving-average crossing. When many agents cross a threshold together, their demands stop being independent and start moving in lockstep — and lockstep is how you manufacture an 8-sigma day.

Precise definition. Fat tails (positive excess kurtosis) emerge from correlated/synchronized demand. Thresholds (stops, margin calls, signal levels) convert a smooth distribution of agent states into a discontinuous, all-at-once action when a price level is breached — herding. The key is what correlation does to the variance of a sum.

Worked example — correlation inflates the tail. Take $N = 100$ agents each contributing a demand with standard deviation $\sigma_0 = 1$. Compare two worlds:

Independent agents. Variances add:

A “big day” is maybe a $3\sigma$ event for the sum, i.e. about $3 \times 10 = 30$ units. Tails are thin; you essentially never see much beyond that.

Herding agents. Suppose a fire alarm fires and every pair of agents now has correlation $\rho = 0.5$. The variance of a sum picks up the cross-terms:

The standard deviation of aggregate demand jumped from 10 to 71 — a factor of about 7 — purely from turning on correlation, with no change to any individual agent. Measured in the independent world’s units ($\sigma = 10$), a routine $1\sigma$ herding move is now $71/10 \approx 7\sigma$. A modest push on top of that and you’ve got an 8-sigma day that no single agent intended. That is a fat tail: an event astronomically unlikely under the independence assumption, made commonplace by coordination. (Under a Gaussian, $8\sigma$ has probability $\sim 10^{-15}$ — once in a thousand-trillion days. Markets serve them up every few years.)

The lesson in one line: clustering comes from feedback (in time); fat tails come from correlation (across agents). Both are independence-breaking, but along different axes.

Now drive the population directly. Load the “Trend-driven” preset below — a market dominated by momentum with thin stabilizing forces. Watch the price path throw bubbles and crashes and the realized-volatility readout sit high. Then switch to “Stabilizing mix” (heavier market-maker + value weights): the same machinery produces a calm, mean-reverting path with modest realized vol. Same agents, different proportions, wildly different tails.

When to use it

Use threshold/herding mechanisms when you need realistic tail risk — stress tests, flash-crash studies, margin-spiral and fire-sale models. If your simulation’s worst day is a tame $3\sigma$, you almost certainly have agents acting too independently; add a coordinating mechanism (shared stop levels, leverage constraints, a common signal) and the tail will thicken. The flip side is also the cure for an over-tailed model: if every other day is an 8-sigma apocalypse, your agents are too synchronized — decorrelate them.

Emergence as explanation, not coincidence

Here’s the payoff that makes all this more than a parlor trick. Because the stylized facts fall out of the agent rules — you didn’t target them, you didn’t fit them, you can switch them off by switching off interaction — the ABM is a candidate explanation. It contains a mechanism that, if it were operating in the real world, would produce exactly these regularities. That’s a scientific claim with a causal shape, not a description.

Analogy. Compare two ways to “explain” the tides. A lookup table of historical tide heights reproduces the tides — feed it a date, get an accurate height — but it explains nothing; it’s a fancy memory. Newton’s gravitation produces the tides from a mechanism (the Moon’s pull, the Earth’s rotation); it can predict tides on a coastline it never saw, on a planet that doesn’t exist yet. The ABM is trying to be Newton, not the lookup table.

Precise distinction — produce vs reproduce.

A generative model can hand you flawless fat tails because it saw fat tails. An ABM hands you fat tails because it has stop-losses that synchronize — and you can test that claim by deleting the stop-losses and watching the tails thin. That counterfactual handle is what turns “my output looks like a market” into “here is why markets look like this.”

But — and this is the warning we’ll spend the next two lessons earning — producing the stylized facts is necessary, not sufficient. Emergence proves your mechanism is a possible explanation, not the true one. Many different, mutually contradictory mechanisms can all spit out superficially identical fat tails and clustering. Matching the rubric narrows the field of candidate models; it does not crown a winner.

Recap

• The rubric is six stylized facts: fat tails (excess kurtosis), volatility clustering, slow-decaying |return| autocorrelation (long memory), the leverage effect, aggregational Gaussianity, and gain/loss asymmetry. A Gaussian random walk flunks ~5 of 6 — it’s the null to beat.
• Independence + aggregation = Gaussian. Independent agent demands are flattened by the CLT into thin-tailed, homoscedastic noise; we showed excess kurtosis of a sum of $N$ flips is $-2/N \to 0$. Emergence requires breaking independence — more independent agents makes it worse.
• Volatility clustering emerges from feedback in time. Momentum’s positive feedback makes loud and quiet regimes persistent — an emergent ARCH/GARCH effect. One 5% move in a toy ARCH rule inflated next-step σ from ~1% to ~4.9% and the elevation decayed slowly (clustering + long memory).
• Fat tails emerge from correlation across agents. Herding and shared thresholds (stops, margin calls) synchronize demand; turning on $\rho = 0.5$ across 100 agents inflated the SD of aggregate demand from 10 to ~71 — a routine move becomes a 7–8σ tail event.
• Emergence is explanation, not coincidence — an ABM produces the facts (has the mechanism) where a generative model only reproduces them (learned the shape). But producing the facts is necessary, not sufficient: many wrong mechanisms produce the same facts, so matching the rubric never proves your mechanism. (That’s lessons 5–6.)