Almgren-Chriss Optimal Execution: A Worked Example

Almgren and Chriss (2000) turned trade execution into a portfolio problem: every liquidation schedule pays a cost with an expectation (market impact) and a variance (timing risk from price moves while you wait), and the optimal schedule is a point on an efficient frontier between the two, selected by a risk-aversion parameter λ. The Execution Simulator computes the impact half of that tradeoff. For a 250,000-share sell into a 2,000,000-share-ADV name at 15% participation, it returns a total cost of 40.13 bps ($64,210 on $16M notional), built from permanent impact, temporary impact and half-spread: the costs the Almgren-Chriss mean-variance machinery trades against the risk of a 325-minute execution window.

The problem Almgren-Chriss solved

Before 2000, execution research mostly minimized expected cost. The flaw is identical to the one Markowitz found in portfolio choice: minimizing expected cost alone says "trade infinitely slowly," because spreading a large order over a long horizon drives the per-share market impact toward zero. But trading slowly leaves you holding the position longer, exposed to price moves that have nothing to do with your trade. A schedule that minimizes impact maximizes timing risk.

Almgren and Chriss (2000) framed this as a mean-variance problem over execution trajectories. For a trajectory that holds x_k shares remaining at each time step, the total execution cost C is a random variable. The trader minimizes:

minimize   E[C] + λ · Var[C]

where λ ≥ 0 is a risk-aversion parameter. The set of solutions across all λ is the efficient frontier of optimal execution, the direct analog of Markowitz's efficient set, but in (expected-cost, cost-variance) space instead of (return, variance) space.

The two impact terms

The paper decomposes the price the trade actually pays into two effects, the decomposition the Execution Simulator implements:

• Permanent impact g(v) — the lasting shift in the equilibrium price caused by the information your order leaks. It does not revert; every later child order trades against the moved price. In the original linear specification, g(v) = γ·v, proportional to the trading rate.
• Temporary impact h(v) — the transient concession you pay to consume liquidity faster than the book replenishes. It reverts after each child order. Linear in the rate: h(v) = η·v.

To these the simulator adds the half-spread, the fixed per-share cost of crossing the quoted spread, which Almgren-Chriss fold into the temporary-impact constant.

The Execution Simulator uses the functional forms and coefficients Almgren, Thum, Hauptmann and Li (2005) estimated on Citigroup's US large-cap orders: permanent impact linear in order size relative to daily volume, scaled by the fourth root of inverse turnover (shares outstanding over daily volume), and temporary impact proportional to the 3/5 power of the trading rate. The order pays half the permanent move plus the temporary impact. The mean-variance structure is Almgren-Chriss (2000); the impact shapes and coefficients are the 2005 estimates.

The worked execution

A realistic institutional liquidation. Sell 250,000 shares of a mid-cap quoting an 18-bps spread, with 2,000,000 shares of average daily volume, 2.5% daily volatility, an inverse turnover of 263 (the IBM figure in the 2005 paper), executing at 15% participation, reference price $64. The engine returns (full inputs and outputs in the verified block below):

Reading the decomposition: the order is 12.5% of a day's volume (250k / 2M). Its permanent price impact, linear in that share and scaled by 2.5% daily volatility and turnover, is 39.52 bps, and the order pays half of it, 19.76 bps, because the price moves gradually while it executes. Temporary impact at a 15% trading rate adds 11.37 bps. The half-spread of 9.00 bps (half of the 18-bps quote) is paid on every share regardless of schedule. The all-in 40.13 bps is $64,210 against a $16M notional.

Where the Almgren-Chriss tradeoff lives in those numbers

The simulator computes one point: the cost of executing at 15% participation over 325 minutes. Almgren-Chriss is about choosing which point. Three of the engine's outputs are the levers the paper trades against each other:

1. Permanent impact (39.52 bps) is schedule-invariant. It depends on total size relative to ADV, not on how fast you trade. No execution algorithm avoids it; only trading smaller or in a more liquid name does. This is the floor.
2. Temporary impact (11.37 bps) falls as you trade slower. Halving participation from 15% to 7.5% cuts the temporary term by about 34% (it scales with the 3/5 power of the rate), but doubles the duration from 325 to 650 minutes.
3. Duration (325 minutes) is the timing-risk exposure. Every extra minute the position stays open is variance: the 2.5% daily volatility can move the unexecuted shares against you for reasons unrelated to your trade. The engine's latency-drift figures (0.46 bps expected, 0.61 worst-case) are a micro-scale glimpse of exactly this price-move risk, scaled to milliseconds rather than the execution horizon.

Almgren-Chriss formalizes the tension between (2) and (3): slower trading cuts temporary impact but raises timing-risk variance. The optimal speed is where the marginal impact saving equals the marginal variance cost, weighted by λ.

The optimal trajectory

For the linear-impact case the 2000 paper derives a closed-form optimal trajectory. The shares remaining follow a hyperbolic sine decay:

x_k = X · sinh(κ(T − t_k)) / sinh(κT)

where X is the initial position, T the total horizon, and κ (kappa) the urgency parameter set by the risk aversion:

κ̃² = λ·σ² / η          (η = temporary-impact coefficient, σ = volatility)

The shape of κ is the whole story:

• λ = 0 (risk-neutral): κ → 0, the sinh curve straightens to a line, and the optimal trajectory is constant-rate trading, equivalent to a TWAP. Minimize expected cost, ignore timing risk.
• λ → ∞ (infinitely risk-averse): κ → ∞, the trajectory front-loads aggressively, dumping most of the position immediately to eliminate timing-risk exposure at the cost of large temporary impact.
• Intermediate λ: a front-loaded but smooth liquidation. The more risk-averse the trader, the more the schedule rushes the early periods.

