Kyle's Lambda and Information Asymmetry: The Auction Model of Price Impact

Why do large orders move prices more than small ones? Kyle (1985) compresses the answer into one number, lambda: how much the price moves per unit of net order flow. This article derives lambda from the three-player game, then shows how to estimate it from real data.

8 of 12 ~12 min

If you’ve ever wondered why a 100,000-share buy order moves the price more than a 100-share order, you need Kyle’s model. If you’ve ever built an execution algo and watched it “chase” the price, you need Kyle’s model. If you’ve ever wondered what “liquidity” actually means in a quantifiable sense, you need Kyle’s model.

Kyle (1985) is one of the most cited papers in microstructure. Its answer compresses into a single number — lambda: how much the price moves per unit of net order flow. That number isn’t sketched off a supply-demand curve; it is solved out of a game of asymmetric information, and that is exactly the model’s value: it says price impact doesn’t come from an order being large, but from an order possibly knowing something. Harris treats Kyle in Ch. 10 and Ch. 13, and everything downstream — Hasbrouck’s information share, Almgren-Chriss, the square-root impact law — stands on it. Let’s derive it.

The Setup

Kyle’s model is a single-period auction with three types of agents, each holding a different hand.

The informed trader observes the asset’s true value $V \sim N(p_0, \sigma_V^2)$ — $p_0$ is the market’s prior expectation, $\sigma_V^2$ the prior variance. He knows something others don’t; the question is how to use it. Noise traders submit random orders $u \sim N(0, \sigma_u^2)$ , independent of value — they trade to rebalance, to hedge, or because they can’t help it. The market maker has the worst seat at the table: she sees only total order flow, not who submitted what, and she must still set a clearing price.

The informed trader picks a quantity $x$ (selling if $V < p_0$ ), and his order arrives blended with the noise:

X = x + u

The market maker sees $X$ and prices linearly:

p = p_0 + \lambda X

$\lambda$ is the price impact coefficient — Kyle’s lambda. At this point it’s still an undetermined number: the equilibrium of the game will pin it down.

The informed trader’s expected profit (assume $V > p_0$ so he buys, for simplicity):

E[\text{profit}] = E[(V - p) \cdot x \mid V] = (V - p_0 - \lambda x) \cdot x

The whole tension is already inside that expression: a larger $x$ earns more, but $\lambda x$ pushes his own execution price against him.

Step One: How the Informed Trader Trades

Given $V$ , differentiate with respect to $x$ :

\frac{\partial E[\text{profit}]}{\partial x} = V - p_0 - 2\lambda x = 0

Solving:

x = \frac{V - p_0}{2\lambda}

The informed order is linear in the value gap $V - p_0$ , scaled by $1/(2\lambda)$ . Read the direction: when lambda is high (the market reacts sharply to flow), he trades small — each additional share costs more in impact; when lambda is low, he sizes up. The informed trader doesn’t slam his information into the market at once — he rations it against the impact cost. What this step buys us: informed flow intensity is inversely proportional to lambda.

Step Two: How the Market Maker Prices

Under competition the market maker earns zero expected profit, so the price must equal the conditional expected value: $p = E[V \mid X]$ . The flow she sees is:

X = x + u = \frac{V - p_0}{2\lambda} + u

Posit linear updating (with normal distributions this is not an approximation — it is the exact Bayesian posterior):

E[V \mid X] = p_0 + \beta X

For the pricing rule to be self-consistent, $\lambda = \beta$ . Now solve for $\beta$ explicitly via Bayes, and that will pin down $\lambda$ .

The moments of flow:

\mu_X = E[X] = E\left[\frac{V - p_0}{2\lambda}\right] + E[u] = 0

\sigma_X^2 = \text{Var}(X) = \text{Var}\left(\frac{V - p_0}{2\lambda}\right) + \text{Var}(u) = \frac{\sigma_V^2}{4\lambda^2} + \sigma_u^2

Normal theory gives the conditional expectation:

E[V \mid X] = p_0 + \frac{\text{Cov}(V, X)}{\text{Var}(X)} \cdot (X - E[X])

