centre-for-swe/MindForge-27B-Training-Trajectories

MindForge: Whole-Life-Cycle Program Synthesis Trajectories

Data release for MindForge: Teaching Small Language Models Whole-Life-Cycle Software Engineering via Source-Free Program Synthesis (arXiv:2607.27146).

MindForge converts open-source command-line programs into source-free ("cleanroom") environments that expose only a compiled reference executable and its sanitized documentation. A teacher agent (GLM-5.2, driven by mini-swe-agent) must elicit the specification by probing the binary, design an architecture, implement it from scratch, and iterate to a passing build. The agent never sees the original source and doesn't have access to the internet.

Contents

File	Description
frontier.surgical.messages_only.jsonl	SFT training data: 1,001 complete program-synthesis trajectories
mindforge_instances.jsonl	Index of all 1,124 cleanroom environment images (562 programs + 562 coverage counterparts)
recipe.sh	Training recipe (ms-swift + Megatron backend)

Dataset format

One trajectory per line, in ms-swift message format:

{"messages": [{"role": "system", "content": "..."},
              {"role": "user", "content": "..."},
              {"role": "assistant", "content": "<think>...</think>\n\n..."},
              {"role": "tool_call", "content": "{\"name\": \"bash\", \"arguments\": {...}}"},
              {"role": "tool", "content": "..."}],
 "tools": "[{\"type\": \"function\", \"function\": {\"name\": \"bash\", ...}}]"}

Assistant reasoning is inlined in <think> tags. Only assistant reasoning, natural language, and tool-call tokens are trained on; system/user messages and tool outputs are masked. With --max_length 262144, 973 of the 1,001 trajectories fall inside the training length budget.

Trajectory statistics

Statistic	Turns	Tokens
Mean	181.6	177K
Median	176	182K
Min	39	37K
Max	477	272K

Software-engineering activity coverage across the 1,001 trajectories:

Software-engineering activity	Coverage
Spec exploration	99.1%
Design	87.1%
Implementation	99.7%
Bug localization	59.4%
Bug fixing	62.6%
Verification	83.7%
Refinement	64.2%

Environments on Docker Hub

The 562 cleanroom images used to collect these trajectories are published as tags on superskyyy/mindforge-clis, one tag per program, named <owner>__<repo>.<commit> (e.g. 01mf02__jaq.9616019). Each image contains only the compiled reference executable and its sanitized public documentation.

Each of the 562 also has a coverage counterpart tag, suffixed -coverage (e.g. 01mf02__jaq.9616019-coverage), which rebuilds the same pinned commit with native coverage instrumentation (go build -cover for Go, -C instrument-coverage for Rust, gcov for C/C++) so that an agent's recorded ./executable invocations can be replayed to measure how much of the reference implementation it actually exercised.

docker pull superskyyy/mindforge-clis:01mf02__jaq.9616019
docker pull superskyyy/mindforge-clis:01mf02__jaq.9616019-coverage

Environment index (mindforge_instances.jsonl)

mindforge_instances.jsonl lists all 1,124 published tags (the 562 programs and their 562 -coverage counterparts), one JSON object per line, so environments can be enumerated and pulled programmatically without querying Docker Hub:

{"instance_id": "01mf02__jaq.9616019", "docker_image": "docker.io/superskyyy/mindforge-clis:01mf02__jaq.9616019"}
{"instance_id": "01mf02__jaq.9616019-coverage", "docker_image": "docker.io/superskyyy/mindforge-clis:01mf02__jaq.9616019-coverage"}

For example, to pull every non-coverage environment:

grep -v -- '-coverage"' mindforge_instances.jsonl \
  | python3 -c "import sys,json;[print(json.loads(l)['docker_image']) for l in sys.stdin]" \
  | xargs -P4 -n1 docker pull

The 562 programs span six compiled languages: Go (231, 41.1%), Rust (212, 37.7%), C (87, 15.5%), C++ (29, 5.2%), Swift (2, 0.4%), and TypeScript (1, 0.2%). They are drawn from repositories disjoint from ProgramBench.

SFT results

Fine-tuning Qwen/Qwen3.6-27B on this data (full-parameter SFT, 8 epochs, bf16) yields MindForge-27B.

ProgramBench (200 instances, average test pass rate)

Model	PassRate (%)
GLM-5.2 (teacher)	64.60
GPT-5.5	56.50
Claude Opus 4.7	51.38
MindForge-27B	49.51
Sonnet 4.6	47.97
GPT-5.4	38.08
Qwen3.6-27B (base)	37.98

37.98% --> 49.51%, +11.53 points absolute, +30.4% relative, reaching frontier-model territory at 27B. The gain is broad, not driven by outliers: MindForge-27B scores strictly higher than the base model on 152 of 200 tasks, lower on 43, and ties on 5.

Generalization to unseen benchmarks

MindForge-27B improves over its base model on all seven out-of-distribution benchmarks (none used during training):

Benchmark	Base	MindForge-27B	Gain
RepoZero-C2Rust	47.00	78.00	+31.00
DeepSWE	1.76	15.92	+14.16 (9.0×)
NL2Repo (w/ tests)	61.27	71.97	+10.70
SWE-bench Pro	45.41	51.34	+5.93
SWE-bench Multilingual	62.55	67.77	+5.22
SWE-bench Verified	68.80	73.84	+5.04
FeatBench	50.10	55.05	+4.94
NL2Repo (w/o tests)	18.92	23.48	+4.56

Behavioral changes

Fine-tuning increases the model's level of interaction with the environment: mean turns increase from 344.0 to 735.7, and tool calls from 174.4 to 373.0. At the same time, the command failure rate decreases from 10.98% to 9.35%. The model also more often follows its reasoning with a concrete code change, with editing after reasoning increasing from 27.8% to 50.1% and editing after failure recovery from 31.8% to 48.8%.

Replaying agent invocations against the -coverage images shows the fine-tuned model explores the reference binary more thoroughly before reimplementing it: 58.39% mean line coverage of the reference implementation vs. 49.34% for the base model (medians 66.47% vs. 52.14%), higher on 154 of 200 instances and lower on only 11.

Training

See recipe.sh. Key settings: full fine-tune of Qwen/Qwen3.6-27B (LLM weights trainable, vision tower frozen), ms-swift with Megatron backend, TP4 × CP4, sequence packing, max_length 262144, micro-batch 1, global batch 96, 8 epochs, AdamW (β = 0.9/0.98, weight decay 0.04), peak LR 4e-5 with 10% warmup and cosine decay to 4e-6, grad clip 1.0, seed 1105.

Citation

@misc{chen2026mindforgeteachingsmalllanguage,
      title={MindForge: Teaching Small Language Models Whole-Life-Cycle Software Engineering via Source-Free Program Synthesis},
      author={Yihao Chen and Shi Chang and Khaled Chawa and Feng Lin and Boyuan Chen and Shaowei Wang and Ahmed E. Hassan},
      year={2026},
      eprint={2607.27146},
      archivePrefix={arXiv},
      primaryClass={cs.SE},
      url={https://arxiv.org/abs/2607.27146},
}

License

Trajectories are released under the MIT license. The underlying programs remain under their own upstream licenses; each instance is pinned to a specific owner/repo@commit recoverable from its image tag.