vera-core-2

vera-core-2 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 keeps the backbone of vera-core, Qwen3.5-2B, and scores 41.3 on the public Jev Decision Index, up from vera-core's 30.1 and within a point of d3-nano, the strongest open model of its size. Every request is read whole: the state, the question and the option descriptions are never cut.

Base model

vera-core-2 is derived from Qwen3.5-2B (Apache-2.0). 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. The whole stack is fully fine-tuned on decision data, and the probabilities are temperature-calibrated per question type.

vera-core-2 is a generalist base: fine-tune it for your use case

The released checkpoint works zero-shot across many kinds of decisions, but it is built to be a starting point. Fine-tune it on decisions from your own domain and it will fit your labels, your wording and your calibration far better than the generalist base.

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.
• 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-core-2 (this repo)	~2B	41.3	21.4	43.9	53.8	61.5	23.9
vera-core	~2B	30.1	–	–	–	–	–
vera-spark	~630M	19.6	–	–	–	–	–

Our run of the public suite (all 140,620 rows answered, nothing truncated). Median latency per request: 78 ms on one MI300X.

Quickstart

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

pip install -U vera-s1

Python 3.10 or newer. The weights (3.8 GB) are downloaded once, on first use, and cached. A GPU is recommended: on CPU a request takes several seconds. For the fastest GPU path, use pip install -U "vera-s1[fast]".

import vera

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

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 (3.8 GB). The full-precision fp32 weights (7.5 GB) are on the fp32 branch:

agent = vera.load("scar-ai/vera-core-2", revision="fp32")                                        # vera package
model = AutoModel.from_pretrained("scar-ai/vera-core-2", 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-core-2 --revision fp32 --include "model*.safetensors*" --include "*.json" --include "*.jinja" --local-dir vera-core-2-fp32
vera-serve --model ./vera-core-2-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-core-2 --port 8200

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). Tested with transformers 5.19.0 (vera-core-2 needs a transformers release that includes Qwen3.5); outputs match the vera package exactly (max probability difference 0.0 on 60 held-out decisions, GPU and CPU). Loading needs no download of the base model.

from transformers import AutoModel

model = AutoModel.from_pretrained("scar-ai/vera-core-2", trust_remote_code=True)   # add .to("cuda") if you have a GPU
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-core-2", trust_remote_code=True)   # device=0 for a GPU
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). On a GPU the backbone runs in bf16, as in the vera package. 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.
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 via engines/ adapter	No vera package needed. See Run with vLLM.
SGLang	Not supported yet	Its Qwen3.5 full-attention layers are causal only; vera-core-2'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-core-2 on any engine: the model scores options, it does not generate text.

Run with vLLM

vllm serve on this repo does not work directly. Use the adapter in engines/: vLLM runs the backbone in its pooling runner, with the full-attention layers bidirectional (is_causal: false, the same encoder-only attention vLLM uses for ColQwen3.5), and the vera readout runs on top, using this repo's own code (vera_model.py, vera_schema.py): the vera package is not needed. A GPU is required.

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

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

agent = from_vllm("scar-ai/vera-core-2", "./vera-core-2-backbone")   # max_model_len=32768 by default
print(agent.predict("I was charged twice. Please fix this ASAP.",
                    {"billing": {"type": "noul", "instructions": "Is this ticket about billing?"}})["answers"])

Tested on an MI300X with vLLM 0.29.0 (no vera package installed) on 400 held-out decisions: the same answer as the vera package on 399/400, the same accuracy, mean probability difference 0.003 (bf16 kernels), median latency per question 40-44 ms. Chunked prefill and prefix caching are off, since a bidirectional prompt must be read in one piece. vLLM refuses prompts longer than max_model_len instead of cutting them; raise it for longer states.

Limitations

• 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.

vera-core-2, vera-core and vera-spark

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

• vera-core-2 (this repo): our most accurate model (~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*	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.4-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.5)