openvulcan/vulcan-decision-shell-v1-mini

vulcan-decision-shell-v1

A small dedicated model that judges an AI coding agent's tool calls before they run: allow, review or block.

English | 简体中文

This repository: vulcan-decision-shell-v1-mini · v1-mini 0.2B · native PyTorch

v1-mini's original FP32 weights (weights/fp32/, 0.80 GB) plus FP16, BF16, mixed FP16, INT16 storage and a TorchAO INT8 MLP variant, the tokenizer, example, the GPU entry decision.py and the CPU entry cpu_decision.py. original is the qualified baseline; the other precisions need --allow-experimental-precision. For ONNX, use vulcan-decision-shell-v1-runtime.

The vulcan-decision-shell-v1 release

The family has three models of different sizes with the same policy, input and three decisions; all of them share this card and the docs/ folder:

Model	Parameters	Base model	Per-call limit	Good for
v1	752,393,024 (0.75B)	Qwen3.5-0.8B-Base	32,768 tokens	Best quality
v1-flash	361,821,120 (0.36B)	SmolLM2-360M	32,768 tokens	Close to v1 in quality, faster
v1-mini	199,088,899 (0.2B)	ModernBERT-base	8,192 tokens (runtime package)	Machines short on memory or compute

Each model has one repository with one folder per format or precision: vulcan-decision-shell-v1, vulcan-decision-shell-v1-flash and vulcan-decision-shell-v1-mini. ONNX runtime packages of all three models with one interface (CUDA, WebGPU, CPU, with deployment parameters) are in vulcan-decision-shell-v1-runtime; VulcanCode and the dsh plugin download them for your hardware, and they are also the first choice for your own integration. The training and validation banks are in vulcan-decision-shell-v1-data. You do not need a whole repository: every version has a ready command under Download below.

All repositories:

Repository	Format	Size	Status
vulcan-decision-shell-v1	PyTorch · ONNX	11.9 GB	v1 0.75B · every format, one folder each
vulcan-decision-shell-v1-flash	PyTorch	2.9 GB	v1-flash 0.36B · native PyTorch
vulcan-decision-shell-v1-mini (this repository)	PyTorch	3.1 GB	v1-mini 0.2B · native PyTorch
vulcan-decision-shell-v1-runtime	ONNX	5.1 GB	ONNX packages of all three · used by VulcanCode and dsh
vulcan-decision-shell-v1-data	Dataset	866 MB	Training and validation banks

Download

Install the command-line tool once:

pip install -U "huggingface_hub[cli]"

Each command downloads one version into the repository's folder; the line under it shows how to run it from that folder. Versions of one model share the folder, so you can add another later. SHA256SUMS lists every file; after a partial download, check with sha256sum -c --ignore-missing SHA256SUMS.

vulcan-decision-shell-v1

# Recommended: original FP32 weights, run as mixed-bf16 or fp32 · 3.2 GB
hf download openvulcan/vulcan-decision-shell-v1 --exclude "variants/*" "onnx/*" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python runtime/judge_native.py --model-directory . --profile mixed-bf16 < requests.jsonl

# Full BF16 conversion · 1.7 GB
hf download openvulcan/vulcan-decision-shell-v1 --include "variants/bf16/*" "runtime/*" "dataset-v1/*" "wheels/*" "requirements-native.txt" "LICENSE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python runtime/judge_native.py --model-directory variants/bf16 --profile bf16 < requests.jsonl

# Full FP16 conversion · 1.7 GB
hf download openvulcan/vulcan-decision-shell-v1 --include "variants/fp16/*" "runtime/*" "dataset-v1/*" "wheels/*" "requirements-native.txt" "LICENSE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python runtime/judge_native.py --model-directory variants/fp16 --profile fp16 < requests.jsonl

# ONNX CUDA FP16 (bundled onnxruntime-gpu wheel) · 2.0 GB
hf download openvulcan/vulcan-decision-shell-v1 --include "onnx/*" "SHA256SUMS" --exclude "onnx/experimental/*" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python onnx/runtime/judge_onnx.py --model-directory onnx --onnx-directory onnx/cuda-fp16 < requests.jsonl

