Multi-turn thinking collapse on Laguna is history rendering, not depth: stripped 0/10 vs preserved 10/10, and the default client is the stripped arm

[Blackwellboy]

Follow-up to the template trap flagged in the gate-study interpretation update, now measured. Raw + writeup: https://github.com/Blackwellboy/laguna-s21-lab/tree/main/context-mass

The measurement. 15-cell sweep on a Laguna S 2.1 lane (3.25bpw hybrid, vLLM): turn depth {1,5,10,20,40} × context mass {~2K,~8K,~32K} under standard OpenAI-style multi-turn (assistant history = content only). 0/150 thinking firing, flat zero on both axes, against a 45% single-turn C7 baseline on the same lane (18/40, n=40 transfer check). The 276 live history-building turns fired 0/276 themselves: the gate closes at turn 2 of any accumulated session.

Then the comparison arm, identical transcripts, one variable: stripped 0/10 vs preserved 10/10 at depth 10 / ~8K, and again 0/10 vs 10/10 at depth 20 / ~8K. Preserved means the prior assistant turns' reasoning fields are resent; the template then renders real think blocks instead of the empty <think></think> it renders by default. Partial preservation was enough (the d10 history carried reasoning on only 5/10 turns).

Why this happens. The chat template renders every prior assistant turn as <think>{reasoning}</think>{content} when thinking is enabled. No standard client resends reasoning, so every prior turn renders an empty think block, and the model reads N turns of "thought about nothing" as how this conversation works. There is an undocumented preserve_thinking kwarg (it matters for thinking-off flows); with thinking on, resending reasoning on assistant messages is sufficient. vLLM passes the field through (verified: prompt_tokens 63→303 with ~200 tokens attached). Cost: ~250–320 prompt tokens per preserved turn — the turn's reasoning length (+1,615 tokens over 5 preserved turns at d10, +4,764 over 19 at d20).

What this touches in the guide (your call, flagging surfaces):