For the covariance, since $X = (V - p_0)/(2\lambda) + u$ with $u$ independent of $V$ :

\text{Cov}(V, X) = \frac{\text{Var}(V)}{2\lambda} = \frac{\sigma_V^2}{2\lambda}

Substituting back:

E[V \mid X] = p_0 + \frac{\sigma_V^2 / (2\lambda)}{\sigma_V^2/(4\lambda^2) + \sigma_u^2} \cdot X

Step Three: Closing the Loop

The pricing rule requires the price slope to equal this Bayesian slope — but the Bayesian slope itself depends on how the informed trader responds to $\lambda$ . The equilibrium is the fixed point:

\lambda = \frac{\sigma_V^2 / (2\lambda)}{\sigma_V^2/(4\lambda^2) + \sigma_u^2}

Cross-multiplying:

\lambda \left[\frac{\sigma_V^2}{4\lambda^2} + \sigma_u^2\right] = \frac{\sigma_V^2}{2\lambda}

\frac{\sigma_V^2}{4\lambda} + \lambda \sigma_u^2 = \frac{\sigma_V^2}{2\lambda}

\lambda \sigma_u^2 = \frac{\sigma_V^2}{2\lambda} - \frac{\sigma_V^2}{4\lambda} = \frac{\sigma_V^2}{4\lambda}

\lambda^2 = \frac{\sigma_V^2}{4\sigma_u^2}

\boxed{\lambda = \frac{\sigma_V}{2\sigma_u}}

That’s Kyle’s result: lambda equals half the ratio of fundamental volatility to noise-trading volatility.

Stay on that formula a moment. High fundamental uncertainty ( $\sigma_V$ large) with little noise trading ( $\sigma_u$ small) makes lambda large — each unit of flow is highly informative and the price reacts hard. Stable fundamentals with heavy noise trading make lambda small — the flow is mostly noise, and the market maker shrugs. The mechanism is a discrimination problem: when noise is thick, the market maker can’t tell informed from uninformed and reacts a little to every unit; when noise is thin, every unit of flow is suspect and impact runs high.

Which leads to a conclusion that is less obvious than it sounds: market depth is endogenous. Depth is not an amenity an exchange provides; it is the equilibrium outcome of the mix of informed and uninformed participants. A market crowded with informed traders and starved of noise flow cannot be deep — noise traders are the fuel of liquidity.

Estimating Lambda from Data

The model’s $\lambda = \sigma_V/(2\sigma_u)$ can’t be used directly — neither $\sigma_V$ nor $\sigma_u$ is observable. But the model also hands you an observable regression structure. The standard approach:

\Delta p_t = \lambda \cdot X_t + \epsilon_t

where $\Delta p_t$ is the (signed) midprice change and $X_t$ is signed order flow — buyer-initiated minus seller-initiated volume — estimated by OLS.

For orders of magnitude (and these are only that: they drift substantially with regime, time of day, and volatility environment — they are not constants): for a liquid US large-cap, lambda is around $5 \times 10^{-8}$ per dollar — a $1M net buy moves the price about $0.05, which is 5 bps on a $100 stock, in line with empirical estimates. For an illiquid small-cap, lambda might be around $5 \times 10^{-7}$per dollar — a$100K net buy moves the price about $0.05, which is 50 bps on a $10 stock. Mind the dimensions: with $\Delta p$ in price units and $X$ in dollars, lambda has units of (price)/(dollar) — lambda is essentially inverse depth, which is why it doubles directly as an illiquidity measure (Amihud’s measure, article 7, is a daily-frequency coarsening of the same idea).

Cross-asset magnitudes:

Asset Class	Typical Lambda (per $)	Impact for $1M Order
US Large-Cap	$10^{-8}$ to $10^{-7}$	1–10 bps
US Small-Cap	$10^{-7}$ to $10^{-6}$	10–100 bps
EM Equity	$10^{-6}$ to $10^{-5}$	100 bps – 1%
Crypto Majors	$10^{-7}$ to $10^{-6}$	10–100 bps
Crypto Alts	$10^{-4}$ to $10^{-3}$	1%–10%
FX Majors	$10^{-9}$ to $10^{-8}$	< 1 bp

