Halve the penalty you put on trading speed and you cut the extra cost you pay for smoothness by a factor of only 1.41. The paper proves that rate, and a first-order argument gets it wrong. The exact statement holds in the constant-coefficient benchmark: beta and lambda constant, no starting impact (y = 0), deterministic and nonzero terminal size. In general the authors prove an upper bound, V(eps) - V(0) = O(sqrt(eps)).
In the Obizhaeva-Wang world, a trade pushes the price by a depth factor lambda and that push decays exponentially at resilience rate beta. In the constant-coefficient version of that model with a known deterministic order size, the optimal schedule is a block at the start, a constant flow in between, and a block at the end. Nutz and Voss generalize two things at once. First, beta and lambda become deterministic functions of time rather than constants. Second, the terminal inventory is a random variable Xi_T, revealed over the trading interval through the martingale Xi_t = E[Xi_T | F_t]. The motivation is a central risk book that keeps receiving client flow while it unwinds, the setting of Nutz, Webster and Zhao. The objective is pure cost minimization: the unaffected-price term is dropped on the assumption that S is a well-behaved martingale, so there is no alpha and no inventory-risk aversion in the problem.
They solve that unregularized problem by projecting in a Hilbert space whose inner product is E[int (2beta + gamma_dot)/(2 lambda) Y Z dt + Y_T Z_T / (2 lambda_T)], where Y is the transient impact process. The first-order condition is just orthogonality to the kernel of the terminal-constraint map. No BSDEs. The optimal impact process turns out to be a martingale after dividing by the deterministic factor eta_t = (beta_t + gamma_dot_t)/(2 beta_t + gamma_dot_t). One consequence worth holding on to: news about the total size to execute, arriving as a jump in Xi, triggers a block trade in the middle of the interval, not only at 0 and T.
Where the deliverable is
Block trades and infinite variation are what the regularization is there to remove; the paper motivates it as forcing strategies "to avoid spikes in trading activity that would leak too much information to the market". The standard fix is to add epsilon times E int Q_dot^2 dt to the objective, which forces absolute continuity. In this setting with a random terminal target and time-varying coefficients, the regularized optimizer has no closed form. So the authors build one by hand: exponentially filter the singular optimizer Q^0 at relaxation scale sqrt(epsilon) until time T minus sqrt(epsilon), then run a linear bridge dQ = (Xi_t - Q_t)/(T - t) dt to the terminal target. The feedback rule is two lines. Q_dot = (Q^0_t - Q_t)/sqrt(epsilon) on the first stretch, Q_dot = (Xi_t - Q_t)/(T - t) on the last.
And it attains the same first-order rate as the optimizer you cannot compute. Theorem 5.7 bounds the excess impact cost J_0(Q^eps) - J_0(Q^0) by C_J times (C-tilde_tr sqrt(epsilon) + 4 Lambda_Xi epsilon), and the same order controls the gap J_eps(Q^eps) - V(0). Corollary 5.8 shows the true optimizer Q^{,eps} converges at the same O(sqrt(epsilon)) rate, both in excess cost and in E int |Q^{,eps} - Q^0|^2 dt. Solving the regularized control problem buys nothing at leading order.
The rate comes from the jumps
The machinery behind this is a tracking result that reaches well past the execution application: it covers every square-integrable cadlag semimartingale target and, at rate kappa^H, fractional Brownian motion. For the generic problem of following a target xi with an absolutely continuous state and a quadratic penalty kappa on speed, the cost is bounded by an exponentially weighted average of omega_xi(h) = E int |xi_t - xi_{(t-h)+}|^2 dt, the squared L2 time-translation modulus. Theorem 2.1. If omega_xi(h) <= L h^alpha, the cost is at most sqrt(kappa) E[(x - xi_0)^2] + 2 L Gamma(alpha+1) kappa^{alpha/2}. There is a matching lower bound for kappa <= T^2/2: v(kappa) >= (1/12) omega_xi(sqrt(2 kappa)), when the initial position matches the target. Pinning the rate from both sides needs a two-sided power law. For moduli bounded above and below by the same power, c h^alpha <= omega_xi(h) <= C h^alpha, the exponent is determined.
Every square-integrable cadlag semimartingale target has omega_xi(h) <= 2h E[<M>_T] + 2h E[|A|_T^2], hence the generic square-root rate. Sharp, too: for a continuous martingale target, v(kappa) = (sqrt(kappa)/2)((x - xi_0)^2 + E[<M>_T]) + o(sqrt(kappa)).
Jumps drive the friction cost. Take a deterministic target with N jumps of size Delta_j. Then v(kappa) = sqrt(kappa)[(1/2)(x - xi_0)^2 + (1/4) sum Delta_j^2] + o(sqrt(kappa)). Remove the jumps and match the initial position and the rate improves to O(kappa), with the explicit bound (kappa/2) int xi_dot^2 dt. As the paper puts it, once the initial mismatch is removed the square-root contribution is "produced entirely by the jumps". Push further: for a fractional Brownian motion target the rate is kappa^H, and for H < 1/2 the time-translation seminorm is literally infinite. Rough flow is strictly more expensive to smooth than semimartingale flow.
Read back into execution, this says something usable. The smoothing cost is set by the time-translation seminorm of the inventory path you are approximating: v(kappa) <= sqrt(kappa)(E[(x - xi_0)^2] + 2[xi]^2_tr) when that seminorm is finite, and kappa^H when the path is fractional Brownian with Hurst H. Both quantities are inherited from how the total size gets revealed to you.
Reachability is the constraint that will bite
The terminal-target machinery needs int_0^T dE[Xi_t^2]/(T - t) < infinity. The authors take this from Bank, Soner and Voß, where it is shown to be equivalent to the constrained admissible set being nonempty. It rules out a jump in Xi at T. A client who reveals a large order in the final seconds makes the constrained problem infeasible, because no square-integrable trading rate can get you there. For a central risk book that is the case where the desk gets hurt, and the theorem does not cover it.
Granting the model, the bound is non-asymptotic. The constants are explicit but built from sup-norms of beta, lambda and gamma_dot, and from E[M_T^2]. They also carry a Lipschitz factor L_Y = ||lambda||_inf sqrt(2 + T(T+2) ||beta + gamma_dot||_inf^2), with C_J = C_H^2 L_Y^2. No numerical magnitude for any of them appears. So the bounds tell you the shape of the cost in epsilon and leave the level open. Sharpness is proved only in benchmark cases: continuous martingale targets, deterministic targets with jumps, and the constant-coefficient deterministic execution problem with zero initial impact (y = 0) and Xi_T nonzero. In that last case V(eps) - V(0) is asymptotically 2 sqrt(beta lambda) Xi_T^2 (beta T + 2)^{-2} sqrt(epsilon), against V(0) = lambda Xi_T^2 / (beta T + 2).
So what would you need to run it?
Three inputs, and none of them are in a daily bar file. You need beta and lambda calibrated, with 2 beta_t + gamma_dot_t bounded away from zero (Assumption 4.1(iii), the no-manipulation condition) and lambda absolutely continuous with a finite-variation derivative. Calibration is the hard part. The model's coefficients are deterministic functions of time by Assumption 4.1. The paper points to Fruth, Schöneborn and Urusov and to Ackermann, Kruse and Urusov as the stochastic-liquidity branch of the literature, and contrasts its own method with theirs: a direct Hilbert-space argument instead of BSDEs. You also need Q^0, the singular optimizer, in closed form, which they give. And Q^0 depends on Xi_t = E[Xi_T | F_t], the conditional expectation of your own future client flow. That last object is a forecasting model you have to build and own, and its error is nowhere in these bounds.
We could not test any of this. Depth and resilience are not identifiable from daily or one-minute OHLCV bars, and the stochastic terminal target presumes client-order-flow or parent-order data we do not have. There is nothing to fit.
The single numerical illustration uses T = 1, beta = lambda = 1, y = 0, deterministic Xi_T = 1, and epsilon in {0.01, 0.0025}. It shows Q^eps and Q^{*,eps} converging on Q^0 as epsilon shrinks. We did not find a sensitivity study across horizons, intraday liquidity shapes, or parameter values, which leaves the constants untested.
Use it as a design principle. If you are already running a schedule that approximates a block-flow-block solution and you want it smoother, the filter-plus-bridge form gives you the right functional shape. The smoothing horizon scales as sqrt(epsilon). And halving epsilon is worth a factor of only 1.41 in excess cost, exactly in the constant-coefficient benchmark of Proposition 5.9, and as an upper bound elsewhere. Our earlier note on an LLM tilting TWAP found the edge collapsing once the book had depth (/articles/an-llm-tilts-twap-by-a-basis-point-in-simulation). The same caution applies here, since every number in this paper is a statement about a model of the book rather than a measurement of one.
What would change my mind about the practical reach: a calibration of beta and lambda from execution data, with C_J and C_tr evaluated at those numbers. Then the O(sqrt(epsilon)) rate stops being a shape and starts being basis points.