Valen-Decision-1.5-9B

Valen-Decision-1.5-9B helps you classify customer messages, check whether images meet your requirements, and identify actions in videos. Try Valen-Decision-1.5 instantly through our free API and web demo (0.8B, 2B and 4B), with no installation, model download, or GPU required. We also release the training code, so you can fine-tune Valen-Decision on your own data. The training data of Valen-Decision-1.5 is not public.

Complete application tutorials

Complete workflows are maintained in the official Cookbook: API basics, local inference basics, ticket routing, product-image screening and video tagging. Pages import executable source and include actual outputs, uncertainty policies, media provenance and licensing notes.

Valen-Decision-1.5 adds block-bidirectional attention and a bbox grounding head: one forward pass returns probabilities for predicate, choice and score questions and a box for each bbox question.

Which version should I choose?

For a first try, use the web experience or free HTTP API, which serves Valen-Decision-1.5 0.8B, 2B and 4B without downloading weights.

Valen-Decision-1.5 comes in five sizes: 0.8B, 2B, 4B, 9B and 27B. Larger sizes score higher on Decision Index (see Evaluation) and need more memory and compute. Each size is published in three formats: native weights for Transformers and fine-tuning (Valen-Decision-1.5-9B), ONNX (Valen-Decision-1.5-9B-ONNX) and GGUF for the Valen llama.cpp runtime 0.2.0 (Valen-Decision-1.5-9B-GGUF). The native weights store the backbone in BF16 and the decision and grounding heads in FP32.

Examples

Image and video decision demonstration of Valen-Decision-1.5 from the Valen repository: boxes, probabilities, choices and scores from one forward pass. Click the preview to watch the full demonstration.

Quick start

Valen supports two decision API formats: SystemOne, used by Jev, and Decisions, used by OpenAI. Both work with the same Valen model.

Start with Decisions if you are new to Valen. If your application already uses the Jev/SystemOne format, use SystemOne. The examples below include everything you need to get started.

See the Valen Transformers documentation for complete request formats, image/video inputs, and inference parameters.

Install and load

The Python example below runs locally on an NVIDIA GPU. If you prefer to skip local setup, try the free web demo or API.

python -m pip install torch torchvision transformers pillow av

import torch
from transformers import AutoModel

model = AutoModel.from_pretrained(
    "Valen-Team/Valen-Decision-1.5-9B", trust_remote_code=True,
    dtype="auto", attn_implementation="sdpa",
).to("cuda").eval()
torch.set_float32_matmul_precision("highest")
torch.backends.cudnn.allow_tf32 = False

Minimal protocol calls

After installation/loading above, verify the path with one predicate. Complete multi-question workflows and image/video tutorials are maintained in Cookbook.

result = model.predict({"input": "A cat is on the sofa.", "questions": [
    {"name": "cat", "type": "predicate", "instructions": "A cat is present."},
]})
print(result["answers"][0]["probability"])
legacy = model.predict({"state": "A cat is on the sofa.", "questions": {
    "cat": {"type": "noul", "instructions": "A cat is present."},
}})
print(legacy["answers"]["cat"]["noul"])

Cookbook · API

Try it free: the API

Try the interactive demo or call the free API directly. No API key is required. The free API serves Valen-Decision-1.5 under the model IDs valen-0.8b, valen-2b and valen-4b. 9B is not on the free API, so the example uses valen-4b (Valen-Decision-1.5-4B).

curl https://api.valen-team.workers.dev/v1/decisions \
  -H 'Content-Type: application/json' \
  -H 'Origin: https://valen-team.github.io' \
  -d '{
    "model": "valen-4b",
    "input": "Please send my order to my new address.",
    "questions": [{"name": "change_address", "type": "predicate",
                   "instructions": "Is the customer requesting a delivery address change?"}]
  }'

Example response (captured from the free API; timing may vary):