And lambda isn’t constant within an asset either: it rises with volatility (informed traders have more to gain — that’s $\sigma_V$ rising), runs higher at the open and close than mid-day, spikes around macro announcements, and spikes during crashes and recoveries. A robust execution strategy estimates lambda on a rolling basis in real time and adjusts its trajectory — that’s what Arithmion’s AdaptiveKyle module does.

The Multi-Period Extension: Where Order Splitting Is Born

In the single-period model the informed trader gets one shot. The multi-period extension (Kyle, 1985, Section V; Back, 1992 in continuous time) brings the story closer to reality: each period the informed trader picks $x_t$ given current beliefs and lambda, the market maker sets $p_t = p_{t-1} + \lambda_t X_t$ , and the price drifts gradually toward $V$ over $T$ periods.

The key new phenomenon: the informed trader deliberately splits his trading to hide his information. His cumulative order approximately satisfies:

\sum_{t=1}^{T} x_t = \frac{V - p_0}{\lambda}

Total informed flow is the value gap divided by lambda, independent of $T$ ; per-period size scales as $x_t \propto 1/T$ . The more periods available, the finer he splits — each slice hides in the noise, information leaks out slower, and he earns more.

This is the theoretical birthplace of order-splitting strategies. When you hold alpha and refuse to dump your full size in one print, you are running the same calculation as Kyle’s informed trader: with no alpha decay the optimum is approximately uniform trading; with decay, it tilts toward the front. Almgren-Chriss (article 9) engineers this intuition — Kyle supplies the framework, Almgren-Chriss adds the temporary/permanent impact distinction and solves for the optimal trajectory; Kyle’s lambda is the theoretical ancestor of the permanent-impact coefficient $\gamma$ there.

Reconciling with the Square-Root Law

Kyle’s impact is linear: flow $X$ moves the price by $\lambda X$ . But measured impact for large orders is sub-linear — it scales with $\sqrt{X}$ , the square-root law of article 8. A contradiction?

No — the two measure different things. Kyle’s lambda is marginal impact: right now, in this state, how much one more unit of flow moves the price. The square-root law is cumulative impact: the total price displacement of a metaorder from start to finish. When the informed trader works across periods, each purchase leaks a bit of information and the subsequent marginal impact decays; integrate the marginal impact along the trajectory and the cumulative impact comes out concave. One is the derivative of the other. For execution the distinction is tangible: in a constant-lambda world total impact grows as $\lambda Q$ , linearly; in a world where lambda decays as you trade, total impact is sub-linear — large orders are cheaper than you fear, provided you split them patiently.

Dark Pools: The Corner Where Lambda Goes to Zero

A modern footnote. In dark pools and other hidden-liquidity venues, lambda is far lower than in lit markets — not because the participants are kinder, but because non-displayed flow can’t trigger the market maker’s Bayesian update. The same $1M order sent to a lit exchange walks the book and moves the price by Kyle’s lambda; sent to a dark pool, it may cross against a single counterparty with impact near zero.

That is the economics of why dark pools exist: institutional flow that believes itself uninformed (rebalancing, indexing) hides to avoid paying for the suspicion of being informed. And whoever takes the other side in the pool must run their own toxicity check — the model’s logic doesn’t disappear, it just migrates from the pricing rule into the counterparty’s risk control. Suspect informed flow, and you widen or decline. The regulatory record isn’t clean either: SEC enforcement actions around 2014 found some pools misleading users about execution quality and how the pool operated. Harris Ch. 25 covers the regulatory context.

The Spread in Kyle, and the Absence of Inventory

There is no bid-ask spread in Kyle — the market maker prices continuously. But an implied spread falls out of lambda: a market order of size $X$ executes at $p_0 + \lambda X$ , so the concession $\lambda X$ plays the role of an effective half-spread for that order, and a full round trip costs roughly $2\lambda X$ . As an aside, the informed trader’s profit at his optimal size equals exactly $\lambda x^2$ (substitute $V - p_0 = 2\lambda x$ back into the profit expression) — every dollar of it comes out of the noise traders’ pockets, routed through the market maker’s pricing rule.

