Queue-Reactive Microprice + Propagator Slippage Controller Playbook

Date: 2026-02-25 (KST)

TL;DR

Classic slippage models answer "how expensive was execution" but often miss "how the book state is about to change before my next child order".

This playbook combines:

1. Queue-reactive order-book dynamics (state-dependent event intensities)
2. Microprice drift nowcast (short-horizon direction from queue state transitions)
3. Transient impact propagator (cost memory from your own recent aggression)

Then it runs a budget-aware controller that switches between Lean Passive -> Priority Join -> Controlled Cross.

Goal: cut tail slippage (p95) while preserving fill completion under fast microstructure regime shifts.

1) Why this stack is useful in live execution

If you only model spread/volatility/depth at snapshot time, two gaps remain:

• Queue state endogeneity: the same spread with different queue composition behaves differently a few hundred milliseconds later.
• Impact memory: your own recent marketable flow keeps pushing future cost, even after a single slice is done.

A practical live controller should answer both:

• "Will this queue survive long enough for passive fill?"
• "How much residual impact am I still carrying if I cross now?"

2) Model architecture (execution-ready)

2.1 Queue-reactive state model

Discretize local LOB state at decision time t:

• Qb, Qa: top-level bid/ask queue sizes (or bucketed depth)
• I = (Qb - Qa) / (Qb + Qa): imbalance
• S: spread state (1 tick, 2 ticks, ...)

For each event type e (limit add, cancel, market buy, market sell), estimate state-conditional intensity:

lambda_e(t) = f_e(Qb, Qa, I, S, tod, vol_bin)

Practical estimators:

• Piecewise-constant buckets (robust starter)
• Poisson GLM / gradient-boosted intensity model (production upgrade)

This is the queue-reactive layer inspired by Huang–Lehalle–Rosenbaum style Markov queueing view.

2.2 Microprice drift nowcast

Define microprice:

m_t = (a_t * Qb + b_t * Qa) / (Qb + Qa)

Estimate short-horizon drift probability over horizon h (e.g., 250ms~2s):

p_up = P(mid_{t+h} > mid_t | state_t)

Use either:

• transition matrix over discrete states, or
• calibrated classifier on event-time features

Convert to drift score:

drift = 2 * p_up - 1 (range [-1, 1])

Interpretation for buy execution:

• negative drift -> passive patience has higher EV
• positive drift -> delay penalty rises, crossing may be justified

2.3 Transient impact memory (propagator)

Track your own signed child-order flow u_k at timestamps t_k.

Impact memory term:

I_mem(t) = sum_k G(t - t_k) * u_k

Use a decaying kernel (single or multi-exponential):

G(dt) = sum_j w_j * exp(-rho_j * dt)

This captures "recent aggression is not free" and prevents over-crossing during short-term impact overhang.

2.4 Slippage quantile head

Predict quantiles directly (q50, q90, q95) with features:

• baseline microstructure: spread, depth slope, volatility, OFI
• queue-reactive outputs: expected queue depletion time, fill hazard
• microprice drift score
• propagator memory I_mem
• schedule pressure (remaining qty / remaining time)

For buy side example:

q95_live = q95_base + a1*max(0, drift) + a2*I_mem + a3*pressure + a4*toxicity

Monotonic constraints help stability (drift+, I_mem, pressure non-decreasing).

3) Controller design: 3 execution modes

Mode A — Lean Passive

Use when:

• drift <= 0,
• impact memory low,
• remaining-time pressure healthy.

Policy:

• join best bid
• wider cancel-replace interval
• larger passive TTL

Mode B — Priority Join

Use when:

• mild positive drift OR queue depletion risk increasing.

Policy:

• join/improve one tick selectively
• shorter TTL + stricter stale-quote cancels
• cap slice size per decision

Mode C — Controlled Cross

Use when:

• strong positive drift,
• high schedule pressure,
• or repeated passive miss with rising delay penalty.

Policy:

• marketable limit with aggression cap
• cool-down if I_mem exceeds threshold
• forbid consecutive hard-crosses beyond N without reset

State transitions should use hysteresis to avoid mode flapping.

4) Data contract (minimal)

interface DecisionFeatures {
  ts: string
  symbol: string
  side: 'BUY' | 'SELL'
  spreadTicks: number
  qb: number
  qa: number
  imbalance: number
  microVol: number
  expectedDepletionMs: number
  fillHazard: number
  driftScore: number
  impactMemory: number
  schedulePressure: number
}

interface DecisionOutput {
  mode: 'LEAN_PASSIVE' | 'PRIORITY_JOIN' | 'CONTROLLED_CROSS'
  childQty: number
  priceOffsetTicks: number
  ttlMs: number
  aggressionCap: number
  reasonCodes: string[]
}

5) Calibration loop (daily + intraday)

5.1 Daily

1. Refit queue-reactive intensities by liquidity bucket
2. Refit drift nowcast (state transition or classifier)
3. Refit propagator decay parameters by symbol bucket
4. Refit quantile head with coverage objective (pinball + p95 breach penalty)

5.2 Intraday guarded updates

• only refresh linear overlay coefficients (a1..a4)
• freeze updates if data quality checks fail (clock skew, missing L2 patches, delayed fills)
• impose max coefficient drift per hour

6) KRX/KIS practical adaptation notes

• Keep decision loop robust to occasional websocket hiccups (stale-state guard + fail-safe passive mode).
• Separate open/close auction windows from continuous session model.
• Treat VI (volatility interruption) windows as a distinct regime with tightened aggression caps.
• Persist model inputs and decisions for replay-grade TCA/audit.

7) Monitoring checklist (what actually catches failures)

1. q95 coverage by symbol bucket and regime (target around nominal)
2. Mode mix drift (sudden Controlled Cross inflation = warning)
3. Impact-memory breaches before/after cool-down trigger
4. Passive miss streak distribution (delay risk)
5. Implementation shortfall decomposition
   • spread/fees
   • delay drift
   • impact memory
   • residual unexplained

8) Failure modes and guardrails

• Over-reaction to noisy imbalance -> require multi-signal confirmation (drift + depletion + pressure).
• Under-reaction in fast trend -> emergency escalation if passive miss streak + drift spike co-occur.
• Controller over-crossing -> hard daily cap on high-aggression slices per symbol.
• Model decay after regime shift -> rolling champion/challenger with forced weekly replacement test.

9) Reference anchors

• Huang, Lehalle, Rosenbaum — Simulating and Analyzing Order Book Data: The Queue-Reactive Model (JASA, 2015 / arXiv:1312.0563)
• Taranto et al. — Linear Models for the Impact of Order Flow on Prices I (arXiv:1602.02735)
• Gatheral — No-Dynamic-Arbitrage and Market Impact (Quantitative Finance, 2010)
• Almgren & Chriss — Optimal Execution of Portfolio Transactions (2000/2001)

One-line takeaway

Don’t choose child-order aggression from static depth snapshots alone—combine queue-state transition risk + impact memory + remaining-time pressure and let the controller switch modes explicitly against a tail-slippage budget.