# Experimental: ONNX with INT8 MLP · 1.7 GB
hf download openvulcan/vulcan-decision-shell-v1 --include "onnx/*" "SHA256SUMS" --exclude "onnx/cuda-fp16/*" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python onnx/runtime/judge_onnx.py --model-directory onnx --onnx-directory onnx/experimental/int8-mlp < requests.jsonl

# Experimental: INT16 storage (restored to floating point at load) · 2.2 GB
hf download openvulcan/vulcan-decision-shell-v1 --include "variants/int16-storage/*" "experimental/*" "runtime/*" "dataset-v1/*" "wheels/*" "requirements-native.txt" "LICENSE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python -c "import sys; sys.path.insert(0, 'experimental'); from load_integer_storage import load_variant; print(type(load_variant('int16_storage', '.')).__name__)"

# Experimental: INT8 delta on top of the FP32 weights · 3.5 GB
hf download openvulcan/vulcan-decision-shell-v1 --exclude "variants/bf16/*" "variants/fp16/*" "variants/int16-storage/*" "onnx/*" --local-dir vulcan-decision-shell-v1
#   run: cd vulcan-decision-shell-v1 && python -c "import sys; sys.path.insert(0, 'experimental'); from load_integer_storage import load_variant; print(type(load_variant('int8_mixed_delta', '.')).__name__)"

# Everything · 11.9 GB
hf download openvulcan/vulcan-decision-shell-v1 --local-dir vulcan-decision-shell-v1

vulcan-decision-shell-v1-flash

# Recommended: original FP32 · 1.5 GB
hf download openvulcan/vulcan-decision-shell-v1-flash --exclude "models/bf16/*" "models/fp16/*" --local-dir vulcan-decision-shell-v1-flash
#   run: cd vulcan-decision-shell-v1-flash && python decision.py --profile original --input example.json

# Experimental: BF16 · 730 MB
hf download openvulcan/vulcan-decision-shell-v1-flash --exclude "models/original/*" "models/fp16/*" --local-dir vulcan-decision-shell-v1-flash
#   run: cd vulcan-decision-shell-v1-flash && python decision.py --profile bf16 --allow-experimental-precision --input example.json

# Experimental: FP16 (profiles fp16 and fp16-graphs) · 730 MB
hf download openvulcan/vulcan-decision-shell-v1-flash --exclude "models/original/*" "models/bf16/*" --local-dir vulcan-decision-shell-v1-flash
#   run: cd vulcan-decision-shell-v1-flash && python decision.py --profile fp16-graphs --allow-experimental-precision --input example.json

# Everything · 2.9 GB
hf download openvulcan/vulcan-decision-shell-v1-flash --local-dir vulcan-decision-shell-v1-flash

vulcan-decision-shell-v1-mini

# Recommended: original FP32 (GPU or CPU) · 803 MB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp16/*" "weights/bf16/*" "weights/mixed-fp16/*" "weights/int16-storage/*" "weights/int8-mlp/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile original --device cuda --input example.json
#   run on CPU: cd vulcan-decision-shell-v1-mini && python cpu_decision.py --root . --profile original --cpu-backend fp32 --threads 16 --input example.json

# Experimental: mixed FP16 (also needs the FP32 base) · 1.3 GB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp16/*" "weights/bf16/*" "weights/int16-storage/*" "weights/int8-mlp/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile mixed-fp16 --allow-experimental-precision --device cuda --input example.json

# Experimental: FP16 (profiles fp16 and fp16-rope-fp32) · 404 MB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp32/*" "weights/bf16/*" "weights/mixed-fp16/*" "weights/int16-storage/*" "weights/int8-mlp/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile fp16 --allow-experimental-precision --device cuda --input example.json

# Experimental: BF16 (profiles bf16 and bf16-rope-fp32) · 404 MB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp32/*" "weights/fp16/*" "weights/mixed-fp16/*" "weights/int16-storage/*" "weights/int8-mlp/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile bf16 --allow-experimental-precision --device cuda --input example.json