Each λ traces one point on the efficient frontier. The 15%-participation schedule the simulator priced corresponds to one such λ; a more risk-averse desk would trade faster (higher participation, higher temporary impact, less duration), a more cost-sensitive desk slower.

What the engine does and does not give you

The Execution Simulator is a cost calculator for a chosen schedule, not the optimizer. It answers "what does executing this size at this participation cost?", the impact-and-spread number you slot into a backtest or pre-trade estimate. It is the E[C] half of the Almgren-Chriss objective, with a glimpse of the variance half through latency drift.

To run the full Almgren-Chriss optimization you would sweep participation rates (equivalently, durations), price each with the simulator, pair each with the timing-risk variance σ² · (horizon) on the unexecuted shares, and plot the (expected-cost, variance) pairs. The lower envelope of that scatter is the efficient frontier; your λ picks the point. The simulator gives you every point's cost; the frontier construction is the wrapper around it.

Why this still matters in 2026

The linear-impact Almgren-Chriss model is a first approximation, later work added nonlinear and transient-impact refinements (Obizhaeva-Wang 2013, Gatheral-Schied 2011), and modern desks calibrate impact per-name from their own fill history. But the framing is unchanged: execution is a risk-reward tradeoff, not a cost-minimization, and the optimal schedule sits on a mean-variance frontier. Every modern execution algorithm (implementation-shortfall, adaptive-arrival-price, the risk-aware variants of VWAP) is a descendant of that 2000 insight.

For a retail-sized order the variance term is usually second-order, the price-drift risk over a five-hour window on a single mid-cap is rarely the binding constraint, so a fixed-participation schedule priced by the simulator is enough. For institutional sizes that consume meaningful fractions of ADV, the full λ-parameterized optimization is where the savings are.

Connects to

• Execution Simulation: Slippage and Impact: the calibrated impact model, a worked slippage example, and the regimes where it breaks.
• Paper vs Live Trading: what a paper account cannot show about execution cost before real capital is at risk.
• Execution Simulator: price your own order.
• Execution Simulator methodology: the full input/output specification.

References

• Almgren, R., & Chriss, N. (2000). "Optimal Execution of Portfolio Transactions." Journal of Risk 3(2), 5–39. DOI: 10.21314/JOR.2001.041. risk.net
• Almgren, R., Thum, C., Hauptmann, E., & Li, H. (2005). "Direct Estimation of Equity Market Impact." Risk 18(7), 58–62. https://www.cis.upenn.edu/~mkearns/finread/costestim.pdf
• Gatheral, J. (2010). "No-Dynamic-Arbitrage and Market Impact." Quantitative Finance 10(7), 749–759. DOI: 10.1080/14697680903373692.
• Obizhaeva, A. A., & Wang, J. (2013). "Optimal Trading Strategy and Supply/Demand Dynamics." Journal of Financial Markets 16(1), 1–32. DOI: 10.1016/j.finmar.2012.09.001.
• Gatheral, J., & Schied, A. (2011). "Optimal Trade Execution under Geometric Brownian Motion in the Almgren and Chriss Framework." International Journal of Theoretical and Applied Finance 14(3), 353–368. DOI: 10.1142/S0219024911006577.

Verified engine output

Show the recompute-verified inputs and outputs

Inputs

side	sell
order_size	250000
adv	2000000
spread_bps	18
daily_vol_pct	2.5
participation_pct	15
latency_ms	80
latency_jitter_ms	30
ref_price	64
inverse_turnover	263

Result

side	sell
permanent bps	39.515602
temporary bps	11.373211
realized impact bps	31.131013
half spread bps	9
total bps	40.131013
total dollars	64209.62
notional usd	16000000
duration minutes	325
latency drift bps	0.46225016
latency drift worst bps	0.61149949
duration trading days	0.83333333
timing risk bps	228.21773

Computed live at build time.

Frequently asked questions

What did Almgren and Chriss add over earlier execution models?

A risk dimension. Earlier models minimized expected execution cost, which implies trading infinitely slowly to drive per-share impact toward zero, but that maximizes timing risk, the exposure to price moves while the position is still open. Almgren-Chriss (2000) minimize expected cost plus lambda times variance of cost, so the optimal schedule is a point on a mean-variance efficient frontier of trajectories, selected by the trader's risk aversion lambda.

What is the difference between permanent and temporary market impact?

Permanent impact is the lasting shift in the equilibrium price caused by the information your order leaks; it does not revert, so every later child order trades against the moved price. Temporary impact is the transient concession you pay to consume liquidity faster than the book replenishes; it reverts after each child order. In the worked example, permanent impact is 39.52 bps (schedule-invariant; the order pays half) and temporary impact is 11.37 bps (falls if you trade slower).

Why does trading slower not always reduce cost?

Because slower trading cuts temporary impact but raises timing-risk variance. Spreading a 250k-share order over more time lowers the per-share liquidity concession, but leaves the unexecuted shares exposed longer to price moves driven by 2.5% daily volatility that have nothing to do with your trade. Almgren-Chriss balances the two: the optimal speed is where the marginal impact saving equals the marginal variance cost, weighted by lambda.

Does the Execution Simulator solve the full Almgren-Chriss optimization?

No. It prices one chosen schedule, the expected-cost half of the objective, returning the permanent, temporary, and half-spread decomposition for a given size and participation rate. To run the full optimization you sweep participation rates, price each with the simulator, pair each with the timing-risk variance on the unexecuted shares, and take the lower envelope of the (cost, variance) scatter; lambda then picks the point on that efficient frontier.