Restart or Wait

A run has been going for time $\tau$ and has not finished. Should we kill it and start again, or keep waiting? In the textbook setting, with a known distribution of run times and independent restarts, the decision has an exact answer. Waiting costs, in expectation, the time the run still has to go: its mean residual life $m(\tau) = \mathbb{E}[T-\tau \mid T>\tau]$. Restarting costs a relaunch $c$ plus a fresh run, $c + \mathbb{E}[T]$. So restart if and only if

The same inequality decides whether a standing policy of restarting every run at cutoff $\tau$ beats never restarting, as we show below. Classically, then, what in the distribution of run times decides is the mean residual life, compared with a fresh run plus the cost of a relaunch.

The Classical Baseline

In this section we assume a run-time law that is known exactly and restarts that are independent and identically distributed. Nothing is fitted to agent data. No public source of the project states these derivations: we derived them for this page and checked them numerically (see Checks, below).

Notation

$T \ge 0$ is the run time of one attempt, with CDF $F$, survival function $S = 1 - F$, density $f$ and hazard $h = f/S$. A cutoff-$\tau$ policy kills any attempt still running at age $\tau$ and relaunches it at cost $c \ge 0$, paid on each relaunch but not on the first launch. $T_{\tau,c}$ is the total time until the first attempt finishes under that policy.

Expected Time Under a Cutoff

Write $A(\tau)$ for the truncated mean:

The number of attempts is geometric with success probability $F(\tau)$, so the expected number of failed attempts is $S/F$, and each costs $\tau + c$. The attempt that succeeds costs $T$ given $T \le \tau$, and $\mathbb{E}[T\,\mathbf 1\{T\le\tau\}] = A(\tau) - \tau S(\tau)$. Hence

An Identity, and the Rule

The mean residual life of a run that has reached age $\tau$ is

Splitting $\mathbb{E}[T]$ on whether the run finishes by $\tau$ gives

By the previous display, $F(\tau)\,\mathbb{E}[T_{\tau,c}] = A + cS$. Adding $S(\tau)\big(m(\tau) - c\big)$ gives the same quantity, so, whenever $\mathbb{E}[T] < \infty$,

So $\mathbb{E}[T]$ is a weighted average of $\mathbb{E}[T_{\tau,c}]$, with weight $F(\tau)$, and $m(\tau) - c$, with weight $S(\tau)$. For $0 < F(\tau) < 1$ and finite $\mathbb{E}[T]$, the first lies below the average exactly when the second lies above it:

The same inequality decides the one-shot question for a run stalled at age $\tau$: restarting once and never again costs $c + \mathbb{E}[T]$, and waiting costs $m(\tau)$.

The Best Cutoff

Differentiating the expected time under a cutoff,

At an interior optimum $A + c = SF/f$, which gives

Where restarting gains almost nothing, $\mathbb{E}[T_{\tau,c}]$ is flat to machine precision, and a search on its values, such as golden-section search, cannot locate $\tau^*$. Bisection on the sign of the numerator $SF - f(A + c)$ still can, and that is how the widget below finds it.

Lognormal Closed Forms

Let $T = e^{\mu + \sigma Z}$ with $Z$ standard normal, $z = (\ln\tau - \mu)/\sigma$, and $\Phi$ the standard normal CDF. Then

$\Phi$ comes from the site's normal-tail routine (an erf series and the Laplace continued fraction), always evaluated on the tail that avoids cancellation. With median 1 ($\mu = 0$) the two main quantities take a few lines:

// Lognormal run time with median 1: T = exp(sigma * Z).
// upper(x) = P(Z > x) and lower(x) = P(Z <= x), each on its accurate tail.
function restartTime(tau, sigma, c) {
  const z = Math.log(tau) / sigma;
  const F = lower(z), S = upper(z);
  const A = Math.exp(sigma * sigma / 2) * lower(z - sigma) + tau * S;  // E[min(T, tau)]
  return (A + c * S) / F;                                              // E[T_{tau,c}]
}

function meanResidual(tau, sigma) {                                   // m(tau)
  const z = Math.log(tau) / sigma;
  return (Math.exp(sigma * sigma / 2) * upper(z - sigma) - tau * upper(z)) / upper(z);
}

How Much Restarting Buys

