Beveridge-Large-C

A System One decision model with open weights. Give it a document (text, email, ticket, log or JSON) and typed questions; it returns typed answers (yes/no, a choice between options you describe, or a score on levels you define) with a calibrated probability for every option, in one pass. It never generates text, so there is nothing to parse and nothing to hallucinate. It runs on your own machines: your documents never leave them.

398.2M parameters (ModernBERT-large plus a 3.5M-parameter decision network), English, up to 4,096 input tokens; runs on a laptop CPU or GPU, an edge box, or any GPU.

Installation

python -m pip install bev-decisions

Python 3.10 or newer. Optional extras: bev-decisions[serve] (HTTP server), bev-decisions[mcp] (MCP server for AI assistants and agents), bev-decisions[structured] (Pydantic schemas), bev-decisions[all]. The first bev.load() downloads the model from this repository and caches it; after that it works offline.

Quickstart

import bev

model = bev.load("sathiskumarjothi0/Beveridge-Large-C")
answers = model.decide(
    "Subject: Charged twice for order 88412. I was billed $49.99 twice on 3 October. Please refund one payment today.",
    {
        "team":     {"type": "choice", "instructions": "Which team should handle this ticket?",
                     "criteria": {"billing": "payments, invoices, refunds", "tech": "bugs, outages, errors", "sales": "pricing and plans"}},
        "urgent":   {"type": "noul", "instructions": "Does the customer ask for urgent handling?"},
        "severity": {"type": "score", "instructions": "How severe is the problem for the customer?", "criteria": ["low", "medium", "high"]},
    },
)
answers["team"]   # {"choice": ..., "confidence": ..., "probabilities": {...}}

Run with or without a GPU

bev.load() picks the best device it finds: an NVIDIA GPU (cuda), an Apple Silicon GPU (mps), otherwise the CPU. Choose one yourself with device=:

model = bev.load("sathiskumarjothi0/Beveridge-Large-C", device="cpu")    # no GPU needed
model = bev.load("sathiskumarjothi0/Beveridge-Large-C", device="cuda")   # NVIDIA GPU
model = bev.load("sathiskumarjothi0/Beveridge-Large-C", device="mps")    # Apple Silicon GPU

Command line: bev "I was charged twice, please refund" --noul "Does the customer ask for a refund?" --device cpu.

The first load includes reading the 1.6 GB weights; after that, use decide_batch for many documents.

Use cases

Check any use case on a few hundred labelled examples of your own first (bev eval my_cases.jsonl).

Voice examples

Beveridge reads text, so it pairs well with open speech models: a caller's voice note is transcribed, Beveridge answers typed questions about it, fixed reply rules turn the answers into a reply, and a text-to-speech model speaks it. Same model, different questions: 23 use cases, from customer service, IT helpdesk and agentic AI to engineering, lab notes and robotics.

Speech to text: Whisper / faster-whisper (MIT). Text to speech: Kokoro-82M (Apache-2.0), stock voices only; no real person's voice is used. Use cases outside the areas Beveridge was tested on are illustrations. Runnable script: examples/14_voice_reply.py. Beveridge can make mistakes; keep a person in the loop for important decisions.

Up to 16 questions per call share one read of the document.

Confidence gating

sure, review = bev.gate(answers, threshold=0.8)   # act on `sure`, send `review` to a person

Route mode

Route mode sends every question to Beveridge-Large-C first and only the unsure answers to Beveridge-Pro-C:

router = bev.Router(load_strong=True, threshold=0.8)
result = router.decide(text, questions)
result["answers"], result["routing"]          # routing: {"team": "fast", "urgent": "strong"}

Schema-driven decisions

from typing import Literal
from pydantic import BaseModel, Field

class Ticket(BaseModel):
    urgent: bool = Field(description="Does the customer ask for urgent handling?")
    team: Literal["billing", "tech", "sales"] = Field(description="Which team should handle this ticket?")

ticket = bev.decide_as(model, text, Ticket)       # Ticket(urgent=True, team='billing')

Self-hosting: HTTP and MCP

