Vox Mens 0.8B is trained for vox-lang (release check: passed).
Diagram (0.8B): a short prompt runs in the browser or on an everyday laptop CPU or GPU offline and returns compiler-checked .vox code.
| Model | Held-out pass@1 (0.8B) | Weights (0.8B) | License | Live Demo |
|---|---|---|---|---|
| Vox Mens 0.8B | 0/52 (0.0%) → 38/52 (73.1%) | Standalone Safetensors + PEFT | apache-2.0 |
Open 0.8B Playground |
Vox Mens 0.8B writes and fixes Vox (.vox), a full-stack language where one file defines database tables, backend queries and mutations, web UI components, and workflows that compile to Rust and TypeScript. Because Vox is newer than mainstream languages, general-purpose AI models often guess Rust or TypeScript syntax that fails to compile; Vox Mens 0.8B is fine-tuned on verified .vox examples so you can generate and repair Vox locally on Windows, Linux, or Mac (Ollama, vLLM, Python, or vox mens serve) or through Hugging Face Inference Providers without paying large cloud API rates on every prompt.
Vox Mens 0.8B is the smallest download in the family, built to run on almost any Windows, Linux, or Mac laptop — even without a dedicated GPU — or in the browser Playground. Use 0.8B to try Vox locally, generate short functions or simple queries, and check basic Vox syntax with minimal memory and disk use. Because 0.8B has very limited capacity for multi-step logic, step up to 2B or 4B for full handlers and use a larger cloud model for app design. Measured QLoRA peak memory during the 0.8B run was 17397 MiB (run_summary).
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 matrix_row_sums 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 `matrix_row_sums` that takes a list of lists of integers `matrix` and returns a list of the sum of each row"
}
],
"max_tokens": 1024,
"temperature": 0.0
}
JSON
Compiler-verified Vox Mens 0.8B output recorded on held-out task matrix_row_sums under qwen3_non_thinking_codegen_v1:
fn matrix_row_sums(matrix: list[list[int]]) to list[int] {
let mut row_sums: list[int] = []
for row in matrix {
let mut running: int = 0
for val in row {
running = running + val
}
row_sums = row_sums.push(running)
}
return row_sums
}
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
Because even 27B is smaller than massive commercial cloud models, Vox projects commonly use a large cloud model for high-level planning while routing .vox file generation and vox check fixes to brbrainerd/vox-mens-qwen3.5-0.8b (locally or via Hugging Face Router) through vox_actor_runtime::llm::llm_chat:
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};
// Keep ambiguous cross-repo planning on your frontier cloud route, and delegate
// .vox handlers, tests, and `vox check` repair loops to brbrainerd/vox-mens-qwen3.5-0.8b:
let mens_specialist = 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 2 held-out tasks Vox Mens 0.8B fixes over the base model; of 52 items it fixes 38 and breaks 0.
test_smokewrite a test named `smoke` that calls `add(1, 2)` and asserts the result equals 3
Unadapted 0.8B base on test_smoke: does not parse (count 68).
use std::collections::HashMap;
type Name = | A | B;
type Table = HashMap<String, Name>;
// Helper function to add two numbers
fn add(a: i32, b: i32) -> i32 {
let mut s = String::from("a: " + &a.to_string() + " + b: " + &b.to_string());
let mut c = s.chars().collect::<Vec<char>>();
let mut d = s.chars().collect::<Vec<char>>();
let mut e = s.chars().collect::<Vec<char>>();
let mut f = s.chars().collect::<Vec<char>>();
let mut g = s.chars().collect::<Vec<char>>();
let mut h = s.chars().collect::<Vec<char>>();
let mut i = s.chars().collect::<Vec<char>>();
let mut j = s.chars().collect::<Vec<char>>();
let mut k = s.chars().collect::<Vec<char>>();
let mut l = s.chars().collect::<Vec<char>>();
let mut m = s.chars().collect::<Vec<char>>();
let mut n = s.chars().collect::<Vec<char>>();
let mut o = s.chars().collect::<Vec<char>>();
let mut p = s.chars().collect::<Vec<char>>();
let mut q = s.chars().collect::<Vec<char>>();
let mut r = s.chars().collect::<Vec<char>>();
// ... [47 more lines omitted; full output in evidence/]
Vox Mens 0.8B on test_smoke: passes.
fn add(a: int, b: int) to int {
return a + b
}
@test
fn smoke() {
assert(add(1, 2) is 3)
}
humaneval_vox_148_is_sorted_uniqueCheck if a list of ints has no duplicate values AND is sorted in strictly ascending order. Return true only if both conditions hold. An empty list or single-element list returns true.
Unadapted 0.8B base on humaneval_vox_148_is_sorted_unique: does not parse (count 2).
type Name { f: T }
type Name = | A | B(f: T)
type Table Name { f: T }
// Check if a list of ints has no duplicate values AND is sorted in strictly ascending order.
// Return true only if both conditions hold. An empty list or single-element list returns true.
fn check_list(list: [T]) to bool {
// Empty list or single element is always true
if list.len() == 0 || list.len() == 1 {
return true;
}
// Check if list is sorted in strictly ascending order
// We iterate from the first element to the last, ensuring no duplicates are present
// and the values are strictly increasing.
let mut is_sorted = true;
for i in 0..list.len() - 1 {
if list[i] != list[i + 1] {
is_sorted = false;
break;
}
}
// If list is not sorted, return false.
// ... [8 more lines omitted; full output in evidence/]
Vox Mens 0.8B on humaneval_vox_148_is_sorted_unique: passes.
fn has_duplicates(nums: list[int]) to bool {
let mut seen: list[int] = []
for item in nums {
if seen.contains(item) {
return true
}
seen = seen.push(item)
}
return false
}
fn is_sorted_asc(nums: list[int]) to bool {
let mut i: int = 0
while i < nums.len() {
if i is 0 {
i = 1
} else {
let prev: int = nums.get(i - 1).unwrap()
let curr: int = nums.get(i).unwrap()
if curr <= prev {
return false
}
i = i + 1
}
}
return true
}
fn check_sorted_unique(nums: list[int]) to bool {
if has_duplicates(nums) {
return false
}
if is_sorted_asc(nums) {
return true
}
return false
}
@test
fn test_check_sorted_unique() {
assert(check_sorted_unique([1, 2, 3]) is true)
assert(check_sorted_unique([3, 2, 1]) is false)
assert(check_sorted_unique([1, 2, 3, 4]) is true)
assert(check_sorted_unique([1, 2, 3, 2]) is false)
assert(check_sorted_unique([]) is true)
assert(check_sorted_unique([1, 2, 3]) is true)
}
| Result for 0.8B | Held-out pass@1 | Collateral accuracy | McNemar p-value |
|---|---|---|---|
| Base 0.8B | 0/52 (0.0%) | — | — |
| Vox Mens 0.8B | 38/52 (73.1%) | — | — |
| gsm8k_think, 128 items, 0.8B (base then Vox Mens) | — | 0.203 then 0.367 | 1.0000 |
| math500_think, 128 items, 0.8B (base then Vox Mens) | — | 0.070 then 0.172 | 0.9993 |
| vox_think, 128 items, 0.8B (base then Vox Mens) | — | 0.039 then 0.188 | 1.0000 |
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 437 optimizer steps (3347740 tokens), ended with a final loss (EMA) of 0.5121, a mean train loss of 0.5410 and a last-epoch validation loss of 0.6155; the 0.8B run took 3h 22m and peaked at 17397 MiB from Vox commit 90eadaf35 (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