The rule says when restarting helps; how much it helps depends on the shape of the law. Figure 3 holds the lognormal family at median 1 and varies $\sigma$, with free relaunches on one side of the slider and a relaunch cost of half a median run time on the other. Drag the divider to compare. Each curve is $\mathbb{E}[T_{\tau,c}]/\mathbb{E}[T]$, and the dots mark the best cutoffs.

A lognormal is one shape among many. Figure 4 has two others, chosen to make a point rather than fitted to anything: a law with two modes, and runs that can hang forever.

Restart or Wait, Interactively

Figure 5 computes the classical quantities for a law you choose: $\mathbb{E}[T]$, $F(\tau)$, $m(\tau)$, $\mathbb{E}[T_{\tau,c}]$, whether restarting at $\tau$ helps, and the best cutoff $\tau^*$. Drag across the plot or use the sliders. Beside the exact value of $\mathbb{E}[T_{\tau,c}]$, a seeded simulation of the restart process runs to 200,000 replications, and its running mean, with one standard error, converges onto the exact value. At cutoffs so early that one replication would need too many attempts to run live, the widget says so instead.

Two cases need care. If runs can hang, $\mathbb{E}[T]$ and $m(\tau)$ are infinite, the identity and the rule do not apply, and any finite cutoff beats never restarting. And where the best attainable gain is below $10^{-6}$ of $\mathbb{E}[T]$, $\tau^*$ is numerically ill-defined, so the widget reports that restarting gains nothing measurable instead of printing one.

Reference Values

The lognormal family with median 1, at the cutoffs that minimise expected time. At $\sigma = 0.5$ the best cutoff is ill-conditioned (Checks, below), so the table reports the gain instead.

Classical baseline (known lognormal run-time law, independent restarts); not project data. Every row was also reproduced by an independent implementation.

Checks

These are checks of this page's classical arithmetic only, not of the project. The closed forms were checked numerically before publication, against pass criteria recorded in a configuration file as fixed before the first run. Of the 69 registered checks, 68 passed and one failed.

The failure is one of solver conditioning, not a counterexample. At $\sigma = 0.5$ the objective is flat to machine precision, so golden-section search cannot locate $\tau^*$; bisection on the numerator $SF - f(A+c)$ satisfies the condition to 7.8 × 10⁻¹⁶, and an independent bisection agrees, with $\tau^* = 20.13$ and a gain of 8.0 × 10⁻¹¹. That diagnosis was made after the fact and is not a registered check; the registered failure stands as recorded. The $\sigma = 0.5$, $c = 0$ check passes only narrowly (5.8 × 10⁻⁶ against 10⁻⁵), for the same reason. Also after the fact, 10 further seeds for the simulation case with the largest $|z|$ gave a mean $z$ of −0.031. Every reference value on this page was reproduced independently in Python, with math.erfc and bisection.

Failures Too Rare to See

The second question is how to estimate the probability of a failure too rare for direct simulation to reach. Picture an agent run as a loop of model and tool calls that, rarely, ends in failure. With per-run failure probability $p$ and $N$ independent runs, the number of failures is $K \sim \mathrm{Bin}(N, p)$, and the classical arithmetic is short. The chance of seeing no failure at all is

the relative standard error of the estimate $\hat p = K/N$ is

and when $K = 0$ the one-sided upper bound is

So when failures are much rarer than one in the number of runs we can afford, direct simulation usually sees none, and zero failures in $N$ runs supports only $p$ below about $3/N$: for $N = 1000$, $p < 0.00299$ at 95%. Crude Monte Carlo then stops being an estimator: it returns zero occurrences and no information about the magnitude.

Figure 7 does that arithmetic for $p$ from $10^{-12}$ to 0.1 and $N$ from 10 to $10^7$, with a seeded direct simulation beside the exact value: whole experiments of $N$ runs, counting how many saw no failure. Push $p$ well below $1/N$ and nearly every experiment comes back empty.

Status

The project has been in the experimentation and development phase since Aug. 2026, and Figure 8 shows how it is set up. The approach and any results are held back until publication. That includes the methods, models, agents, tools, environments, benchmarks and estimators, which restart policies a pilot would test, the pilot designs and the content of their kill criteria, and which direction the experiments take. No number on this page is a project result: every one is classical arithmetic computed for this page. No paper, preprint or repository for this project is public.

---

Early-Feedback Calibration    All research