Speculative Receding-Horizon Control

Model predictive control (MPC) picks each action by solving a small optimization problem. At every tick of the control loop, it plans the best sequence of actions over a short future window, applies only the first action, and then solves again once the next sensor reading arrives. That repeated solve is the bottleneck. It is why nonlinear and robust MPC struggle to meet millisecond deadlines, and why the field keeps replacing the solver with cheaper learned or tabulated approximations that give up guarantees. We propose borrowing the central trick of speculative decoding, a way of speeding up language models by letting a cheap model guess several tokens that an expensive model then checks all at once. Here a cheap drafter guesses the next $K$ control actions. The exact MPC solutions at the corresponding predicted future states are then computed in one batched parallel solve. The controller keeps the longest prefix on which the guess and the exact solutions agree.

The reason this is more than an analogy is that MPC has the same circular dependency that makes language generation sequential. The problem to solve at step $t+2$ depends on the state at $t+2$, which depends on the action MPC will choose at $t+1$, which is not known until that problem is solved. A draft breaks the circle. It supplies guessed actions, which give guessed future states, which let all $K$ future problems be solved at the same time on hardware that would otherwise sit mostly idle during a single small solve. The draft can then be checked for self-consistency. When the check passes, the controller applies actions that match exact MPC to within a certified tolerance, while paying for roughly one batched solve per $K$ steps instead of $K$ sequential solves.

Core Claim

A draft-then-verify loop can reproduce the closed-loop behavior of exact MPC to within a bound that is set in advance, while cutting the average number of full solves per applied action by the expected accepted block length. The loop has three parts. The first is a drafter that proposes $K$ actions. The second is a batched parallel solver that returns, at each predicted state $\hat x_{t+k}$, the exact MPC action $\kappa(\hat x_{t+k})$ and its sensitivity $S_k = \partial \kappa / \partial x$. The sensitivity is obtained from the optimality (KKT) conditions of the solved problem. The third is a cheap runtime test that decides whether each precomputed action can stand in for the true one once the real state is measured.

A drafted step $k$ is accepted if two conditions hold. The first is a consistency condition: the drafted action matches the verified action at the predicted state, $\|u^{\text{draft}}_{t+k} - \kappa(\hat x_{t+k})\| \le \delta$. The second is a realization condition: the measured state $x_{t+k}$ falls inside a certified region around $\hat x_{t+k}$. In that region the set of active constraints is unchanged, and the first-order corrected action $\kappa(\hat x_{t+k}) + S_k (x_{t+k} - \hat x_{t+k})$ has error below $\epsilon$. At the first failure, the rest of the block is thrown away and the controller solves exactly at the measured state. This is the analogue of the correction token in speculative decoding.

Choosing $\epsilon$ below the robustness margin of a robust MPC scheme lets the controller inherit that scheme's closed-loop guarantees. The argument follows the same route that ALKIA-X uses for its interpolation error (Automatic Nonlinear MPC Approximation With Closed-Loop Guarantees).

If the verification batch costs $c_B(K)$ and the runtime test costs $c_r$, and $\bar n$ denotes the expected number of steps accepted per block, then the average cost per applied action is

$$C \approx \frac{c_B(K) + \bar n\, c_r}{\bar n}.$$

The method beats one solve per step, whose cost we write $c_1$, only when $c_B(K)$ grows much more slowly than $K \cdot c_1$ and $\bar n$ is well above 1. Both are empirical questions, and the experiments measure both directly.

We are explicit about one limit. The worst case, when every block is rejected at its first step, still costs one exact solve per step. The method lowers average compute and energy. It also hides latency by computing a lead of several steps in the background. It does not lower worst-case latency unless it is paired with a cheap safe backup controller.

Relation to Prior Work

Speculative decoding supplies the mechanism. Blockwise parallel decoding (Blockwise Parallel Decoding for Deep Autoregressive Models) introduced the idea of guessing several tokens and verifying them in one parallel pass while keeping the longest correct prefix, and the survey of Xia et al. catalogues the resulting families of drafters and verification rules. We reuse greedy prefix verification. The target "token" here is the output of a deterministic optimizer rather than a sample, so exact match becomes match within a certified tolerance. Stochastic acceptance rules such as Gumbel coupling (Coupling without Communication and Drafter-Invariant Speculative Decoding) and tree verification (Accelerated Speculative Sampling Based on Tree Monte Carlo) do not apply directly, because they are built for categorical distributions. We leave tree-shaped drafts, meaning several candidate futures verified together, as an extension. Online Speculative Decoding shows that drafters degrade when the query distribution shifts, and that distilling a drafter online from the verifier's own outputs raises token acceptance by 0.1 to 0.65. We adopt that recipe, because the verifier in our loop produces exact MPC solutions as a free by-product.

