cb_thinking_nemotron_v4

See also sammshen/cb_thinking_multihop, the companion dataset with the same stored/measured protocol and a gold answer for the turn after the reasoning is dropped (research-then-ask over MultiHop-RAG, 1,309 rows, measured requests of 22K tokens at the median, 98% at a new position). This dataset has no gold: its turns sit behind earlier conversation turns, which is the historied case (79% at a new position), and its next-turn answers are references for a paired comparison only.

A filtered view of the knowledge_agent subset of nvidia/Nemotron-SFT-Agentic-v4 (OpenMDW-1.1) for evaluating non-prefix KV-cache reuse when a model's earlier reasoning is dropped from the conversation: the request that produced an agent turn carried the turn's reasoning; the next request carries the same turn without it, so everything the turn wrote or received after the reasoning sits at a new position.

Why this pattern, and why real data

A thinking model writes reasoning before its visible answer and tool calls. Inside one turn that reasoning stays in the prompt across the model's own tool calls. When the next user message arrives, most chat templates and serving stacks drop the reasoning of the finished turn, and the user turn is rendered directly after the turn's visible output. The KV cache of that output was computed behind the reasoning; in the next request it sits a few hundred to a few thousand tokens earlier. Prefix caching cannot serve it; position-independent (non-prefix) reuse can. This dataset exists so that claim can be tested on turns a real agent pipeline produced, with their own recorded reasoning, rather than on a contrived layout.

Dropping the finished turn's reasoning is the documented default of the installed base, on both sides of the market:

• Open-weight chat templates. Qwen3's model card states that the history carries no thinking content (Qwen/Qwen3-32B; template walk-through: Qwen3 chat template deep dive). Rendering a marked five-message conversation through each model's own chat_template.jinja (fetched 2026-11-13) shows the same rule in Qwen3 and Qwen3.6 (preserve_thinking opt-in), GLM-4.7, GLM-5.1 and GLM-5.2 (clear_thinking defaults to true), Kimi K2 Thinking and Kimi K2.6 (preserve_thinking opt-in), MiniMax-M2.5, gpt-oss (harmony; handling raw chain of thought), Nemotron-3 Nano and DeepSeek-R1: the current turn's reasoning is kept across its tool calls and every earlier turn's reasoning is dropped once a new user message arrives.
• Serving engines. vLLM and SGLang return reasoning in a separate field and do not re-inject it; the client has to put it back into the assistant message (vLLM reasoning outputs, vLLM interleaved thinking, SGLang separate reasoning). A standard OpenAI-compatible client does not carry reasoning_content on assistant messages, so for open models served this way the reasoning is dropped on the client side whatever the template says.
• Hosted APIs. Anthropic: Claude Sonnet 4.5, Haiku 4.5 and earlier models strip prior turns' thinking blocks once a non-tool-result user message arrives; Opus 4.5 and models numbered 4.6 and higher keep them (extended thinking). OpenAI: for models released before GPT-5.6 the default is to carry turns over "without rendering reasoning from earlier turns" (reasoning.context: current_turn) (preserved reasoning). DeepSeek: without the tools parameter, "the CoT content from previous turns will not be concatenated into the context in the next turn" (reasoning model guide). OpenRouter preserves reasoning only if the client sends it back (reasoning tokens).

The newest generation flips the default to keep (Qwen3.8 preserve_thinking true, MiniMax-M3, Claude Opus 4.5+, GPT-5.6), but only when the harness resends the reasoning. A result on this dataset therefore speaks for the stripping population: shipped open-weight templates through 2026, hosted APIs before the switch, and any OpenAI-compatible client that does not echo reasoning. When the served model keeps reasoning by default, the measured request must drop it explicitly (template flag or client), and the run should record that choice.

What one row is

One row is one user-turn boundary of one conversation from the source: a support agent with tools over a company's policy documents (search, lookup, verification), with recorded reasoning_content on its assistant messages, generated with Qwen3.5-397B-A17B and GLM-5.2.

• messages[turn_start - 1] is the user message that opens the turn; messages[turn_start:turn_end] is the turn the model generated in answer to it: one or more assistant messages, each with reasoning, tool calls or a reply, interleaved with tool results; messages[turn_end] is the next user message. The messages after it are the recorded answer to that next user message, kept as reference output.
• The stored request is messages[:turn_end] with reasoning_content kept on the turn's assistant messages and removed from all earlier turns (the template being tested had already dropped those when this turn was generated).
• The measured request is messages[:turn_end + 1] with reasoning_content removed from every assistant message. Its shared prefix with the stored request ends at the first reasoning block of the turn; everything after that is at a new position.

def strip(msgs):
    return [{**m, "reasoning_content": None} if m["role"] == "assistant" else m for m in msgs]

stored = strip(msgs[: r["turn_start"]]) + msgs[r["turn_start"] : r["turn_end"]]
measured = strip(msgs[: r["turn_end"] + 1])

Every reasoning block in the turn is removed, so a turn with several tool-call steps shifts in several segments, one per step (segments). CacheBlend reuses whole stored chunks, so a segment counts toward the share only when it is at least 511 tokens (2 x 256 - 1, the length from which a shifted segment is guaranteed to contain one whole 256-token chunk).

