A system prompt collects rules the way a codebase collects flags: one at a time, each one clearly reasonable. Graded individually by code — no model in the judging loop — compliance decays gently, about 0.92× per added rule. The chance of getting every rule right in one response does not decay; it collapses. At eight simultaneous rules, models still satisfy each one about 41% of the time and satisfy all eight 5.7% of the time.
Drag the number of simultaneous rules. The upper curve is the average per-rule pass rate; the lower one is the share of responses where every rule held at once — which is the only thing a deployment cares about, because a response that breaks one rule is a broken response. The gap between them is not a measurement artefact. It is what multiplication does to numbers slightly below one.
The measured pair at eight rules is 40.7% per rule against 5.7% for the whole response — a 35-point gap. Below four rules the two curves are close enough that a per-rule dashboard looks like a fair summary of the system. Past six it stops being one, and nothing in a per-rule metric tells you when you crossed over.
The paper defines a compositional half-life: the smallest number of simultaneous rules at which fewer than half of responses satisfy all of them. It is a more useful number than an average, and it is small. Step through the panel — the bar is the per-rule rate, the dot is the all-pass rate, and the distance between them is the compositionality penalty.
Scale does not predict this. One model ranks second at a single rule with a 90.5% pass rate and eleventh overall once rules are composed; another ranks sixth at one rule and third overall. And the token budget moves it on its own — the same reasoning-heavy model at 16,384 output tokens instead of 4,096 jumps from tenth place to second with no change in its compositional capacity, because chain-of-thought was eating the budget the answer needed.
Not every rule degrades at the same rate, and the pattern is not about difficulty. What predicts a rule's decay is the gap between understanding it and maintaining it — the paper scores partial compliance too, so a rule the model clearly grasps but drifts away from mid-response shows a large gap. Counting words has a 50-point gap. Emitting valid JSON has a gap of 0.2 points and is effectively immune. Step through the families.
The intuitive story is that rules fight each other: the format rule crowds out the length rule, some pairs are incompatible in the model's head. If that were true you could fix it by choosing rules that get along. The paper measures the pairwise coupling across 601 rule pairs and finds it almost absent. Flip between the two worlds.
The few pairs that do couple share an output feature rather than competing for attention: produce the wrong number of sentences and every sentence-dependent rule fails together. Grouping by shared output feature separates coupled from uncoupled pairs at p < 10⁻⁶; grouping by the paper's own categories does not reach significance. Near-independence is exactly why the decay is predictable to a fifth of a point — and exactly why re-pairing or re-ordering your rules buys nothing.
If the collapse is set by per-rule reliability, then restructuring the prompt should do nothing and buying extra attempts should buy a bounded improvement. That is the prediction, and it is what happens. Step through what was tried.
The instructive number is in the retry row. Five independent generations, with the draws near-fully distinct, deliver roughly two-fifths of the lift that independent resampling predicts: the model repeats the same failure across draws. Both facts hold at once — which rules fail inside one response is close to independent, which is what makes the collapse multiplicative, while whether a given prompt fails at all is largely deterministic across attempts.
Set the number of hard rules in your prompt and the per-rule reliability you believe you have, and read off the share of responses where every one of them holds. The multiplicative model is the paper's; the two inputs are yours. The retry row applies the measured two-fifths realisation rather than the arithmetic ideal.
The lever that works is not in this widget, because it is not a runtime setting: fewer rules per call. Split the response into two calls with three rules each and you are multiplying two numbers instead of six — and the paper's own deployment note is that a system reliable at three rules can fail badly at five.