Where the model is fragile.

One number per Linear, over four orders of magnitude.

The sensitivity of a Linear is the trace of its KL-Fisher block: the energy of the gradient of the end-to-end KL objective with respect to its weights, averaged over calibration tokens. It is a property of the model and the calibration text only — no format has been chosen yet, and nothing has been quantized. Two things are worth noticing immediately.

• The spread is enormous. On the Qwen3.6-27B panel the most sensitive Linear is roughly 10^4.8 times more sensitive than the least. That is why the ramp below is logarithmic; on a linear scale a handful of matrices would saturate and everything else would read as identical black.
• The structure is not uniform, and not obvious. Sensitivity varies down the depth of the network and across projection types, and the pattern is not the one most rules of thumb assume. This is the concrete reason a single format applied everywhere leaves quality on the table.

What a model knows specifically, it keeps in its extremes.

The distribution above is not merely wide, it is concentrated. On the Qwen3.6-27B panel, the five most sensitive Linears — one percent of the model's matrices, 351 MB of a 23.6 GB checkpoint — carry 13.9% of its total measured sensitivity. Half of all sensitivity lives in 88 of 496 Linears. The most sensitive matrix is 45× the median and 58,000× the least sensitive one.

That concentration is the whole reason this project exists, and it is also the reason quantization can go quietly wrong. A general capability is carried redundantly and survives almost anything; a specific one — the distinction between two similar tokens at one decision point, the sharp preference that fires a tool call instead of a paragraph — is carried by a small number of large values, and those are exactly the values a coarse format rounds away. Averages are built to be insensitive to extremes. Quantization damage is not.

The same shape recurs one level down, inside a single matrix: a handful of large-magnitude weights and a few activation channels dominate the error a format makes. That is what a per-16-value FP8 block scale in NVFP4 is for, and it is why the production render solves for the clipping point (joint_scale_opt) rather than assuming one — where you put the top of the scale is the decision about which outliers survive.

Stated precisely, so the picture is not oversold: the per-Linear concentration above is measured, on this page, from the cost stage's own artifact. The outlier structure of the inputs is measured here too — switch the panel to Activation magnitudes and the caption carries the numbers. The per-channel structure inside a single matrix is the one granularity this page does not draw; what PrismaQuant measures at that level is the consequence: what a given format actually costs at a given position, which is the next view.

Sensitivity is not cost. Cost is sensitivity times what the format breaks.

Switch the panel above to Cost of a format and the same grid changes meaning. Each cell is no longer "how fragile is this Linear" but "what does this particular rung cost, applied here" — the quantity the knapsack actually spends its budget against. Drag the format slider from the cheapest rung to the most expensive and watch the heat drain out of the grid.

The middle view, What the format breaks, is the factor between the two: the cost divided by the sensitivity, which is how badly a rung renders each matrix with the model's own fragility taken back out. It is the quantity most people assume they are looking at when they look at a cost map, and it is worth a minute on its own, because on these artifacts it does not behave the way the folklore says.

• It is nearly flat. Across the Qwen3.6-27B panel, NVFP4's misfit varies about 8× from the best-represented Linear to the worst — against 10^4.8 of sensitivity. Scale-adaptive formats carry a per-group scale, so their relative error is close to a property of the format rather than of the matrix. The cost map is therefore mostly a restatement of the sensitivity map, and the exact figures are computed from the loaded artifact and printed under the panel.
• What variation there is runs the wrong way. The rank correlation between sensitivity and misfit is negative on every rung of both panels — about −0.35 for NVFP4 on that panel, and as strong as −0.63 on the FP8 codebook rungs. The most fragile Linears in the model are, if anything, slightly easier to represent than the average one.

Those two facts together are the answer to the obvious objection — surely a very sensitive matrix cannot be squeezed into four bits. It can, and routinely is. Fragility says how much a given amount of damage matters; it says almost nothing about how much damage a format will actually do. Only the product decides, and only bytes decide what the product is worth paying.

The Qwen3.6-27B menu here is the codebook lane's on-plan rungs — the FP8 codebook sizes that are multiples of four. The cost stage swept every intermediate K as well, because measuring one more costs almost nothing, but pricing a rung the lane does not intend to offer would invite you to allocate against a menu that does not exist. Some earlier artifacts did ship on off-plan sizes; their maps in the explorer draw exactly what they shipped.

A necessary caveat about what these three datasets are, because they are not the same objective. The Qwen3-4B panel is the AURA objective, where the price is the KL-adjoint projection directly and the sensitivity term is already inside it; its weight deltas are round-to-nearest rather than the production render, so it is the cost stage's shape, not a shipped artifact's. The Qwen3.6-27B panel is the older render-score objective, where the price is formed explicitly as ½ · sensitivity · weight error. The Qwen3.8-27B panel is the newest, and is the only one whose price is not purely weight-space: it adds the activation-side term described in the next section. All three are upstream of any byte budget — nothing on this panel is itself an allocation.

What a weight-space map cannot see: the activations.

Every quantity on the two older panels is a weight-space quantity. On the render-score panel the cost is literally ½ · h_trace · weight_mse: the sensitivity of the weights times the error the format makes in the weights. The AURA adjoint is not that product, but it is weight-space in the same sense — it prices dW and never dX. But NVFP4 as vLLM serves it is W4A4: it quantizes the activations flowing through the Linear as well as the Linear itself. None of that damage appears anywhere in this field, and the consequence is sharper than "the estimate is a bit off."

