CrowdMind/sft-mix-trace-v2

Freaky Labz SFT Mix v2

Four corpora in one dataset: 8,732 synthetic conversations, 2,767 real agent sessions, and both splits of NVIDIA's Nemotron-SFT-SWE-v2 — 46,278 OpenHands software-engineering trajectories and 209,975 single-turn SWE answers. 267,752 rows, 4.18 billion tokens, ms-swift canonical format, one schema throughout.

It is a concatenation and nothing else — no resampling, reweighting or deduplication. All four parts were built to the same schema so this could be a copy rather than a conversion.

part	domain	rows	share of rows	tokens	share of tokens	median row
Nemotron agentless	nemotron_agentless	209,975	78.4%	1.691B	40.5%	6.5k tok
Nemotron openhands_swe	nemotron_swe	46,278	17.3%	2.451B	58.7%	51.4k tok
conversations	not trace_*, not nemotron*	8,732	3.3%	6.20M	0.1%	622 tok
agent traces	trace_<source>	2,767	1.0%	28.80M	0.7%	7.0k tok
total		267,752		4.177B		7.3k

Read that table before you train on it

This is the full Nemotron-SFT-SWE-v2, both splits, plus the two earlier corpora — and that makes it 99.2% software-engineering data by token budget. The behavioural corpus, which is where the refusal, honesty, typo-tolerance and reasoning-discipline persona lives, is 0.1% of the tokens. One epoch over v2 as shipped will teach a model to fix GitHub issues and very little else. That may be exactly what you want; it is not a general assistant.

If you want one model that both behaves and codes, weight it at training time:

# as shipped: 99.2% SWE tokens
--dataset CrowdMind/sft-mix-trace-v2

# stage it — behaviour first, then agent skill on top
--dataset CrowdMind/fred-sft-qwen                 # 6.2M tokens, the persona
--dataset CrowdMind/fred-sft-traces               # 28.8M tokens, pi + Claude Code
--dataset CrowdMind/sft-mix-trace-v2#domain=nemotron_agentless
--dataset CrowdMind/sft-mix-trace-v2#domain=nemotron_swe

# or repeat the two small parts inside one run. They are 0.8% of the token budget
# between them, so this is the factor that gets you to a 50/50 split:
--dataset CrowdMind/sft-mix-trace-v2 \
         CrowdMind/sft-mix-trace-v2#domain=identity \
         CrowdMind/sft-mix-trace-v2#domain=reasoning \
         CrowdMind/sft-mix-trace-v2#domain=mt_plain \
         CrowdMind/sft-mix-trace-v2#domain=mt_ml \
         CrowdMind/sft-mix-trace-v2#domain=mt_tools \
         CrowdMind/sft-mix-trace-v2#domain=mt_tools_ml

domain is the only lever, and it is exact: nemotron_agentless, nemotron_swe, eight trace_<source> values, and 64 conversation domain names.

Length

Built for a 256k context, and it fits: the longest row in the whole mix is 189k tokens, so every row sits inside the window without truncation. The distribution is bimodal, because it is two datasets — short single-turn answers and long trajectories.

approx tokens per row	rows	share
median	7,344
over 8k	121,600	45.4%
over 16k	63,843	23.8%
over 32k	44,186	16.5%
over 64k	8,643	3.2%
over 128k	25	0.0%
over 256k	0	0%

At --max_length 262144 nothing is dropped. --max_length 131072 drops 25 rows and is the setting to reach for by default: 16.5% of rows are over 32k, and paying attention cost on all of them to save 25 rows is a bad trade. --max_length 65536 is the throughput choice if you would rather train faster and accept losing 3.2%.

The practical constraint here is compute, not context.

Format

Same eleven columns everywhere.

• Tool calls are rendered into the assistant turn in Qwen's native XML, with the structured form in tool_calls_json. Qwen3.5's template rebuilds a call with tool_call.arguments|items, so the OpenAI-convention JSON string raises TypeError: Can only get item pairs from a mapping and a trainer that drops rows on template failure loses every tool-using row silently. datasets cannot store a real mapping either — pyarrow's map type is not loadable by datasets — and this template has no tool_call role branch, so there is no representation that is both a genuine mapping after a parquet round-trip and renderable. Every row with calls is verified against what the template produces for the equivalent structured form, byte for byte.
• Three system prompts. Conversations and traces carry the Fred persona. openhands_swe carries the OpenHands agent prompt, because every trajectory was produced under it and it is the only thing that explains str_replace_editor and finish. agentless had no system prompt of its own and gets the Fred persona, which is what its rows describe anyway: reason first, do not state a fact you cannot check. harness says which is which.
• images is empty on every row. No part of this dataset has an image in it.
• agentless is the only part with <think> blocks from the source, because it is the only part that carries reasoning in a field the template understands: 2.73 billion characters of reasoning_content, 72% of that split's text, rendered into <think> so it trains the same way as the rest. openhands_swe has none — its reasoning arrives as calls to a think tool, 124,167 of them — and the conversations and traces are think-heavy with 14% of turns deliberately empty-think.
• difficulty is 0 on every Nemotron and trace row: those conversations were not difficulty-rated, and 0 means "not rated".

The two Nemotron splits