Also absent from the model: inventory. Kyle is purely informational. Stoll (1978) and Ho-Stoll (1981) supply the inventory half. The two are complements — information determines the permanent component of impact, inventory the temporary component. Projected onto the bid-ask spread, the classic decomposition is:

s = s_{\text{adverse selection}} + s_{\text{inventory}} + s_{\text{order processing}}

How the three components split empirically is highly sensitive to the estimation method — different models give very different proportions. That is precisely the subject of article 12 (spread decomposition), so no spoilers here. Harris Ch. 13 makes the decomposition explicit.

Empirical Estimation in Python

The simplest possible lambda estimator:

import numpy as np
import pandas as pd
import statsmodels.api as sm

def estimate_kyle_lambda(prices, signed_flow, lags=1):
    """
    Regress price changes on signed order flow.
    prices: array of midprices
    signed_flow: array of signed (buy - sell) volumes
    """
    dp = np.diff(prices)
    flow = signed_flow[1:]  # align

    if lags > 1:
        # Build lagged predictors
        X = pd.DataFrame({"flow": flow})
        for k in range(1, lags):
            X[f"flow_lag{k}"] = pd.Series(flow).shift(k).bfill()
        X = sm.add_constant(X)
        model = sm.OLS(dp, X.values, missing="drop").fit()
        return float(model.params[1])  # contemporaneous lambda
    else:
        X = sm.add_constant(flow)
        model = sm.OLS(dp, X).fit()
        return float(model.params[1])

# Toy data: true lambda = 5e-7 (price per share), impact baked into the price path
rng = np.random.default_rng(0)
lam_true = 5e-7
flow = rng.normal(0, 1000, 10_000)
prices = 100 + np.cumsum(lam_true * flow + rng.normal(0, 0.01, 10_000))
print(f"Lambda estimate: {estimate_kyle_lambda(prices, flow):.3e}")  # ≈ 5e-7

Note how the toy data is built: the impact must be baked into the price path (lam_true * flow inside the cumsum) or the regression has nothing to find — a reminder that the regression estimates the covariation of flow with contemporaneous price changes, and anything else co-moving with price will contaminate it. Real applications use high-frequency data, intraday windows, and controls for volatility clustering. Harris Ch. 13 has the practitioner version; Hasbrouck (2007), Ch. 4, has the formal treatment.

What Arithmion Computes

arithmion.microstructure.KyleModel provides single-period Kyle calibration, multi-period simulation of informed-trader execution paths, lambda estimation from order-flow and price data, and a bridge to Almgren-Chriss (article 9) via the lambda → impact-coefficient mapping. When you build execution algos in Arithmion, you specify a temporary impact function and a Kyle-style permanent impact coefficient; the simulator models the price trajectory and your realized cost, with AdaptiveKyle’s rolling estimator keeping lambda current with the regime.

Kyle’s model has held its seat for four decades, and the reason is worth remembering: with three players and one linear pricing rule, it turned the vague words “liquidity,” “depth,” and “impact” into a single number you can estimate, test, and wire into an execution algorithm. Read on: article 8 shows how this linear story bends into a square root for large orders, and article 9 shows how to take lambda and plan your own trading trajectory with it.

References

Harris, L. Trading and Exchanges: Market Microstructure for Practitioners. Oxford University Press, 2003. Ch. 10 (information), Ch. 13 (dealers). ISBN: 978-0-19-514470-3.
Kyle, A. “Continuous Auctions and Insider Trading.” Econometrica, 1985.
Back, K. “Insider Trading in Continuous Time.” Review of Financial Studies, 1992.
Hasbrouck, J. Empirical Market Microstructure. Oxford University Press, 2007. Ch. 4 (price impact). ISBN: 978-0-19-518115-9 (hardcover) / 978-0-19-539320-0 (paperback).