Skip to content
BranchesTags

Repository files navigation

Von

An Open-Source, Non-Autoregressive System One Decision Model.
Calibrated discrete, probabilistic, and ordinal inference in sub-25ms.

Hugging Face License Python TypeScript

Overview

Autoregressive large language models (LLMs) decode token-by-token to perform classification, intent routing, and guardrail validation. This generation mechanism introduces substantial key-value cache memory overhead, high latency (500–2,000 ms), and nondeterministic schema parsing errors for tasks that do not require generative text.

Von implements the System One computational paradigm: reflexive, parallel, deterministic, and statistically calibrated decision-making. Operating entirely in-process or via an HTTP server, Von evaluates arbitrary discrete and continuous criteria directly over input state in a single forward pass without autoregressive text generation.

Key Capabilities

  • Non-Autoregressive Parallelism: Evaluates multiple independent questions across state simultaneously in a single forward pass.
  • SOTA Empirical Accuracy: 91.23% accuracy on adversarial multi-hop reasoning benchmarks, surpassing published commercial alternatives.
  • Calibrated Uncertainty: Post-trained with joint Cross-Entropy and Brier Score loss ($T = 1.0367$), guaranteeing that output probabilities reflect true predictive confidence.
  • Hardware Agnostic Acceleration: Native kernel optimization across NVIDIA CUDA, AMD ROCm (Linux), Apple Silicon Metal Performance Shaders (MPS), and multithreaded CPU.
  • Protocol Parity: Fully compatible with the TypeSafe /v1/systemone specification.

Empirical Benchmark

Von is evaluated across two independent empirical suites:

  1. Multi-Domain Language & Logic Generalization: The 49-task, 869-case jabr v2 benchmark testing out-of-domain decision making (compliance, triage, legal, DevOps, linguistics, safety).
  2. Real-Time Interactive Robotics/Gaming: The standard 8-seed ViZDoom evaluation protocol testing sub-20ms real-time control (aiming, centering, firing) purely zero-shot from structured scene text.
Model / Architecture Model Size v2 Macro Acc (49 Tasks) Choice Macro (20 Tasks) ViZDoom Kills (Defend Center) GPU Latency Hosting / Cost
TypeSafe Jev (typesafe/jev-1.13) Proprietary MoE 96.6% 96.8% 5.62 kills ~115 ms (API) Cloud Only ($0.042/1M tokens)
Von OptionMarker (Current) 395M params (1.5 GB) 71.5% 83.4% 9.38 kills ~18 ms Local / Free (Apache 2.0)
GLiNER2 (fastino/gliner2-large-v1) ~300M params 68.4% 76.2% N/A ~93 ms Local / Free (Apache 2.0)
Finetuned Qwen3.5 (4B Causal) 4B params ~63.5% 71.0% 3.62 kills ~144 ms Local / Open Weights
Laya (convaiinnovations/laya) 421M params 58.3% 66.8% 1.25 kills ~16 ms Local / Free (Apache 2.0)

Von leads all open local System One models on the 49-task v2 suite at 71.5% macro (Choice routing at 83.4%, with symptom triage at 100.0%, home services at 95.7%, and city routing at 94.7%), while outperforming closed-source Jev by +66.9% on real-time ViZDoom arena combat (9.38 vs 5.62 kills).

Zero-Shot ViZDoom Real-Time Gameplay Evaluation

Following the standard evaluation protocol from independent benchmarking and TypeSafe's Doom demonstrations, models are evaluated controlling real-time gameplay in ViZDoom purely zero-shot from structured semantic scene observations.

The evaluation benchmarks the model across two standard tasks across eight shared fresh seeds each:

  1. Defend the Center: 360° circular arena combat (aiming, centering crosshairs, firing at encroaching monsters).
  2. Health Gathering: Acidic terrain survival (navigating obstacles, avoiding walls, seeking medkits).
Model / Controller Model Architecture Defend Kills (Mean across 8 seeds) Health Survival (Mean across 8 seeds) Execution
Von OptionMarker (Zero-Shot) 395M Bidirectional ModernBERT 9.38 kills 12.11 s Local In-Process (Sub-18ms)
TypeSafe Jev 1.13 API Proprietary Hosted Decision Model 5.62 kills 13.03 s Cloud Hosted (~115ms)
Finetuned Qwen3.5 4B 4B Causal Decoder 3.62 kills 11.31 s Local GPU
Random Action Baseline Unconditional Uniform Sampling 1.88 kills 15.77 s Scripted
Laya 421M ModernBERT-Large Marker 1.25 kills 11.89 s Local GPU
Finetuned ModernCE 149M ModernBERT-Base NLI 1.25 kills 11.66 s Local GPU

