vera-large

vera-large is a non-autoregressive System 1 decision model. Give it a state (text, email, ticket, or JSON) and typed questions; it returns typed answers with calibrated probabilities. It never generates text, so there is nothing to parse and nothing to hallucinate. It speaks the same wire format as Jev (POST /v1/systemone).

It is our largest and most accurate vera: vera-core-2's way of reading options on a Qwen3.8-27B backbone. It scores 68.4 on our sample of the public Jev Decision Index, ahead of d3 (65.5) and Jev 1.14 (60.7). Every request is read whole: the state, the question and the option descriptions are never cut.

Base model

vera-large is derived from Qwen3.8-27B (Apache-2.0); it keeps the text backbone (~26B parameters). Each question is read in one forward pass: the prompt lists every option under a short answer code, the full-attention layers see the whole prompt (the Gated DeltaNet layers stay causal), and each option is scored at the last prompt token through its answer code plus an option-pointer readout that looks back at the option's own line. Training updates the full-attention projections, the DeltaNet gates and every norm in full and the rest of the backbone through LoRA; the LoRA updates are folded into the released weights, so the checkpoint is a plain full model. The probabilities are temperature-calibrated per question type.

Use cases

• Routing and triage: send a ticket, email or request to the right team, queue or priority.
• Intent and topic classification: map messages to your own intent set, with calibrated confidence for escalation.
• Tool and function selection: choose which tool or API an agent should call next, or none.
• Policy and compliance checks: decide whether a case follows a rule or breaks it, including long policy documents.
• Scoring and severity: rate on an ordinal scale (urgency, sentiment, risk) with a full probability distribution.
• Fact and claim verification: check a statement against a document.
• Judging and ranking: compare candidate responses and pick the better one.
• Confidence-gated workflows: act automatically when confident, hand off to a slower model or a human when not.

Benchmarks

Jev Decision Index 0.3 (public suite, higher is better)

model	params	Decision Index	knowledge	language	retrieval	tools	arts
vera-large (this repo)	~26B	68.4	51.7	77.0	67.5	84.5	61.5
vLLM-SR d3	27B	65.5	55.3	68.0	66.9	82.6	51.0
Jev 1.14 (reference)	–	60.7	57.1	61.2	63.5	73.8	39.2
vera-core-2	~2B	41.3	21.4	43.9	53.8	61.5	23.9

vera-large's row is our run of the official kit on a 5% stratified sample of the public suite: 7,281 rows, of which 7,249 were answered and the rest count as wrong. On the same sample d3 scores 65.44, against 65.45 on the board; on our 2B models the sample read about 1.4 points above the full suite. The d3 and Jev rows are from the public board (Decision Index 0.3.2); vera-core-2's is our run of the full suite. vera-large is not on the board yet. Median latency per request: 139 ms on one MI300X.

Quickstart

vera-large uses the same vera package (vera-s1, version 0.1.6 or newer) as vera-core-2, vera-core and vera-spark:

pip install -U "vera-s1[fast]"

Python 3.10 or newer. The weights (~51 GB) are downloaded once, on first use, and cached. A GPU is required: plan for an 80 GB-class card or larger (H100 80GB, RTX PRO 6000 96GB, MI300X). [fast] adds flash-linear-attention for the DeltaNet layers.

import vera

agent = vera.load("scar-ai/vera-large")

state = "Hi, we were billed twice for March. Please refund the duplicate today or we will cancel our plan."
questions = {
    "department": {"type": "choice", "instructions": "Which department should handle this?",
                   "criteria": {"billing": "invoices, payments, refunds",
                                "technical": "bugs, outages, system errors",
                                "other": "everything else"}},
    "urgency": {"type": "score", "instructions": "How urgent is this?",
                "criteria": ["not urgent", "soon", "blocking"]},
    "churn_risk": {"type": "noul", "instructions": "Does the user threaten to cancel or leave?"},
}

