Float: Agentic Liquidity

Before diving into equations, let's build intuition. Understanding why market making is difficult illuminates how Float addresses these challenges.

1.1 The Market Maker's Dilemma

Imagine operating a currency exchange booth at an international airport. You maintain a drawer of US dollars and another of Euros. Travelers approach throughout the day seeking to exchange one currency for the other.

Your profit model is straightforward: buy Euros for slightly less than the “true” exchange rate and sell them for slightly more. That difference—the spread—constitutes your margin. If the true rate is €1 = $1.10, you might buy at $1.09 and sell at $1.11. Each round-trip nets $0.02. Simple enough, right? Here's where it becomes interesting.

Suppose you've just purchased €50,000 from a departing tourist, then hear breaking news: the European Central Bank is cutting rates. The Euro is about to depreciate. You're now holding €50,000 in rapidly devaluing currency, and all those $0.02 spreads you collected? They won't cover your losses.

This exemplifies the winner's curse of market making. Whenever someone wants to trade with you, ask yourself: “Why? What information do they possess that I lack?”

1.2 From Booth to Algorithm

In modern electronic markets, this currency booth manifests as a Limit Order Book (LOB). Rather than travelers approaching physically, we publish prices electronically. The LOB is a priority-ranked list of all participants' willingness to buy (bids) and sell (asks) at various price levels.

When we place a limit order, we commit: “I will buy 500 units if the price reaches \(X\).” We're not trading immediately—we're providing liquidity. Other participants (takers) seeking immediate execution will “take” our resting orders.

Float functions as a sophisticated version of that airport booth operator—one that:

1. Continuously adjusts prices based on inventory risk exposure
2. Distributes liquidity strategically across price levels
3. Maintains protective buffers against predatory strategies
4. Operates at millisecond timescales responding to market dynamics

1.3 Scope and Contribution

This paper presents Float as a methodological proposal—a principled heuristic adaptation of optimal market-making theory for practical deployment in continuous (24/7) electronic markets.

Our primary contributions are:

1. Continuous-Operation A-S Adaptation: We simplify the classical time-dependent framework using an effective risk horizon suitable for perpetual operation
2. Rayleigh Liquidity Shaping: We introduce a distribution whose boundary conditions naturally create protective buffers
3. Unified “Probability Cloud” Model: We reconceptualize the market maker as projecting a floating, skewed distribution rather than discrete quotes

3.1 The Core Question

Avellaneda and Stoikov posed a beautifully simple question: “At what price am I truly indifferent to buying or selling one more unit?”

Consider this carefully. With zero inventory, your indifference price equals the market mid-price \(p^*\). You have no directional bias.

But holding 50,000 units (a long position) exposes you to downside risk. If prices fall, your inventory loses value. Rationally, you should be:

• Eager to sell: Lower your ask to attract buyers
• Reluctant to buy: Lower your bid to avoid accumulating more

The price reflecting this inventory-adjusted indifference is the Reservation Price.

3.2 Classical Formulation

Through stochastic optimal control with exponential utility (constant absolute risk aversion), Avellaneda and Stoikov derived:

3.3 Continuous Operation and Effective Horizon

The classical model assumes a finite liquidation time \(T\)—appropriate for strategies that explicitly unwind inventory by a known deadline. Float targets 24/7 markets (cryptocurrency, FX) with no natural terminal time.

A practical way to retain the meaning of the classical expression is to replace \((T-t)\) with an effective risk horizon \(\tau > 0\): a characteristic time scale over which inventory is actively managed (for example, the typical time between risk resets, inventory re-hedges, or strategy re-centering). This yields:

In implementation, \(\gamma\) and \(\tau\) are not separately identifiable from fills alone, so we absorb \(\tau\) into a single calibrated coefficient. By abuse of notation, we continue to write this effective coefficient as \(\gamma\) (see Cartea et al., 2015, Ch. 10), giving:

3.4 Interpreting the Formula