On the MPC side, several papers constrain the design or supply parts of it. A Parallel-in-Time Newton's Method for Nonlinear Model Predictive Control turns the sequential recursion over the planning horizon into associative scans on a GPU, but depends on a good initial guess. We use it as the verification engine, and the draft serves as that initial guess, so the draft improves the verifier's convergence as well as proposing actions. Performance Guaranteed MPC Policy Approximation via Cost Guided Learning shows that plain squared-error imitation of MPC gives large closed-loop cost gaps. It proposes weighting errors by the Hessian of the problem's Lagrangian, and it approximates only the first action. We extend that loss to a drafter that outputs $K$ actions and use it without any trust, because every drafted action is checked.

ALKIA-X (Tokmak et al.) gives offline error bounds tied to a robust MPC margin, but it partitions the state space in advance and so scales poorly with state dimension. We borrow its route from an error bound to a stability guarantee, but check the bound online and only where the system actually goes. Asynchronous Computation of Tube-based Model Predictive Control separates a fast nominal solve from a slow background computation of the robust "tube" around the nominal plan, yet still solves a quadratic program at every step. Our scheme removes the per-step nominal solve on accepted steps, and can use their fast loop as the backup on rejection.

Diffusion Model Predictive Control proposes multi-step action sequences with a learned model and scores them. It has no step that checks against an exact solver and no truncation to a valid prefix, which is precisely what we add. Variance-Reduced MPPI concerns sampling-based control, where the controller averages many random rollouts. It uses a quadratic model to guide which rollouts are sampled and leaves the one-solve-per-step structure untouched.

Research Program

The work has three technical pieces and one analysis.

The first piece is the verifier. We batch $K$ optimal control problems, which are posed at the draft-predicted states and warm-started from the draft, into one GPU call of the parallel-in-time Newton solver. From the converged KKT system we extract each solution's sensitivity to the initial state, together with a certified radius within which the active set, meaning the set of constraints that bind at the optimum, provably does not change. We will derive the radius from the gap between multipliers and constraint slacks, plus a Lipschitz bound on the second-order error. On CPU and embedded targets, the same batch runs on multiple cores, and we report honestly whether the batching advantage survives there.

The second piece is a family of drafters of increasing cost. The first is the shifted tail of the previous MPC solution, which costs nothing and plays the role of self-drafting in language models. The second is a small network trained offline with a multi-step version of the cost-guided loss. The third is that network updated online from a replay buffer of verifier solutions, following Online Speculative Decoding.

The third piece is a scheduler that adapts the block length $K$ to the recent acceptance rate. Short blocks waste little work when acceptance is low, and long blocks amortize well when it is high.

The analysis proves that, when $\epsilon$ is below the robustness margin of a tube or robust MPC, accepted actions preserve recursive feasibility (the guarantee that a solvable problem at one step leads to a solvable problem at the next) and stability. It also characterizes the expected accepted length as a function of disturbance size and of how far the drafter deviates from exact MPC.

Baselines

The naive reference point is exact MPC solved from scratch at every step with a standard nonlinear solver and conventional one-step warm-starting. It fixes the closed-loop cost $J^*$ and the per-step compute that everything else is measured against. On the uncertain linear system, Sieber et al. report 19.32 ms per step and an average cost of 59.07 for synchronous online tube MPC. That is our "exact" point on that benchmark.

The strongest competitor on speed with guarantees is ALKIA-X. On the chemical reactor (CSTR) benchmark it reports 44 μs online evaluation against 3000 μs for earlier neural approximations. On the cold atmospheric plasma device it reports 100 μs and a 1000x speedup over the IPOPT solver in 33 MB of memory (Tokmak et al.). We will not beat ALKIA-X on raw speed in the low-dimensional systems where it applies. The fair comparison is on closed-loop cost gap and constraint satisfaction at matched $\epsilon$, together with offline construction cost: 10.3 hours for ALKIA-X, against our drafter training time. The decisive comparison is on the higher-dimensional systems, cart-pole and the cluttered unicycle, where partitioning becomes infeasible. Beating ALKIA-X means matching its guarantee level where both methods run, and continuing to work where it cannot be built.

