Robot Execution Horizon Is Not a Tuning Knob: A Staleness–Amortization Boundary Law

The Execution Horizon Treated as a Tuning Knob

Every vision-language-action (VLA) policy released this year uses the same playbook: return an entire chunk of future actions for a single query, then open-loop execute a prefix of that chunk before re-querying. The length of this prefix — the execution horizon L — is set manually by whoever last tuned it for the deployment environment.

Nearly every 2026 paper states the contradiction governing L almost verbatim, yet responds with "scheduling." PACE measured that success rate "depends strongly on the task and is non-monotonic in the horizon," and so proposed a phase-aware schedule. Staircase Policy noted that "performance degrades under long execution horizons because subsequent actions remain conditioned on stale observations," and responded with interleaved sub-chunks. Urgent Actions Go First exploited the fact that actions are "jointly generated, sequentially consumed." Another parallel line of work — AutoHorizon, DEHP, ChunkTrust, SplineWAM — treats L as an adaptive decision variable, estimating it at runtime from attention weights, learned branches, latent evidence, or a B-spline world-action model.

Nine independent works have located the same contradiction, but none has written it as an objective function. And so adaptive horizons are tuning against a quantity no one has derived, with "it depends on the task" as the terminal explanation.

rss source screenshot

Write the Objective Function, and the Horizon Stops Being a Knob

The trade-off is two costs sharing one control variable:

Amortization — each query costs λ_c (latency, energy, real-time budget), so per-step query cost falls as λ_c/L.
Staleness — every action in the executed prefix is conditioned on an observation from some number of steps ago, so tracking error grows with the horizon.

Put both into a single objective, pair it with a plant whose closed loop is exactly known, and the interior optimum is a stationarity condition, not a fitted curve:

λ_c = L · [ c(τ + L) − C(L) ]

where c is the per-delay tracking cost, τ is the inference latency, and λ_c is the price per query. The point of writing it down is that this is an identity: it reproduces the discrete-sweep optimum exactly on a 4×7 plant-and-latency grid, across 22 prices spanning seven orders of magnitude — worst deviation 0.0000 at grid resolution 0.02. Of 28 design cells, 24 are feasible and on record; the remaining four fall beyond the wall described below.

This changes what "depends on the task" means. The horizon is a function of the inference price and a measurable property of the plant — namely the curvature of the latency cost at the operating horizon. Task dependence enters only through that property. Read in reverse, the heuristic wave is just a set of approximations to one boundary, not a pile of unrelated tricks.

Action chunking and amortized inference are the prerequisites for understanding the trade-off in this paper. Modern VLA policies (such as ACT, Diffusion Policy, π0) no longer query actions step by step; instead, a single forward pass generates a sequence of future actions (a chunk) over H steps, and a prefix of length L is executed open-loop before re-querying. This is done because the marginal cost of large-scale Transformer inference is high: the latency, energy, and compute budget of one query is approximately fixed at λ_c, and spreading that cost across L plant steps gives a per-step amortized cost of λ_c/L. The larger L is, the fewer queries are made and the more amortization saves — but the later actions in the prefix remain conditioned on earlier observations, increasing closed-loop tracking error. This trade-off is exactly the source of the two terms in the objective: the amortization term λ_c/L and the staleness term growing with L. Open-loop execution at fixed L therefore naturally has an interior optimum, rather than being a monotonic choice where bigger or smaller is always better.

The Feasible Set Is a Window Closed at Both Ends

The law comes with a constraint that is easy to overlook and hard to engineer around: the feasible set is exactly

L* ∈ [ τ , d_max − τ ]

Low price pins the lower bound. Inference is cheap, and the equation wants to query constantly — but the horizon cannot fall below the latency τ. Once the lower bound binds, buying more inference does not shorten the committed length; there is nothing left to shorten.
High price pins the upper bound. The top of the window is d_max − τ, which is a feasibility ceiling, not a cost optimum.
When τ = d_max/2, the window collapses to a point. No feasible execution horizon exists at all. We call this the latency wall, and neither the upper bound nor the wall appears in any registered preset.