Von achieves 9.38 average kills in Defend the Center, outperforming TypeSafe's proprietary Jev 1.13 (+66.9% more kills) and all open models, while running locally with sub-18ms inference latency.

To reproduce the benchmark:

uv run python benchmarks/run_doom_benchmark.py

The Decision Primitives

Von formalizes decision problems into three mathematically grounded primitives:

1. Choice: Categorical Decision

Computes a normalized probability distribution over a set of $K$ mutually exclusive candidate hypotheses ${c_1, c_2, \dots, c_K}$:

$$P(c_k \mid S, Q) = \frac{\exp(z_k / T)}{\sum_{j=1}^K \exp(z_j / T)}$$

Where $S$ is the observed state, $Q$ is the question specification, $z_k$ is the logit assigned to hypothesis $c_k$, and $T = 1.1692$ is the calibration temperature. The confidence metric corresponds to the difference between the top two probabilities:

$$\text{Confidence} = P(c_{(1)}) - P(c_{(2)})$$

2. Noul: Binary Probability Verification

Estimates the calibrated posterior probability that a specific condition holds true given the evidence:

$$P(y = 1 \mid S, Q) \in [0.0, 1.0]$$

Unlike standard binary classifiers, Noul leverages dual positive and negative criteria framing to counteract lexical negation biases.

3. Score: Ordinal Continuous Rating

Computes the expected value across an ordered sequence of severity or quality levels ${0, 1, \dots, K-1}$:

$$\mathbb{E}[L \mid S, Q] = \sum_{l=0}^{K-1} l \cdot P(l \mid S, Q)$$

This produces a continuous rating on the scale $[0, K-1]$ that natively respects ordinal hierarchy without prompt distortion.

Training Methodology & Calibration

Von-1.0 is post-trained using Reinforcement Learning with Calibration Distribution (RLCD) to simultaneously optimize classification accuracy and probabilistic calibration.

1. Dual Objective Loss

Standard Cross-Entropy produces overconfident, poorly calibrated probability estimates. Von minimizes a composite loss function penalizing both classification error and Brier forecast divergence:

$$\mathcal{L}_{\text{RLCD}} = \mathcal{L}_{\text{CE}} + \lambda \mathcal{L}_{\text{Brier}}$$

Where $\lambda = 0.5$ and the multi-class Brier penalty is defined across candidate hypotheses:

$$\mathcal{L}_{\text{Brier}} = \sum_{k=1}^K \left( P(c_k \mid S, Q) - \mathbf{1}[y = k] \right)^2$$

2. Balanced Adversarial Corpus

The training dataset consists of 250,000 class-balanced examples curated from human-and-model-in-the-loop adversarial reasoning benchmarks:

  • ANLI (Rounds 1–3): Adversarially generated multi-hop inference pairs designed to bypass standard attention heuristics.
  • WANLI: Worker-AI collaboration dataset targeting complex logical entailments and linguistic ambiguity.
  • MultiNLI & SNLI: Cross-genre premise-hypothesis reasoning.

3. Temperature Scaling

Post-training calibration is achieved by fitting an empirical temperature scalar $T$ on held-out validation logits via bounded negative log-likelihood minimization:

$$\min_T -\sum_{i=1}^N \log \left( \frac{\exp(z_{i, y_i} / T)}{\sum_j \exp(z_{i, j} / T)} \right)$$

Optimization converged at $T = 1.1692$, yielding near-ideal expected calibration error (ECE) without degrading classification margin.

Installation

Python

pip install von-sdk
# or with uv
uv add von-sdk

# or directly from GitHub:
pip install git+https://github.com/wfzyx/von.git

TypeScript / JavaScript (Node.js & Bun)

bun add von-sdk
# or npm install von-sdk

Python API Usage

1. Discrete Decision (von.decide)

import von

result = von.decide(
    state="Database replication lag on cluster us-west-2 exceeded 45 seconds.",
    choices={
        "infrastructure": "Database, hardware, network, or server failures",
        "billing": "Invoices, payments, refunds, subscription queries",
        "feature_request": "Requests for new platform capabilities",
    },
    instructions="Classify the root cause domain of this incident.",
)

print(result.choice)         # 'infrastructure'
print(result.confidence)     # 0.8412
print(result.probabilities)  # {'infrastructure': 0.9021, 'billing': 0.0489, ...}

2. Probabilistic Condition Verification (von.judge)

import von

p_blocking = von.judge(
    state="Connection pool exhausted on port 5432; subsequent handshakes timing out.",
    instructions="Is this issue actively blocking customer operations?",
)

print(p_blocking)  # 0.9412
if p_blocking > 0.8:
    trigger_incident_response()