The clean demonstration is a pair of formats that differ only on the activation side. NVFP4 quantizes weights to 4 bits and activations to 4 bits; NVFP4A16 quantizes the same weights the same way and leaves activations at 16. Rendered on the live format registry, the two produce weights that are bit-identical — maximum absolute difference exactly 0.0. So every number on this page is the same for both, they are assigned the same predicted Δloss and the same 4.500 bits per parameter, and the allocator is not merely biased between them: it is exactly indifferent. One of them perturbs activations and the other does not, and the cost model cannot tell you which is which.

That is the sense in which a Linear can be quantized perfectly and still be the wrong decision. The weight render can be optimal — the best 4-bit approximation of that matrix that exists, scales solved, error minimised — and the served model can still be worse than the map predicts, because a second error channel was opened at the same moment and nothing measured it. It is also the reason the misfit view above is as flat as it is: a real part of what a format breaks is not in the picture being drawn.

AQUA-AURA is the workstream that closes this: price the activation term explicitly — cost = E_w + E_a rather than a fudge factor on E_w — using per-output-channel Fisher and per-input-channel activation statistics the probe already records, so no new measurement pass is required. As of 14 August 2026 it has produced an artifact: Qwen3.8-27B-PrismaAQUA-5.5bit-vllm, whose cost stage is the Qwen3.8-27B panel above. That panel is the first on this site whose price is not weight-space, and it lets the size of the blind spot be read off rather than argued about.

What this is not. The weight-only allocation in that comparison was never rendered, exported or served — it exists as a solve. So this establishes that the blind spot changed the decision, on one model, at one budget; it does not establish that the activation-aware allocation is better served. There is no served A/B between the two arms, and until there is, the quality of the published artifact is evidence about that artifact and not about the method that chose it. The 84.5% is likewise a property of this cost stage's own estimate of the activation term, not an independently measured share of real damage. Every other allocation in the explorer was chosen under the weight-space blind spot described above.

And then the budget decides.

The third view, What shipped, drops the published artifact's actual per-Linear allocation onto the identical grid — same projections, same layers, same cells — so the two can be read against each other. They are not the same picture, because a knapsack spends where the cost per byte saved is best, not where the cost is highest.

That difference is disorienting the first time, so the view now explains itself. The ten most sensitive Linears are ringed and numbered on the map, so where the hot cells landed is visible at a glance; every cell reports its format, its size on disk and its sensitivity rank on hover; and the caption beneath computes the census live from whichever pair is loaded. On the Qwen3.8-27B panel — the one whose cost stage literally produced its allocation — the caption goes one step further and prices the obvious counterfactual in the allocator's own currency. The readings below are the pattern to expect.

• At the top, the allocation does track sensitivity. On the Qwen3.6-27B panel the eleven most sensitive Linears all shipped at FP8 or BF16; the first NVFP4 appears at rank 12 of 496. The two white cells in the heat view — layer 0's linear-attention output projection and layer 63's mlp.down_proj — are ranks 1 and 2, and both shipped FP8.
• They did not get BF16, and that is the interesting part. Moving those two from NVFP4 to FP8 already removes about 13× of the error. Buying the rest costs a second full copy of the tensor — 31 MB and 89 MB — for a remainder smaller than what the same bytes buy elsewhere in the model. The knapsack equalises marginal cost per byte; it does not rank matrices by fragility and protect from the top down.
• And most of the BF16 went to the coldest Linears in the model. 54 of the 57 BF16 cells are in_proj_a / in_proj_b, which sit between rank 402 and rank 480 — near the bottom of the sensitivity distribution. They are 0.5 MB each. Leaving all 54 untouched costs 0.11% of the checkpoint, so there was nothing to gain by quantizing them. That is the single most counterintuitive stripe on the map, and it is not an error: it is the cost model correctly noticing that a tiny tensor is free to protect.
• And why the flips are overwhelmingly NVFP4 → FP8, almost never → BF16. On the three-format menu, FP8 is about 92% of the way to BF16: at the median Linear it removes 91.7% of the 4-bit error on the Qwen3.8 field and 92.2% on the Qwen3.6 field, leaving BF16 only the last ~8% to buy — and the FP8 step costs 3.5 extra bits per parameter where BF16's remainder costs 8 more. Multiply the two and a cell's second upgrade pays roughly 25× worse per byte than its own first one, so the budget buys first upgrades nearly everywhere before it buys a second one anywhere. Eight bits already carries most of the descriptive power; the FP8-heavy map is the picture of that fact.

Both readings are checks you can run on this page. One more mechanism to know about before calling a ring an anomaly: q, k and v serve from one packed tensor, so they must share one format, and a 3 MB v_proj rides whatever its 35 MB q_proj group-mate justifies — on the Qwen3.8-27B panel that is exactly why rank 8 sits at NVFP4. If the shipped map ever stops tracking sensitivity at the top and the deviation is not explained by size or by a fused group, that is a real defect worth chasing — the readouts exist so that question has an answer instead of an impression.

To be exact about the pairing, which differs by panel. On Qwen3.6-27B this is the same model but not the same solve: the cost panel is a render-score field over the codebook menu, while the shipped PrismaAURA checkpoint beside it was allocated on the AURA-adjoint objective over the three-format menu. That overlay shows how a cost field and an allocation relate on one model's geometry; it is not a literal input and its output. On Qwen3.8-27B it is: that cost stage is the file the allocator read, and the map beside it is the checkpoint published from the solve it produced.

One consequence is worth pulling out, because it is the argument for this whole approach in a single pair of cells. In the Qwen3.8-27B allocation, the linear-attention block's input projection in_proj_qkv is mostly 4-bit — 34 of its 48 layers at NVFP4 — while out_proj, the projection on the way out of the same block, is mostly 8-bit, 37 of 48 at FP8. Same block, same layer, adjacent in the graph, and they land two formats apart. Nothing about the shapes says that should happen. It came out of measurement, and a uniform recipe has no way to express it.