The engineering consequence is direct: a runtime adapter that estimates L from signals is solving a different problem from a system whose window has already closed. Adaptation is no substitute for the boundary, and at the wall there is nothing to adapt to — the policy must change form (query more cheaply, or act on a shorter observation age), because no horizon can satisfy the constraint.

Inference latency τ and the mean decision step have physical meanings that determine the two ends of the window. τ is the wall-clock time from initiating a query to receiving the action chunk, during which the robot must keep executing the previous prefix; therefore any newly committed execution horizon cannot be shorter than τ — otherwise the next query has not yet returned while the previous chunk is already exhausted, leaving a gap in the control loop, so L ≥ τ is a hard lower bound. The upper bound d_max − τ comes from the rolling horizon or safety envelope: the plant must receive a new observation within d_max steps, and after subtracting the window τ occupied by inference, the longest prefix that can actually be committed is d_max − τ. When τ grows to d_max/2, the two ends coincide and the feasible interval degenerates to empty. At that point, no matter how L is estimated or adapted, no solution satisfying the constraint exists; the querying method itself must change (e.g., by shortening τ or tolerating older observations). This is the engineering meaning of the latency wall.

Two Registered Predictions Failed, and Both Are in the Paper

This is where a paper earns or loses trust, so here is the part against ourselves.

The square-root law is refuted. L* ≈ √(2λ_c/s) is the form obtained from an asymptotic expansion, and it is wrong for these plants: across 19 fits, the exponent of L* relative to λ_c falls within [+0.184, +0.635], with mean +0.348, and 14 of the 19 regression intervals lie entirely below 0.5. Within the same plant, the exponent also depends on latency, so no single exponent can describe it.

Its natural substitute is refuted too. The obvious patch — EXPONENT = 1/(p+1) under a power-law latency cost — failed our own check: correlation +0.773, mean error 0.072. The reason is measured rather than asserted: the latency cost curve is not a power law within the sweep window. So the exponent is a derived reading of the latency-cost curvature at the operating horizon, not a universal constant, and any tuning rule that assumes it is constant is fitting the wrong functional form.

If you have a heuristic that says "committed length scales as the square root of inference cost," that is precisely the object refuted here.

Asymptotic expansion and the square-root law deserve their backstory. Differentiating the objective with respect to L and setting it to zero, if one approximates the staleness cost as quadratic and Taylor-expands the latency cost near the operating point, yields the form L* ∼ √(2λ_c/s), where s is the second-order curvature of the latency cost. This is exactly the origin of the "committed length scales as the square root of inference cost" heuristic in the literature. That form holds in the limit, but for actual plants, the latency cost curve within the sweep window is neither a power law nor purely quadratic, so the first-order asymptotics are dominated by higher-order terms, and the observed exponent falls between 0.18 and 0.64 rather than 0.5. The substitute assumption EXPONENT = 1/(p+1) also fails, because p (the power-law exponent) itself drifts with the operating point. The correct reading is: the exponent is a derived quantity of the local curvature of the latency cost curve at L*, varying with the plant and the latency grid, not a universal constant.

Two Perturbation Channels, One of Which Moves Nothing

Robotics folklore bundles perturbations into a single knob. They act on different quantities:

A nonzero-mean perturbation adds a latency-invariant term — measured at 400% of the covariance part — which raises the cost level but moves the optimum by zero. Adding a constant bias to the plant does not change how long you should commit.
Changes in perturbation shape at matching second moments do move the optimum, with effects growing in staleness. Same variance, same mean, different decision.

On the linear branch, the channel preset was a tautology: two perturbation processes with matching second moments yield the same cost, exact to 4.3e-16. The channel is only real on the nonlinear branch, where it must be re-registered. A prior that cannot fail is not a prior; it is an identity wearing the guise of a hypothesis.