nemotron_swe (46,278 rows, 2.451B tokens) is data/swe.jsonl: real SWE tasks on real repositories, one trajectory each — a GitHub issue, then execute_bash, str_replace_editor, think and finish calls. 2,662,262 tool calls. Median row 51.4k tokens, longest 174k. The same task appears more than once: 35,463 distinct tasks across 46,278 rows, and 5,278 tasks have between two and nine recorded attempts which are different trajectories, not duplicates. Useful for training on recovery after a wrong turn. Nothing was dropped — 45% of the split ends with a visible final text of ## Summary and nothing else, which looks empty and is not, because the summary is in the finish call's message argument. Dropping those on the visible text alone would have discarded 45% of the corpus for nothing.

nemotron_agentless (209,975 rows, 1.691B tokens) is data/agentless.jsonl: single-turn SWE answers. A GitHub issue plus a slice of the repository in, and either the list of files to look at or the patch out. No tools, no system prompt in the source. Median row 6.5k tokens, longest 54k. One row dropped, for an empty answer.

Both are not anonymised and not credential-scanned, unlike the other two parts. NVIDIA's publishing pipeline includes a pii_swe_filter stage, both splits are published under cc-by-4.0, and the repository paths are the training signal rather than an identity. The conversations and traces were anonymised — 8,292 ids, 4,410 email addresses, 1,528 ip addresses and 46,950 paths rewritten, 22 sessions dropped for credentials. The difference is deliberate.

One cost worth naming: adding the Fred persona to all 209,975 agentless rows adds 81M tokens, about 2% of this dataset, of the same 1,540 characters repeated. Strip messages[0] and set --system if you would rather not pay it.

Splits

split	rows
train	262,533
validation	5,219

Each part keeps its own selection: ~2% stratified by domain for the conversations and traces, and a stable hash of the row id at 1-in-50 for both Nemotron splits, so the split does not depend on the order rows were read.

Validation

Structural checks run over all 267,752 rows: system first, assistant last, uniform message keys, no residual tool_calls field on a message, every call covered by its own row's tools column, tool_calls_json indices in range and pointing at assistant turns, rendered marker count equal to call count, and no duplicate ids.

The chat-template pass is sampled, because v2 is 4.18 billion tokens and rendering it twice through Jinja would take hours: 15,443 of 267,752 rows (5.8%), comprising every row from the two small parts, an even stride through each Nemotron split, and the 100 longest rows of each. Result: 0 render failures, 3,975 tool rows compared against the template's own structured rendering, 0 differences. Thirty rows across the whole dataset have more tool-call markers in their text than they have calls, because the source text quotes tool-call markup — reported here rather than hidden; it is 0.01% and it is the data, not the rendering.

Loading it

from datasets import load_dataset

ds = load_dataset("CrowdMind/sft-mix-trace-v2")
print(ds["train"][0]["messages"][-1]["content"])

conversations = ds["train"].filter(lambda r: r["domain"][:1] not in ("t", "n"))
traces        = ds["train"].filter(lambda r: r["domain"].startswith("trace_"))
swe           = ds["train"].filter(lambda r: r["domain"] == "nemotron_swe")
agentless     = ds["train"].filter(lambda r: r["domain"] == "nemotron_agentless")

3.4 GB. The parquet is written in batched row groups rather than as one table: a single-row-group file with a nested messages column at this size cannot be read by datasets at all (ArrowNotImplementedError: Nested data conversions not implemented for chunked array outputs), which is a property of how pyarrow hands the column back, not of the data.

Training it

CUDA_VISIBLE_DEVICES=0 swift sft \
  --model Qwen/Qwen3.5-4B \
  --dataset CrowdMind/sft-mix-trace-v2 \
  --train_type lora \
  --max_length 131072 \
  --loss_scale default+ignore_empty_think \
  --num_train_epochs 1 \
  --per_device_train_batch_size 1 \
  --gradient_accumulation_steps 16 \
  --learning_rate 1e-4 \
  --lora_rank 16 \
  --lora_alpha 32 \
  --target_modules all-linear \
  --output_dir output

• --max_length 131072 drops 25 of 267,752 rows. Go to 262144 to keep those, or down to 65536 to train 3x faster and lose 3.2% of rows.
• #domain=nemotron_agentless is the half whose rows are mostly under 16k, if you want a cheap first pass; #domain=nemotron_swe is the trajectory half and is where the long rows are.
• --loss_scale ignore_empty_think matters for the conversations, the traces and agentless. It does nothing for openhands_swe, which has no think blocks.
• Packing is pointless: the median row is already 7k tokens, so there is little to pack and a lot of padding to avoid.

Provenance and licence

Three provenances in one file:

• Conversations are synthetic and fully invented, on the reserved .test domain, no real credentials or personal data.
• Traces are other people's published agent sessions, redistributed after anonymisation with 22 credential-bearing sessions removed. Check each source's licence: the code, prose and tool output belong to the people who recorded them.
• Nemotron is NVIDIA's published dataset, redistributed as published under cc-by-4.0. It is real SWE work on real open-source repositories, and the issues, patches and repository contents in it are theirs.

other for this mix as a whole, because it aggregates all three.

The Fred persona is the one real-world surface in three of the four parts. Strip messages[0] and set --system if you would rather not train it.