result = agent.predict(state, questions)
print(result["answers"]["department"]["choice"])       # billing
print(result["answers"]["department"]["probabilities"])
print(result["answers"]["churn_risk"]["noul"])         # probability the answer is yes

All questions in a call are answered together. The state can be plain text or any JSON-serialisable object. Question types: choice (2 to 255 options), score (2 to 10 ordered levels, returns an expected score and the full distribution) and noul (yes/no probability).

Weights: bf16 (default) and fp32

main holds the weights in bf16 (51 GB). The full-precision fp32 weights (102 GB) are on the fp32 branch:

agent = vera.load("scar-ai/vera-large", revision="fp32")                                        # vera package
model = AutoModel.from_pretrained("scar-ai/vera-large", revision="fp32", trust_remote_code=True)  # transformers

For vera-serve, download the branch first and point --model at the folder:

hf download scar-ai/vera-large --revision fp32 --include "model*.safetensors*" --include "*.json" --include "*.jinja" --local-dir vera-large-fp32
vera-serve --model ./vera-large-fp32 --port 8200

Self-hosting: Jev-compatible HTTP server

vera-serve exposes the model on the same POST /v1/systemone request and response shape as Jev, so existing clients work by changing their base URL:

vera-serve --model scar-ai/vera-large --port 8200                    # PyTorch engine
vera-serve --model scar-ai/vera-large --engine vllm --port 8200      # vLLM engine, see below

curl -s localhost:8200/v1/systemone -H 'Content-Type: application/json' -d '{
  "state": {"document": "I was charged twice. Please fix this ASAP."},
  "questions": {"billing": {"type": "noul", "instructions": "Is this ticket about billing?"}}
}'

It binds 127.0.0.1 by default (use --host 0.0.0.0 to expose it) and has no authentication, so put it behind your own gateway if you expose it. Concurrent requests are batched.

Use with transformers

The checkpoint also loads through transformers with AutoModel (custom code, so trust_remote_code=True). It needs transformers 5 or newer, in a release that includes Qwen3.5. Outputs match the vera package. Loading needs no download of the base model. On main the backbone loads in bf16 (the decision readout stays fp32). device_map needs accelerate (pip install -U transformers accelerate).

from transformers import AutoModel

model = AutoModel.from_pretrained("scar-ai/vera-large", trust_remote_code=True, device_map="cuda")
state = "Hi, we were billed twice for March. Please refund the duplicate today."
questions = {"department": {"type": "choice", "instructions": "Which department should handle this?",
                            "criteria": {"billing": "invoices, payments, refunds", "other": "everything else"}}}
print(model.predict(state, questions)["answers"]["department"])    # same shape as POST /v1/systemone

The same model is also available as a transformers pipeline task, decision:

from transformers import pipeline

decide = pipeline("decision", model="scar-ai/vera-large", trust_remote_code=True, device=0)
print(decide(state=state, questions=questions)["answers"])
# also: decide({"state": ..., "questions": {...}}) or a list of such requests

For tensor-level use, model.encode_batch(state, questions) builds the inputs and model(**batch).logits returns the calibrated option scores (softmax(logits, -1) gives probabilities). The model is non-autoregressive and has no generate().

Inference engine and decision API status

vera answers decisions through the Jev-compatible POST /v1/systemone API, not through text generation. That decides which engines can serve it.

engine / API	status	notes
vera-serve (POST /v1/systemone, /api/v1/decide)	Supported	The reference decision API server; batches concurrent requests. PyTorch or vLLM engine (--engine vllm).
vera.load(...).predict(...) (Python)	Supported	Same result shape as the HTTP API.
transformers (AutoModel, trust_remote_code=True)	Supported	See above. predict() mirrors the decision API.
vLLM	Supported	Through vera-serve --engine vllm, or the engines/ adapter with no vera package. See Run with vLLM.
SGLang	Not supported yet	Its Qwen3.5 full-attention layers are causal only; vera-large's read the whole prompt.
Ollama (and llama.cpp / GGUF)	Not supported	There is no GGUF architecture for the decision readout, and Ollama serves text generation only.