# Experimental: INT16 storage (also needs the FP32 base) · 1.2 GB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp16/*" "weights/bf16/*" "weights/mixed-fp16/*" "weights/int8-mlp/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile int16-storage --allow-experimental-precision --device cuda --input example.json

# Experimental: TorchAO INT8 MLP (needs the FP32 base and requirements-int8.txt) · 1.4 GB
hf download openvulcan/vulcan-decision-shell-v1-mini --exclude "weights/fp16/*" "weights/bf16/*" "weights/mixed-fp16/*" "weights/int16-storage/*" --local-dir vulcan-decision-shell-v1-mini
#   run: cd vulcan-decision-shell-v1-mini && python decision.py --root . --profile int8-mlp --allow-experimental-precision --device cuda --input example.json

# Everything · 3.1 GB
hf download openvulcan/vulcan-decision-shell-v1-mini --local-dir vulcan-decision-shell-v1-mini

vulcan-decision-shell-v1-runtime

VulcanCode and the dsh plugin download these packages themselves; the commands are for your own integration.

# v1 (standard) FP16: CUDA, WebGPU, CPU · 1.5 GB
hf download openvulcan/vulcan-decision-shell-v1-runtime --include "standard/fp16/*" "catalog.json" "LICENSE" "NOTICE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1-runtime

# v1-flash FP16: CUDA, WebGPU, CPU · 822 MB
hf download openvulcan/vulcan-decision-shell-v1-runtime --include "flash/fp16/*" "catalog.json" "LICENSE" "NOTICE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1-runtime

# v1-flash FP32: CUDA, WebGPU · 1.5 GB
hf download openvulcan/vulcan-decision-shell-v1-runtime --include "flash/fp32/*" "catalog.json" "LICENSE" "NOTICE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1-runtime

# v1-mini FP16: CUDA, WebGPU · 487 MB
hf download openvulcan/vulcan-decision-shell-v1-runtime --include "mini/fp16/*" "catalog.json" "LICENSE" "NOTICE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1-runtime

# v1-mini FP32: CUDA, WebGPU, CPU · 800 MB
hf download openvulcan/vulcan-decision-shell-v1-runtime --include "mini/fp32/*" "catalog.json" "LICENSE" "NOTICE" "SHA256SUMS" --local-dir vulcan-decision-shell-v1-runtime

vulcan-decision-shell-v1-data

# Everything · 866 MB
hf download openvulcan/vulcan-decision-shell-v1-data --repo-type dataset --local-dir vulcan-decision-shell-v1-data

What it is for

vulcan-decision-shell-v1 is a 752,393,024-parameter text model fine-tuned from Qwen3.5-0.8B-Base. An agent host shows it one tool call (the tool name, the complete arguments, the project root and three fixed authorization choices) and it answers allow, review or block. It is the decision model behind Vulcan Decision Guard and VulcanCode's auto approval, usually followed by an optional review LLM that only sees calls the model did not allow. v1-flash and v1-mini are smaller, faster models for the same task, fine-tuned from SmolLM2-360M and ModernBERT-base; the architecture and length notes under "How it decides" apply to v1.

What it guards against. Accidental mistakes an AI agent makes while running commands: deleting the wrong directory after a variable chain, wiping a database, mirroring in the wrong direction, writing outside the project, force-pushing or resetting a whole project.

What it does not guard against. An agent that is deliberately getting around the check, for example by writing a script and then running it. Stopping that would require analysing every file the agent writes and every script before execution, which no per-call judge can do. Auto approval lowers the odds of an accident; it does not guarantee that every risk is refused, and no model can. Keep using a sandbox, version control and backups.

How it decides

• Input. A fixed English policy, the tool name, the complete actual arguments, the project root and three authorization choices: cross_project_writes (allow/review), database_reset (confirm/allow) and project_reset (confirm/allow). No task description or previous chat turn is needed.
• Output. One forward pass scores three single-token candidates ( A, B, C → allow, review, block) and takes the argmax. No text is generated, no JSON is parsed and no threshold is tuned.
• Length. A complete input may be up to 32,768 tokens. Longer inputs are refused with an error and the host must not execute the call; inputs are never truncated. Batches split automatically.