Let's verify intuition with a concrete example:

We've established where to center prices (reservation price). Now we determine how to distribute liquidity around that center.

4.1 The Problem with Naive Approaches

The simplest approach places all liquidity at a single bid-ask pair. This creates critical vulnerabilities:

1. Concentration risk: All capital exposed at one price
2. Sniper vulnerability: High-frequency arbitrageurs easily pick off stale quotes

Uniform distribution (equal size at every tick) wastes capital—why allocate equally to prices that rarely execute?

We need a shaped distribution providing:

• Minimal liquidity near center: Protection against noise and latency
• Ramping at moderate distances: Capturing execution in healthy zones
• Tapering at extremes: Capital efficiency

4.2 Why Rayleigh? A Principled Selection

The critical insight motivating Rayleigh selection is its boundary condition: \(f(0)=0\).

The Rayleigh distribution starts at zero, rises to a peak at distance \(s\) (the scale parameter), then decays. This shape inherently incorporates a safety buffer that purely decaying distributions lack.

4.3 Mathematical Formulation

The Rayleigh probability density function:

4.4 Graphical Representation

To build intuition, we plot the following theoretical Rayleigh distribution:

4.5 Mapping to Discrete Order Sizes

Rayleigh provides a convenient shape, but real venues require discrete orders at discrete price levels. Float therefore uses the Rayleigh profile as an unnormalized weighting function and then normalizes to a fixed quoting budget.

Let \(d = |p - r|\) be distance from the reservation price. With a hard gap \(x_{gap}\), define:

Define the Rayleigh-shaped weight:

Let \(K\) be the total base-asset quantity the strategy is willing to quote across both sides on each refresh. We split it evenly by default:

Given a discrete set of \(N\) bid levels and \(N\) ask levels at distances \(\{d_i\}\) from \(r\), the allocated size at each level is:

This guarantees bounded posted size (exactly \(K/2\) per side before rounding) while preserving the Rayleigh shape.

4.6 The Hard Gap Enhancement and Spread Safety

Beyond Rayleigh's natural soft gap, we introduce an explicit hard gap \(x_{gap}\): no orders are placed within \(|p-r|\le x_{gap}\).

This creates a deterministic buffer that helps:

1. High-frequency noise: Small fluctuations don't trigger execution
2. Latency arbitrage: Time buffer for quote updates
3. Internal spread floor: After tick rounding, our own best bid remains below our own best ask

When the venue publishes a best bid \(b_t\) and best ask \(a_t\), Float additionally enforces a top-of-book safety rule: it drops (or clips) any bid that would lock or cross \(a_t\), and any ask that would lock or cross \(b_t\). This ensures we remain a passive liquidity provider even under rounding edge cases or fast oracle moves.

Having established building blocks, let's formally define the optimization problem.

5.1 Market Environment

Float operates in a Continuous Double Auction (CDA) mechanism with two data streams:

5.2 Volatility Estimation

We estimate volatility using an Exponentially Weighted Moving Average (EWMA) of squared log-returns, a common approach in risk management and trading systems (Hull, 2018):

Rather than treating \(\lambda\) as a fixed constant, it is often more intuitive to choose an EWMA half-life \(h\) measured in update steps. Update steps are the number of observations after which a return's influence decays by half (i.e., 50%). The corresponding decay factor is:

If updates arrive every \(\Delta t\) seconds, then the half-life in time is \(h\Delta t\). Smaller \(h\) adapts faster to regime changes but is noisier; larger \(h\) is smoother but slower. The right choice depends on the oracle update rate and the microstructure of the market being bootstrapped.

5.3 Agent Definition

We define the Float agent \(\alpha\) as a mapping from state to orders:

State vector:

where \(\Theta = \{\gamma, x_{gap}, s, K, N, \Delta_{\max}, \delta_p, \delta_v, h\}\) is the parameter set.

Output: The agent produces two sets of limit orders: bids (buy orders below the reservation price) and asks (sell orders above it):