The strongest competitor on amortized nominal compute is the asynchronous tube scheme, which reports a 1.74 ms primary loop and cost 67.36, against 85.92 for offline tube MPC. We run it on the same simulated system, with the same noise realizations and the same hardware. Beating it means lower average per-step compute at a cost no worse than 67.36, and ideally closer to 59.07.

The unverified alternative is the cost-guided neural policy of Cao et al., trained on the same data with the same network size as our drafter and deployed without checks. The file reports only qualitative results for it on CSTR, a significantly lower $J - J^*$ than squared-error imitation, and no reported numeric result for it was found on Lacuna.

Two ablations isolate the key ingredients. The first uses the shifted-tail drafter inside the full speculative loop. It tests whether a learned drafter is needed at all. The second removes the sensitivity-based realization test and requires the measured state to equal the predicted one. It tests whether certified correction is what makes acceptance survive disturbances.

All methods share the plant models, cost functions, horizons, noise seeds, tuning budget and hardware. Timings are reported both as wall-clock time and as the number of full solves per applied action.

Why not just…?

Why not just shift the previous solution and warm-start the next solve? This is the strongest simple alternative. We absorb it rather than argue against it: the shifted tail is our zero-cost drafter. On its own, warm-starting still runs a full solve at every step, and Iacob et al. note that Newton-type convergence depends heavily on the quality of the initial guess. The experiment that settles the matter compares accepted block length for the tail drafter and for the learned drafter. If the tail matches the learned drafter everywhere, the paper's contribution narrows to the verification-and-acceptance loop, and we will report it that way. We expect the tail to lose after setpoint changes and near constraint switches, where the solution from one step earlier stops being optimal.

Why not just deploy a cost-guided neural policy with no solver online? It is faster than any verified scheme, but its errors at constraint boundaries go undetected. Cao et al. show that the choice of loss alone changes the cost gap substantially. On the unicycle, unverified or simplified tracking gives 160 collisions per 1000 trials for LQR against 75 for nonlinear MPC at $\sigma^2 = 0.0035$ (Safaoui et al.). Our "no-check" ablation is exactly this policy. If it matches our collision count and cost gap, verification buys nothing on these tasks.

Why not just use explicit MPC such as ALKIA-X? Where the state dimension is small it is faster and already certified, and we concede that regime. Its offline partitioning grows exponentially with state dimension and cannot adapt online. Our method checks certificates only along the trajectory actually visited. The cart-pole and unicycle experiments test whether that difference matters in practice.

Why not just split the controller into fast and slow loops? Sieber et al. still solve a quadratic program at every step in the fast loop, and they do not address nonlinear nominal dynamics. The two ideas combine rather than compete: their fast loop is our natural backup on rejection, and we test that hybrid.

Proposed Experiments

We will use four systems from the file.

On the uncertain linear system with polytopic constraints from Sieber et al., we measure average cost, region of attraction and per-step compute against the reported 1.74 ms, 19.32 ms, 67.36 and 59.07.

On CSTR, we compare the closed-loop cost gap and constraint violations with cost-guided learning and ALKIA-X at matched $\epsilon$.

On the torque-limited pendulum and cart-pole, with horizons up to 1000 on a GPU as in Iacob et al., we measure how the batched verification cost $c_B(K)$ grows with $K$. This is the first decisive check: if $c_B(K)$ grows nearly linearly in $K$, the amortization premise fails on that hardware. We also measure whether draft warm-starts reduce Newton iterations compared with tail warm-starts.

On the cluttered unicycle at both noise levels from Safaoui et al., we measure collisions over 1000 trials against the 75 reported for nonlinear MPC, together with acceptance length. This is the second decisive check: at $\sigma^2 = 0.0035$, the realization test should reject far more often. We will report whether $\bar n$ stays above about 2, the rough point below which the scheme costs more than simply solving at every step.

A third check introduces a mid-episode change in dynamics or cost weights. It tests whether online distillation restores acceptance, mirroring the recovery under distribution shift reported by Online Speculative Decoding.

Across all systems, the headline result is a curve of solves per applied action against closed-loop cost gap. Success means cutting solves per action by at least half while keeping the cost gap and violation counts statistically indistinguishable from exact MPC.