von

Von is an open decision model by Victor Hugo Panisa, built on ModernBERT-large and released under Apache-2.0. It reads a question's instructions and the state, then every option with its own [MASK] marker, all in one sequence, and scores each option at its marker. Every question is one forward pass, whatever its number of options.

Archived upstream. On 2026-10-19 the author archived Von: the weights and von-sdk stay available, but they will not be updated, and the card points new projects to d1-omni, which Ollaya serves as d1-omni. von:1.1 keeps working as it is.

Models

Accuracy is the argmax against the majority label on all 400 typed-decisions states. For comparison, decider scores 0.608, nli 0.536, gliclass 0.477 and laya:en 0.357. The labels have low annotator agreement, so compare the numbers to each other rather than reading them as absolutes. On the author's JevBench harness Von 1.1 scores 0.938 (easy), 0.653 (standard) and 0.351 (hard).

Usage

ollaya run von --preset triage "My order never arrived and support ignores me. Refund me today or I'm switching to your competitor."

Point any TypeSafe client at http://localhost:11435 and set the model to von.

Speed

• RTX 5090, through the HTTP API (Ollaya Bench): a five-question request with a short state takes 19 ms at the median.
• CPU: the same request takes 2591 ms on the Threadripper 3960X (24 cores).
• State length: every question reads the whole state, and attention cost grows faster than the sequence: five questions about a 2,200-token state take about 0.78 s on the GPU and 25 s on the CPU. On the CPU a full 8,192-token sequence needs about 25 GB of memory.

How it works

• One sequence per question. The instructions and the state come first, then [SEP], then every option's description after its own [MASK]. An option is read from its description; a bare label is read as it is.
• State as text. A JSON state is written the way Von was trained on it: one key: value line per top-level key, with Python's rendering of nested values.
• Yes/no without criteria. A noul question without true/false descriptions adds a second sequence without the state. It measures the question's own lean towards yes or no, which is taken off the answer, as Von does.
• Calibration. The temperature is computed per question from the answer's entropy, the state's length and the number of options, with Von's own fitted coefficients.
• Weights. Von's weights exist only in the author's option_marker.pt, a PyTorch archive with uncompressed tensors, downloaded from Hugging Face, pinned to a commit and verified by sha256. The ONNX graph reads the tensors in place by byte offset, so nothing is unpickled or executed; Ollaya hosts only the graph (3 MB).
• Parity. Ollaya's Rust runtime reproduces upstream Von computed in float64: the same token ids and option markers, the same decision on every test question, and logits within 4.4e-4 on x86-64 CPU and CUDA. On Apple silicon's CPU one row is 1.1e-3 off, and every decision is still the same.

Limits

• English. Von is trained on English.
• Context. A question's instructions, state and options share 8,192 tokens. A longer state is cut to fit; instructions and options that do not fit on their own are rejected.
• Long policy text. The model card calls Von weak on long, multi-hop policy text, and quality drops visibly near the context limit.
• [MASK] in the input. The literal text [MASK] in a state, instruction or option is replaced by a space, because Von would read it as an option marker.
• Von 1.2. The author has since released Von 1.2, which changes how options attend to each other. It needs a new graph; von:1.1 stays pinned to 1.1 until then.

Weights and license

Apache-2.0. Von is developed by Victor Hugo Panisa (model card on Hugging Face, code at github.com/wfzyx/von). It is built on ModernBERT-large by Answer.AI and LightOn, also Apache-2.0. Ollaya downloads the weights from the author's repository, pinned to a commit and checked against sha256; it never re-hosts them.