Vox Mens 0.8B is trained for vox-lang (release check: passed).
| Model | Held-out pass@1 (0.8B) | Weights (0.8B) | License | Live Demo |
|---|---|---|---|---|
| Vox Mens 0.8B | 1/52 (1.9%) → 24/52 (46.2%) | Standalone Safetensors + PEFT | apache-2.0 |
Open 0.8B Playground |
Vox Mens 0.8B writes, repairs, and explains code in Vox — a full-stack, AI-native language where database tables, backend queries and mutations, reactive web UI components, deterministic workflows, and typed AI agents live in one compiler-checked .vox file. Every Vox Mens 0.8B release is verified against vox check compilation, anti-stub invariants, and paired reasoning benchmarks so you get idiomatic full-stack Vox without losing general coding and math capability.
Vox Mens 0.8B is the instant-response entry model built for everyday laptops, browser WebGPU, and edge devices with minimal memory. Reach for 0.8B when sub-second autocomplete, quick Vox syntax answers, and continuous compiler checks matter more than deep cross-file planning. Step up to 2B or 4B whenever you start wiring database schemas, backend routes, and UI components together across a file. The measured training peak for 0.8B is 16393 MiB (peak_source: run_summary), and no serving memory figure has been measured for it.
Query Vox Mens 0.8B immediately over Hugging Face Inference Providers (:auto or :featherless-ai) with any OpenAI-compatible client:
from openai import OpenAI
client = OpenAI(base_url="https://router.huggingface.co/v1", api_key="$HF_TOKEN")
resp = client.chat.completions.create(
model="brbrainerd/vox-mens-qwen3.5-0.8b:auto", # or "brbrainerd/vox-mens-qwen3.5-0.8b:featherless-ai"
messages=[{"role": "user", "content": "Write a Vox table and query for open tasks."}],
)
print(resp.choices[0].message.content)
Run Vox Mens 0.8B locally with Ollama or serve high-throughput batches via vLLM:
ollama run hf.co/brbrainerd/vox-mens-qwen3.5-0.8b
vllm serve brbrainerd/vox-mens-qwen3.5-0.8b
Download the BLAKE3-verified Vox Mens 0.8B standalone checkpoint (hf_sync_manifest.json, or pull files directly from the Files tab) and serve it natively via vox mens serve:
vox mens hub download --repo brbrainerd/vox-mens-qwen3.5-0.8b --output-dir mens/runs/qwen3.5-0.8b
vox mens serve --model mens/runs/qwen3.5-0.8b --port 11435
Load Vox Mens 0.8B directly with transformers using enable_thinking=False:
from transformers import AutoModelForCausalLM, AutoTokenizer
tok = AutoTokenizer.from_pretrained("brbrainerd/vox-mens-qwen3.5-0.8b")
model = AutoModelForCausalLM.from_pretrained("brbrainerd/vox-mens-qwen3.5-0.8b", dtype="auto", device_map="auto")
prompt = tok.apply_chat_template(
[{"role": "user", "content": "Write a Vox hello-world function."}],
tokenize=False,
add_generation_prompt=True,
enable_thinking=False,
)
inputs = tok(prompt, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=256)
print(tok.decode(out[0], skip_special_tokens=True))
Or mount the lightweight Vox Mens 0.8B LoRA weights (subfolder="peft") onto Qwen/Qwen3.5-0.8B:
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3.5-0.8B", dtype="auto", device_map="auto")
model = PeftModel.from_pretrained(base, "brbrainerd/vox-mens-qwen3.5-0.8b", subfolder="peft")
tok = AutoTokenizer.from_pretrained("Qwen/Qwen3.5-0.8B")
This request sends the user turn of held-out item string_is_rotation to the 0.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 a function named `string_is_rotation` that takes two strings `a` and `b` of equal length and returns true if `b` is a rotation of `a`"
}
],
"max_tokens": 1024,
"temperature": 0.0
}
JSON
The code below is the 0.8B adapter's recorded output for item string_is_rotation 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 a function named `string_is_rotation` that takes two strings `a` and `b`
// of equal length and returns true if `b` is a rotation of `a`
fn string_is_rotation(a: str, b: str) to bool {
if len(a) != len(b) {
return false
}
let mut i = 0;
let mut j = 0;
while j < len(b) {
if a[i] != b[j] {
return false
}
i = i + 1;
j = j + 1;
}
return true
}
Beginners can write and run their first full-stack .vox file alongside Vox Mens 0.8B in under a minute, or call brbrainerd/vox-mens-qwen3.5-0.8b from Python and Rust.
Try Vox in 60 seconds (0.8B)
Vox keeps your schema, backend queries, mutations, and helpers in one compiler-checked file so Vox Mens 0.8B can edit an entire feature coherently:
table Note {
title: str
done: bool
}
query list_notes() to Result[list[Note], str] {
return db.Note.all()
}
mutation add_note(title: str) to Result[int, str] {
return db.Note.insert({ title: title, done: false })
}
fn format_status(done: bool) to str {
if done { return "done" }
return "open"
}
Type-check and execute your program locally while Vox Mens 0.8B assists in the same workspace:
vox check main.vox
vox run --interp main.vox
vox llm prompt "Add an archive mutation to main.vox"
Use 0.8B from Vox and Rust
Inside a Vox workspace or Rust crate, route chat requests to brbrainerd/vox-mens-qwen3.5-0.8b through vox_actor_runtime::llm::llm_chat instead of hardcoding vendor URLs:
export HF_CHAT_MODEL="brbrainerd/vox-mens-qwen3.5-0.8b"
export HF_TOKEN="hf_your_token_here"
export VOX_POPULI_LOCAL_OLLAMA_URL="http://127.0.0.1:11435"
use vox_actor_runtime::inference_env::resolve_huggingface_router;
use vox_actor_runtime::model_resolution::{RouteResolutionInput, resolve_chat_provider_route};
// Build a model-agnostic route to brbrainerd/vox-mens-qwen3.5-0.8b via Hugging Face Router or local MENS:
let hf_endpoint = resolve_huggingface_router("brbrainerd/vox-mens-qwen3.5-0.8b");
Use 0.8B from Python
Call brbrainerd/vox-mens-qwen3.5-0.8b with the standard openai Python SDK through Hugging Face Inference Providers or a local vox mens serve endpoint:
import os
from openai import OpenAI
# Cloud inference via Hugging Face Router (:auto selects the fastest available host)
client = OpenAI(
base_url="https://router.huggingface.co/v1",
api_key=os.environ["HF_TOKEN"],
)
# Or target your local machine after running `vox mens serve`:
# client = OpenAI(base_url="http://127.0.0.1:11435/v1", api_key="local")
reply = client.chat.completions.create(
model="brbrainerd/vox-mens-qwen3.5-0.8b:auto",
messages=[{"role": "user", "content": "Write a Vox query that returns open Note rows."}],
)
print(reply.choices[0].message.content)
Manage Python dependencies inside a Vox project for Vox Mens 0.8B using [python] in Vox.toml and vox py:
# Vox.toml
[python]
version = "3.12"
packages = ["openai", "transformers", "peft"]
vox py sync
vox py doctor
vox py bind openai
Generate a typed Python client from a Vox service API built with Vox Mens 0.8B using OpenAPI:
vox emit openapi src/main.vox --out dist/openapi.json
openapi-python-client generate --path dist/openapi.json
For 0.8B, the examples are the 2 shortest items the adapter fixes and the shortest it still fails; of 52 items it fixes 23 and breaks 0.
mutation_updatedefine a mutation named `update_item` that takes an integer `id` and a string `title` and updates the item with the matching id
Unadapted 0.8B base on mutation_update: does not parse (count 4).
mod item;
mod update_item;
mod item;
mod update_item;
Vox Mens 0.8B on mutation_update: passes.
mutation update_item(id: int, title: str) to Result[str] {
if id <= 0 {
return Error("invalid id")
}
return Ok("updated")
}
matrix_row_sumsdefine a function named `matrix_row_sums` that takes a list of lists of integers `matrix` and returns a list of the sum of each row
Unadapted 0.8B base on matrix_row_sums: does not parse (count 2).
type MatrixRowSums = List[SumRow]
type SumRow = List[Int]
Vox Mens 0.8B on matrix_row_sums: passes.
fn matrix_row_sums(matrix: list[list[int]]) to list[int] {
let mut result: list[int] = []
for row in matrix {
let mut row_sum: int = 0
for val in row {
row_sum = row_sum + val
}
result = result.push(row_sum)
}
return result
}
humaneval_vox_042_reverse_listReturn a new list with the elements in reverse order.
Unadapted 0.8B base on humaneval_vox_042_reverse_list: does not parse (count 4).
type List = [T];
type Reverse = Vec<T>;
fn reverse_list<T>(list: List) to Reverse {
let mut reversed: Vec<T> = list.iter().rev().collect();
return reversed;
}
Vox Mens 0.8B on humaneval_vox_042_reverse_list: type errors (count 1).
fn reverse_list(lst: list[int]) to list[int] {
let mut out: list[int] = []
for i in range(len(lst)) {
out = out.push(lst.pop())
}
return out
}
| Result for 0.8B | Held-out pass@1 | Collateral accuracy | McNemar p-value |
|---|---|---|---|
| Base 0.8B | 1/52 (1.9%) | — | — |
| Vox Mens 0.8B | 24/52 (46.2%) | — | — |
| gsm8k_think, 128 items, 0.8B (base then Vox Mens) | — | 0.203 then 0.234 | 0.7975 |
| math500_think, 128 items, 0.8B (base then Vox Mens) | — | 0.070 then 0.086 | 0.7880 |
| vox_think, 128 items, 0.8B (base then Vox Mens) | — | 0.039 then 0.109 | 0.9904 |
The 0.8B rows compare the unadapted base checkpoint with Vox Mens 0.8B on identical items, and a slice p-value below 0.05 would mean the model lost ground on that slice.
The release gate record for 0.8B is gate_receipt.json.
Vox Mens 0.8B fine-tunes base pin Qwen/Qwen3.5-0.8B@2fc06364715b967f1860aea9cf38778875588b17 over 180 optimizer steps (1309349 tokens), ended with a final loss (EMA) of 0.7048, a mean train loss of 0.8105 and a last-epoch validation loss of 0.6849; the 0.8B run took 1h 00m and peaked at 16393 MiB from Vox commit 36c233789 (shared settings: docs page).
The 0.8B repository holds the standalone merged checkpoint (config.json, model.safetensors, tokenizer.json, tokenizer_config.json) built by vox mens merge-qlora, exported PEFT adapter files under peft/, raw candle_qlora_adapter.safetensors, tokenizer and chat_template.jinja, .eval_results/vox_mens_eval.yaml, external_serving_handoff_v1.json, 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.
model.safetensors 1.5 GBpeft/adapter_model.safetensors 41 MBcandle_qlora_adapter.safetensors 41 MBQwen/Qwen3.5-0.8B