Self-Trade-Prevention Collision Slippage Playbook

Date: 2026-03-06
Category: research (execution / slippage modeling)

Why this playbook exists

As desks run more strategies against the same symbols, self-trade prevention (STP) is doing its legal/compliance job while quietly creating execution drag:

• intended passive fills are canceled by own incoming flow,
• replacement orders lose queue priority,
• child-order timing desynchronizes across tactics,
• late catch-up aggression pays spread + impact tax.

Most TCA stacks treat these as generic rejects/cancels. That hides a specific, controllable cost source: intra-firm order-flow collisions.

This playbook models STP collisions as a first-class slippage factor.

Core failure mode

For a buy-side parent (mirror for sells):

1. Strategy A posts resting bid with STP key K.
2. Strategy B (same firm / matching key) sends an aggressive sell or crossing sell intent.
3. Venue STP rule triggers (cancel newest / cancel oldest / decrement-and-cancel variant).
4. Outcome branches:
   • queue reset and re-entry at worse rank,
   • underfill then urgency escalation,
   • partial decrement with fragmented residual path.

Net result: self-generated slippage that is neither market-impact-only nor pure infra-latency.

Minimum data contract

Per child order and per relevant market-data snapshot:

• parent_id, child_id, strategy_id, symbol, side, qty, venue
• decision_ts, send_ts, ack_ts, fill_ts, cancel_ts, replace_ts
• stp_key, stp_mode, stp_event_flag, stp_prevented_qty
• stp_counterparty_child_id (if venue/reporting supports linkage)
• queue/price context: px, touch depth, imbalance, spread, microprice
• lifecycle counters: replace_count, cancel_count, reject_code
• completion context: residual qty trajectory, final completion time
• post-fill markouts (e.g., 100ms / 1s / 5s)

Without explicit STP tags in lifecycle data, collision cost is mostly invisible.

Metrics that expose STP slippage

1) STP Collision Rate (SCR)

[ SCR = \frac{#(child\ events\ with\ STP\ trigger)}{#(child\ submits)} ]

Track by symbol, venue, strategy-pair, and time bucket.

2) Prevented Quantity Share (PQS)

[ PQS = \frac{\sum stp_prevented_qty}{\sum child_qty_submitted} ]

High PQS means STP is no longer edge-case hygiene; it is a material flow pathway.

3) Queue Priority Reset Loss (QPRL)

Approximate bps loss from queue reset after STP-triggered cancel/replace.

[ QPRL = \frac{\sum q_i,(p^{post\text{-}reset}_i - p^{counterfactual\ no\ reset}_i)}{\sum q_i,p^{counterfactual\ no\ reset}_i} \times 10^4 ]

4) Collision Recovery Latency (CRL)

[ CRL = E[t_{first_effective_reentry} - t_{stp_event}] ]

This captures control-plane time lost due to collision handling.

5) STP Adverse Markout Differential (SAMD)

[ SAMD_h = E[markout_h\mid STP_event] - E[markout_h\mid no\ STP_event] ]

for horizon h.

6) Internal Contention Heat (ICH)

A concentration indicator for collision-heavy strategy pairs:

[ ICH = \sum_{(a,b)} w_{a,b},SCR_{a,b} ]

where w can be parent-notional or risk-budget weights.

Modeling blueprint (branch decomposition)

Model realized child-level cost as branch mixture:

[ C = \pi_{newest}C_{newest} + \pi_{oldest}C_{oldest} + \pi_{decr}C_{decr} + \pi_{clean}C_{clean} ]

Branch A: cancel-newest pathway

Incoming order gets canceled; resting keeps queue.

• risk: missed tactical intention + delayed completion
• costs: opportunity delay + subsequent aggression

Branch B: cancel-oldest pathway

Resting order is canceled; incoming trades/continues.

• risk: queue rank destruction on passive leg
• costs: queue-reset tax + re-entry spread cost

Branch C: decrement/cancel pathway

Crossing quantities are decremented/canceled according to venue logic.

• risk: fragmented residuals and control complexity
• costs: residual path inefficiency + timing skew between tactics

Branch D: clean pathway

No STP trigger; standard slippage model applies.

Feature set for estimation

• STP-key overlap density (per symbol/venue/time bucket)
• strategy-pair overlap score (simultaneous opposing intents)
• queue fragility signals (cancel bursts, refill half-life, spread elasticity)
• quote age + decision-to-send latency
• short-horizon order-flow imbalance and microprice drift
• venue/session regime (open/continuous/close/event windows)

Quantile-first estimation (q50/q90/q95) is preferred over mean-only models.

Execution control state machine

1. HARMONIZED

   • low SCR, low QPRL
   • normal tactic autonomy

2. CONGESTED

   • rising SCR or CRL
   • reduce simultaneous opposite-side child bursts
   • tighten strategy-level collision budgets

3. COLLIDING

   • sustained SCR + SAMD breach
   • enforce parent-level intent netting before child routing
   • downshift passive repost churn; protect queue priority

4. SAFE

   • repeated severe collisions, unstable residual completion
   • hard throttle conflicting tactic pairs
   • optional temporary single-controller execution per symbol

Use hysteresis to avoid state flapping.

Practical controls

Control 1) STP-key governance

Do not assign one broad STP key to many independent tactics by default. Use intentional key partitioning aligned to strategy interaction policy.

Control 2) Parent-level intent netting

Before child submission, net opposite intents across sibling strategies for same symbol/time slice.

Control 3) Collision budget per strategy pair

Define max SCR and max PQS per pair; once breached, auto-throttle the noisier side.

Control 4) Queue-preserving replacement policy

Where possible, prefer amend semantics that minimize queue loss; avoid unnecessary cancel/repost loops after STP events.

Control 5) Micro-jitter anti-synchronization

Tiny randomized send offsets between competing internal tactics can reduce deterministic collision bursts.

Control 6) Venue-aware STP mode choice

If venue permits selectable STP mode, pick mode based on execution objective (queue preservation vs immediate completion), not static defaults.

Calibration workflow

1. Build STP-tagged lifecycle dataset with strategy lineage.
2. Label branch outcomes by observed STP mode/result.
3. Estimate branch probabilities + branch-specific cost surfaces.
4. Backtest counterfactual controls (netting, throttles, key partitioning).
5. Shadow-run state controller in production telemetry.
6. Promote with canary traffic ladder and rollback triggers.

Promotion gates (example)

• QPRL reduction >= 20%
• SCR reduction >= 25% in high-contention symbols
• q95 slippage improvement >= 4 bps on collision-prone cohort
• completion-rate degradation <= 1.0 percentage point
• no compliance regression in wash-trade prevention behavior

Rollback triggers:

• two consecutive windows with q95 regression > 6 bps
• underfill spike beyond agreed threshold
• unstable SAFE-state oscillation indicating controller miscalibration

Common mistakes

1. “STP is purely compliance, not execution.”
   Compliance mechanism, yes; but it materially changes queue dynamics.

2. “More strategy independence is always better.”
   Without flow coordination, independence can become self-cannibalization.

3. “Reject/cancel bucket already captures this.”
   Generic buckets hide branch-specific costs and block targeted fixes.

4. “One STP mode fits all symbols and regimes.”
   Mode choice is an execution policy decision, not a static config checkbox.

Implementation note

STP should be modeled like any other endogenous microstructure tax:

• measurable,
• state-dependent,
• controllable,
• and governed with explicit tail-risk budgets.

If your desk is active enough to collide with itself, this is no longer edge-case plumbing.