Each order is a price-size pair \((p_i, v_i)\) where \(p_i\) is the limit price and \(v_i\) is the order quantity.

5.4 Success Criteria

We define success along three dimensions:

6.1 Concepts

Float reconceptualizes market making not as a static ladder of discrete quotes, but as a dynamic probability cloud centered on a reservation price. This reservation price acts as an anchor, calculated from the external oracle but continually shifted by internal inventory pressures.

Analogous to a vessel moored in a tidal current, the strategy's quoting distribution “drifts” in response to inventory accumulation (the current). A long position shifts the reservation price downward, skewing liquidity to discourage further buying and facilitate selling. Conversely, a short position shifts prices upward. This adaptive skew ensures the agent remains tethered to fundamental value while actively neutralizing directional exposure risk.

6.2 Symbol Definitions

Base and quote convention. We write prices in quote currency per 1 unit of base currency. For example, in EUR/USD the base asset is EUR and the quote asset is USD, so \(p=1.1000\) means 1 EUR costs 1.10 USD. In this convention, 1 pip for EUR/USD is 0.0001 USD per EUR.

6.3 Market Incentivization by Example

The market itself becomes the mechanism neutralizing exposure.

6.4 Reference Configuration

6.5 Algorithm Specification

6.6 Reference Pseudocode Implementation

{
    "gamma": 0.0004,
    "gap_width": 0.0004,
    "scale": 0.0005,
    "delta_max": 0.0020,
    "tick_size": 0.0001,
    "lot_size": 1.0,
    "min_size": 1.0,
    "quote_budget": 100000,
    "levels_per_side": 10,
    "ewma_half_life": 20
}

def _ewma_lambda(self) -> float:
    h = max(1, int(self.config.ewma_half_life))
    return float(np.exp(np.log(0.5) / h))

def update_volatility(self, log_return: float) -> float:
    lam = self._ewma_lambda()
    self._sigma_sq = lam * self._sigma_sq + (1 - lam) * (log_return ** 2)
    return float(np.sqrt(self._sigma_sq))

def _round_bid_price(self, p: float) -> float:
    t = self.config.tick_size
    return float(np.floor(p / t) * t)

def _round_ask_price(self, p: float) -> float:
    t = self.config.tick_size
    return float(np.ceil(p / t) * t)

def _round_size(self, v: float) -> float:
    lot = self.config.lot_size
    return float(np.floor(v / lot) * lot)

def _calc_reservation_price(
    self, 
    oracle_price: float, 
    inventory: float
) -> float:
    return oracle_price - inventory * self.config.gamma * self._sigma_sq

def _generate_tick_ladder(self) -> np.ndarray:
    cfg = self.config
    tick = cfg.tick_size

    min_ticks = int(np.floor(cfg.gap_width / tick)) + 1
    max_ticks = int(np.floor(cfg.delta_max / tick))

    if max_ticks <= min_ticks:
        return np.array([])

    ticks = np.linspace(min_ticks, max_ticks, cfg.levels_per_side)
    ticks = ticks.round().astype(int)
    ticks = np.unique(ticks)

    if ticks.size < cfg.levels_per_side:
        tick_cap = min(min_ticks + cfg.levels_per_side, max_ticks + 1)
        ticks = np.arange(min_ticks, tick_cap, dtype=int)

    return ticks * tick

def _compute_weights_and_sizes(self, distances: np.ndarray) -> np.ndarray:
    if len(distances) == 0:
        return np.array([])

    d_prime = np.maximum(0.0, distances - self.config.gap_width)
    s2 = self.config.scale ** 2
    w = (d_prime / s2) * np.exp(-(d_prime ** 2) / (2 * s2))

    w_sum = float(w.sum())
    if w_sum <= 0:
        return np.zeros_like(distances)

    K_side = self.config.quote_budget / 2.0
    sizes = K_side * (w / w_sum)

    return sizes

