A Market-Making Strategy

The PnL of a passive market maker breaks down roughly as:

PnL ≈ spread captured        (half-spread × fills, measured against the mid at fill time)
    − adverse selection      (the mid moving against you after fills; week 41's markouts)
    ± inventory moves        (position × mid changes not caused by your fills)
    + rebates − fees         (venue pricing)

The first term is the reason to do it. The second is why it's hard: week 41 showed that the realized spread can be close to zero once impact is taken into account. The third is the risk you carry, and the main thing a market maker controls: hold inventory briefly and in small amounts. That's what inventory skew is for. The fourth is often bigger than you'd expect, as the drill on Day 4 shows.

Formal models make the trade-off precise. Avellaneda and Stoikov (2008) model a market maker with risk aversion γ, facing a mid that moves randomly with volatility σ and taker orders whose arrival rate falls off exponentially with distance from the mid. The optimal quotes are centred not on the mid but on a reservation price that moves against your inventory. Guéant, Lehalle and Fernandez-Tapia (2013) add inventory limits and give closed-form approximations. Practitioners rarely run these models literally, but most quoting logic in practice uses some version of their main idea: skew the centre by inventory and widen with volatility.

The Avellaneda–Stoikov reservation price is

r = s − q · γ · σ² · (T − t)

where s is the mid, q your inventory (+ long), γ your risk aversion, σ² the variance of the mid per unit time, and T − t the time left. When you're long, r falls below the mid, and centring your quotes there makes your ask more competitive (you sell more readily) and your bid less so (you buy less readily). Their optimal total spread is γσ²(T − t) + (2/γ)·ln(1 + γ/k): a term for inventory risk plus a term for how quickly fill probability falls off with distance (k).

In practice you usually turn that into a handful of parameters: a half-spread in ticks, a skew in ticks per lot of inventory, and hard inventory limits. Then three details catch everyone out:

• Rounding. Your theoretical bid is rarely on the tick grid. Round bids down and asks up. Rounding toward the mid would quietly tighten your quotes and give away edge.
• Never cross the market. A heavy skew can push your bid to or past the best ask. A passive quoting engine must clamp (bid ≤ best ask − tick, ask ≥ best bid + tick) or use post-only orders that the exchange rejects instead of executing (week 8).
• Hard limits. At the inventory limit, stop quoting the side that would add to the position. Don't rely on skew alone to stop accumulation.

Compare the two inventory lines: without skew the same taker flow wanders to the hard limit and stays there for stretches, because pulling the adding side stops accumulation but nothing pulls the position back; with skew it keeps returning to flat. Then add informed takers and watch the inventory term eat most of the spread capture, a preview of Day 4's PnL split and Day 6's experiments.

#[derive(Clone, Copy, Debug)]
pub struct Params {
    /// Tick size in price units (prices are integers on a tick grid).
    pub tick: i64,
    /// Distance from the center to each quote, in ticks.
    pub half_spread_ticks: f64,
    /// How far the center moves per lot of inventory, in ticks.
    pub skew_ticks_per_lot: f64,
    /// At |inventory| ≥ this, stop quoting the side that adds to it.
    pub max_inventory: i64,
}

#[derive(Clone, Copy, Debug)]
pub struct Market {
    pub best_bid: i64,
    pub best_ask: i64,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Quotes {
    pub bid: Option<i64>,
    pub ask: Option<i64>,
}

/// Avellaneda–Stoikov reservation price: r = mid − q·γ·σ²·τ
/// (q = inventory, γ = risk aversion, σ = volatility per unit time,
/// τ = time left in the horizon).
pub fn reservation_price(mid: f64, inventory: i64, gamma: f64, sigma: f64, tau: f64) -> f64 {
    todo!()
}

/// Two-sided quotes around `fair` (a price, not ticks), skewed against
/// inventory:
///   center = fair − skew_ticks_per_lot · inventory · tick
///   bid    = center − half_spread_ticks · tick, rounded DOWN to the grid
///   ask    = center + half_spread_ticks · tick, rounded UP to the grid
///   post-only safety: bid ≤ best_ask − tick, ask ≥ best_bid + tick
///   inventory ≥  max_inventory → no bid (don't buy more)
///   inventory ≤ −max_inventory → no ask (don't sell more)
/// Rounding tip: floor(x / tick + 1e-9) and ceil(x / tick − 1e-9) keep
/// 99.99999999 from becoming the wrong tick.
pub fn quotes(fair: f64, inventory: i64, p: &Params, m: &Market) -> Quotes {
    todo!()
}

Deciding what to quote is the easy part. The quotes then have to live on a real exchange, where every message takes time, and the hard work is in keeping track of them:

• Requoting costs queue position. Under price-time priority, a price change is a cancel plus a new order at the back of the queue. Week 8's Reduce keeps priority, but only for size decreases. If you requote on every tick of the weighted mid, you'll always be at the back of the queue, and that's where week 41 showed the worst fills come from. Add hysteresis: requote only when the target price moves by at least a tick, or when your resting quote has become dangerous (stale, or on the wrong side of a fast move).
• Every order has a state, and fills can arrive in any of them. A cancel and a fill can cross on the wire. You send a cancel for your bid, and before the cancel acknowledgement arrives, a fill on that same bid shows up. The exchange's ordering decides, and you only find out afterwards.

/// One resting quote as the strategy sees it. Fills may arrive in
/// every state except Dead.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum QuoteState {
    PendingNew { qty: u64 },                      // sent, no ack yet
    Live { id: OrderId, open: u64 },               // acked, resting
    PendingCancel { id: OrderId, open: u64 },      // cancel sent; may still fill
    Dead,                                          // cancelled, filled or rejected
}

• Count in-flight orders in your limits. The worst-case position isn't your current position. It's your position plus every buy quantity that could still fill, which includes pending-new and pending-cancel orders. That's week 15's "position including open orders" check, now applied from the strategy's side.
• Message budgets. Exchanges throttle message rates and often watch order-to-trade ratios. Week 17's token bucket is what an exchange uses to enforce that. Your strategy should stay well inside the limit rather than learn about it from rejects.
• Stale data means pull your quotes. If the market-data feed has a sequence gap (week 10) or hasn't updated for longer than you expect, your fair value is unknown. Cancel both quotes first and investigate afterwards.

A single PnL number doesn't tell you whether your quoting is good or you got lucky. Split it up:

• Spread capture. For each fill, the edge against the mid at that moment: (mid − px)·qty for buys and (px − mid)·qty for sells. Positive means you bought below and sold above fair value.
• Inventory PnL. For every mid move, position × Δmid. This is where adverse selection shows up: buy, then the mid drops.
• Fees and rebates.

If you mark with the same mid you attribute against, the three components add up exactly to the total, cash + position × final_mid + fees. That identity is your accounting test.

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Side {
    Buy,
    Sell,
}

#[derive(Clone, Copy, Debug)]
pub enum Ev {
    /// One of our orders filled: we bought or sold `qty` at `px`.
    Fill { side: Side, px: i64, qty: i64 },
    /// The market mid moved to this value.
    Mid(i64),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
pub struct Pnl {
    /// Signed inventory at the end (+ long, − short).
    pub position: i64,
    /// Edge vs the mid AT FILL TIME, summed over fills:
    ///   buy:  (mid − px) · qty      sell: (px − mid) · qty
    pub spread: i64,
    /// What holding inventory made or lost while the mid moved:
    ///   Σ position_before_move · (new_mid − old_mid)
    pub inventory: i64,
    /// Σ −fee_per_lot · qty. A negative fee_per_lot is a maker rebate,
    /// so it shows up here as a positive number.
    pub fees: i64,
    /// cash + position · final_mid + fees, where buying costs px·qty cash
    /// and selling earns it. Always equals spread + inventory + fees.
    pub total: i64,
}

/// Replay our fills and the mid path, starting flat at `start_mid`.
pub fn attribute(events: &[Ev], start_mid: i64, fee_per_lot: i64) -> Pnl {
    todo!()
}

Look at the drill's last case. The market maker captured +14 of spread, lost −22 on inventory as the mid moved against its fills, and ends up +6 overall only because of +14 in rebates. That shape is common in practice: spread capture roughly cancelled by adverse selection, with fee economics making the difference. It's also why a change in a venue's fee schedule can turn a strategy that worked into one that doesn't, with no change to its code.

Most market-making disasters come from missing controls, not bad quoting:

• Inventory limits. A soft limit, where skew increases sharply, and a hard limit, where the adding side stops quoting. Both are measured on worst-case position, including in-flight orders.
• Loss limits. Intraday realized + unrealized loss beyond a threshold pulls all quotes and latches a kill switch that a human has to reset. Week 45 builds the real-time version.
• Order sanity. Maximum order size and price bands around a reference price (week 15). A bug that quotes 100× size or one tick from zero is caught here.
• Self-trade prevention. Your own bid must never be at or above your own ask. Exchanges also offer self-trade prevention, but don't rely on it.
• Market sanity. Don't quote into a crossed or locked book, an unusually wide market, or a halted instrument. Those conditions usually mean your data or the market is broken.
• Stale data. Covered on Day 3, and the most important item on this list. No fresh data means no quotes.

The simulated takers decide your results. Run the same market maker against:

1. Uninformed takers only (random side, random timing). The market maker will look great, because nobody is adversely selecting it. This is your baseline for the accounting, not a result about markets.
2. Add informed takers who trade in the direction of the next mid move (they peek at the simulator's future). Watch markouts go negative and inventory PnL go against you, and see how much skew and width it takes to survive.
3. Add a fast competitor that quotes at the same prices and gets to new levels before you. Watch your fill rate drop and your remaining fills get worse.

Evaluate across many seeds and report the distribution of PnL, maximum inventory and drawdown, not one run. Resist tuning the half-spread and skew to the seed you happened to use. That's overfitting, and week 43 shows how quickly it happens.