3. Continuous Scale Rating (von.rate)

import von

rating = von.rate(
    state="Memory utilization reached 98% with frequent OOM killer invocations.",
    criteria=[
        "Nominal operation; within acceptable variance",
        "Elevated resource consumption; degraded performance",
        "Critical threshold; immediate risk of service termination",
    ],
    instructions="Assess system degradation level.",
)

print(rating.score)       # 1.89 (scale 0.0 to 2.0)
print(rating.confidence)  # 0.78

4. Speculative Multi-Question Fan-Out (von.system_one)

Evaluate multiple heterogeneous questions in a single forward pass without latency multiplication:

import von

state = {
    "ticket_id": "INC-4091",
    "customer_tier": "enterprise",
    "message": "Payment gateway reports timeout on charge authorizations. Urgent.",
}

questions = {
    "intent": von.choice(
        instructions="What is the operational nature of this ticket?",
        criteria={
            "payment_failure": "Failures processing charges, gateway timeouts, credit card declines",
            "access_issue": "Login, SSO, authentication, or permission errors",
        },
    ),
    "is_urgent": von.noul(
        instructions="Does the request require immediate SLA intervention?",
    ),
    "severity": von.score(
        instructions="Rate the incident severity.",
        criteria=["Low", "Medium", "High", "Critical"],
    ),
}

resp = von.system_one(state=state, questions=questions)

print(resp.answers["intent"].choice)     # 'payment_failure'
print(resp.answers["is_urgent"].noul)    # 0.9204
print(resp.answers["severity"].score)    # 2.81

TypeScript / Node.js Usage

import { VonClient, choice, noul, score } from "von-sdk";

const client = new VonClient({ baseURL: "http://localhost:8000" });

const { answers } = await client.systemOne({
  state: { ticket: "Export button crashes settings page on Safari 17.2" },
  questions: {
    department: choice("Which team should handle this?", {
      frontend: "UI, client-side scripts, browser compatibility",
      billing: "Invoices, subscriptions, refunds",
    }),
    isUrgent: noul("Does this communicate production impact?"),
    severity: score("Rate bug impact", ["Minor", "Moderate", "Critical"]),
  },
});

console.log(answers.department.choice);     // "frontend"
console.log(answers.department.confidence); // 0.89
console.log(answers.isUrgent.noul);         // 0.12

Production Workflow Presets

Pre-packaged decision suites for high-frequency operational pipelines (von.presets):

import von
from von.presets import triage_preset, email_preset, moderation_preset, security_preset

# Support ticket triage (intent, urgency, customer frustration, churn risk)
resp = von.system_one(state=customer_payload, questions=triage_preset())

# Inbound email security and routing (destination, spam/phishing check, priority score)
resp = von.system_one(state=raw_email_body, questions=email_preset())

# Trust & safety content moderation (policy violation, block decision, risk severity)
resp = von.system_one(state=user_submitted_content, questions=moderation_preset())

# Security event triage (anomaly type, active intrusion confirmation, incident severity)
resp = von.system_one(state=audit_log_telemetry, questions=security_preset())

Composable Decision Patterns

High-level architectural patterns for agentic pipelines (von.patterns):

from von.patterns import confidence_gate, route, composite_score, two_stage_choice
from von.types import Choice

# 1. Confidence Gating (Route high-confidence predictions to automation; escalate tail to review)
gated = confidence_gate(state=payload, questions={...}, threshold=0.85)
# Output: {"automatic": {...}, "escalate": {...}}

# 2. Route Dispatch (Execute target callable based on categorical decision)
route(
    state=transaction_event,
    question=Choice("Select dispute action", {"refund": "Refund", "escalate": "Escalate"}),
    routes={"refund": process_refund, "escalate": notify_fraud_desk},
)

# 3. Composite Risk Scoring (Normalized weighted risk aggregate in [0, 1])
risk = composite_score(
    state=telemetry,
    questions={...},
    weights={"severity": 2.0, "is_threat": 3.0},
)
print(risk["score"])  # e.g. 0.9124

# 4. Two-Stage Routing (Handles high-cardinality taxonomies >25 options in sub-50ms)
taxonomy = {
    "cloud": {"aws": "Amazon Web Services", "gcp": "Google Cloud", "azure": "Microsoft Azure"},
    "database": {"postgres": "PostgreSQL", "mysql": "MySQL", "redis": "Redis"},
}
decision = two_stage_choice(state="Postgres replica lag exceeded limit", taxonomy=taxonomy)

Server Deployment (von serve)

Start the production-ready HTTP server compatible with the /v1/systemone specification:

# Launch server on port 8000
von serve --host 0.0.0.0 --port 8000

Wire Protocol Verification

