Vox MENS — Qwen3-4B adapter

4B 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 middle rung, sized for a workstation or a laptop with a generous unified memory budget. It is the everyday choice for writing and editing several related functions in one pass. Climb when a change spans files, or drop down when memory runs tight. The measured training peak for 4B is 34460 MiB (peak_source: run_summary), and no serving memory figure has been measured for it.

Examples

For 4B, 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 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-4B base on humaneval_vox_041_nth_prime: does not parse (count 3).

fn nth_prime(n: int) to Result[int] {
    // Check if n is a positive integer
    if n <= 0 {
        return Error("n must be a positive integer")
    }

    // Start with the first prime number (2)
    let candidate: int = 2
    let count: int = 1

    // Generate primes until we find the nth one
    while count < n {
        // Check if candidate is a prime
        let is_prime: bool = true
        for i in 2..candidate {
            if candidate % i == 0 {
                is_prime = false
                break
            }
        }

        // If candidate is prime, increment count
        if is_prime {
            count += 1
        }

        // Move to next candidate
        candidate += 1
    }

    // Return the nth prime number
    return Ok(candidate)
}

4B adapter on humaneval_vox_041_nth_prime: passes.

fn nth_prime(n: int) to int {
  if n == 1 { return 2 }
  if n == 2 { return 3 }
  if n == 3 { return 5 }
  let mut count = 3
  let mut candidate = 5
  while true {
    if is_prime(candidate) {
      count += 1
      if count == n { return candidate }
    }
    candidate += 2
  }
}

fn is_prime(n: int) to bool {
  if n <= 1 { return false }
  if n == 2 { return true }
  if n % 2 == 0 { return false }
  let mut i = 3
  while i * i <= n {
    if n % i == 0 { return false }
    i += 2
  }
  return true
}

Fixed mutation_update

define a mutation named `update_item` that takes an integer `id` and a string `title` and updates the item with the matching id

Qwen3-4B base on mutation_update: does not parse (count 3).

mutation update_item(id: int, title: str) to Result[Unit] {
    // Assume we have a database table named 'items'
    // This is a simplified example; in a real application, you would use a database query
    let result = query update_item_query(id: id, title: title) with { retries: 1, timeout: "5s" }
    return result
}

query update_item_query(id: int, title: str) to Result[Unit] {
    // This is a placeholder for the actual database query
    // In a real application, you would use a database client to update the item
    return Ok(())
}

4B adapter on mutation_update: passes.

mutation update_item(id: int, title: str) to int { return 0 }

Still fails humaneval_vox_042_reverse_list

Return a new list with the elements in reverse order.

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

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

4B adapter on humaneval_vox_042_reverse_list: type errors (count 4).

fn reverse_list(items: List[int]) to List[int] {
  let mut result = List[int]();
  for i in items {
    result = result.push(i);
  }
  return result;
}

Use it

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

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

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

Results

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

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

Training

4B ran 138 optimizer steps over 67134 tokens, ended with a final loss (EMA) of 0.5435, a mean train loss of 0.5226 and a last-epoch validation loss of 0.6971, took 0h 23m and peaked at 34460 MiB, from Vox commit 3ec31a00f; the settings every size shares are on the docs page.

Files

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