Three rows to scale

Each pair of bars is one row: the stored request above, with the turn's reasoning (grey) in place, and the measured request below, with it removed, so every block after the first grey one sits further left. In the first row the turn opens the conversation and three reasoning steps precede three search calls each; 96% of the measured request is at a new position. In the second row an earlier turn (already without its reasoning) sits in the history and is a prefix hit; the share is 63%. In the third row twenty tool-call steps each carry a reasoning block, so the shifted span is cut into twenty segments, and only the ones over 511 tokens count.

Filters

Of the 84,957 source conversations:

1. Two or more user turns, so a boundary exists: 39,162 conversations have one.
2. The turn carries reasoning: 1,455 boundaries had none and were skipped.
3. Share above 50%: the shifted tokens in 511+ segments divided by the whole measured request (tool schema, system prompt, history, turn without its reasoning, next user message). 20,434 boundaries were at or below.
4. Measured request of at least 28,000 tokens, so that every row is a long request: 49,006 boundaries that passed the share test were shorter. Without this floor the same build gives 44,393 rows with a median measured request of 7,393 tokens.
5. One row per conversation, the first boundary that passes all of the above: a later boundary's history contains the earlier boundary's whole measured request, so two rows of one conversation would make each other prefix hits. 42,926 multi-turn conversations had no boundary that passed.

Result: 2,869 rows, one per conversation. 1,228 are the conversation's first boundary; the rest are a later boundary, where the history before the turn is longer (the earlier turns, with their reasoning already dropped) and the length floor is met with it.

Sizes

Tokens are o200k_base; recompute with the served model's tokenizer. Per row, median:

• Stored request: 42,511 tokens, of which 6,065 are the history before the turn (tool schema, system prompt, earlier turns without their reasoning, opening user message), 8,739 the turn's reasoning, and 27,264 the rest of the turn.
• Measured request: 32,889 tokens (p10 28,761, p90 42,965); the next user message adds 81. The shifted span is 27,264 tokens, 25,157 of them tool results (retrieved policy text) and 2,042 written by the model (replies and tool calls); across all rows the model-written part is 8% of the shifted tokens, so this measures the shift of a whole agentic turn rather than of a long answer.
• Longest shifted segment: 6,706 tokens (p10 4,435); every row has a segment of 2,048 or more. Non-prefix share of the measured request: 0.79 (p10 0.55, p90 0.94).
• Reasoning blocks per turn: three or more in 98% of rows (the long turns are the ones with many tool-call steps); every block is a cut in the shifted span.
• Source conversations have 3 user turns at the median (up to 10).

Columns

Column	Meaning
id	<conversation_index>-b<boundary>
uuid	the source conversation's uuid
conversation_index	0-based line number in the source file
boundary	0-based index of the user turn that opens the measured turn
turn_start, turn_end	message indices: the turn is messages[turn_start:turn_end], messages[turn_end] the next user message
n_user_turns	user messages in the source conversation
tools	the source tools list as a JSON string (OpenAI function schema)
messages	source messages up to the end of the recorded answer to the next user message: role, content, reasoning_content, tool_calls (JSON string), tool_call_id, name
prefix_tokens	tool schema, system prompt and history through the opening user message, earlier reasoning removed
think_tokens	reasoning tokens in the turn, all removed at the boundary
span_tokens	tokens in the turn after its first reasoning block, excluding reasoning
segments	the span split at each later reasoning block, in order
span_floor_tokens	tokens in segments of 511+
span_model_tokens, span_tool_tokens	the span's assistant-written tokens (replies, tool calls) and tool-result tokens
next_user_tokens	the next user message
measured_tokens	prefix_tokens + span_tokens + next_user_tokens
share	span_tokens / measured_tokens
share_floor	span_floor_tokens / measured_tokens, the filtered quantity
n_reasoning_blocks	reasoning blocks in the turn, equal to len(segments)

Intended protocol

Send the stored request first so its KV cache is computed with the reasoning in place; then send the measured request as the measurement and compare its output with the same request served without reuse. The next user message's recorded answer (messages[turn_end + 1:]) is a reference, not a gold label; the comparison is between the two serving modes. Concurrency 1 keeps per-request cache counters exact. Rows are independent: no two rows share a conversation, and tool schemas and policy documents differ per company.

Provenance

• Source: nvidia/Nemotron-SFT-Agentic-v4, file data/knowledge_agent.jsonl, revision a4593a26ea83a700035bbe0ec1edc9ef3810669d, OpenMDW-1.1 (the licence text and the source's notices of origin are in LICENSE, as the agreement requires). Synthetic conversations generated by NVIDIA with Qwen3.5-397B-A17B and GLM-5.2; persona grounding from Nemotron-Personas-USA (CC BY 4.0).
• Built with thinking_nemotron.py; figures by plot_thinking_nemotron.py and plot_thinking_examples.py (filter and token counts as described above) and checked with verify_thinking_nemotron.py (ids unique, one row per conversation, the turn carries reasoning, shares recompute from the messages). Build statistics are in stats.json and the drop counts in dropped.json.
• Message text is unchanged from the source. Rows keep the source uuid so any row can be traced back.