Vox MENS — Qwen3-8B adapter

8B 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

A larger rung for machines with plenty of memory, such as a high-end laptop or a workstation. It suits edits that touch several files and designs that need a longer chain of reasoning about types. Back off to the middle size when memory is short; there is one bigger rung above it for the hardest work. The measured training peak for 8B is 49374 MiB (peak_source: run_summary), and no serving memory figure has been measured for it.

Examples

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

Fixed humaneval_vox_042_reverse_list

Return a new list with the elements in reverse order.

Qwen3-8B base on humaneval_vox_042_reverse_list: type errors (count 1).

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

8B adapter on humaneval_vox_042_reverse_list: passes.

fn reverse_list(xs: List[int]) to List[int] {
  xs.reverse()
}

Fixed humaneval_vox_069_binary_search

Search for target in a sorted list xs using binary search.
Return the index of target if found, or -1 if not found.

Qwen3-8B base on humaneval_vox_069_binary_search: type errors (count 2).

fn binary_search(xs: list[int], target: int) to Result[int] {
    let mut left: int = 0
    let mut right: int = xs.len() - 1

    while left <= right {
        let mid: int = (left + right) / 2
        let mid_val: int = xs[mid]

        if mid_val == target {
            return Ok(mid)
        } else if mid_val < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }

    return Error(-1)
}

8B adapter on humaneval_vox_069_binary_search: passes.

fn binary_search(xs: List[int], target: int) to int {
  let mut left = 0
  let mut right = len(xs) - 1
  while left <= right {
    let mid = (left + right) / 2
    if xs[mid] == target {
      return mid
    } else if xs[mid] < target {
      left = mid + 1
    } else {
      right = mid - 1
    }
  }
  return -1
}

Still fails test_smoke

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

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

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

8B adapter on test_smoke: type errors (count 1).

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

Use it

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

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

vox mens serve loads the 8B 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 8B adapter cannot be loaded with transformers or PEFT.

Results

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

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

Training

8B ran 138 optimizer steps over 2711427 tokens, ended with a final loss (EMA) of 0.5129, a mean train loss of 0.7057 and a last-epoch validation loss of 0.6570, took 12h 03m and peaked at 49374 MiB, from Vox commit 448df0192; the settings every size shares are on the docs page.

Files

The 8B 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.