Vox MENS — Qwen3-0.6B adapter

0.6B is trained, its spoke is vox-lang and its gate is needs re-gate: its collateral report is out of date for the current rule: “slice vox_think was scored on 21a201449c03a7fc02ddff45e7a65df537b4ec3f1733bbbaee39e84e378c6102, expected 73b4219a9becdb67e9753cabfcca099804d79a41e3f2e7035c40507612f0957c (re-run vox mens eval-collateral-damage for this size)”.

Why this size

The smallest rung, aimed at machines with very little memory, including CPU-only boxes. It suits quick completions and short single-function edits where reply time matters more than depth. Step up when it loses the thread of a multi-step task; there is no smaller size to step down to. The measured training peak for 0.6B is 15321 MiB (peak_source: run_summary), and no serving memory figure has been measured for it.

Examples

For 0.6B, the examples are the 2 shortest items the adapter fixes and the shortest it still fails; of 52 items it fixes 11 and breaks 2.

Fixed test_smoke

write a test named `smoke` that calls `add(1, 2)` and asserts the result equals 3

Qwen3-0.6B base on test_smoke: type errors (count 1).

@test fn smoke() {
    let result = add(1, 2);
    assert(result == 3);
}

0.6B adapter on test_smoke: passes.

fn add(a: int, b: int) to int {
    return a + b
}

@test
fn smoke() {
    assert(add(1, 2) is 3)
}

Fixed humaneval_vox_041_nth_prime

Return the nth prime number (1-indexed). nth_prime(1) = 2, nth_prime(2) = 3, nth_prime(3) = 5.

Qwen3-0.6B base on humaneval_vox_041_nth_prime: type errors (count 1).

fn nth_prime(n: usize) to usize {
    let result = if n == 1 {
        2
    } else {
        // Find the nth prime number
        // This is a simplified version for demonstration purposes
        // Actual implementation would use a prime-checking algorithm
        // For the purpose of this example, we return 5 for n=3
        5
    };
    return result
}

0.6B adapter on humaneval_vox_041_nth_prime: passes.

fn nth_prime(n: int) to int {
    let mut i = 2
    while i * i <= n {
        if n % i == 0 {
            return i
        }
        i = i + 1
    }
    return n + 1
}

Still fails humaneval_vox_042_reverse_list

Return a new list with the elements in reverse order.

Qwen3-0.6B base on humaneval_vox_042_reverse_list: passes.

fn reverse_list(input: list) to list {
    return input
}

0.6B adapter on humaneval_vox_042_reverse_list: type errors (count 3).

fn reverse_list(lst: list[int]) to list[int] {
    return list.rev(lst)
}

Use it

The 0.6B adapter sits on the base pin Qwen/Qwen3-0.6B@c1899de289a04d12100db370d81485cdf75e47ca, and this command downloads it after checking the BLAKE3 hash of every file in hf_sync_manifest.json.

vox mens hub pull --size 0.6B --namespace brbrainerd --allow-ungated

vox mens serve loads the 0.6B adapter only from a run directory that holds a passing collateral report and a passing gate_receipt.json, so the pull needs --allow-ungated and no serving example is given.

The docs page explains why the 0.6B adapter cannot be loaded with transformers or PEFT.

Results

The 0.6B rows compare the base model with the adapter on identical items.

The release gate record for 0.6B is gate_receipt.json.

Training

0.6B ran 138 optimizer steps over 2740235 tokens, ended with a final loss (EMA) of 0.7491, a mean train loss of 0.9337 and a last-epoch validation loss of 0.9182, took 2h 29m and peaked at 15321 MiB, from Vox commit 4fa847889; the settings every size shares are on the docs page.

Files

The 0.6B repository holds candle_qlora_adapter.safetensors, the adapter, training and gate manifests and records, evidence/, and hf_sync_manifest.json with the BLAKE3 hash of every file.

This card is generated by vox mens hub sync; the ladder index lists the other sizes and how the cards are made is on the docs page.