Architecture: Qwen3.5 text model, 24 layers (18 Gated DeltaNet linear-attention layers and 6 full-attention layers), hidden size 1024, vocabulary 248,320, tied embeddings. The vision module is not included.

Quick start

Qualified environment: Linux x86_64, Python 3.11, an NVIDIA RTX 4090 (24 GB), PyTorch 2.9.1+cu128. Other GPUs, CPU inference, NPUs, Windows and macOS have not been qualified.

v1

Download your version with its command under Download above, then enter the vulcan-decision-shell-v1 folder.

Native PyTorch runtime:

python3.11 -m venv .venv && source .venv/bin/activate
python -m pip install torch==2.9.1 --index-url https://download.pytorch.org/whl/cu128
python -m pip install -r requirements-native.txt
python -m pip install --no-deps wheels/causal_conv1d-1.7.0+cu12torch2.9cxx11abiTRUE-cp311-cp311-linux_x86_64.whl

ONNX runtime: install onnx/requirements-onnx.txt and the bundled onnx/wheels/onnxruntime_gpu-1.30.0.dev20260812001-cp311-cp311-manylinux_2_28_x86_64.whl in a separate Python 3.11 environment. A stable onnxruntime-gpu release lacks the CUDA LinearAttention kernel this graph needs.

Requests are JSON lines. runtime/request.py builds them:

import json, sys
sys.path.insert(0, "runtime")
from request import make_record

record = make_record(
    tool_name="shell_command",
    arguments={"command": "rm -rf build/ && npm run build"},
    project_root="/home/me/project",
    settings={"cross_project_writes": "review", "database_reset": "confirm", "project_reset": "confirm"},
)
print(json.dumps(record))

python runtime/judge_native.py --model-directory . --profile mixed-bf16 < requests.jsonl

The runtime prints one decision per input line. It requires CUDA and refuses to fall back to CPU or to slower kernels.

Flash and Mini portable packages

The portable packages are verified only on Python 3.11, Linux x86_64, an RTX 4090 and CUDA 12.8. In a separate virtual environment, enter the repository folder, run pip install -r requirements.txt, then:

# Flash
python decision.py --profile original --input example.json
# Mini (GPU)
python decision.py --root . --profile original --device cuda --input example.json
# Mini (CPU)
python cpu_decision.py --root . --profile original --cpu-backend fp32 --threads 16 --input example.json

The input is a JSON array of settings/rendered objects, shaped like the package's example.json. original is the preserved baseline; other precisions need --allow-experimental-precision. Per-precision results are in each package's precision-formats.json and in docs/flash/ and docs/mini/.

Formats compared

Same 106,501-input core and the same RTX 4090. "Changes" and "new risky allows" are counted against the same-batch FP32 reference. Latency is the mean of short inputs; memory is the PyTorch peak (ONNX: sampled device memory).

Format	Folder	Weights	Core changes	New risky allows	Short call	Batch of 10	32K input	GPU memory, short / 32K
FP32 weights, BF16 compute	root	3.01 GB	reference	—	40.8 ms	51.1 ms	800 ms	3.78 / 6.05 GiB
mixed-bf16 (186 linears BF16)	root	3.01 GB	0 (0 of 531,692)	0	39.4 ms	47.5 ms	779 ms	1.94 / 4.25 GiB
Full BF16	variants/bf16	1.50 GB	2	2	54.4 ms	47.0 ms	751 ms	1.46 / 3.58 GiB
Full FP16	variants/fp16	1.50 GB	2	1	44.2 ms	46.4 ms	770 ms	1.46 / 3.58 GiB
ONNX FP16	onnx/cuda-fp16	1.51 GB	4	2	27.8 ms	130.5 ms	1680 ms	2.42 / 15.4 GiB
ONNX MLP INT8 (experimental)	onnx/experimental/int8-mlp	1.25 GB	9	2	27.3 ms	122.7 ms	1667 ms	2.42 / 15.4 GiB
INT16 storage (experimental)	variants/int16-storage	2.02 GB	2	1	40.6 ms	51.1 ms	786 ms	3.78 / 6.05 GiB
TorchAO INT8 delta (experimental)	variants/int8-mixed-delta	+0.31 GB on FP32	16	7	50.3 ms	56.8 ms	841 ms	2.34 / 4.65 GiB

