Slippage Modeling Latency-Race + Flow-Memory Reality-Gap Playbook

How to Keep Backtest Costs Honest When Microsecond Timing and Order-Flow Memory Dominate

Why this note: Many production slippage models fail not because impact math is wrong, but because simulation assumptions miss two practical facts: (1) latency races create discrete fill-priority cliffs, and (2) signed flow memory changes impact/reversion dynamics nonlinearly.

1) Failure Mode in One Sentence

If your model ignores latency-race modes and long-memory order-flow pressure, it will systematically underprice adverse fills in fast tapes and overestimate passive alpha persistence.

2) Minimal Production Model (State + Timing + Memory)

At decision time (t), estimate implementation shortfall for action (a):

[ \mathbb{E}[IS_t(a)] = C_{spread}(a) + C_{queue}(a) + C_{temp}(a\mid m_t) + C_{timing}(a) + C_{fees}(a) ]

Where:

• (C_{spread}): crossing/inside-touch terms
• (C_{queue}): queue-priority and non-fill penalties
• (C_{temp}): transient impact conditioned on signed-flow memory (m_t)
• (C_{timing}): alpha decay + deadline pressure
• (C_{fees}): realized maker/taker + venue economics

The key is joint modeling of queue state and flow memory, not separate post-hoc adjustments.

3) Core Equations You Can Operate

A) Queue-reactive event intensities

Let (S_t) be compact book state (spread, imbalance, near-touch depth bins):

[ \lambda_k(t) = \lambda_k(S_t), \quad k \in {\text{LO},\text{MO},\text{Cancel}} ]

This gives practical fill-hazard estimates under current local liquidity.

B) Signed flow-memory state (power-law decay)

[ m_t = \sum_{\tau < t} \epsilon_{\tau} v_{\tau} \cdot g(t-\tau), \quad g(\Delta)= (\Delta + c)^{-\gamma} ]

• (\epsilon_{\tau}\in{-1,+1}): trade sign
• (v_{\tau}): signed trade size proxy
• (\gamma): persistence exponent

Use (m_t) as a control feature for temporary impact and markout tails.

C) Latency-race fill cliff

Model effective queue rank as:

[ q^{eff}_t = q_t + \phi(\ell_t) ]

• (q_t): inferred queue position
• (\ell_t): measured end-to-end latency sample
• (\phi): nonlinear latency-to-rank mapping (empirically step-like near exchange RTT mode)

Then fill probability over horizon (h):

[ P(\text{fill}\le h) = 1 - \exp!\left(-\int_t^{t+h} \mu_{fill}(S_s, q^{eff}_s) ds\right) ]

4) Calibration Protocol (Reality-Gap First)

Step 1 — Build compact state representation

Use robust state variables only:

• spread_ticks
• imbalance_l1_l3
• depth_ahead
• trade_sign_ewm
• latency_ms/p50,p90,p99

Avoid high-dimensional features until telemetry is stable.

Step 2 — Fit timing model before cost model

• Estimate event timing and latency distribution by venue/session bucket.
• Explicitly detect RTT mode concentration (latency-race clustering).

Step 3 — Fit impact with flow-memory conditioning

• Fit (C_{temp}) as function of participation, state, and (m_t).
• Track both mean and upper quantiles (P90/P97.5).

Step 4 — Define Reality-Gap Index (RGI)

[ RGI = w_1,|\widehat{fill\ rate} - fill\ rate| + w_2,|\widehat{IS}{P90} - IS{P90}| + w_3,|\widehat{markout}{5s} - markout{5s}| ]

Promote model/routing changes only when RGI is below threshold across liquid/illiquid deciles.

5) Live Policy Coupling

Use model outputs to switch execution states:

• NORMAL: optimize expected cost + tail penalty
• RACE_GUARD: trigger when latency tail or RTT-mode mass spikes
  • reduce passive dwell
  • cap cancel/repost rate
  • increase minimum price-improvement threshold
• FLOW_PRESSURE: trigger when (|m_t|) crosses symbol/session threshold
  • throttle same-side aggression bursts
  • widen tactical randomization window
• DEADLINE_EXIT: force completion with explicit exception tag

This prevents the common "chase then panic-cross" pattern.

6) Telemetry Contract (Must-Have)

Decision-time

• decision_ts, symbol, side, parent_id, child_id
• state_bucket, q_est, q_eff_est, m_t
• latency_est_ms, deadline_ms_left

Market/event-time

• order_event_ts, exchange_ts, ack_ts
• spread, depth, imbalance, trade_sign
• cancel_rate, trade_rate

Outcomes

• fill_qty, fill_px, fill_delay_ms, reject_reason
• realized_is_bps, markout_1s/5s/30s
• fee_bps, rebate_bps

Without consistent decision-time latency and queue snapshots, RGI is not trustworthy.

7) Validation Ladder (Safe Rollout)

1. Shadow: predict only, no policy impact (1–2 weeks)
2. Replay: counterfactual on frozen historical decisions
3. Canary: low-notional symbols + hard kill-switch
4. Scale: only if all hold:
   • RGI improves,
   • tail undercoverage decreases,
   • deadline breach rate does not worsen.

8) Fast Checklist

[ ] Model queue state and signed-flow memory jointly
[ ] Calibrate latency-race mode (RTT clustering) explicitly
[ ] Track P90/P97.5 slippage and markout, not mean only
[ ] Gate promotions with a Reality-Gap Index
[ ] Wire model to NORMAL/RACE_GUARD/FLOW_PRESSURE/DEADLINE_EXIT states

References

• Huang, W., Lehalle, C.-A., Rosenbaum, M. (2015), Simulating and Analyzing Order Book Data: The Queue-Reactive Model, JASA.
• Bacry, E., Mastromatteo, I., Muzy, J.-F. (2015), Hawkes Processes in Finance.
• Alfonsi, A., Blanc, P., Schied, A. (2015), Extension and calibration of a Hawkes-based optimal execution model.
• Gatheral, J. (2010), No-Dynamic-Arbitrage and Market Impact.
• Souilmi, S. et al. (2026), Bridging the Reality Gap in Limit Order Book Simulation.
• Almgren, R., Chriss, N. (2000), Optimal Execution of Portfolio Transactions.

TL;DR

Treat slippage as a timing-sensitive control problem: combine queue-reactive state, latency-race cliffs, and signed-flow memory; then enforce rollout by a measurable reality-gap index instead of trusting backtest averages.