Vox MENS — Qwen3-8B adapter

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

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 36356 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 8 and breaks 0.

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.

// Search for target in a sorted list xs using binary search.
// Return the index of target if found, or -1 if not found.
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
}

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-8B base on mutation_update: does not parse (count 1).

mutation update_item(id: int, title: str) to Result[Unit] {
    // Assume we have a database table named `items` with fields `id` and `title`
    // This is a simplified example; in a real application, you would use a database connection
    let updated = db.update("items", { id: id, title: title })?
    return Ok(())
}

8B adapter on mutation_update: passes.

mutation update_item(id: int, title: str) to Result[str] {
    return Ok("updated")
}

Still fails 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: type errors (count 1).

// Return a new list with the elements in reverse order.
fn reverse_list(xs: list[int]) to list[int] {
    return xs.reverse()
}

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

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

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

This request sends the user turn of held-out item action_delete to the 8B 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 an action named `delete_item` that takes an integer parameter `id` and returns a boolean indicating success"
    }
  ],
  "max_tokens": 1024,
  "temperature": 0.0
}
JSON

The code below is the 8B adapter's recorded output for item action_delete 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.

// define an action named `delete_item` that takes an integer parameter `id` and returns a boolean
fn delete_item(id: int) to bool {
    return true
}

Results

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

Training

8B ran 480 optimizer steps over 3447051 tokens, ended with a final loss (EMA) of 1.5863, a mean train loss of 1.5543 and a last-epoch validation loss of 1.1773, took 9h 10m and peaked at 36356 MiB, from Vox commit 36c233789; 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.