Optimal Execution Algorithms: TWAP, VWAP & Market Impact

When a portfolio manager decides to buy one million shares of a stock, the real challenge has just begun. Executing that order is not simply a matter of sending it to an exchange. As we explored in the previous chapter on market microstructure and as we examined in depth in our discussion of transaction costs and market impact, your large orders move markets. The very act of buying pushes prices higher, eroding the alpha that motivated the trade in the first place.

Execution algorithms emerged to solve this fundamental problem. Unlike the alpha-seeking strategies we covered in Part VI, execution algorithms have a different objective. They take a given trading decision as input and focus purely on minimizing the cost of implementation. A portfolio manager might use machine learning to identify an undervalued stock, but the execution algorithm's job is to buy that stock as cheaply as possible, not to question whether it should be bought at all. develops the theory and practice of optimal execution. We begin with simple schedule-based algorithms like TWAP and VWAP, progress to implementation shortfall frameworks, and culminate in the Almgren-Chriss model, which provides a rigorous mathematical foundation for balancing the competing costs that execution traders face. Understanding these algorithms is essential for anyone building or evaluating quantitative trading systems, as execution quality often determines whether a profitable strategy remains profitable after accounting for real-world frictions.

Consider an institutional trader who needs to sell 500,000 shares of a stock that trades approximately 2 million shares per day. Selling the entire position immediately would require crossing roughly 25% of the daily volume in a single burst, almost certainly moving the price against you and resulting in poor execution.

The alternative is for you to spread the execution over time, but this introduces a new risk. The price might move unfavorably while you wait. This tension between market impact and timing risk lies at the heart of optimal execution.

::: {.callout-note title="Market Impact vs. Timing Risk"} Market impact is the adverse price movement caused by your trading activity. Timing risk (also called price risk or volatility risk) is the risk that the asset price moves unfavorably while waiting to complete execution. Aggressive execution minimizes timing risk but maximizes impact, while patient execution minimizes impact but maximizes timing risk.

Understanding why this fundamental tension exists requires us to think carefully about the mechanics of trading. When a trader submits a large buy order, the immediate effect is to consume available liquidity on the ask side of the order book. As the order depletes offers at the best price, subsequent fills occur at increasingly worse prices. This is market impact in its most direct form. The trader's own activity causes the execution price to deteriorate. The more aggressively the trader buys, the more liquidity is consumed in a short window, and the more severe the impact.

Conversely, if the trader waits patiently, spreading the order over hours or even days, each individual trade is small enough to have minimal impact. However, during this extended waiting period, the underlying price is free to move based on market forces entirely unrelated to the trader's activity. Perhaps unfavorable news arrives, or the broader market sells off, or other participants independently decide to sell the same stock. This is timing risk, the random price movement that accumulates while the trader waits to complete execution.

Let's formalize the execution problem mathematically. You need to execute a position of $X$ shares over a time horizon $T$. At any time $t$, let $x_t$ denote the remaining inventory. The execution schedule specifies the trading rate $v_t = -dx_t/dt$, which represents how quickly shares are being executed at each moment. The negative sign appears because inventory decreases as trading proceeds. This trading rate must satisfy the fundamental constraint that execution completes by the horizon:

$$\int_0^T v_t \, dt = X$$

where:

• $v_t$: trading rate at time $t$ measured in shares per unit time
• $T$: execution time horizon
• $X$: total shares to be executed

This integral constraint simply states that the cumulative amount traded over all time must equal the total order size. It ensures that the trader neither under-executes, leaving inventory unfinished, nor over-executes, trading beyond the intended position.

The trader's objective is to choose the trajectory $\{v_t\}$ that minimizes some cost function, typically involving both expected execution cost and its variance. The expected cost captures the average amount paid above the initial price, while the variance captures the uncertainty around that average. Different algorithms embody different trade-offs between these objectives, and different traders may prefer different points along the efficiency frontier depending on their risk tolerance and urgency.

Schedule-based algorithms follow predetermined trading patterns, executing orders according to fixed rules regardless of short-term market conditions. These algorithms are simple, transparent, and widely used for benchmarking purposes.