Second-moment matching is the experimental design used here to isolate the perturbation channel. If two perturbation processes have the same mean and covariance (second-moment matching), then in a linear system their effects on the state distribution are identical, because a linear system propagates uncertainty only through first and second moments. This paper exploits that to construct a tautological preset: on the linear branch, two second-moment-matched processes must yield the same cost, numerically exact to 4.3e-16, i.e., machine precision. The reason this "preset" must hold is that it is not an empirical claim about the system but an algebraic identity of linear propagation. Only on the nonlinear branch do higher moments and perturbation shape enter the cost, giving the channel falsifiable content and allowing it to actually move the optimal horizon. This distinction is a reminder: a prior that can never fail is not a scientific hypothesis.

Run It — Don't Just Trust My Arithmetic

The package ships with a single command, and the honest approach is to run it on its declared build and be clear about whose checkers they are — they are the package's own, and running them tests the arithmetic and the wiring from claims to numbers, not the science.

On the declared build (CPython 3.9.6 / NumPy 2.0.2), run bash reproduce.sh from the export of the published commit:

canonical_results.json == regenerated artefact
    sha256 afaaee8e56148dfab8f98cc1721d1ea0508b722c1fa6e442026de923e99e31c0
figures     4 of 4 byte-identical to a fresh draw
product     manuscript.md 78300 chars, 137 references, all cited, 0 uncited
criterion 1 the two exact routes agree to 1.52e-14 (registered <= 1e-6)
            the candidate closed form is reported refuted by the run itself
REPRODUCE: ALL GREEN

The last line is worth noting: the package's own checks refute the closed form the paper proposed as a substitute, and print it out. A reproduction script that only proves the code runs has only proved that the code runs.

Scope Before Conclusion

The empirical branch is in silico — a controlled plant/perturbation instrument whose ground truth is given by construction, not a deployed policy. Registered criterion (v), the out-of-sample sign test, was not run, and the paper says so where it makes claims; generality claims are therefore confined to the modeled plant family. Identifying the latency-cost curvature c(·) from deployed policy logs is an open problem and is not claimed to be solved.

What transfers is the structure: the horizon is the solution to a stationarity condition, the window has two ends and a wall, and the exponent is a curvature reading rather than a constant. What does not transfer is any single number.

The Short Version

If you are tuning the execution horizon, you are solving λ_c = L·[c(τ+L) − C(L)], whether or not you write it down — and the two things that will bite you are the lower bound at τ, below which even cheap inference cannot take you, and the wall at τ = d_max/2, where no feasible horizon exists and there is nothing for adaptation to adapt to.

The paper is titled How Long Should a Robot Commit? A Staleness–Amortization Boundary Law for the Action-Chunk Execution Horizon and was published in SILICON SCIENCE: Computer Science, a journal I help run, where submissions, open peer review, and editorial decisions all happen in the open, and every manuscript ships with a reproduction script and data. The instrument, the sweeps, and the script above are all in the same repository.

One-line Summary

The execution horizon is not a tuning knob but the solution to the stationarity condition of an amortization-vs-staleness trade-off.

Paragraph Summary

This paper argues that the execution horizon L of a vision-language-action policy is not a manually set tuning knob but the interior optimum of an objective function satisfying the stationarity condition λ_c = L·[c(τ+L) − C(L)]. This identity reproduces the discrete-sweep optimum exactly on a controlled plant-and-latency grid, with deviation 0.0000. The feasible set is [τ, d_max − τ]: low prices pin the lower bound, high prices pin the upper bound, and at τ = d_max/2 the window collapses into a latency wall that cannot be adapted to. The article also refutes the square-root law and its power-law substitute, showing that the exponent is a derived reading of the latency-cost curvature; and it distinguishes two perturbation channels, with nonzero mean only raising the cost level while perturbation shape moves the optimum. The empirical work is confined to an in-silico controlled plant, and the out-of-sample sign test was not run.