• §2: the two-axis model is single-turn and stands as merged; multi-turn needs one sentence: firing in accumulated conversations is dominated by whether prior reasoning survives history assembly, not by the prompt axes.
• §5 (agentic): every agent loop that doesn't resend reasoning runs the stripped arm. Agentic-loop data point: thinking off produced zero edits where thinking on produced edits (n=1 pair) #15's ON-arm (kwarg absent, 54 turns, 1,340 reasoning chars total) is consistent with this suppression, not with free choice.
• The Laguna: thinking may be regime-dependent, not simply net-negative (needs review + independent test) #10 "discriminating experiment" (codegen + full agent prompt): the multi-turn arm needs reasoning-resend controlled or it is confounded — it would measure the template, not the regime.
• verify-your-setup: the check generalizes — render the assembled prompt at turn N and grep it for your reasoning marker (our trap-registry Laguna: actionable thinking guidance + setup verification (follow-through on #2) #4 has a three-turn marker check and a preflight script).

Scope. One lane, 3.25bpw hybrid quant; 45% single-turn transfer vs the NVFP4's 60% (overlapping CIs, same task-shape profile). NVFP4 confirmation on the production lane is queued. Replication note: a session cannot bootstrap its own preserved history — once the gate closes there is no reasoning to preserve (our first arm was vacuous exactly this way, 0/50 turns; kept in the raw) — generate history turns statelessly.

---

Housekeeping footnote while I'm in §2's territory: the prompt-identity wrinkle quotes the non-summary C0 prompts as "116 to 124" tokens; from grid_turns.jsonl the actual ranges are 114–125 (code 114–117, math 120–122, reasoning 121–125; summary 286–289, so the ~288-vs-~120 contrast stands untouched).

[Blackwellboy]

Independent confirmation of this mechanism from a different client and serving
stack, measured at the wire. @quantumleap68 put a logging proxy between client
and server (Hermes CLI to vLLM 0.25.1; Laguna NVFP4 TP=1 and FP8 TP=2, N>=6
per cell, all claims read off the wire) and watched the collapse turn-by-turn:
a client that strips reasoning from replayed history produced 199 reasoning
deltas on turn 1 and none on turns 2 and 3. Each replayed prior turn renders
as an empty <think></think>, which is the same stripped arm as the 0/10 vs
10/10 comparison above, observed at the transport layer, on a client neither
of us had run. His client-side fix pattern is the right shape for tooling
authors: opt providers into echoing reasoning on replay via an explicit
capability flag, rather than vendor-sniffing which models need it.

One adjacent finding from the same battery is worth flagging as a separate
hypothesis, not part of this mechanism: he measures thinking collapse
tracking whether the template's trained identity sentence is the literal
first line of the system message. His cells: no system message 8/8 fired;
"You are a helpful assistant." 6/6; full 40K agent prompt 0/8; the same
prompt with the identity sentence prepended first 6-7/8; identity appended at
the end 0/8; spliced mid-sentence 1/6; intact plus one sentence after it 4/6.
A pure prefix prior. If it holds, it touches both section 2 (the prompt-dose
axes would be confounded with first-line identity) and section 5 (every real
agent prompt evicts the identity line). We have a study running on our lanes
to test it independently and will report the result either way; registry
entries are up meanwhile (KNOWN_TEMPLATE_TRAPS #6 identity eviction, #7
reasoning_effort no-op, and trap #4 now carries his turn-by-turn wire
measurement:
https://github.com/Blackwellboy/laguna-s21-lab/blob/main/KNOWN_TEMPLATE_TRAPS.md).

His battery also puts a build split on record: the FP8 and NVFP4 uploads of
this model apply different thinking policies (FP8 skips trivial follow-up
turns under every prompt tried, 1/6 even on a byte-exact replay of a
known-good request shape; NVFP4 reasons essentially every turn), so firing
rates need build and revision attached, including everything in this thread
(all our numbers here are NVFP4-build or the labeled 3.25bpw hybrid).

[Defilan]

Reproduced the rendering half on a different stack, and found one thing that differs in a way that matters for anyone implementing the fix.

Stack: llama.cpp (not vLLM), Laguna S 2.1 Q4_K_M (not 3.25bpw hybrid), Vulkan on gfx1151, poolside GGUF with the corrected fork template. Different runtime, different quant, different template build, so I treated nothing as transferring.

The rendering reproduces exactly. /apply-template, so this is deterministic and repeats byte for byte, no sampling. Three prior assistant turns carrying content only, which is what a standard client sends:

<system>You are a coding agent.</system>
<user>Step 1: what next?</user>
<assistant><think></think>Doing step 1.</assistant>
<user>Step 2: what next?</user>
<assistant><think></think>Doing step 2.</assistant>
<user>Step 3: what next?</user>
<assistant><think></think>Doing step 3.</assistant>

Three turns, three empty think blocks, exactly as you describe.

The part that differs: the field name is runtime-specific. I probed both rather than assume, same transcript, same everything else:

preserved via	rendered result
reasoning_content	3 filled blocks, +180 chars, reasoning text present
reasoning	byte-identical to the stripped arm

You verified vLLM passes reasoning through, at prompt_tokens 63 to 303. On llama.cpp only reasoning_content reaches the template; reasoning is silently dropped. So the remedy does not port by copying the field name. Someone reading #16, adding reasoning to their assistant messages on a llama.cpp lane, and re-measuring would get the stripped arm and conclude the effect does not reproduce.

That is #8's field-name trap one layer down: #8 was reading the reasoning field under the wrong name, this is writing it under the wrong name, and both fail silently by producing absence. Might be worth its own line in your registry, since the read side and the write side have different correct answers on the same two runtimes.

What I have not shown, and am not claiming. All of the above is rendering. I have not demonstrated behavioural suppression on this stack. Your 0/10 vs 10/10 is on your lane, and rendering is necessary for the mechanism but not sufficient to prove the effect here. Our quant, runtime and template build all differ, and I would rather report the mechanism confirmed and the effect untested than round one into the other. That measurement is running now on an idle box; I will post it either way, including if it fails to reproduce.

Why I care about the answer. Our agentic harness strips reasoning from every prior turn except one, deliberately, as a fix for an unrelated 400 from the server rejecting an assistant message with neither content nor tool_calls. So it is structurally the stripped arm, and its coder runs go 4 to 120 turns. If the effect transfers, every one of those has been running with thinking collapsed from turn 2, which is a much larger finding for us than the original 400 ever was.

One methodological note in case it saves someone a wasted arm: your point about a session not being able to bootstrap its own preserved history is the trap I would have walked into. I am generating the history turns statelessly and assembling both arms from identical content, so the only variable between them is whether the reasoning is resent.

[Blackwellboy]

@Defilan thank you. This is exactly the failure mode this thread exists to catch, and you caught it before anyone shipped it.

Correction to the fix as I stated it in the opening post. I wrote that resending reasoning on assistant messages is sufficient. That is true on vLLM (0.25.1, this model's parser; the prompt_tokens 63 to 303 passthrough) and wrong on llama.cpp, where your both-fields probe shows only reasoning_content reaches the template and reasoning is silently dropped, rendering byte for byte identical to the stripped arm. Anyone on llama.cpp who implements the fix with reasoning gets the stripped arm back and will reasonably conclude the effect does not reproduce. The field name is a property of the runtime, not of the fix, and both wrong-field cases fail silently by producing absence rather than an error.

Registry updates, credited to you:

• New entry for the write-side divergence: trap 20, the reasoning write field is runtime-specific, with your same-transcript both-fields probe as the check. It is cross-linked with the read side (trap 01), since as you said the read side and the write side have different correct answers on the same two runtimes.
• Trap 04's fix section now names the field per runtime instead of prescribing reasoning unconditionally, and its stacks section carries your llama.cpp rendering replication (Q4_K_M, Vulkan, deterministic via /apply-template).

The status is labelled the way you drew the line: rendering reproduced on llama.cpp, behavioral suppression on that stack under test, with your commitment to post the result either way noted in the entry. The stateless-history point is in there too; that bootstrap trap cost us a vacuous 0/50 arm before we caught it, so flagging it will save someone a wasted run. Given your harness is structurally the stripped arm across 4 to 120 turn coder runs, your behavioral result is the number I am most interested in seeing in this thread either way.