Start with mixed-bf16 on the root FP32 weights: it kept every decision on the full 531,692-input set while lowering memory. Smaller formats change a few borderline decisions; quantization is not automatically faster. Details: docs/QUANTIZATION-NOTES.en.md, docs/reports/QUANTIZATION-v8055-RESOURCES-CPU-GPU.en.md, docs/HARDWARE.en.md.

Evaluation

On 2026-10-27 we compared the three models of this family (v1 0.75B, v1-flash 0.36B, v1-mini 0.2B) with two external decision services on one frozen bank: JEV 1.14.0 (jev-1.14.0) and the Alibaba Cloud Bailian decision model bailian-decision-preview. All five used the same fixed English policy, complete arguments, project root and authorization choices, no task description, and each its own native decision rule with nothing tuned for the comparison. The merged report was finalized on 2026-10-28; external results describe the services as they were then.

Labelled core (106,501 inputs). A large share of these questions come from our own training and test banks, which clearly favours us, and the reference labels are ours, not production ground truth.

Metric	v1	v1-flash	v1-mini	JEV 1.14.0	Bailian
Normal calls allowed (higher is better)	99.07%	97.74%	92.82%	73.10%	96.60%
Should-review calls allowed (lower is better)	2.40%	2.72%	10.49%	17.03%	90.92%
Should-block calls allowed (lower is better)	0.04%	2.01%	6.47%	2.99%	76.85%
Severe accidents allowed	0 / 16,613	2.07%	6.56%	2.43%	76.88%
Harmless calls blocked (lower is better)	0.20%	1.07%	2.89%	8.11%	1.79%

Real commands. 483,680 occurrences of 415,194 distinct Codex and Claude calls (bodies are private and not published): allowed by frequency 99.76%, 99.80%, 99.18%, 99.69% and 99.99% in the order above. An AI static review of the 1,144 calls v1 did not allow found 861 clear false positives, 188 calls worth confirming and 95 that could not be decided. Allow rate is not accuracy.

Calls we have not trained for. On the conditional-guard, variable copy and cleanup development holdout, should-block calls allowed were v1 43.75%, v1-flash 55.00%, v1-mini 38.75%, JEV 1.88% and Bailian 100%; harmless calls blocked were 15.36%, 16.70%, 20.32%, 4.82% and 0%.

How to read this. The difference is in direction and training goals, not in who is stronger:

• JEV is clearly trained for command judgement and covers more ground than we do; on calls we have not trained for it is far better than us. Its lower allow rate on our bank means it is more cautious about the patterns we specialise in.
• The Bailian decision model serves broad, general purposes and was most likely not trained on coding agents' command mistakes, so it tends to allow on this bank and almost never blocks normal work. This is not a criticism of it.
• We are good at the mistake families we trained for: variable chains and deletion targets, mirror and sync direction and dry-run switches, showing versus running, Git project roles and targets, database execution scope, long commands and SCP uploads. Outside them we keep filling gaps with samples exported from decision records.

All 96 evaluation sets for the five, long inputs, the RTK-prefix pairs and speed: docs/FAMILY-COMPARISON.en.md. Full v1 results: docs/EVALUATION.en.md, docs/COMPARISON-JEV-ALIYUN.en.md, docs/reports/REAL-TRAFFIC-REVIEW.en.md, docs/reports/vulcan-decision-shell-v1-v8055-test.en.md.

Training

Why it was trained this way. The goal is fewer accidents caused by an AI's unintended mistakes, not stopping every possible risk:

• The risk of a mistake is in the arguments of the single call, so reading them is enough to judge it. Deliberate bypass (write a script, then run it) looks like normal development at every step; a per-call judge cannot stop it in principle, and sandboxes and isolation should.
• 99.76% of real calls are normal. The more the first layer stops, the more likely users are to turn auto-approval off or approve without reading, so normal allows matter as much as risky misses.
• Thresholds are therefore set by accident consequences: zero direct allows of risky calls carrying an accident flag, and normal allows at 98% or higher. The curriculum is built around concrete mistake mechanisms such as deletion scope, variable values, mirror and dry-run switches, target scope and authorization options. Uncertain calls go to review; the error to avoid most is a wrong allow.