An OpenAI-style chat or completions client will not work with vera-large on any engine: the model scores options, it does not generate text.

Run with vLLM

vllm serve on this repo does not work directly: vLLM runs the backbone in its pooling runner, with the full-attention layers bidirectional (is_causal: false, encoder-only attention), and the vera readout runs on top. A GPU is required. The bf16 backbone is ~51 GB: one 96 GB-class GPU (RTX PRO 6000, MI300X) holds it, or split it over two 80 GB GPUs with tensor parallelism.

The simplest way is vera-serve, which exports the backbone once (cached in ~/.cache/vera/vllm) and serves the same HTTP API:

pip install -U "vera-s1[vllm]"
vera-serve --model scar-ai/vera-large --engine vllm --port 8200                            # one 96 GB+ GPU
vera-serve --model scar-ai/vera-large --engine vllm --tensor-parallel-size 2 --port 8200   # two 80 GB GPUs

or in Python: vera.load("scar-ai/vera-large", engine="vllm", tensor_parallel_size=2). --gpu-memory-utilization defaults to 0.9 for vera-large. A request longer than --max-model-len (default 32,768 tokens) is refused, never cut; raise it for longer states.

Without the vera package, use the adapter in engines/, which runs this repo's own code (vera_model.py, vera_schema.py):

pip install vllm
hf download scar-ai/vera-large --include "engines/*" --local-dir .
python engines/export_backbone.py --model scar-ai/vera-large --out ./vera-large-backbone

import sys; sys.path.insert(0, "engines")
from vera_engine import from_vllm

agent = from_vllm("scar-ai/vera-large", "./vera-large-backbone", tensor_parallel_size=2)   # 1 on a 96 GB+ GPU
print(agent.predict("I was charged twice. Please fix this ASAP.",
                    {"billing": {"type": "noul", "instructions": "Is this ticket about billing?"}})["answers"])

Chunked prefill and prefix caching are off, since a bidirectional prompt must be read in one piece. Answers match the PyTorch engine up to bf16 kernel differences.

Limitations

• vera-large needs a large GPU: 51 GB of bf16 weights, so an 80 GB-class card or larger, or two GPUs with vLLM tensor parallelism. It is not practical on CPU. For a small footprint, use vera-core-2 (2B) or vera-spark.
• Knowledge-heavy decisions are its weakest area on the Decision Index (51.7, 3.6 points behind d3).
• The released checkpoint is not tuned for browser or computer-use agents. For those, fine-tune it on traces from your own agent first.
• Requests are never truncated, so very long states cost memory and time in proportion to their length.

The vera family

All share the same System One interface and wire format, so you can swap one for another.

• vera-large (this repo): our largest and most accurate model (~26B parameters).
• vera-core-2: the same way of reading options at ~2B parameters.
• vera-core: the first 2B vera.
• vera-spark: the compact model (~630M parameters).

All are generalist bases meant to be fine-tuned for your use case.

Files

file	description
model-*.safetensors, model.safetensors.index.json	weights (bf16 on main, fp32 on fp32), calibration temperatures included; read by the vera package, transformers and the vLLM export
config.json	transformers-format config (AutoModel, trust_remote_code=True)
configuration_vera.py, modeling_vera.py, vera_model.py, vera_schema.py	custom code for the transformers loader
pipeline_vera.py	the decision pipeline (pipeline("decision", ..., trust_remote_code=True))
dist/vera_s1-0.1.6-py3-none-any.whl	the vera-s1 Python package, also on PyPI
engines/export_backbone.py, engines/vera_engine.py	vLLM adapter (see Run with vLLM)
arch.json	architecture flags for the loader
tokenizer.json, tokenizer_config.json, chat_template.jinja	tokenizer and prompt template (Qwen3.8)