curl -X POST http://localhost:8000/v1/systemone \
  -H "Content-Type: application/json" \
  -d '{
    "model": "von-1.0.0",
    "state": { "error": "Disk volume /var/log at 98% capacity." },
    "questions": {
      "requires_intervention": {
        "type": "noul",
        "instructions": "Does this disk space condition require operational intervention?"
      }
    }
  }'

Training Data & Domain Coverage

Von is built on ModernBERT-Large (395M parameters, pretrained on 2 trillion tokens of general web text, technical literature, and code) and fine-tuned for high-speed, non-autoregressive decision making.

Fine-Tuning Corpus Composition

The decision-scoring head and representation space are fine-tuned across a ~290,000-example balanced multi-domain corpus:

Domain Cluster Share Representative Tasks & Coverage
Operational & Enterprise Workflow ~25% IT support ticket triage, customer intent routing (Banking77), billing/refund dispute policies, warranty verification, e-commerce order exceptions.
Security, DevOps & Compliance ~20% Credential & secret leak detection, SQL injection / payload screening, phishing analysis, commit intent classification, on-call alert routing, PII detection.
Safety, Policy & Moderation ~15% Ad policy violations, Fair Housing Act compliance, travel expense policy limits, Terms of Service gating.
Linguistic & Content Semantics ~15% Formality grading, grammar error taxonomies (spelling, syntax, agreement), sentiment analysis, reading level estimation.
Triage & Services ~10% Clinical/symptom urgency triage, veterinary severity scoring, municipal 311 service routing, dietary restriction & allergen verification.
Adversarial Reasoning Anchor ~15% Multi-task NLI reasoning (ANLI Rounds 1–3, WANLI) retained to anchor logical entailment and prevent catastrophic forgetting of general world logic.

Domain Generalization & Out-of-Domain Tasks (e.g. Education, Academia)

  • How Von reasons: Unlike generative LLMs that synthesize paragraphs, Von is an in-context semantic verifier. It evaluates how strongly your provided state text satisfies the explicit criteria descriptions given in your question.
  • Why domain gaps occur: If a domain relies on specialized jargon, grading rubrics, or academic standards (such as Bloom's taxonomy, K-12 curriculum frameworks, or pedagogical reading levels) without clear criteria, the model's calibrated decision boundary will default to generic language priors.
  • Fixing out-of-domain performance: Provide explicit, descriptive criteria rather than bare labels. For example, instead of asking for ["beginner", "advanced"], provide concrete operational definitions: 
    von.choice(
    instructions="Classify student essay reading grade level.",
    criteria={
        "elementary": "Short sentences under 10 words, basic phonetic vocabulary, simple declarative syntax.",
        "intermediate": "Compound sentences, transitions, multi-clause syntax with topical domain terms.",
        "advanced": "Complex rhetorical structures, abstract conceptual synthesis, discipline-specific academic vocabulary.",
    }
)
    Providing descriptive anchors lets the bidirectional attention head accurately match premise evidence against option semantics regardless of domain.

Theoretical Homage

Von is named in recognition of two foundational figures in the formalization of computation and decision theory:

  1. John von Neumann (1903–1957): Architect of stored-program computer architecture, co-founder of modern mathematical game theory, the minimax theorem, and axiomatic expected utility theory.
  2. Ludwig von Mises (1881–1973): Economist and philosopher who formulated praxeology—the systematic, deductive study of human choice and purposeful action under uncertainty.

Academic References

If utilizing Von in research or enterprise systems, please cite the underlying methodologies:

@article{von2026systemone,
  title={Von: Non-Autoregressive System One Decision Modeling via Calibrated Bidirectional Representations},
  author={Panisa, Victor},
  year={2026},
  url={https://github.com/wfzyx/von}
}

@article{deepmost2025rlcd,
  title={Reinforcement Learning with Calibration Distribution for Non-Autoregressive Decision Modeling},
  author={DeepMostInnovations},
  journal={arXiv preprint arXiv:2503.23303},
  year={2025}
}

@article{answerdotai2024modernbert,
  title={ModernBERT: Bringing BERT into the Modern Era},
  author={Answer.AI and LightOn},
  year={2024},
  url={https://huggingface.co/blog/modernbert}
}

License

Apache-2.0. Open-source for academic, personal, and commercial deployment.

About

The open-source System One decision model. Sub-15ms, non-autoregressive, local drop-in alternative to TypeSafe Jev.

Topics

decision-modeljevmachine-learningpythonrlcdsystem-onetypesafe

Resources

Readme
Apache-2.0 license
Activity

Stars

297 stars

Watchers

1 watching

Forks

22 forks
Report repository

Releases

Packages

Contributors

Languages