pip install "bev-decisions[serve]"
bev serve --model sathiskumarjothi0/Beveridge-Large-C --port 8000      # POST /v1/decide, /v1/batch; GET /v1/presets, /health
pip install "bev-decisions[mcp]"
bev mcp --model sathiskumarjothi0/Beveridge-Large-C                    # tools: decide, decide_preset, list_presets

The server listens on 127.0.0.1 without authentication; put it behind your own gateway before exposing it. Docker files and examples are in the GitHub repository.

Benchmarks

Accuracy (%) = correct answers ÷ questions on held-out test sets; the same cases for every system (October 2026). Bold = best in the row; – = not run. * = an area Beveridge was not built for.

Decisions on documents

Public classification tests

Areas Beveridge was not built for

Size and speed

Accuracy on the same 10,238 answers against total parameters (log scale), for every system with a published size: Beveridge-Large-C (0.4B) and Beveridge-Pro-C (25.8B) are more accurate than LLMs of 31B to 675B.

The LLMs and Jev were measured through their cloud APIs (median response time per decision, including network and queueing): Jev 98 ms, the five LLMs 4.1 to 7.0 s.

How much of the work can you automate?

Sort every answer from most to least confident and hand over the most confident ones first. The share you can hand over while those decisions stay at least 95% (or 90%) correct is the automation rate. Example: "76% at 95%" means 3 of every 4 decisions are taken automatically and at least 95% of them are right; the rest go to a person. Answers given with the same confidence are handed over together, so a system whose "100% sure" answers are only 94% right reaches 0% at the 95% target. Held-out tests: Beveridge-Bench, typed decisions and Aegis 2.0 request safety, 10,238 answers per system.

Beveridge-Bench, question by question

Averages hide weak spots. Bold = within 10 points of always answering the most common label, i.e. little or no skill.

Calibration

ECE (expected calibration error) = Σ over 10 confidence bins of (share of answers in the bin × |accuracy − mean confidence|); 0 is perfect. Example: a bin holding 40% of the answers at mean confidence 0.95 with 90% of them right adds 0.4 × 0.05 = 0.02. Calibration temperatures: noul 1.5, choice 1.2, score 1.0. Option-order flips: 103 of 3,035 answers (3.4%) change when options are shuffled.

Package check

The bev-decisions package was checked against the official evaluation run on 3,000 questions: 100.0% identical answers.

Honest limits

• Knowledge-heavy decisions are weak: legal case holdings 42.0%, financial-news topics 37.8%; use Beveridge-Pro-C for these.
• How late an invoice is paid, judged against today's date, is not reliable: compute due dates and lateness in your own code.
• Very large intent sets and five-level sentiment are weaker than the operations questions.
• With very many options (hundreds), the top answer is often right but its probability is low (on a 250-option question: right every time, at about 14% confidence); choose that question's threshold on your own data.
• Option order matters for a small share of questions: 3.4% of answers change when the options are shuffled, so keep the order stable between calls.
• English only; text beyond 4,096 tokens is cut; no images.
• Not for medical, legal or financial advice. For decisions with serious consequences, validate on your own data (bev eval my_cases.jsonl) and keep a person in the loop.

Files

Links

• Package: pypi.org/project/bev-decisions
• Code and examples: github.com/sathiskumarjothi0-oss/bev-decisions-pypi
• Beveridge-Pro-C: huggingface.co/sathiskumarjothi0/Beveridge-Pro-C

Support

If Beveridge is useful to you, you can support its development: buymeacoffee.com/sjothi

Licence and credit

Apache-2.0, © 2026 Dr. Sathiskumar JOTHI. Built on ModernBERT-large (Apache-2.0) by Answer.AI and LightOn.

About the name

Beveridge is named after Sir William Beveridge (1879–1963), the British economist, born in British India and educated in England, whose 1942 Beveridge Report laid the foundations of the modern welfare state and of the National Health Service (NHS), built for the good of future generations. The name is a reminder of what we want from the model: dependable, fair decisions that serve people, made carefully and checked against the facts.

Other models on Hugging Face are called Bev; they are not related to this model. The Python package keeps its short name: pip install bev-decisions, import bev.