§0The patient

§1The echo saga — 66% of responses scored without containing a guess

Before any result, the cautionary tale that reshaped the whole lab's grading: the first overnight sweep produced a clean leaderboard (top config 14-15 + 17-18 ×2 at 0.40 vs baseline 0.19, t=7.5, ~30 configs beating baseline at t≥2), encouraging, and substantially fake.

The grader took the last integer in each response. But on hard mental math, a model that won't commit often just echoes the question: "We are asked: 'What is 8273645928374659 plus 9384756192847362?'" and never emits a guess. The parser grabbed an input number, the partial-credit scorer rewarded its digit-overlap with the answer, and 66% of the overnight responses scored on echo alone, with no actual model guess in them. observation The leaderboard was partly measuring prose-emission rate.

The fix (regrade_no_echo.py) blocklists each prompt's own integers and re-scores:

De-contamination grew the effect. interpretation The baseline had been quietly scoring on echo too; removing the cheating widened the real gap. The signal was hiding under the baseline's contamination. (This is the canonical echo case the methods writeup generalizes — every partial-credit grader on free text needs this check.)

§2Two mechanisms, opposite directions, equal lift

With the grading fixed, two different surgeries produce the same-size improvement by doing opposite things.

• prune_9 — t = +5.13. Delete layer 9 and the model gets better at mental math.
• 17_21_x2 — t = +5.06. Amplify the layers-17–20 circuit (duplicate it) and the model gets better at mental math.

Two distinct interventions (one additive, one subtractive) converge on a similar outcome. Strict baseline 0.025 → both land near 0.17 (prune_9 0.175, 17_21_x2 0.165). Composing them is not additive interpretation, which fits their reaching the same capability rather than stacking independent gains. The way to see why is a per-layer capability fingerprint: run every layer's duplication and every layer's prune, and plot the two t-statistics together. The map is sharply structured, not a smear:

Two things jump out. No single layer reproduces the 17_21_x2 block (+5.06): the strongest single-layer dup is L13 at +3.4, so the circuit is a genuine multi-layer unit, not one hot layer riding the rest. And L14 is load-bearing in both directions: duplicating it is among the largest single-layer gains (+3.1) while pruning it is catastrophic (−2.0, the model falls back to tool-calls). You want more of it, and you can't take it away.

You can read the anatomy off the failure modes

Each prune breaks the model in a characteristically different way:

• prune_9 produces terse, direct equations: 8273645928374659 + 9384756192847362 = 17658401121221921 — no wrappers, and on add_huge a single seed landed one digit off. Its m|g (score given a guess) is the highest of any config, ~0.90. interpretation Layer 9 was apparently spending capacity on output-formatting overhead at the cost of accuracy; removing it recovers the latent arithmetic.
• RYS duplicates produce wrapped answers: <p>... = 17658120711221801</p> — clean-looking structure, but 4–5 digit errors. Their lift is rate-dominated (the model commits more often) with a smaller accuracy gain.
• prune_14 produces tool-call attempts (<function=calculate-product>): remove it and the model falls back to its tool-use training. The "I can do this internally" nickname fits the failure mode, but that label is a hypothesis the behaviour invites, not a role we localized.
• prune_18 produces preamble without execution: "I'll calculate the sum… Let me do this carefully…" then nothing. Read as a hypothesis, L18 looks like a "follow-through to an answer" circuit (the most "anxious little model" failure of all). (Same caveat: the nickname is what the failure suggests, not a measured function.)

§3The control test: the model already knew (it mostly wouldn't say)

This control recolours everything above. The natural reading of "surgery improved mental math" is the surgery added arithmetic capability. A control test says mostly no.

Force the bare baseline to commit: logit-bias the <think> token to −100 and stop on the reasoning-wrapper strings, so it physically cannot open a deliberation. The bare model's m|g then jumps to 0.522, within reach of the unbiased top-RYS m|g of 0.58. In other words: when you make the untouched model answer instead of letting it stall, its guesses are nearly as good as the surgically-boosted model's. Most of Nanbeige's "no-CoT badness" was unwillingness to commit, not poor intuition. observation (And the mechanical-damage configs stay broken under bias: 5_6_x2 still craters, so this isn't an artifact of the bias itself. Layer-5–7 damage is structural, not a policy effect.)

So the RYS lift decomposes. Using overall = rate × m|g (rate = fraction that actually guess; m|g = quality given a guess):