{
  "answers": [
    {
      "type": "predicate",
      "name": "change_address",
      "probability": 0.9985537506636069
    }
  ],
  "model": "Valen-Decision-1.5-4B",
  "model_id": "valen-4b",
  "revision": "local",
  "usage": {
    "input_tokens": 79,
    "output_tokens": 0
  },
  "internal_usage": {
    "compute_tokens": 79
  },
  "timing": {
    "total_ms": 311.15,
    "image_ms": 0.0,
    "compile_ms": 5.62,
    "forward_ms": 304.32,
    "queue_ms": 0.01
  },
  "images": []
}

The predicate result is in answers[0].probability. See the API reference for image inputs, both protocols, and available model IDs.

SGLang / vLLM deployment

Install the corresponding Valen plugin in a compatible official engine environment. Use Linux, Python 3.11+, and an NVIDIA GPU; the SGLang example uses FA3 on H100/H200-class GPUs. The two alternatives below expose /v1/systemone and /v1/decisions for text and image requests.

SGLang

python -m pip install "git+https://github.com/Valen-Team/Valen.git#subdirectory=serving/sglang"
valen-sglang --model-path Valen-Team/Valen-Decision-1.5-9B \
  --served-model-name valen --host 127.0.0.1 --port 30000 \
  --attention-backend fa3

vLLM

python -m pip install "git+https://github.com/Valen-Team/Valen.git#subdirectory=serving/vllm"
valen-vllm --model-path Valen-Team/Valen-Decision-1.5-9B \
  --served-model-name valen --host 127.0.0.1 --port 8000

Once the chosen server is ready, send a local request. Use port 8000 for vLLM or 30000 for SGLang:

curl http://127.0.0.1:8000/v1/decisions \
  -H 'Content-Type: application/json' \
  -d '{"model":"valen","input":"Please send my order to my new address.",
       "questions":[{"name":"change_address","type":"predicate",
                     "instructions":"Is the customer requesting a delivery address change?"}]}'

For Docker images, offline deployment kits, and complete setup instructions, see the SGLang guide and vLLM guide.

Fine-tuning

Use the complete native main revision for LoRA or full SFT, retaining the trained Mixer. Start with complete Valen-Decision-1.5-0.8B and LoRA for a small domain run; ONNX/GGUF are inference formats. Methods, data, resume and export are maintained in the website training guide; the complete executable split/train/compare recipe lives in Cookbook. A short smoke does not establish domain improvement.

Evaluation

Jev Decision Index

Decision Index 0.4.1 public Text and Vision tracks, evaluated with JevalKit. These are normalized index scores (0–100), not accuracy percentages. Best scores are bold.

Model	Public Text ↑	Public Vision ↑
Valen-Decision-1.5-0.8B	54.71	58.84
Valen-Decision-1.5-2B	61.89	70.54
Valen-Decision-1.5-4B	69.01	77.85
Valen-Decision-1.5-9B	70.61	79.93
Valen-Decision-1.5-27B	74.66	82.91

Per-size metrics, official scorer outputs and run manifests: Valen-Decision-Index-Results.

JevalKit

JevalKit benchmarks. Values are accuracy (%), higher is better.

Benchmark	Valen-Decision-1.5-9B
JevBench	86.15
Typed Decisions	77.80
VisualDecisionBench — Image	89.71
VisualDecisionBench — Video	87.58
DecisionBench	83.34
Procedural Typed Decisions	95.71
JevAlt-Bench	93.81
zh-decision-bench	92.72

License

Apache-2.0. See LICENSE.

Citation

If you use Valen-Decision in your work, please cite this repository:

@misc{valen,
  author       = {{Valen Team}},
  title        = {Valen-Decision},
  howpublished = {GitHub - Valen-Team/Valen: A multimodal System One decision model for text, images and video.},
  note         = {GitHub repository},
  year         = {2026},
  url          = {https://github.com/Valen-Team/Valen}
}

User concepts, methods and references are maintained only on the website: Documentation · Probabilities.