The simplest execution algorithm is TWAP, which divides the total order into equal-sized pieces and executes one piece at regular intervals throughout the trading period. The logic behind TWAP is straightforward: without any information about when liquidity will be available or when prices might be favorable, the most sensible approach for you is to spread risk evenly across time.

For an order of $X$ shares executed over $N$ intervals of duration $\Delta t$, TWAP trades at a constant rate. In continuous time, this rate is simply the total shares divided by the total duration:

$$v_{\text{TWAP}} = \frac{X}{T}$$

where:

• $v_{\text{TWAP}}$: trading rate in shares per unit time
• $X$: total order size
• $T$: total duration

This formula expresses a fundamental principle: TWAP commits to a fixed pace of execution that does not vary regardless of market activity. Whether the market is quiet or hectic, or whether spreads are narrow or wide, the algorithm continues trading at the same steady rate.

Equivalently, in discrete intervals where the trading day is divided into $N$ equal periods:

$$q_n = \frac{X}{N}$$

where:

• $q_n$: shares traded in interval $n$
• $X$: total order size
• $N$: number of intervals

Each interval receives exactly the same allocation of shares. The index $n$ ranges from 1 to $N$, and every interval is treated identically regardless of its position in the sequence or the market conditions prevailing at that time.

TWAP's appeal lies in its simplicity: it requires no forecasting of volume patterns, no estimation of market impact parameters, and no optimization. You can implement TWAP with nothing more than a clock and a calculator. The algorithm performs well when true trading costs are linear in execution rate and when the trader has no information about intraday volume patterns. In such circumstances, there is no basis for preferring one time period over another; equal treatment of all periods is the natural choice.

The output confirms that the algorithm divides the total order into equal chunks, ensuring a constant trading rate regardless of market activity or price movements.

VWAP improves on TWAP by executing in proportion to expected market volume. The key insight motivating VWAP is that markets naturally absorb more trading during high-volume periods, so concentrating execution during these times reduces market impact. Think of it this way. If one million shares trade during the open but only one hundred thousand during lunch, submitting your large order during the open will constitute a smaller fraction of total activity and therefore have less price impact.

If $V_n$ represents the expected volume in interval $n$ and $V_{\text{total}} = \sum_n V_n$ is total expected volume across all intervals, then VWAP allocates shares according to the volume weights:

$$q_n = X \cdot \frac{V_n}{V_{\text{total}}}$$

where:

• $q_n$: target shares to trade in interval $n$
• $X$: total order size
• $V_n$: expected volume in interval $n$
• $V_{\text{total}}$: total expected volume

This formula ensures that the algorithm participates at a consistent rate relative to market activity. When volume is high, the algorithm trades more shares. When volume is low, the algorithm trades fewer shares. The ratio $V_n / V_{\text{total}}$ represents the fraction of daily volume expected in interval $n$, and this same fraction is applied to the total order size.

The VWAP benchmark itself, which gives the algorithm its name, is defined as the volume-weighted average of all prices observed during the trading period:

$$\text{VWAP} = \frac{\sum_{n=1}^{N} P_n \cdot V_n}{\sum_{n=1}^{N} V_n}$$

where:

• $\text{VWAP}$: volume-weighted average price benchmark
• $P_n$: price in interval $n$
• $V_n$: volume in interval $n$
• $N$: total number of intervals

This benchmark represents the average price at which all market participants traded during the period, with more weight given to prices during high-volume intervals. A VWAP algorithm aims to achieve an average execution price close to this benchmark. If the algorithm executes exactly according to the volume profile, it will by construction achieve a price equal to the market VWAP, assuming prices don't move in response to the algorithm's own trading.

The figure illustrates a key difference between the two approaches. TWAP maintains constant execution throughout the day, while VWAP front-loads and back-loads execution to match the typical U-shaped volume pattern observed in equity markets.

While simple and transparent, schedule-based algorithms have significant limitations:

• No adaptation to conditions: They execute regardless of whether the spread is wide, the order book is thin, or prices are moving adversely
• Predictability: Sophisticated market participants can detect and exploit predictable execution patterns
• Benchmark mismatch: Matching a volume-weighted benchmark may not align with minimizing actual execution cost

