| Optimizer | |
|---|---|
| weights after update ; update index | |
| learning rate | |
| training loss; its gradient; its Hessian | |
| momentum | |
| momentum kernel weights, ; last lag, so weights | |
| momentum decay; Nesterov mix | |
| map from momentum to update; Muon's polar factor | |
| decoupled weight decay coefficient | |
| Stability | |
| sharpness, the top Hessian eigenvalue; its value at | |
| learning rate times curvature, or | |
| characteristic polynomial of the kernel; one of its roots | |
| root radius, the largest root modulus | |
| bubbleforce, the first with a root on the unit circle | |
| center of the oscillation; top Hessian eigenvector; displacement along it | |
| Muon | |
| update as a function of current weights, past gradients frozen; its Jacobian | |
| derivative of the polar factor at | |
| pathspring, largest positive real eigenvalue of | |
| Constants | |
| baseline Muon learning rate and weight decay | |
| baseline Nesterov momentum | |
| bubbleforce of the baseline kernel () | |
| last lag of the 256-weight kernel in the experiments | |
| tokens per update; the figures plot | |
Context. Run full-batch gradient descent with a constant learning rate the step size: each update subtracts times the update direction from the weights on a neural network, and the sharpness, the largest eigenvalue of the Hessian of the training loss at the current weights: the curvature along the steepest direction rises until and then stays there while the loss keeps falling, although on a fixed quadratic any diverges. This is the edge of stabilitythe regime, found by Cohen et al. (2021), in which training holds the sharpness at the largest value the learning rate can tolerate, for gradient descent (Cohen et al., 2021). No such threshold was known for Muonan optimizer for hidden weight matrices that replaces the momentum matrix by its polar factor , so every singular direction moves by the same amount, the optimizer behind the recent records of the NanoGPT speedruna public race to train a small GPT-2 model to a fixed validation loss in the least wall-clock time, in Keller Jordan's modded-nanogpt repository. Jeffrey Siedar Cheng and Jack Neo Zheng's post bubbleforce: Predicting the Edge-of-Stability for Muon (2026) derives such a threshold for Muon and tests it on the speedrun's Muon baseline, with code on GitHub.
Any momentum rule that averages past gradients with fixed weights has a threshold for learning rate times curvature, read off the roots of one polynomial: the post calls it bubbleforce the smallest value of at which a fixed quadratic stops converging under a given momentum rule, and it equals 2 for plain gradient descent. For Muon the curvature to use is the pathspring the largest positive real eigenvalue of the Jacobian of Muon's update with respect to the weights, divided by the weight of the current gradient in the momentum. The post's claim, a conjecture supported by runs, is that Muon training settles at , fast enough to track a decaying learning rate and to be steered along a chosen path by learning rate and momentum alone.
Setting. Write the momentum at update as a weighted sum of past gradients, , where the weights after updates are the weights and the momentum kernelthe weights that the momentum puts on the current gradient and the before it, normalized to sums to 1; the experiments keep 256 weights, the last lag in the kernel: the momentum uses the current gradient and the before it, weights in all. Gradient descent has . Heavy-ballmomentum that steps along an exponential moving average of past gradients instead of the current gradient plus Nesterovmomentum that steps along a mix of the current gradient and the moving average, giving the newest gradient extra weight momentum with decay the momentum decay: the moving average multiplies its old value by and adds times the new gradient and Nesterov mix the weight on the moving average in the step; goes to the current gradient alone, is heavy-ball, is standard Nesterov has ; the speedrun's Muon uses . A non-adaptive optimizerone whose update is a fixed map of the momentum, , with no other running state such as Adam's second moments updates : is the identity for SGD with momentum, and for Muon it is the polar factor of , its thin singular value decomposition: with every nonzero singular value set to 1. The test bed is Konstantin Mishchenko's tuned Muon baseline for the speedrun: a 12-layer GPT-2 trained with 524,288 tokens per update for 3,250 updates, Muon with and decoupled weight decayshrinking the weights by the factor at each update, separately from the gradient step; here on the hidden matrices, AdamWAdam with decoupled weight decay, the optimizer that scales each coordinate's step by running estimates of its gradient's mean and size on the rest, and a learning rate constant for 975 updates, then decayed linearly to zero.
Main findings. On a fixed quadratic loss the threshold is a theorem: if why: each eigendirection of is its own recurrence with ; below all of its roots lie inside the unit circle, so every mode decays (Step 1), the iterates converge. Everything about real training is measured, one run per setting: after shocks to learning rate or momentum, through the learning-rate decay, and along a drawn path, the measured follows , with the exceptions in Steps 4 to 6.
For someone training with Muon, the law turns two hyperparameters into one curvature setting: the settled pathspring is , and momentum enters only through , which for is 13.4 at , 26.9 at 0.95 and 53.8 at (my check). A momentum change can therefore do what a learning-rate change does. Whether a lower or higher trains to a better loss is not tested.
On a fixed quadratic, each momentum kernel has a threshold set by the roots of a polynomial. Take and write . The update is a linear recurrence whose solutions are sums of modes , with a root of the characteristic polynomial the polynomial whose roots are the per-update growth factors of the recurrence's modes; a complex root gives a mode that scales by and rotates by the angle of each update,A root with is a mode that grows at every update, so the recurrence is stable when the root radius the largest modulus of a root, is below 1. Small is stable, and bubbleforce is the first at which a root reaches the unit circle,For gradient descent , whose root leaves the circle at when . For untruncated heavy-ball plus Nesterov momentum the moving average is one extra state, and . A nonreal pair of roots has squared modulus equal to the constant term, at most , so it never reaches the circle; rules out ; the exit is at , a period-two oscillation, and gives Gitman et al.'s (2019) thresholdFor a Hessian the Hessian of the loss, constant on a quadratic, with eigenvalues the eigendirections decouple with , which gives the theorem above. At , (my check, unchanged by the 256-weight truncation), about 13 times gradient descent's 2. Lee and Lee (2026) give this general construction concurrently; the post's own contribution is the extension to Muon.
For gradient descent, oscillation pushes the sharpness down, so training settles at the threshold. The argument is Damian et al.'s (2023). Write , with the local time average of the iterates, the center the run oscillates around the center of the oscillation, the unit top eigenvector of the Hessian at the top Hessian eigenvector and the signed displacement of from along the displacement along it. Averaging the gradient over a symmetric oscillation removes the term linear in , and for a simple top eigenvalue the quadratic term, which comes from the loss's third derivative, is the gradient of the sharpness:The oscillation thus performs gradient descent on the sharpness until and it dies, and progressive sharpeningthe steady rise of the sharpness during training while it is below the threshold; it is observed, and has no accepted explanation pushes back up. The post's Conjecture 1 extends this to any kernel, , under persistent progressive sharpeningwhy: something must keep raising the curvature; without it the run can sit below the threshold and nothing brings it to the edge and a slowly moving Hessianwhy: the threshold of Step 1 is computed for a fixed ; it applies to a real run only if changes little over the updates the kernel remembers; the second fails in practice, since top Hessian eigenvectors turn by about 50° per update.
For Muon the pathspring takes the place of the sharpness, and the same polynomial applies. Freeze the past gradients at update ; the update is then the optimizer operatorthe update as a function of the current weights with past gradients frozen , with . By the chain rule its Jacobian at iswith the derivative of the polar factor at the momentum , a linear map on matrices and the Hessian. The pathspring is , the largest positive real eigenvalue of , defined for why: the definition divides by ; a kernel with no weight on the current gradient makes independent of the current weights. A displacement of the weights changes the momentum by and the update by . Holding and fixed over the kernel's window, a displacement along an eigenvector of with eigenvalue obeysthe recurrence of Step 1 with . So Muon's threshold is , with the same as SGD with that kernel, and the post's Conjecture 2 is that non-adaptive optimizers settle there; for SGD, is the sharpness. The post measures by Arnoldi iterationa Krylov method that finds a few extreme eigenvalues of a large, possibly nonsymmetric matrix using only matrix-vector products on , each product a Hessian-vector product, computed by differentiating once more, without forming followed by a Jacobian-vector product, the first-order change in Muon's update when the momentum moves by , computed by differentiating through the Newton–Schulz iterations that Muon uses to approximate the polar factor: 6 to 13 minutes per value on 8 H100 GPUs.
After a change of learning rate or momentum, the pathspring moves to the new predicted level. The baseline was run at constant through update 2,009 and then changed once: all learning rates halved or doubled (the AdamW ones too, per the code's configs), or lowered to 0.8991 or raised to 0.9751 to halve or double . The measurements spike above the prediction, at times several-fold, and what the law matches is their floor, which the post estimates with a lower envelopea curve through the lowest level around which the measurements repeatedly cluster within a window of 400 updates on each side. In every case the floor moves from the shared prediction to the new one: the post says within a few updates; by my reading of the figures, about two updates after the momentum decrease and a few hundred, approaching from above, after the doubled learning rate. After the momentum increase the floor stays about 10% below the prediction for the 4,000 updates measured, and the mean sits on it; the authors suspect the kernel's doubled memory (mean gradient age 40 updates instead of 20).
The prediction tracks the pathspring through a decaying learning rate and a changing kernel. The post has no theory for a moving target. In the unmodified baseline the prediction rises as decays, and the measurements follow it, about fivefold, to near update 2,700; after that the prediction grows without bound and the measurements level off, because late in a linear decay falls by a large fraction per update, faster than can settle (the authors' explanation). A harder test is the authors' MaxEntSlopthe authors' momentum kernel: the maximum-entropy weights over 256 lags under linear constraints on , , total weight, mean lag and spread, and odd against even lags kernel, maximum-entropy weights under linear constraints that include equal total weight on odd and even lags, ; from update 1,000 its weights move linearly between two such solutions (the code's config). That constraint makes for every (my check), which closes the period-two exit, so the roots that reach the circle first are a nonreal pair. The measured again follows the prediction to about update 2,700, somewhat above it early on (my reading of the figure). MaxEntSlop's speedrun submission, which also changes the weight-decay schedule, takes 3,060 updates instead of 3,250 (190 fewer; the post also says 200); the authors do not recommend it.
Learning rate and momentum together can steer the pathspring along a chosen path. Choosing and so that equals a target should make follow it. With fixed at 0.0125 and the momentum scheduled, the target traced the upper outline of a Bulbasaur drawing over roughly updates 3,500 to 11,500 (read from the figure); most measurements stayed within 15% of it, and the validation loss kept falling. The lower outline, near a quarter of that level, failed: after about 3,000 updates ran to 2 to 10 times the target, the losses stopped falling at about the same time, and a simplified outline and other learning rates also failed. The authors guess that progressive sharpening makes low targets unstable.
Limits and open questions. All runs use one model and data set. What holds Muon at the threshold is unknown: Damian et al.'s argument needs oscillation along a fixed top eigenvector, but only about 25% of Muon's oscillation lies in the span of the top 64 eigenvectors of , and those turn by about 75° per update. With no theory of progressive sharpening, nothing predicts how fast returns or which targets can be reached. The extension to Adam failed: as Bai et al. (2026) found, nearly dead neurons make top eigenvalues a poor measure of its curvature.
Terms
- Edge of stability
- training holds the sharpness at the largest value the learning rate tolerates: for gradient descent
- Momentum kernel
- the weights the momentum puts on past gradients, , with
- Characteristic polynomial
- ; its roots are the growth factors of the modes on a quadratic with
- Bubbleforce
- the first at which a root of reaches the unit circle; 2 for gradient descent, for heavy-ball plus Nesterov
- Self-stabilization
- oscillation along the top eigenvector adds the step , which lowers the sharpness until the oscillation dies (Damian et al.)
- Progressive sharpening
- the observed rise of the sharpness during training below the threshold; no theory yet
- Non-adaptive optimizer
- for a fixed map : SGD, Muon; not Adam
- Pathspring
- largest positive real eigenvalue of ; the sharpness for SGD
- Bubbleforce law
- : conjectured equilibrium, matched by the floor of the measurements in nanoGPT runs
- Lower envelope
- the level the measurements repeatedly return to from above; what the law is compared with
- MaxEntSlop
- maximum-entropy kernel with , which removes the period-two exit at
- Sharpness scheduling
- choosing and so that follows a target path for
Quiz
- MaxEntSlop forces . What does this do to the threshold calculation?At the kernel term is , leaving , so is never a root and the period-two mode cannot be excited. The roots that reach the circle first rotate by some other angle, which makes this kernel a harder test of the law.
- Which part of the gradient-descent story does the post not carry over to Muon?Self-stabilization needs oscillation along a fixed top eigenvector, but only about 25% of Muon's oscillation lies in the top 64 eigenvectors of , and those turn about 75° per update. The threshold and the measurements carry over; the restoring mechanism is an open question.
Sources
- Jeffrey Siedar Cheng and Jack Neo Zheng. bubbleforce: Predicting the Edge-of-Stability for Muon. Blog post, 2026.
- Jeffrey Siedar Cheng and Jack Neo Zheng. bubbleforce. GitHub repository, 2026.
- Jeffrey Siedar Cheng. Track 3: improve Muon with MaxEntSlop momentum and Defazio-style decay. Modded-nanogpt pull request #369, 2026.
- Jeremy M. Cohen et al. Gradient Descent on Neural Networks Typically Occurs at the Edge of Stability. ICLR, 2021.
- Alex Damian, Eshaan Nichani, and Jason D. Lee. Self-Stabilization: The Implicit Bias of Gradient Descent at the Edge of Stability. ICLR, 2023.