Execution-Induced Volatility Feedback (EIVF) Slippage Playbook

Date: 2026-03-01
Category: research (slippage modeling)

Why this matters

Most execution models treat volatility as exogenous (market gives it, we react to it).
In practice, when participation and aggression rise in thin books, our own flow can:

1. widen spread,
2. increase short-horizon return variance,
3. trigger additional cancellations,
4. worsen queue survival for the next child orders.

That creates a feedback loop:

more urgency → more local volatility → worse expected slippage → even more urgency near deadline.

If this loop is not explicitly modeled, average slippage may look acceptable while p95/p99 blows up during fragile intervals.

Core idea

Model slippage as a coupled system:

• direct cost (spread + impact + delay/opportunity)
• feedback cost (today’s child order increases near-future volatility, which increases cost of remaining inventory)

So each child-order decision should optimize not only immediate fill quality, but also its future volatility footprint.

Minimal state and notation

At decision time (t):

• (x_t): remaining shares
• (\tau_t): remaining time to deadline
• (u_t): control action (POV/aggression level)
• (s_t): spread
• (\sigma_t): short-horizon realized volatility estimate
• (r_t): refill rate (depth recovery)
• (k_t): cancel intensity near touch
• (z_t): regime features (OFI, auction proximity, event flags, latency)

Target objective:

[ \min_{u_{t:T}} ; \mathbb{E}[\text{IS}] + \lambda_{95} \cdot Q_{0.95}(\text{IS}) + \lambda_{\text{miss}}\cdot \Pr(\text{underfill by deadline}) ]

with safety constraints (hard):

• max participation cap,
• max short-horizon expected markout,
• kill-switch at stress thresholds.

Model decomposition

1) Base slippage model

Predict baseline conditional quantiles:

[ \hat{q}{\alpha}^{\text{base}}(t, u_t) = f{\alpha}(x_t, \tau_t, s_t, \sigma_t, r_t, k_t, z_t, u_t) ]

Use quantile model family (LightGBM/XGBoost quantile, or conformalized residual layer).

2) Volatility-feedback transition model

Estimate near-future volatility response from own action:

[ \Delta \sigma_{t+\delta} = g(\sigma_t, r_t, k_t, z_t, u_t) + \epsilon_t ]

Practical parameterization:

[ \sigma_{t+\delta} = a\sigma_t + b_1\cdot \text{POV}_t + b_2\cdot \text{crossFrac}_t + b_3\cdot \text{cancelShock}_t + b_4\cdot \text{latencyJitter}_t + \eta_t ]

where (b_1,b_2) represent execution-induced volatility sensitivity.

3) Feedback-adjusted slippage

For each candidate action (u_t):

1. predict immediate cost quantile (\hat{q}^{\text{base}})
2. simulate one-step volatility transition (\hat{\sigma}_{t+\delta}(u_t))
3. estimate marginal cost increase on remaining inventory

[ \text{EIVF}(u_t) \approx \frac{\partial \hat{q}{0.95}}{\partial \sigma} \cdot \big(\hat{\sigma}{t+\delta}(u_t)-\hat{\sigma}_{t+\delta}(u_t^{\text{neutral}})\big) ]

Final score:

[ \text{Score}(u_t)=\hat{q}{0.95}^{\text{base}}(u_t)+\gamma\cdot \text{EIVF}(u_t)+\lambda{\text{miss}}\cdot \widehat{\Pr}(\text{miss}|u_t) ]

Pick action with minimal score under constraints.

Causal estimation notes (important)

Naive regression overestimates/underestimates feedback because urgency is endogenous. Use at least one:

1. Micro-randomization windows: tiny randomized perturbation in aggression bucket under safe bounds.
2. Instrumental variables: queue-priority tie-break randomness, exchange micro-latency noise proxy.
3. Doubly robust correction: propensity model + outcome model for action assignment.
4. Regime-stratified estimation: estimate (b_1,b_2) by liquidity regime to avoid Simpson reversals.

Without this, EIVF control can become a confidence theater.

Controller design (state machine)

Define EIVF stress index:

[ \text{EIVFIndex}t = \frac{\hat{\sigma}{t+\delta}(u^{\text{planned}})-\hat{\sigma}{t+\delta}(u^{\text{neutral}})}{\hat{\sigma}{t+\delta}(u^{\text{neutral}})+\epsilon} ]

States

• CALM: low EIVFIndex, healthy refill.
• WATCH: rising EIVFIndex or cancel intensity spike.
• STRESS: high EIVFIndex + weak refill + spread widening.
• SAFE: hard risk breach.

Policy sketch

• CALM → standard POV band, passive-first.
• WATCH → reduce crossing fraction, increase child spacing, tighten venue filters.
• STRESS → cap aggression, pause toxic venues, prioritize completion via safer slices.
• SAFE → emergency throttling / temporary halt / human review rule.

Use hysteresis and minimum dwell time to prevent state flapping.

Online algorithm (pseudo)

for each decision tick t:
  observe state S_t = (x_t, tau_t, market features)
  for u in candidate_actions:
    q_base[u] = BaseQuantileModel.predict_q95(S_t, u)
    sigma_next[u] = VolFeedbackModel.predict(S_t, u)
    eivf[u] = dQdSigma(S_t) * (sigma_next[u] - sigma_next[neutral])
    miss[u] = FillModel.predict_miss_prob(S_t, u)
    score[u] = q_base[u] + gamma*eivf[u] + lambda_miss*miss[u]
  feasible = apply_hard_constraints(candidate_actions)
  u_t = argmin(score[u] for u in feasible)
  execute(u_t)
  update online diagnostics/calibration

What to log in production

Per child order:

• selected action + top-3 rejected actions and score decomposition
• predicted q50/q90/q95, predicted EIVF term
• realized fill, markout(5s/30s/60s), spread change, volatility change
• state transitions and trigger reasons

Daily diagnostics:

1. Calibration of (\widehat{\Delta\sigma}): MAE, directional accuracy.
2. q95 coverage reliability (target vs realized exceedance).
3. Regime-wise EIVF benefit: p95(IS)_baseline - p95(IS)_EIVF.
4. Completion-rate impact (avoid “tail improvement by underfilling”).
5. Action entropy (guard against controller collapse to one action).

Rollout plan (safe)

1. Shadow mode (2–4 weeks): score and recommend actions, do not control.
2. Canary traffic: 5% notional with strict kill criteria.
3. Progressive ramp: 5% → 15% → 30% if guardrails remain green.
4. Champion–challenger governance: weekly review with fixed promotion thresholds.

Hard rollback triggers:

• q95 IS degradation > threshold,
• miss probability surge,
• calibration drift in (\Delta\sigma) model,
• operational instability (state flapping, venue reject spikes).

Failure modes and mitigations

1. Over-throttling near deadline

   • Mitigation: time-decay in (\gamma), explicit deadline penalty.

2. False positive stress detection

   • Mitigation: multi-signal confirmation + dwell-time hysteresis.

3. Non-stationary microstructure

   • Mitigation: rolling retrain + conformal residual monitor + drift alarms.

4. Cross-venue spillover not modeled

   • Mitigation: venue interaction features and venue-level stress caps.

5. Policy gaming via metric focus

   • Mitigation: monitor multiple objectives (q95 + completion + markout + rejects).

Practical implementation checklist

• Define candidate action lattice (POV × aggression × spacing × venue mask)
• Build base quantile slippage model with robust tails
• Add one-step volatility feedback model with causal correction
• Implement EIVF score decomposition and hard constraints
• Add state machine with hysteresis and emergency safe mode
• Instrument detailed decision logs for attribution
• Run shadow→canary→ramp with explicit rollback criteria

References (starting points)

• Almgren, R. & Chriss, N. (2000), optimal execution framework.
• Bouchaud et al., propagator / transient impact literature.
• Gatheral and follow-up work on no-dynamic-arbitrage impact structure.
• Bacry, Mastromatteo, Muzy on Hawkes-style order-flow dynamics.
• Recent TCA/quantile risk-control practice for p95/CVaR-focused execution.

Bottom line

A good slippage controller should optimize future path quality, not just immediate fill cost.
EIVF modeling turns “our flow changed the game board” from a postmortem sentence into an online control signal.