Update, 27 October 2026: we’ve published build 1.2 of cox-1-3b, which now replaces the build described here on Hugging Face. The numbers below are for the first build, 1.1, which you can still load with
revision="cox-1.1".
21 October 2026. Today we’re releasing cox-1-3b, the first open-weight model in our Cox family of decision models. It’s available now on Hugging Face under Apache-2.0, and you can run it on your own GPU with coxlm, our open-source Python package.
What it does
A lot of the work teams hand to large language models today is really a small decision about a piece of text: which team should handle this ticket, does this message ask for a refund, does this clause contradict the policy, is there enough information here to go ahead. A general-purpose model can answer those questions, but it replies in prose you have to parse, it takes seconds, and its “I’m fairly sure” is a sentence rather than a number you can act on.
cox-1-3b answers them directly. You give it a text and a set of typed questions (yes or no, pick one of these options, or rate on this scale), and it returns a probability for every option of every question, without generating any text. Since every answer is one of the options you offered, your code can use the result without parsing it, and since the probabilities are calibrated (answers given at 80% confidence are right about 80% of the time), you can automate the confident answers and send the rest to a person.
import coxlm
from coxlm import Questions, choice, yesno
class Ticket(Questions):
team = choice(["billing", "support", "sales"], instructions="Which team should handle this?")
refund = yesno("Is the customer asking for a refund?")
with coxlm.load("Vitund/cox-1-3b") as model:
ans = model.decide("My card was charged twice for the same order.", Ticket)
print(ans.team.choice, ans.team.confidence, ans.refund.p_yes)One request can carry as many questions about the same text as you need. The model reads the text once and answers each question as if it had been asked alone, so adding a question never changes the answers to the others.
How it compares
We scored cox-1-3b against Kev 4B and Kev 9B, the open decision models closest to it in size, and against TypeSafe AI’s hosted Jev, on 15 public datasets that none of the compared models is known to have trained on: about 18,500 decisions covering moderation, intent detection, contract clauses, scientific claims, paraphrase, spam and more. We ran every model through the same code and reviewed the test labels the same way for every model before scoring.
| model | size | skill (95% interval) | accuracy | calibration error |
|---|---|---|---|---|
| cox-1-3b | 2.9B | +0.648 (+0.635 to +0.660) | 80.3% | 0.082 |
| Kev 4B | 4B | +0.615 (+0.601 to +0.628) | 78.7% | 0.082 |
| Kev 9B | 9B | +0.652 (+0.639 to +0.664) | 80.7% | 0.082 |
| Jev 1.14.0 | hosted | +0.669 (+0.655 to +0.682) | 82.0% | 0.064 |
Skill is 0 for always giving the most common answer and 1 for a perfect score, so it can be compared across tasks with different numbers of options. cox-1-3b scores above Kev 4B, although it’s the smaller model, and close to Kev 9B, a model three times its size, while Jev scores higher than both. Its stated confidence is slightly lower than its actual accuracy, by about a point on average, which is the safer side when you automate everything above a threshold.
On JevBench, an independent public benchmark for decision models maintained by Benchmark Heaven, cox-1-3b answers 77.1% of the 231 scenarios correctly with the benchmark’s unmodified harness, against 75.8% for Kev 4B, 79.7% for Kev 9B and 87.9% for Jev 1.14.0.
Other decision models we’ve tested
Most other decision models trained on some of the public datasets in our test suite, so we can’t put them in the table above without scoring them on datasets they were trained on. Instead we score each model only on the tasks its makers don’t list as training data, and put cox-1-3b’s score on the same tasks beside it. Where a model’s training data isn’t published, we can’t rule anything out, so its row uses every task and may overstate its skill.
| model | open weights | size | tasks | its skill | cox-1-3b, same tasks | what we know about its training data |
|---|---|---|---|---|---|---|
| Liquid d1-ultra | no | not disclosed | 21 | +0.750 | +0.657 | not published |
| Perplexity Decider V1.2 | yes | 27B | 14 | +0.747 | +0.628 | partly published; also trains on benchmarks’ official training splits |
| Perplexity Decider Flash V1.2 | yes | 4B | 14 | +0.705 | +0.628 | as above |
| Jev 1.14.0 | no | not disclosed | 21 | +0.701 | +0.657 | not published |
| Strands Decider 2B | yes | 2B | 9 | +0.536 | +0.659 | published |
| Jeff 2B | yes | 2B | 12 | +0.432 | +0.683 | published |
Several of these models score higher than cox-1-3b, and we want to say so plainly. Perplexity’s Decider Flash, an open 4B model built on the same base model as ours, scores 0.077 higher on the 14 tasks we can compare, and it stays ahead on the five tasks that no model in the table lists as training data (+0.657 against +0.596). Since its makers say it also trains on the official training splits of public benchmarks (with test items removed), part of that lead may come from data drawn from the same datasets as our test items, but we can’t tell how much. Our article Decision models compared on one test suite explains how we built the comparison and reports every model’s scores in more detail, and the model card has cox-1-3b’s score on every dataset.
What we can offer alongside the scores is a model you can run on your own GPU in tens of milliseconds, with confidences slightly below its accuracy, trained only on data whose licenses allow commercial use, with every source listed.
Fast, and small enough to run yourself
cox-1-3b has 2.9 billion parameters and needs about 6 GB of GPU memory in bf16. On an RTX 4090 it answers a short text with a couple of questions in about 36 ms, a 1,000-token text in about 63 ms and an 8,000-token document in about 405 ms, one request at a time. It reads texts up to 64,000 tokens long. coxlm runs it on NVIDIA GPUs under Linux, Windows and WSL2, and on Apple-silicon Macs, where it runs on Apple’s MLX framework at about 0.4 s for a short request, which is fine for trying it out and for development. Loading it in FP8 changed its skill by only 0.002 in our tests, so FP8 and 4-bit builds for smaller GPUs will follow.
coxlm-serve runs the model as an HTTP service, including an endpoint compatible with the System One decision API,
so tools that already send requests in that format can call cox-1-3b without changes.
Trained on data you can build on
We trained cox-1-3b only on data whose licenses allow commercial use. Every public dataset we used was reviewed for its license terms, and we left out any source without clear commercial terms. About 101,000 of the training rows are our own generated data, where code decides the right answer before an Apache-2.0 open model writes a text that matches that answer, so the labels are correct by design. The model card lists every source with its license and citation, and marks the 5.5% of rows that come from share-alike datasets.
We think this matters as much as the scores. A model you put into a product should come with a clear answer to the question of what it learned from, and we’ve tried to make that answer easy to check.
What it isn’t good at yet
We’d rather you hear the limits from us than find them in production:
- Multi-step questions, where several facts or rules have to be chained together, are its weakest area, so it helps to ask the steps as separate questions and combine them in code.
- Questions about every item in a long text (“has every order shipped?”) are answered poorly at any text length, although questions that need a single fact from a long document are answered well.
- Exact counting and length rules near a threshold are better done in code.
- It judges what a text says, not whether it’s true, so questions about the world need the evidence in the text.
- It’s trained and tested in English only.
Calibration is measured on our test data rather than guaranteed on yours, so we recommend choosing your automation threshold from a small labeled sample of your own.
The name
Cox is named for the physicist Richard T. Cox (1898–1991), whose theorem (1946) showed that any consistent way of reasoning about uncertain statements has to follow the rules of probability. That’s the idea we built the model around: every answer it gives is a probability over the options you offered.
What’s next
We’re working on FP8 and 4-bit builds, a larger open model, and new question families including grading against a rubric, attribution, record matching and reasoning over longer documents. We’re also developing a hosted Cox API for teams who’d rather not run a GPU themselves.
Try it
- Model: huggingface.co/Vitund/cox-1-3b
- Package: github.com/Vitund-AI/coxlm, installed with
pip install "coxlm[local,fast] @ git+https://github.com/Vitund-AI/coxlm.git" - Worked examples: real inputs and outputs, including routing, policy checks and putting events in order
If you try cox-1-3b on your own decisions, we’d be glad to hear how it does, including where it falls short. You can reach us at [email protected], and if you’d like early access to the hosted API, subscribe or email [email protected].