def compute_orders(
    self,
    oracle_price: float,
    inventory: float,
    best_bid: Optional[float] = None,
    best_ask: Optional[float] = None,
) -> Tuple[List[Tuple[float, float]], List[Tuple[float, float]]]:

    r = self._calc_reservation_price(oracle_price, inventory)

    distances = self._generate_tick_ladder()
    sizes = self._compute_weights_and_sizes(distances)

    if len(distances) == 0:
        return [], []

    bids: List[Tuple[float, float]] = []
    asks: List[Tuple[float, float]] = []

    for dist, sz in zip(distances, sizes):
        bid_p = self._round_bid_price(r - dist)
        ask_p = self._round_ask_price(r + dist)

        v = self._round_size(sz)
        if v < self.config.min_size:
            continue

        if best_ask is None or bid_p < best_ask:
            bids.append((bid_p, v))

        if best_bid is None or ask_p > best_bid:
            asks.append((ask_p, v))

    return bids, asks

7.1 Computational Performance

Float achieves low latency through vectorization and a small fixed number of price levels. The core computation is \(O(N)\) per refresh, and for bootstrap settings (e.g., \(N \le 10\)) it is typically sub-millisecond on modern CPUs. The exact latency depends on hardware, runtime, and how much surrounding infrastructure (serialization, risk checks, RPC) is included.

7.2 Fail-Safe Mechanisms

8.1 Synthetic Market Generator

To validate Float's behavior without risking capital in live markets, we employ a synthetic price process that captures key statistical properties of real order flow. Specifically, we model the oracle price as an Ornstein-Uhlenbeck process—a mean-reverting stochastic differential equation that produces realistic ranging behavior (Hull, 2018):

Here, \(\theta\) controls the speed of mean reversion, \(\mu\) is the long-run equilibrium price, and \(dW_t\) is a Wiener process providing random shocks. This model produces price paths that wander but tend to return to \(\mu\), mimicking the behavior of many financial instruments over short horizons.

To capture the empirical phenomenon of volatility clustering—the observation that large price moves tend to follow other large moves—we allow volatility itself to evolve stochastically. One simple choice is a mean-reverting stochastic variance process (Hull, 2018; Cartea et al., 2015):

The parameter \(\kappa\) governs how quickly volatility reverts to its long-run mean \(\bar{\sigma}^2\), while \(\xi\) controls the volatility-of-volatility. This two-factor model generates realistic market conditions ranging from quiet consolidation periods to turbulent high-volatility regimes.

8.2 Evaluation Metrics

The Inventory Mean approaching zero indicates that the skewing mechanism successfully prevents directional drift. A bounded Inventory Standard Deviation confirms that position sizes remain within acceptable risk limits rather than ballooning during adverse conditions. The Sharpe Ratio measures risk-adjusted profitability—values above 1.0 suggest the strategy generates returns commensurate with the volatility of those returns. Finally, a stable Fill Rate indicates consistent market participation without excessive quote staleness.

8.3 Expected Qualitative Behavior

9.1 Model Assumptions

Float's design rests on several simplifying assumptions that may not hold in all market conditions. Understanding these limitations is essential for practitioners considering deployment.

9.2 Parameter Sensitivity

Float's performance depends critically on parameter calibration. The risk coefficient \(\gamma\) presents a fundamental tradeoff: values too low fail to skew aggressively enough, allowing inventory to accumulate dangerously; values too high sacrifice profitability by quoting prices that rarely execute. Optimal calibration requires backtesting across diverse market conditions and may need periodic recalibration as market microstructure evolves.

Similarly, the gap width \(x_{gap}\) balances protection against execution probability. An excessively wide gap provides safety but misses profitable trading opportunities; too narrow a gap exposes the agent to latency arbitrage. Market-specific tuning based on typical bid-ask spreads, tick size, and order book depth is essential.

9.3 Future Directions

Several extensions could enhance Float's robustness and profitability: