Reading this card
The card names the machines the work ran on by their hardware. The records behind its figures (graded files, run
reports, logs) are kept privately with the project, so the card does not cite them.
Table with columns: name, what it is| name | what it is |
|---|
| the 3090 Ti workstation | the project's main workstation. NixOS; Intel Core i7-12700KF (20 threads); 46 GiB RAM; one NVIDIA RTX 3090 Ti, 24 GB. It holds the files of record and grades the answers. The full-precision merge was computed on its CPU and checked on its card. |
| the 4090 workstation | a second workstation with an NVIDIA RTX 4090, 24 GB. It verified training rows for the earlier corpora. |
| the H100 | rented cloud GPUs: one NVIDIA H100 80 GB per droplet (DigitalOcean gpu-h100x1-80gb). wollf-v9-q38 was trained on one, and the grades of record on this card were generated on one: heldout-v3.3 and agentic-v1 in one window (2026-10-27), heldout-v4.2 in two (2026-11-01). The merge's sanity check ran on the 3090 Ti workstation's card. |
Serving profiles: rented-card is one llama-server on the rented card, the whole model on the GPU,
llama.cpp 6f4f53f2b. A profile is an instrument of its own (greedy decoding diverges between devices at near-tie
tokens), so every comparison below reads models served in the same window on the same card.
Headline: the hardest held-out wolf tiers
heldout-v4.2, T3 (40 one-rule wolf tasks), pass@3: a median of 32 of 40 over three seeds (32, 35, 32), against
wollf-v7sf3's 16 and the untrained base's 9. T4 (20 closeouts: repair a program to a named rule), pass@3: 20 of 20
on every seed, against 14 and 4. Clean scores equal the full ones: none of the 60 T3 and T4 items is tagged for
overlap with public text or with a training row.
Table with columns: heldout-v4.2, pass@3 (behave@1), n, bar, Qwen3.8-27B base, wollf-v7sf3, seeds 1 / 2 / 3, wollf-v9-q38, seeds 1 / 2 / 3| heldout-v4.2, pass@3 (behave@1) | n | bar | Qwen3.8-27B base | wollf-v7sf3, seeds 1 / 2 / 3 | wollf-v9-q38, seeds 1 / 2 / 3 |
|---|
| T3, one-rule tasks | 40 | 16 (band 4) | 9 (8) | 14 (4) / 17 (4) / 16 (3), median 16 | 32 (31) / 35 (31) / 32 (31), median 32 · c32/40 |
| T4, closeouts | 20 | 14 (band 4) | 4 (3) | 12 (11) / 16 (11) / 14 (11), median 14 | 20 (20) / 20 (20) / 20 (20) · c20/20 |
| T3 and T4 items tagged | | | | | 0 of 60 |
How to read it:
- The bars are wollf-v7sf3's medians and the bands its seed spread, fixed by a reading rule committed before any
v4.2 answer existed. A tier gates only when the previous model's median
sits between 25 % and 75 % of the tier and both untrained bases sit below it by more than the band. T3 and T4 met
that rule; T2 (40 library items) did not, so it is not reported as a grade, and wollf-v9-q38 was not run on it. The
Qwen3.6-27B base reads 4 (2) on T3 and 3 (2) on T4.
- T3 measured q38 at +4.0, +4.75 and +4.0 bands above v7sf3's median. Every q38 seed sits above the highest seed of
its sibling
wollf-v9-q36 (Qwen3.6-27B on the same data and recipe: 24, 26, 28). T3's 40 items are heldout-v4.1's,
byte for byte. v4.1 was the pilot that chose them, so T3 is not a fresh sample of the tier.
- T4 is at its ceiling for both models trained on corpus-v9: it separates them from v7sf3 and the bases, but it
cannot rank them against each other or against a better model. The greedy T4 answers are small repairs of the given
program (a median similarity of 0.93 to it), not rewrites; v7sf3's sit at 0.62 to the reference.
- Seeds are decoding seeds (20261027, 20261028, 20261029; k = 3, one sample at temperature 0 and two at 0.6 / top-p
0.95), not training seeds: there is one wollf-v9-q38 training.
- wollf-v9-q38 was trained on 2026-10-26. heldout-v4.1 was sealed on 2026-10-29 and v4.2 on 2026-10-30, so the model
could not have seen the items. The sealed guard finds 0 collisions between the training file and v4.2's 936 texts.
The instrument is heldout-v4.2: 140 wolf items in four tiers plus heldout-v3.3's 136
general items. T1 is heldout-v3.3's 40 wolf programs, read as the regression guard on its own bars (next section).
Wolf answers are built and tested by the pinned wolf 0.2.35 compiler in a networkless rootless container; pass is
behaviour (the fixed tests, main exiting 0, the item's rules), and formatting is reported beside it, never gating
(fmt@1 39–40 of 40 on T3 and 20 of 20 on T4 for every q38 run).
The regression guard: heldout-v3.3
heldout-v3.3 is heldout-v3.2 with the 13 items that had near-twin rows in the previous training file replaced by
fresh ones. Its 40 wolf programs are v4.2's T1, read against the bars set on v3.2 and inherited unchanged.
All three models below were served in one H100 window (rented-card, 2026-10-27; k = 3, one sample
at temperature 0 and two at 0.6 / top-p 0.95), and wolf was graded at the seal's pin, wolf 0.2.13 / lupin 0.1.36. The
bars were set on the 3090 Ti workstation's single card; here they are read on the rented card. On the 175 items v3.2 and v3.3 share,
v7sf3's rented grade flips no temperature-0 wolf-program verdict against its single-card grade, and one general item
each way.
Table with columns: heldout-v3.3, behave@1 unless named, bar, band, wollf-v7sf3, wollf-v9-q38, q38 − v7sf3| heldout-v3.3, behave@1 unless named | bar | band | wollf-v7sf3 | wollf-v9-q38 | q38 − v7sf3 |
|---|
| wolf program (40; clean 24) | 30/40 | 5 | 36/40 · c21/24 | 32/40 · c19/24 | −4, inside the band |
| wolf program compile@1 | 33/40 | 3 | 38/40 · c23/24 | 35/40 · c21/24 | −3, inside |
| wolf program run@1 | 34/40 | 3 | 39/40 · c23/24 | 37/40 · c23/24 | −2, inside |
| wolf program pass@3 | 32/40 | 4 | 37/40 · c22/24 | 36/40 · c22/24 | −1, inside |
| wolf diagnose acc@1 (12; clean 10) | none (reported) | 3 | 4/12 · c4/10 | 7/12 · c5/10 | +3 |
| general (136; clean 124) | 122/136 | 4 | 129/136 · c118/124 | 133/136 · c121/124 | +4, at the band |
| python (25; clean 22) | 23/25 | 1 | 25/25 · c22/22 | 25/25 · c22/22 | 0 |
| C (25; clean 25) | 18/25 | 2 | 23/25 · c23/25 | 23/25 · c23/25 | 0 |
| javascript (86; clean 77) | 76/86 | 3 | 81/86 · c73/77 | 85/86 · c76/77 | +4, above the band |
| js word-split class (42; clean 40) | 32/42 | 2 | 38/42 · c36/40 | 41/42 · c39/40 | +3, above the band |
| bars cleared | | | 9/9 | 9/9 | |
c k/n is the clean score: the same metric on the items not tagged for overlap (30
of 188 tagged, 19 for public wolffe-lang text and 11 for public benchmark suites, none for a training row). The bars
are read on the full leg. On v3.3 wollf-v9-q38 ties v7sf3 on every gated wolf leg, inside each band, and is ahead on
javascript and its word-split class. The wolf-program figure is lower by four at temperature 0: v3.3's wolf items are
graded at wolf 0.2.13, and corpus-v9 taught the language at 0.2.35; under the 0.2.34 compiler (one item whose
reference the newer toolchain rejects left out for every model) the wolf-program behave@1 reads 31 for q38 against
v7sf3's 32. The 16 tagged wolf programs share text with the public wolffe-lang repositories, which corpus-v9 trains
on directly; the clean score leaves them out.
The untrained Qwen3.8-27B base was not graded on v3.3. On heldout-v3.1 (the 3090 Ti workstation, single card, 2026-09-15) it scored 0
of 40 on every wolf-program leg, 3 of 12 on diagnose and 129 of 136 on general (python 25, C 19, javascript 85, class
41). v3.1 differs from v3.3 by 26 items, so these sit beside the
table, not in it.
Agentic use: a diagnostic, not a grade
agentic-v1 drives a model through opencode on eight sealed mini projects under a 60-turn budget and scores the
projects' own acceptance rows. In the 2026-10-27 window (51 of 72 sessions ran to their end; the 21 lost were the same
for every model):
Table with columns: agentic-v1 (51 sessions), score, rows passed of 372, sessions with a green build, whole-file rewrite rate, sessions circling "cannot compile this yet", failed std calls| agentic-v1 (51 sessions) | score | rows passed of 372 | sessions with a green build | whole-file rewrite rate | sessions circling "cannot compile this yet" | failed std calls |
|---|
| wollf-v7sf3 | 0.058 | 20 | 3 of 17 | 0.27 | 12 | 14 |
| wollf-v9-q38 | 0.009 | 6 | 5 of 17 | 0.10 | 2 | 1 |
The caveat: the instrument cannot rank these models. The same v7sf3 GGUF scored 0.012 in an earlier window on the
same flags, a move of 0.046 against a within-window spread of 0.028, and a later version of the instrument, measuring
v7sf3 against itself, was unreadable at both turn budgets it tried. The project uses agentic results as
a regression diagnostic only, never to rank models. Read the behaviour columns as what they are: q38 rewrote less,
circled the compiler's refusals in fewer sessions and failed fewer standard-library calls, and most sessions of every
model still ended at the turn budget with the project unfinished (12 of 17 for q38, 15 of 17 for v7sf3). Both untrained
bases scored 0.000.
The general leg
General coding is measured by heldout-v3.3's 136 general items above: wollf-v9-q38 reads 133 of 136 (c121/124), four
above v7sf3 in the same window, every general bar cleared. The twelve-suite general instrument (HumanEval+, MBPP+,
MultiPL-E, IFEval and eight more) was not run on wollf-v9-q38; v7sf3's numbers on it, on another base, are in
v7sf3's own card.
Using it
Table with columns: file, what it is| file | what it is |
|---|
model-000{01..18}-of-00018.safetensors (18 shards), model.safetensors.index.json, config.json, generation_config.json, the tokenizer files (tokenizer.json, tokenizer_config.json, vocab.json, merges.txt, chat_template.jinja) and the processor files (processor_config.json, preprocessor_config.json, video_preprocessor_config.json) | the full-precision merge: the adapter merged into the bf16 base, in bf16. Load it with transformers (5.5.0; the architecture is the base's Qwen3_5ForConditionalGeneration) |
adapter/adapter_model.safetensors, adapter/adapter_config.json | the QLoRA adapter itself (r 32), for PEFT on Qwen/Qwen3.8-27B at revision 1d4bf0f2…. It is in a subfolder so that transformers loads the merge from the root rather than the adapter |
wollf-v9-q38-Q6_K_L.gguf | the GGUF every number on this card was graded on, for llama.cpp |
wollf-v9-q38-Q8_0.gguf | a Q8_0 made on the 3090 Ti workstation from the merge, 29.0 GB; checked against the Q6_K_L, not graded (see "Measured: the merged weights") |
LICENSE | Qwen's license file for the base revision, unchanged (see License) |
The model was graded with this system line: "You are a careful programmer. Answer with a single complete code block
unless the task asks for a short answer." Thinking was off (enable_thinking: false in the chat template's
arguments). Training used no system turn and a sequence length of 16,384 tokens. The chat template is the base's
(Qwen3.8-27B's own, unchanged). The base's vision inputs were never trained or tested.
The model
Table | |
|---|
| name | wollf-v9-q38 (its sibling on Qwen3.6-27B is wollf-v9-q36) |
| base | Qwen/Qwen3.8-27B, revision 1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0 |
| recipe | v7sf3's recipe, with the sequence length raised: QLoRA r32 / α32 on q/k/v/o/gate/up/down, dropout 0; 4-bit NF4 base with double quantization, bf16 compute; sequence 16,384; 2 epochs; lr 2e-4 linear, warmup 0.03; adamw_8bit, weight decay 0.01; batch 1 × gradient accumulation 8; on-GPU recompute; seed 20260914. Its training config differs from wollf-v9-q36's only in the base. |
| run | 4,506 steps, 33,835 s (9.4 h, 7.51 s/it), 25,067,748 tokens, peak 58,179 MiB, loss 2.3233 → 0.3337 (epoch-2 mean 0.3275), on one H100 80 GB (DigitalOcean) with the fast path (fla 0.5.2 + causal-conv1d 1.7.0; 48 of 48 linear-attention modules on the fused kernels, no fallback). Stack: torch 2.11.0+cu128, transformers 5.5.0, peft 0.20.0, trl 0.24.0, unsloth 2026.8.21, llama.cpp 6f4f53f2b. |
| data | corpus-v9, sha256 654100ab7b82312023ee2e6e3af649346d84dae4b327bd9dac5476c4c0d8c498, 18,018 rows, published as the dataset's release config byte for byte (see Training data). |
| weights | the Q6_K_L graded everywhere: wollf-v9-q38-Q6_K_L.gguf, 23,046,833,280 B, sha256 7161dffa41d852a078fcee16853afe1c40a21b8e631986b53f2efbae6c576b90, merged and quantized on the training card. The adapter: adapter_model.safetensors sha256 df494e0bba0dc37345206c85327ecb9818c77c1e062220828ecceab75603623c, 637,610,624 B; the release copy of its adapter_config.json names Qwen/Qwen3.8-27B as its base. The full-precision merge, computed on the 3090 Ti workstation's CPU, and the Q8_0 made from it: see "Measured: the merged weights". |
| grade toolchain | heldout-v4.2: wolf 0.2.35 in a networkless container. heldout-v3.3: wolf 0.2.13 (pin 4cc3dcd) / lupin 0.1.36 (pin a7f517e), the pin v3.3 was sealed at. |
Training data
The training mix is published as the dataset's release config. It is the same file byte for byte (654100ab…,
18,018 rows, 66,761,232 B), so this card's data sha is the dataset's, and the dataset card is its datasheet. Half the
rows are wolf, half general, by rows. The composition, read from the file's own meta fields:
Table with columns: part, rows, where the rows come from, license of the source| part | rows | where the rows come from | license of the source |
|---|
| wolf: the previous corpus, re-verified | 2,290 | corpus-v7's wolf rows re-verified at wolf 0.2.35 (teachers qwen3-coder:30b 1,009, Qwen3.6-35B-A3B 968, GLM-4.7-Flash 313), less the 24 rows that carried a held-out item's solution | wolffe-lang text under the wolf Training Data Permission; teacher outputs Apache-2.0 (Qwen), MIT (GLM) |
| wolf: the repositories | 4,350 | module, test and edit rows from 17 pinned wolffe-lang repositories (3,799 module-level, 551 commit edits rendered as edit traces), each build-checked at its pin | GPL-3.0-or-later under the wolf Training Data Permission v1.0 (15 repositories); Apache-2.0 (spell, mk) |
| wolf: the standard library | 2,342 | 87 usage and 2,255 reference rows built from a census of every public wolf-std item, each run at the pin (343 of them answered by wollf-v7sf3 and kept only when verified) | wolf-std under the permission |
| wolf: behaviour | 27 | repair probes and verified edits that teach the behaviours the session logs showed (surgical edits, staying on a failing case) | wolffe-lang text under the permission |
| general: CodeAlpaca-20k | 6,715 | the dataset's prompts (444 carried from corpus-v7, 140 of those answered by the Qwen3.6 base and kept when verified; 6,271 new) | CC BY 4.0 (credited in the dataset card) |
| general: glaive-code-assistant | 1,869 | carried from corpus-v7 (158 answered by the Qwen3.6 base and kept when verified) | Apache-2.0 |
| general: wollf-node-js | 264 | this project's javascript tasks, answered by Qwen3.6-35B-A3B (30 by the base) and checked under node | Apache-2.0 |
| general: wollf-answer-form | 161 | this project's C prompts, answered by wollf-v7sr and kept only when they compile alone | CC BY 4.0 |
Magicoder: 0 rows; the release rule excludes it from any release mix and passes on this file. The two agentic
mini projects the organization later published with solutions (tomlq, jobq) are on a denylist every corpus source
refuses; corpus-v9 was assembled before they were published, and the published-project guard finds none of their
code in it.
Contamination, measured on the released file: the sealed guard (12-character shingles, Jaccard ≥ 0.5) finds 0
collisions against heldout-v3.3 (512 texts) and heldout-v4.2 (936), and 0 in the agentic-v1 projects; against the
twelve public general suites, 0 exact and 0 near hits, with 39 partial pairs listed in the audit. The row guard, which
reads every row against every held-out item of every version by signature shingles, accepts 330 row–item pairs, all
inside the baseline characterised on the previous corpus, and finds 0 new or grown ones.
Rows that share text with held-out items: the previous training file carried 45 rows that held a held-out item's
solution in substance. corpus-v9 dropped the 24 wolf rows among them and keeps the 21 general rows, byte for byte;
all 19 of those items had been replaced in the instrument (at heldout-v3.2 or v3.3) before wollf-v9-q38 was graded,
so no score on this card reads an item a training row solves. Which rows they are is not published, because naming
them would point at the items.
License
Apache-2.0, matching the base.
- Base notice. wollf-v9-q38 is a modified version of Qwen/Qwen3.8-27B (revision
1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0), Copyright 2026 Alibaba Cloud, licensed under the Apache License,
Version 2.0. QLoRA fine-tuning changed the weights: the adapter, or the adapter merged into the base and quantized.
This repository carries Qwen's LICENSE file for that revision unchanged. The base repository has no NOTICE file.
"Qwen" names the origin and nothing more.
- Training data is corpus-v9, with 0 Magicoder rows. Its licenses by component are in the table above and in the
dataset card. The wolf Training Data Permission v1.0 says a trained model's weights and outputs are not a work based
on the wolffe-lang text. Model outputs used as answers (the teachers', the base's own, and the earlier wollf
models') carry no restriction on outputs.
- The dataset is published under CC BY 4.0, with attribution to wolffe-lang, CodeAlpaca 20K, glaive-code-assistant
and the Apache-2.0 notices of spell and mk in its card.
Measured: the merged weights
The release's safetensors are a merge computed on the 3090 Ti workstation's CPU (2026-11-01), not the training card's:
the droplet merged on its GPU to quantize, and that merge was never shipped. The merge script read the adapter and the bf16
base (Qwen3.8-27B at 1d4bf0f2…, fetched from the Hub and held to its LFS record, every file read twice) one shard at
a time, with the merge of record's arithmetic (W + scaling·B@A in float32, cast to bf16), on six cores in 10 minutes
at a peak of 7.2 GiB. The script's verify step read it back from disk: 256 modules merged once each and all 256 changed;
the other 943 of 1,199 tensors byte-identical to the base's; four sampled rows of every merged tensor within one bf16
ulp of a float64 reference (worst 0.97), five elements inside float32's slack under cancellation.
18 shards, 55,562,855,904 B of tensors, every file's sha read twice by the
build and three times by the stage.
From the merge, on the 3090 Ti workstation (llama.cpp 6f4f53f2b, the training card's commit): a bf16 GGUF of 54,657,733,760 B, the
training card's master size exactly; a Q6_K_L of 23,046,833,280 B; and the Q8_0 in this repository, 29,047,084,160 B
(sha256 8fb36c236aad255c…). The merge's own Q6_K_L is not the one of record and is not published: its sha differs
(7532e9f5… against 7161dffa…), its metadata is identical, and 824 of its 866 tensors are byte-identical to the one of
record. The 42 that differ are 38 ssm_a tensors, which the converter derives from A_log, a tensor this merge leaves
byte-identical to the base (for v7sf3 such differences were one float32 ulp, a different CPU's exp the likely cause;
not re-measured here), and four merged FFN tensors (ffn_gate ×2, ffn_up, ffn_down), where float32 arithmetic on a
CPU against the training card's GPU before the bf16 cast is the likely cause, not measured further.
The sanity check. Each form answered the first eight heldout-v4.2 T3 items at temperature 0 under the grading
protocol, on the 3090 Ti workstation's card, and the answers were graded by v4.2's own grader:
Table with columns: answered by, served as, byte-identical to, identical, behave@1| answered by, served as | byte-identical to | identical | behave@1 |
|---|
| the Q6_K_L of record, the 3090 Ti, whole on the card | its own grading answers on the H100 | 7 of 8 | 5 of 8, the same items |
| the merge's Q6_K_L, the 3090 Ti, whole on the card | the Q6_K_L of record, same profile | 7 of 8 | 5 of 8, the same items |
| the merge's Q6_K_L, the 3090 Ti, whole on the card | the H100 grading answers | 8 of 8 | 5 of 8, the same items |
| the merge's Q8_0, the 3090 Ti, 52 of 65 layers on the card | the Q6_K_L of record, same profile | 4 of 8 | 5 of 8, the same items |
| the Q6_K_L of record, 52 layers on the card | itself, whole on the card | 5 of 8 | 5 of 8, the same items |
So the merge regenerates the graded answers wherever the quantization is the same (the merge's Q6_K_L reproduces the
H100 answers on all eight), and no behave@1 verdict moves anywhere. The Q8_0 changes the greedy text of four answers,
but the offload split alone changes three answers of the Q6 of record, so that difference is the size of a near-tie,
not of a change in what the model does. Where answers differ, only one item's compile and run verdicts move (it fails
its behaviour either way). Eight items is a sanity check, not a grade: the Q8_0 and the safetensors were not graded on
an instrument.
Not measured
- The bf16 weights served as bf16 (54.7 GB fits neither the 3090 Ti workstation's card nor its RAM), and the merge or its Q8_0 on any
instrument: they were checked against the Q6_K_L of record on eight items, not graded.
- The twelve-suite general instrument, on any form of wollf-v9-q38.
- heldout-v4.2's T2, and T3/T4 beyond three decoding seeds of one training. There is one training of q38.
- The untrained Qwen3.8-27B base on heldout-v3.3.
- Contexts past the 16,384 training tokens, thinking on, image or video inputs, other system prompts, prompts in
languages other than English, and safety or misuse behavior. None was evaluated.
- The language past wolf 0.2.35, the pin the corpus was verified at.
Known limits
- T4 is at its ceiling (20 of 20 on every seed): it cannot rank wollf-v9-q38 against a better model.
- On heldout-v3.3's wolf programs at the 0.2.13 pin, q38 reads four below v7sf3 at temperature 0, inside the band of
five; the gap is one item under the 0.2.34 diagnostic. The instrument of record cannot tell a cost from pin drift
at that size.
- Agentic use is unsolved: most sessions end at the turn budget, and q38 finished with a green build in 5 of 17. The
behaviour columns moved the right way; the outcome did not.
- Diagnose (predict the toolchain's verdict) is 7 of 12, reported and not gated.
- The heldout's own blind spots (the toolchain's envelope, prescribed behaviors) are in its design notes, kept
private with the items.