The full explanation is the first section of docs/TRAINING-HISTORY.en.md.

Weights restart from Qwen/Qwen3.5-0.8B-Base (revision dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68); earlier 164M and 199M models contributed data, not weights. The selected chain has 26 stages, v8001 to v8055, combining native fixed-English three-candidate classification, replay, reference-score preservation and operand and scope auxiliary tasks, with LoRA in later stages. The banks hold 575,693 prompts (576,397 prompt and supervision pairs). Privacy screening withheld private and reserved-test items without replacing them.

How the model got here, including the failures and what each one changed: docs/TRAINING-HISTORY.en.md. Data: docs/TRAINING-DATA.en.md, docs/VALIDATION.en.md and the vulcan-decision-shell-v1-data dataset.

Documents

Document	Contents
docs/EVALUATION.en.md	Every cohort, every format, all 90 core source groups
docs/FAMILY-COMPARISON.en.md	Five-way comparison of this family with JEV and Bailian, all 96 evaluation sets
docs/flash/, docs/mini/	Full v1-flash and v1-mini assessments, precisions and their five-way source reports (Chinese)
docs/COMPARISON-JEV-ALIYUN.en.md	The full v1 comparison with JEV and Bailian bailian-decision-preview
docs/TRAINING-HISTORY.en.md	Training phases, lineage, pitfalls and lessons
docs/history/INDEX.md	Selected original training reports (Chinese)
docs/HARDWARE.en.md	Tested environment, installation and resources
docs/QUANTIZATION-NOTES.en.md	Why precision is kept per layer
docs/BATCH-CONTROLS.en.md	Batch-size controls
docs/TRAINING-DATA.en.md, docs/VALIDATION.en.md	Training and validation banks
docs/reports/	Release test reports (quantization, ONNX, real traffic, portable entry)
docs/evaluation/	Machine-readable aggregate metrics

Every document has a Chinese version with the .zh.md suffix. SHA256SUMS in each repository lists the checksum of every file; the v1 files match the original verified release packages.

Limitations

• Only one RTX 4090 on Linux x86_64 with Python 3.11 was qualified. CPU inference, NPUs, DirectML, CoreML, ROCm and other GPUs were not.
• The ONNX graph needs the pinned development build of onnxruntime-gpu and runs on CUDA only.
• Known weaknesses remain in new compositions, copy scope, authorization and some Git operations; see the evaluation documents.
• The model gives no reasons. Explanations of its behaviour in the reports are inferences.
• Opaque tools (business scripts, MCP servers with unclear effects) cannot be judged from the call alone.
• The Flash and Mini portable packages are verified only on one RTX 4090; the runtime packages were checked on CUDA, WebGPU and CPU on an RTX 5080, with WebGPU tested on NVIDIA only. Mini's FP16 graphs crash on the CPU under ONNX Runtime 1.30, so use fp32 there.
• v1-flash was not trained on SCP uploads; v1-mini trails v1 and v1-flash on most evaluation sets. Where an allowed mistake is costly, prefer v1.

License

The weights and code are released under the Apache License 2.0. The model is derived from Qwen3.5-0.8B-Base by the Qwen team (Apache-2.0); v1-flash derives from SmolLM2-360M and v1-mini from ModernBERT-base, both Apache-2.0. Third-party sources in the training data keep their own licenses; see docs/licenses/.

The cloud command decision model is free, permanently (committed on October 27, 2026); sign in with an OpenVulcan account in Vulcan Decision Guard or VulcanCode to use it.

Citation

@misc{openvulcan2026vulcandecisionshellv1,
  title  = {vulcan-decision-shell-v1: a dedicated decision model for AI agent tool calls},
  author = {OpenVulcan},
  year   = {2026},
  url    = {https://github.com/OpenVulcan/vulcan-decision-guard}
}