The forced-commit row is n=1, from the biased singles phase: forcing the bare model to answer barely moved the rate (0.194→0.244) yet lifted quality to m|g 0.522, nearly top-RYS's 0.582. So what suppression was hiding was mostly intuition the model already had, not just the willingness to use it. One caveat on m|g itself: it's conditional on the answers the model actually emits, so it's a selection effect, not a pure capability measure: if surgery makes the model commit more often, the extra answers it ventures may be systematically harder ones, which would if anything understate the gap.

Both axes lift ~3×. The rate lift is a compliance story: the surgery makes the model stop narrating and commit. The m|g lift can't be compliance: when the surgical model does guess, its guesses are individually closer. So there's a real residual: a small genuine-computation component (the 0.52 → 0.58 gap) riding on a large willingness-to-commit component. So the headline isn't "surgery taught it math"; it's "surgery mostly unlocked intuition the model already had, and sharpened it a little."

What the model is doing when it succeeds is worth naming, because it isn't arithmetic. On add_huge (truth 17,658,402,121,222,021) the top config guessed 17,658,121,721,212,121: first five digits exact, right magnitude, right digit count, plausible tail. It can't be memorizing 17-digit sums; the simplest reading is magnitude pattern-matching: what eight-quadrillion-plus-nine-quadrillion looks like. That's the mental-estimation skill no-CoT probing is meant to elicit, and surgery in the 13–22 band appears to sharpen it.

§4The disconnect (why this isn't shippable yet)

Now the caveat, and the reason there's no GGUF attached. The no-CoT sweep measures intuition under suppressed deliberation. That is not the same axis as "is this a better model to chat with," and they can move in opposite directions.

Spin up the 17_21_x2 GGUF and talk to it in normal thinking mode, and it drives more thinking tokens, sometimes to worse answers: it got 47 × 83 wrong while spending ~6× more thinking than baseline (697 vs 112 reasoning tokens). observation The surgery that makes the model commit a good gut answer when forbidden to think can, when it is allowed to think, push it into longer, escape-proof deliberation loops. (prune_9_10_21's zero-token "just answer" reflex is the opposite failure — fast but fragile, breaking on novel framings.) The no-CoT win and the chat-quality outcome are orthogonal, and you can't assume one buys the other.

This is the kind of result I'm not willing to paper over. The phase-3 work reframes the metric to efficiency (score per thinking-token) and adds the missing axes — easy-math (does it preserve trivial ability?), EQ (did a useful "doubt circuit" get removed?), and conversational sanity (did we make a math autoencoder?). Until those land, and until the whole thing re-runs on the v4 battery for cross-model comparability, the responsible claim is bounded:

On no-CoT arithmetic intuition, two opposite surgeries each produce a real lift — t ≈ +5 apiece — mostly by unlocking commitment and partly by sharpening magnitude-intuition — and it is not yet shown that this transfers to deployed chat behaviour.

§5What this specimen contributes

• Two mechanisms, one effect size. Removing an overhead layer (prune_9) and amplifying a circuit (17_21_x2) give equal lift. Composing them is not super-additive (prune_9 + 17_21_x2 + 21_22_x2, t≈+5.27, barely above either alone) → they reach overlapping capability, not independent gains.
• Prune is a first-class, independent intervention, not the inverse of dup — certain layers (9, output-overhead) carry computation the model is better off without. The prune-rescue asymmetry recurs across the whole lab (E4B, Granite).
• The willingness/capability decomposition (rate × m|g + the biased baseline) separates "made it commit" from "made it smarter," and on this model the answer is "mostly the former, a little of the latter." This is the cross-model through-line: Nanbeige's unwillingness, MiniCPM-V's indecision tax, the 26B's colon-stall are the same disease in three architectures.
• The failure-mode gallery shows layer roles are legible by how the model breaks, not just by the score.

Caveats

This is a preliminary result from ongoing model exploration, not an exhaustive or cross-model comparable finding. The no-CoT math lift is one axis: easy-math, EQ, CoT efficiency, and chat quality are unmeasured or still in-flight, and the v4-battery re-run (Phase 2) is what would extend this into a cross-model comparison. Until then, read it as a single-model result.

• All numbers are Q8 / May-2026 battery and point-in-time from memory.
• Publish framing (locked in the plan): documented result + reproducible tooling, not "custom model." Any uploaded GGUF is a representative variant, never "best." Credit chain: Nanbeige → David Ng (technique + probe design) → this lab (the inferential layer). License Apache-2.0 from base.
• Engine: llama.cpp / llama-server, build-on-demand GGUFs via layer_path.py, -fa on, Q8_0 KV cache. De-echo + magnitude regrade via regrade_no_echo.py. Closed-think prefill forces no-CoT.