TWAP performs poorly when volume varies significantly throughout the day, while VWAP can underperform when the actual volume distribution differs from the historical pattern used for scheduling. Both approaches ignore the trader's risk preferences and the specific characteristics of the security being traded.

Implementation shortfall, introduced by André Perold in 1988, measures the total cost of implementing an investment decision. Unlike TWAP or VWAP, which compare execution to market-derived benchmarks, implementation shortfall compares your actual performance to a "paper portfolio" that could have been achieved if your entire trade executed instantaneously at the decision price.

The power of implementation shortfall as a concept lies in its comprehensiveness. When you identify an opportunity, say a stock trading at $50 that you believe is worth $60, the value of that idea is based on the price at which the decision was made. Every penny your actual execution price deviates from that decision price represents value lost, value that transfers from your trading strategy to the market or to intermediaries. Implementation shortfall captures all of these costs in a single unified measure.

Implementation shortfall can be decomposed into several components that help identify where execution costs originate. Let $P_0$ be the decision price (the price when the trading decision was made), $\bar{P}$ the average execution price achieved across all fills, and $P_T$ the price at the end of the trading period.

For a buy order of $X$ shares, the total implementation shortfall is simply the difference between what was paid and what would have been paid at the decision price:

$$\text{Implementation Shortfall} = X \cdot (\bar{P} - P_0)$$

where:

• $X$: total shares
• $\bar{P}$: average execution price
• $P_0$: decision price

This total shortfall represents the aggregate cost of execution, but it does not reveal where those costs came from. To gain deeper insight, we can decompose the shortfall into components that isolate different sources of slippage:

$$\begin{aligned} \text{IS} &= \underbrace{X \cdot (\bar{P} - P_0)}_{\text{Total}} \\ &= \underbrace{X \cdot (\bar{P} - \tilde{P})}_{\text{Market Impact}} + \underbrace{X \cdot (\tilde{P} - P_0)}_{\text{Timing Cost}} \end{aligned}$$

where:

• $\text{IS}$: implementation shortfall
• $X$: total shares
• $\bar{P}$: average execution price
• $P_0$: decision price
• $\tilde{P}$: benchmark price representing value absent trading (e.g., VWAP or arrival price)

The market impact component captures the portion of the price movement that can be attributed to the trader's own activity. The timing cost component captures price drift that would have occurred even without the trader's participation, reflecting market movements that happened simply because execution took time.

A more detailed decomposition, often used in transaction cost analysis, includes additional components:

• Delay cost: Price movement between decision and start of execution, capturing the cost of any lag between deciding to trade and entering the market
• Market impact cost: Adverse price movement caused by our trading, the direct consequence of consuming liquidity
• Timing cost: Unfavorable price drift during execution, representing exposure to random market movements
• Opportunity cost: Cost of any unexecuted portion, relevant when the algorithm fails to complete the full order

Implementation shortfall (IS) algorithms attempt to minimize expected shortfall while controlling its variance. Unlike VWAP, which targets a benchmark regardless of market conditions, IS algorithms adapt their aggressiveness based on an urgency parameter specified by you. The urgency parameter controls the trade-off between market impact and timing risk, allowing you to express your preferences about how to balance these competing concerns. High urgency means execute quickly to minimize timing risk while accepting higher market impact. Low urgency means execute patiently to minimize impact, accepting higher timing risk.

If you believe prices are about to move unfavorably or if you have limited risk budget for the position, you would choose high urgency. If you have a long-term view and tolerance for volatility, you would choose low urgency, preserving capital by avoiding unnecessary impact costs.

The visualization demonstrates how urgency transforms the execution profile. At zero urgency (0.0), the algorithm resembles VWAP. As urgency increases to 1.0, execution concentrates increasingly in early intervals, allowing traders to reduce price volatility exposure.

The Almgren-Chriss model, published in 2000, provides a rigorous mathematical framework for optimal execution. It formalizes the trade-off between market impact and timing risk, deriving closed-form optimal trajectories under specific assumptions about price dynamics and market impact. This framework provided explicit mathematical solutions that practitioners could implement and analyze.

The framework begins by modeling the midpoint price $S_t$ as following arithmetic Brownian motion. This means the price evolves randomly over time, with increments that are normally distributed and independent across time periods:

$$dS_t = \sigma \, dW_t$$

where:

• $S_t$: midpoint price at time $t$
• $\sigma$: arithmetic volatility, representing the standard deviation of price changes per unit time
• $W_t$: standard Wiener process, the mathematical representation of random price fluctuations

Note the deliberate absence of drift in this equation. The framework assumes no alpha and no expected direction of price movement. This assumption is philosophically consistent with the role of execution. The decision about what to trade and why has already been made elsewhere; it is not the execution algorithm's responsibility. The execution algorithm's job is not to predict where prices are going but to minimize the cost of getting the desired position, given that prices will fluctuate randomly during execution.

You must liquidate $X$ shares over time horizon $T$. Let $x_t$ denote remaining inventory at time $t$, with initial condition $x_0 = X$ (we start with the full position) and terminal condition $x_T = 0$ (we must be completely liquidated by the horizon). The trading rate is $v_t = -\dot{x}_t$, where the negative sign reflects that inventory decreases as we trade. A positive trading rate means we are selling, and our inventory is declining.

The model incorporates both temporary and permanent market impact, as we discussed in detail in the chapter on transaction costs. These two types of impact capture different mechanisms by which trading affects prices. When trading at rate $v_t$:

• Permanent impact. A fraction of impact persists permanently, moving the midpoint price for all subsequent trades and the wider market. Permanent impact reflects the information content of order flow. When you trade, the market updates its beliefs about fair value. The cumulative permanent impact is $g(v_t) = \gamma v_t$, where $\gamma$ is the permanent impact coefficient. Every share traded permanently shifts the price by $\gamma$ in the adverse direction.
• Temporary impact. Additional adverse price movement affects only the current trade, not future ones. This Temporary impact reflects the cost of demanding immediacy. To trade quickly, one must pay for liquidity, crossing the spread or walking up the order book. The temporary impact is $h(v_t) = \eta v_t + \epsilon \, \text{sgn}(v_t)$, where $\eta$ is the temporary impact coefficient measuring the additional cost per share from trading quickly, and $\epsilon$ represents fixed costs like half the bid-ask spread that must be paid regardless of trade size.

For mathematical tractability, and because the fixed cost does not affect the optimal trajectory shape, the model typically uses linear impact functions without the fixed component:

$$\begin{aligned} g(v) &= \gamma v && \text{(permanent)} \\ h(v) &= \eta v && \text{(temporary)} \end{aligned}$$

where:

• $g(v)$: permanent impact function describing how price permanently shifts with trading
• $h(v)$: temporary impact function describing additional cost for the current trade only
• $\gamma$: permanent impact coefficient in dollars per share per share traded
• $\eta$: temporary impact coefficient in dollars per share per share traded
• $v$: trading rate

The linearity assumption, while stylized, captures the essential economics. Trading faster costs more due to temporary impact, and total trading permanently moves prices. The distinction between temporary and permanent impact is crucial because permanent impact represents a cost that cannot be avoided by changing the trading schedule, while temporary impact depends critically on how aggressively we trade.

The expected execution cost consists of permanent and temporary components. For a trading trajectory with trading rate $v_t$, we can derive your expected cost by integrating the impact over time. The calculation proceeds as follows:

$$\begin{aligned} E[\text{Cost}] &= \int_0^T \left( \gamma(X - x_t)v_t + \eta v_t^2 \right) dt \\ &= \gamma \int_0^T (X - x_t) \left(-\frac{dx_t}{dt}\right) dt + \int_0^T \eta v_t^2 \, dt && \text{(substitute } v_t = -\dot{x}_t \text{)} \\ &= -\gamma \int_X^0 (X - x) \, dx + \int_0^T \eta v_t^2 \, dt && \text{(change variable to } x \text{)} \\ &= \gamma \left[ Xx - \frac{x^2}{2} \right]_0^X + \int_0^T \eta v_t^2 \, dt \\ &= \frac{1}{2}\gamma X^2 + \int_0^T \eta v_t^2 \, dt \end{aligned}$$

where:

• $E[\text{Cost}]$: expected execution cost across all trading
• $X$: initial inventory to be liquidated
• $x_t$: remaining inventory at time $t$
• $v_t$: trading rate at time $t$
• $\gamma$: permanent impact coefficient
• $\eta$: temporary impact coefficient
• $T$: trading horizon

This derivation reveals a fundamental insight about the structure of execution costs. The expected cost decomposes into two qualitatively different terms. The permanent impact term $\frac{1}{2}\gamma X^2$ depends only on total shares and is completely path-independent. No matter how we schedule our trades, we will pay this cost. The factor of one-half appears because early trades suffer the full permanent impact of later trades, while later trades have already "locked in" some of that impact, creating an averaging effect. The temporary impact term $\int \eta v_t^2 \, dt$ depends on the execution speed and is the only component we can minimize through clever scheduling. Because it is quadratic in the trading rate, this term penalizes bursts of rapid trading and rewards smooth, steady execution.

The variance of execution cost arises from the accumulation of price risk on the held inventory. The intuition is straightforward: while we hold shares, their value fluctuates randomly. The more shares we hold and the longer we hold them, the more exposed we are to these fluctuations. If the price evolves as $dS_t = \sigma dW_t$, the fluctuation in portfolio value is $\int_0^T x_t dS_t = \int_0^T x_t \sigma dW_t$. This stochastic integral represents the cumulative random gains and losses from price movements applied to our inventory over time.

By the Itô isometry, a fundamental result in stochastic calculus, the variance of this integral can be computed by integrating the squared integrand:

$$\begin{aligned} \text{Var}[\text{Cost}] &= E\left[ \left( \int_0^T \sigma x_t \, dW_t \right)^2 \right] \\ &= \int_0^T E[(\sigma x_t)^2] \, dt && \text{(Itô isometry)} \\ &= \sigma^2 \int_0^T x_t^2 \, dt && \text{(deterministic } x_t \text{)} \end{aligned}$$

where:

• $\text{Var}[\text{Cost}]$: variance of execution cost
• $\sigma$: price volatility per unit time
• $T$: trading horizon
• $x_t$: remaining inventory at time $t$

This variance formula captures the essence of timing risk. The unexecuted inventory $x_t$ remains exposed to price volatility $\sigma$ at every moment. The variance integrates $x_t^2$ because variance is a quadratic measure. Holding twice as many shares exposes us to four times the risk. An execution schedule that maintains high inventory for a long time will have high variance, while a schedule that rapidly reduces inventory will have low variance.

With expressions for both expected cost and variance in hand, we can formulate the optimization problem. The Almgren-Chriss objective balances expected cost against variance using a risk aversion parameter $\lambda$:

$$\min_{\{x_t\}} \quad E[\text{Cost}] + \lambda \cdot \text{Var}[\text{Cost}]$$

where:

• $\{x_t\}$: execution trajectory over time, the decision variable we optimize
• $\lambda$: risk aversion parameter, expressing how much the trader dislikes variance relative to expected cost

This mean-variance formulation should feel familiar. It is directly analogous to Markowitz portfolio optimization, which we covered in Part IV. In portfolio theory, we balance expected return against portfolio variance when choosing asset weights. Here, instead of choosing portfolio weights, we choose an execution trajectory. Instead of maximizing return while controlling risk, we minimize cost while controlling execution uncertainty. The mathematical structure is identical, which is why the Almgren-Chriss framework produces an "efficient frontier" of execution strategies just as Markowitz produces an efficient frontier of portfolios.

The risk aversion parameter $\lambda$ is chosen by the trader and reflects their preferences. A trader with high risk aversion, large $\lambda$, will pay more in expected impact to achieve certainty about execution cost. A trader with low risk aversion, small $\lambda$, will accept uncertain outcomes in exchange for lower expected cost. There is no objectively "correct" value for $\lambda$; it depends on the trader's circumstances, constraints, and risk tolerance.

To derive the optimal trajectory, we must solve this optimization problem using calculus of variations. We first observe that the permanent impact term $\frac{1}{2}\gamma X^2$ depends only on total shares $X$, not the trading path. Since this term is the same for all feasible execution schedules, we can drop it from the optimization without affecting which trajectory is optimal.

Substituting the trading rate $v_t = -\dot{x}_t$ into the remaining cost and variance terms gives the objective functional that we seek to minimize:

$$\begin{aligned} J[x] &= \int_0^T \eta v_t^2 \, dt + \lambda \int_0^T \sigma^2 x_t^2 \, dt \\ &= \int_0^T \left( \eta \dot{x}_t^2 + \lambda \sigma^2 x_t^2 \right) dt \end{aligned}$$

where:

• $J[x]$: objective functional to minimize, a function of the entire trajectory
• $\eta$: temporary impact coefficient
• $\dot{x}_t$: time derivative of inventory, equal to negative of trading rate
• $\lambda$: risk aversion parameter
• $\sigma$: volatility parameter
• $x_t$: inventory at time $t$

The integrand acts as the Lagrangian $\mathcal{L}(x, \dot{x}) = \eta \dot{x}_t^2 + \lambda \sigma^2 x_t^2$. This Lagrangian has the structure of a harmonic oscillator in classical mechanics, with a term quadratic in position (inventory) and a term quadratic in velocity (trading rate). This connection to physics is not merely coincidental; the same mathematical structure appears whenever a system must balance a position penalty against a velocity penalty.

The Euler-Lagrange equation provides the necessary condition for optimality. Any trajectory that minimizes the functional must satisfy:

$$\frac{\partial \mathcal{L}}{\partial x} - \frac{d}{dt} \left( \frac{\partial \mathcal{L}}{\partial \dot{x}} \right) = 0$$

where:

• $\mathcal{L}$: Lagrangian function
• $x$: state variable representing inventory
• $\dot{x}$: time derivative of state variable representing trading rate

Calculating the necessary partial derivatives from our Lagrangian:

$$\begin{aligned} \frac{\partial \mathcal{L}}{\partial x} &= 2 \lambda \sigma^2 x_t \\ \frac{\partial \mathcal{L}}{\partial \dot{x}} &= 2 \eta \dot{x}_t \\ \frac{d}{dt} \left( 2 \eta \dot{x}_t \right) &= 2 \eta \ddot{x}_t \end{aligned}$$

where:

• $\mathcal{L}$: Lagrangian function
• $x_t$: inventory at time $t$
• $\dot{x}_t$: first time derivative of inventory (negative of trading rate)
• $\ddot{x}_t$: second time derivative of inventory (negative of rate of change of trading rate)
• $\lambda$: risk aversion parameter
• $\sigma$: volatility parameter
• $\eta$: temporary impact coefficient

Substituting these expressions into the Euler-Lagrange equation $\frac{\partial \mathcal{L}}{\partial x} - \frac{d}{dt} \frac{\partial \mathcal{L}}{\partial \dot{x}} = 0$ yields the governing linear differential equation:

$$\begin{aligned} 2 \lambda \sigma^2 x_t - 2 \eta \ddot{x}_t &= 0 \\ \ddot{x}_t - \frac{\lambda \sigma^2}{\eta} x_t &= 0 \end{aligned}$$

where:

• $\ddot{x}_t$: second time derivative of inventory
• $\lambda$: risk aversion parameter
• $\sigma$: price volatility
• $\eta$: temporary impact coefficient
• $x_t$: inventory at time $t$

This is a second-order linear ordinary differential equation with constant coefficients. The positive coefficient on $x_t$ indicates that solutions will be hyperbolic functions rather than trigonometric ones. Solving this ODE subject to boundary conditions $x(0)=X$ (we start with full inventory) and $x(T)=0$ (we must be fully liquidated by the horizon) yields a remarkable result: the optimal trajectory has a closed-form solution expressible in terms of hyperbolic functions.

Defining the risk-adjusted time constant that emerges naturally from the coefficient ratio:

$$\kappa = \sqrt{\frac{\lambda \sigma^2}{\eta}}$$

where:

• $\kappa$: decay constant for the optimal trajectory, with units of inverse time
• $\lambda$: risk aversion parameter
• $\sigma^2$: price variance rate
• $\eta$: temporary impact coefficient

This parameter $\kappa$ plays a central role in the solution. It combines all the relevant model parameters into a single quantity that determines the shape of optimal execution. The numerator $\lambda \sigma^2$ represents the marginal cost of holding inventory, risk aversion times variance, while the denominator $\eta$ represents the marginal cost of trading faster. The ratio balances these competing costs, and the square root converts this ratio into a time-scale parameter.

The optimal inventory trajectory is:

$$x_t^* = X \cdot \frac{\sinh(\kappa(T-t))}{\sinh(\kappa T)}$$

where:

• $x_t^*$: optimal remaining inventory at time $t$
• $X$: initial inventory
• $T$: trading horizon
• $\kappa$: risk-adjusted decay constant
• $\sinh$: hyperbolic sine function, defined as $\sinh(z) = (e^z - e^{-z})/2$

This elegant formula describes exactly how inventory should decline over time. The hyperbolic sine function ensures that the trajectory satisfies both boundary conditions. At $t=0$, the argument is $\kappa T$ and the ratio equals 1, giving $x_0 = X$. At $t=T$, the argument is 0 and $\sinh(0)=0$, giving $x_T=0$.

The optimal trading rate follows as the derivative of the inventory trajectory:

$$v_t^* = X \cdot \frac{\kappa \cosh(\kappa(T-t))}{\sinh(\kappa T)}$$

where:

• $v_t^*$: optimal trading rate
• $X$: initial inventory
• $\kappa$: risk-adjusted decay constant
• $T$: trading horizon
• $t$: time
• $\cosh, \sinh$: hyperbolic cosine and sine functions, where $\cosh(z) = (e^z + e^{-z})/2$

The trading rate is highest at the beginning when $\cosh(\kappa(T-t))$ is largest, and decreases over time as the remaining horizon shrinks.

The optimal trajectory encompasses several intuitive limiting cases that help build understanding of what the solution means:

• Risk-neutral trader (λ → 0): When you have no risk aversion, κ → 0 and the optimal strategy approaches TWAP. Without concern for timing risk, there is no reason to accept higher impact by trading quickly. Mathematically, as $\kappa \to 0$, the ratio $\sinh(\kappa(T-t))/\sinh(\kappa T)$ approaches $(T-t)/T$, which is the linear inventory path of TWAP.

• Infinite risk aversion (λ → ∞): When timing risk is completely unacceptable, κ → ∞ and you liquidate immediately, accepting maximum market impact. You effectively treat any exposure to price uncertainty as infinitely costly and are willing to pay any amount in impact to eliminate it.

• High volatility: Increasing σ increases κ, leading to faster execution. Higher volatility means greater timing risk per unit time, which justifies the acceptance of more impact to complete sooner. This makes intuitive sense: if prices are whipping around wildly, you want to finish quickly rather than remain exposed.

• High temporary impact: Increasing η decreases κ, leading to slower execution. When impact is costly, patience pays off, as each share of accelerated trading costs more. This captures the fundamental trade-off: when impact is cheap, trade fast; when impact is expensive, trade slow.

The trajectories reveal the fundamental insight of the Almgren-Chriss model. A risk-neutral trader ($\lambda = 0.01$) executes nearly linearly, resembling TWAP. As risk aversion increases, the trajectory becomes increasingly convex, with rapid early execution that slows as the position decreases. The most risk-averse trader ($\lambda = 10$) completes over half the execution in the first 20% of the time horizon.

The optimal trajectory achieves a specific expected cost and variance that depend on the model parameters. These expressions allow you to understand what you gain and give up by choosing a particular level of risk aversion. For the Almgren-Chriss solution:

$$E[\text{Cost}^*] = \frac{\gamma X^2}{2} + \frac{\eta X^2 \kappa (\cosh(\kappa T) - 1)}{T \sinh(\kappa T)}$$

where:

• $E[\text{Cost}^*]$: minimal expected cost achievable for the given risk aversion
• $\gamma, \eta$: permanent and temporary impact coefficients
• $\kappa$: risk-adjusted decay constant
• $X$: total shares
• $T$: time horizon
• $\cosh, \sinh$: hyperbolic cosine and sine functions

The first term $\frac{\gamma X^2}{2}$ represents the unavoidable permanent impact cost that applies regardless of execution strategy. The second term represents the minimized temporary impact cost and depends on how aggressively we trade. A higher $\kappa$ (more aggressive trading) increases this term because we incur more temporary impact.

The minimal variance of the execution cost is given by integrating the squared inventory trajectory:

$$\text{Var}[\text{Cost}^*] = \sigma^2 \int_0^T (x_t^*)^2 \, dt$$

where:

• $\text{Var}[\text{Cost}^*]$: minimal cost variance for the given trajectory
• $\sigma$: price volatility
• $x_t^*$: optimal inventory trajectory
• $T$: trading horizon

This integral can be computed in closed form using properties of hyperbolic functions. The key observation is that faster execution, higher $\kappa$, reduces variance by reducing the integral of squared inventory but increases expected cost through higher temporary impact.

The efficient frontier illustrates that reducing execution risk requires accepting higher expected cost. Just as in portfolio theory, there is no free lunch: faster execution eliminates timing risk but increases market impact. The trader's risk aversion determines where on this frontier they should operate.

While the Almgren-Chriss framework provides optimal trajectories given known parameters, real markets present additional challenges. Volatility fluctuates, liquidity varies, and short-term price movements may signal information. Adaptive algorithms modify their behavior in response to market conditions.

Percentage of Volume algorithms trade as a fixed fraction of observed market volume, adapting execution speed to current liquidity. The algorithm monitors real-time trading activity and participates proportionally. This approach gives you natural camouflage.

$$v_t = \alpha \cdot V_t^{\text{market}}$$

where:

• $v_t$: trading rate at time $t$
• $\alpha$: target participation rate, typically between 5% and 20%
• $V_t^{\text{market}}$: observed market volume at time $t$

The participation rate $\alpha$ is specified by you and represents what fraction of all market activity the algorithm should constitute. A 10% participation rate means that for every 100 shares traded in the market the algorithm trades 10.

POV offers natural camouflage. By trading proportionally with the market, your algorithm's activity is harder to distinguish from background flow. Other market participants cannot easily detect that your algorithmic execution is underway because the trading pattern mirrors overall market activity. POV also automatically slows during thin markets and accelerates during liquid periods, providing a built-in adaptation mechanism that schedule-based algorithms lack.

Pegging algorithms dynamically adjust limit order prices to maintain a position relative to the current market. Rather than crossing the spread to execute immediately, these algorithms post passive orders that capture Common peg types include:

• Midpoint peg: order price tracks the midpoint between bid and ask, offering price improvement to both sides
• Primary peg: order tracks the same-side best quote, joining the queue at the bid for buys or the ask for sells
• Passive peg: order tracks one tick behind the best quote for added price improvement at the cost of lower fill probability

These algorithms are useful when you prioritize execution price. By posting limit orders rather than crossing the spread, pegging algorithms capture the spread rather than paying it but risk non-execution if the market moves away.

Modern implementation shortfall algorithms combine the theoretical foundation of Almgren-Chriss with real-time adaptation. Rather than committing to a fixed trajectory computed at the start of execution, these algorithms continuously revise their plans based on incoming market data. Key features include:

• Intraday volatility estimation: adjusting urgency based on current versus expected volatility
• Spread monitoring: slowing execution when spreads widen beyond normal levels
• Momentum detection: accelerating or decelerating based on short-term price trends
• Volume surprise: adjusting participation when actual volume differs from forecast

These algorithms maintain a target trajectory as a baseline but allow deviations when market conditions diverge significantly from expectations.

The adaptive algorithm increases execution during the high-volatility regime (periods 10-20) to reduce timing risk, while the widened spreads partially counteract this acceleration. This dynamic adjustment is impossible with static schedules like TWAP or pre-computed VWAP.

To solidify these concepts, let's build a complete execution simulation that compares algorithm performance across different market scenarios.