Vox MENS — Qwen3-32B adapter

32B is trained, its spoke is vox-lang and its gate is passed.

Why this size

The largest rung, sized for high-memory unified workstations and studio GPUs. It handles the deepest cross-file reasoning, architectural refactors, and multi-module Vox synthesis without a cluster. Step down to the next smaller rung whenever available memory or decode latency is tight. The measured training peak for 32B is 101635 MiB (peak_source: run_summary), and no serving memory figure has been measured for it.

Examples

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

Fixed test_smoke

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

Qwen3-32B base on test_smoke: does not parse (count 1).

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

@test
fn smoke() to Result[Unit] {
  let result = add(1, 2)
  assert result is 3
  Ok(())
}

32B 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_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-32B base on humaneval_vox_069_binary_search: type errors (count 4).

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

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

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

  return -1
}

32B 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] is target {
            return mid
        }
        if xs[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return -1
}

Still fails humaneval_vox_042_reverse_list

Return a new list with the elements in reverse order.

Qwen3-32B base on humaneval_vox_042_reverse_list: type errors (count 4).

fn reverse_list(xs: List[int]) to List[int] {
  let mut result = List[int]();
  for x in xs {
    result.insert(0, x);
  }
  return result;
}

32B adapter on humaneval_vox_042_reverse_list: type errors (count 1).

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

Use it

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

vox mens hub pull --size 32B --namespace brbrainerd

The pull writes the 32B run directory that this command serves.

vox mens serve --model mens/runs/qwen3-32b --port 11435

This request sends the user turn of held-out item page_index to the 32B server, which applies its codegen lane to it.

curl -s http://127.0.0.1:11435/v1/chat/completions -H 'Content-Type: application/json' -d @- <<'JSON'
{
  "lane": "codegen",
  "messages": [
    {
      "role": "user",
      "content": "Write a Vox program that: define a page named `IndexPage` with a title 'Home' that displays a heading with the text 'Welcome'"
    }
  ],
  "max_tokens": 1024,
  "temperature": 0.0
}
JSON

The code below is the 32B adapter's recorded output for item page_index in the held-out evaluation, taken from evidence/heldout_adapter_nothink.ckpt.jsonl, where the codegen lane's prompt protocol qwen3_non_thinking_codegen_v1 wrapped the same user turn and every stored check passed; it is not a transcript of vox mens serve.

component IndexPage() {
    view: heading(level=1) { "Welcome" }
}

Results

The 32B rows compare the base model with the adapter on identical items, and a slice p-value below 0.05 would mean the adapter lost ground on that slice.

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

Training

32B ran 168 optimizer steps over 1185861 tokens, ended with a final loss (EMA) of 0.7682, a mean train loss of 0.6644 and a last-epoch validation loss of 0.5461, took 12h 14m and peaked at 101635 MiB, from Vox commit b2ce949b4; the settings every size shares are on the docs page.

Files

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