autotrust-jev on Ollama: AutoTrust's decision model, first look

AutoTrust's autotrust-jev is on the Ollama library: a decision model that returns choices, probabilities and ratings instead of prose. Here's what each size needs and how to run it.

Listen to this post · 10 min

Accessibility: the whole post is read aloud — Space plays or pauses, ← → skip 10 seconds, and you can change the speed. It keeps playing with your screen locked.

Share this post

In short

  • autotrust-jev is AutoTrust's Apache 2.0 decision model family, on the Ollama library as of 4 November 2026 — it returns choices, yes/no probabilities and ratings, never prose.

AutoTrust's autotrust-jev is on the Ollama library as of 4 November 2026, under Apache 2.0. It's the latest entry in this autumn's decision-model wave — we've covered d3, pplx-decider, kev and d1 in recent weeks — and it follows the same pattern: one forward pass, structured output, no text generation. If you've been waiting for a decision model with a long context window and image support at the top end, this one's worth a look.

What autotrust-jev is

autotrust-jev is AutoTrust's decision model family. It doesn't chat. You supply an input — a document, a customer request, a structured state — along with a question, and it returns the decision: a choice from options you define, a yes/no probability, or a rating on a scale.

Three checkpoints exist: a 9B text model, a 27B-VL and a 35B. The readme points image decisions at the latter two, though only the 35b's inputs (text and image) are actually listed on the page. Ollama lists the 9b and 35b tags today; the 27b-vl appears in the readme but not in the tag list as of this morning.

The pitch is the same as its rivals: anywhere you currently run a chat model and parse its prose to make a call — routing a ticket, classifying a document, grading an answer — you replace that with a single structured query and get calibrated probabilities back.

AutoTrust reports results for its 9B checkpoint on its held-out test_set_30k evaluation: 0.996 yes/no AUROC across all evaluation rows, and a rating mean absolute error of 0.103 on a 0–5 scale. Those are vendor numbers on the publisher's own test set — no independent benchmarks exist yet, the same caveat we've applied to every decision model this autumn. Treat them as a signal of intent, not proof.

Sizes, memory and hardware

Two tags are listed on the Ollama page:

TagDownloadContextInputs
autotrust-jev:9b (also latest)11GB256KText
autotrust-jev:35b26GB256KText, Image

The readme also mentions autotrust-jev:27b-vl for image decisions, but it isn't among the listed tags as of today — check the live page before planning around it.

As always, budget roughly the download size in RAM or VRAM, plus headroom for context. The 9b's 11GB file realistically wants a 16GB Mac or a 12–16GB gaming GPU. The 35b's 26GB needs a 32GB Mac or a 24GB+ GPU — and more if you actually intend to fill that context window, since long-context KV cache sits on top of the weights.

That 256K window is the standout spec, and it's generous for a decision model. For context on the field: in our launch coverage we found Strands Decider limited to 4,096 tokens, which restricts it to short documents, while d3 and pplx-decider both listed 256K. For routing long tickets, contracts or transcripts, a big window is a real differentiator — but filling it costs memory on top of the weights.

The entry point is the story here: autotrust-jev's floor is 11GB, which is chunky for a decision workload. d1 and d3 both start far lighter, per our launch coverage of each — more on that below.

How to run it

One command pulls the 9B text model:

ollama run autotrust-jev

The readme's routing example shows the shape of a request — input text first, then your question and choices:

ollama run autotrust-jev "My card was charged twice for the same order. Please refund the duplicate charge." \
  --ask "Which team should handle this request?" \
  --choice "billing=Charges, payments, and refunds" \
  --choice "shipping=Deliveries and tracking" \
  --choice "technical=App errors and account access"

A few things worth knowing:

  1. autotrust-jev (no tag) runs the 9B text model — that's the latest tag.
  2. For image decisions, the readme says to choose autotrust-jev:27b-vl or autotrust-jev:35b.
  3. You can ask several questions about the same input in a single request — that's the efficient way to use it, rather than one call per question.
  4. Ollama's decision documentation covers the CLI options and the API.

As of release day, the Ollama library page is the only run documentation we've seen for autotrust-jev — no LM Studio, llama.cpp or vLLM instructions. If you're not on Ollama already, our engine guide covers setup.

What it's good for — and its limits

The readme names three use-cases, and they're the same jobs the other decision models target: routing requests to teams, classifying documents, and grading answers against your own criteria. Anywhere you currently parse a chat model's prose to make a binary or multi-way call, this replaces fragile prompt-parsing with a structured query.

The full probability distribution is the point. Rather than trusting a single label, you get probabilities for every option — so you can automate the confident cases (say, billing at 0.97) and send the ambiguous ones (say, 0.55 vs 0.41) for human review. Those numbers are hypothetical illustrations, not model outputs — the principle is what matters: the threshold is yours to set, and that's where the real engineering value sits.

You define the categories, and there are six built-in rating levels plus yes/no probabilities. No fine-tuning needed to adapt it to your workflow — the criteria live in the request, not the weights.

If your classification job is simpler safety-style gating rather than multi-way routing, a dedicated small classifier may serve you just as well — llama-guard3:1b is one option on the marketplace, from £0.018 per 1M output tokens.

The limits, honestly:

  • It never generates text. Not a chat model, not a summariser. If you need prose, this is the wrong tool.
  • All quality numbers are AutoTrust's own, on its own held-out set. The 0.996 AUROC is on test_set_30k — we've linked AutoTrust's evaluation so you can read the methodology yourself, but no third-party results exist yet.
  • The 35b is a 26GB download for a decision workload. If your inputs are text-only, the 9B is the sensible default; the 35b earns its size only if you need image decisions.

How it compares with the other decision models

This is now a crowded field, and the differences are mostly practical — size, vision, context and platform restrictions. Everything below comes from our launch coverage of each model, as of its release day (October–November 2026); re-check the live Ollama pages before relying on any figure, since tags and sizes can change after launch.

**Against d3**: d3 has vision at every size, from 2b to 27b, with Ollama-measured loads starting at 3.62GB when we covered it. If you're on a smaller machine or need image decisions below 35B, d3 is the pick. autotrust-jev's 9B text entry point is 11GB — roughly three times d3's floor.

**Against pplx-decider**: Perplexity's 27B is text-only at 17GB, with vendor-reported 85.7% across 11 public benchmarks at launch. autotrust-jev offers a smaller 9B text option and image input at 35b.

**Against kev**: kev spans 0.8B to 27B but runs on the Apple Silicon MLX runner, so it's Mac-only for now. autotrust-jev's page states no such restriction.

**Against d1**: Liquid's 3B at 3.7GB is far lighter for laptop routing. autotrust-jev trades size for a 256K window and image support at the top end.

The honest summary: no head-to-head benchmark exists between any of these families. Each publisher reports on its own evaluation, so cross-family comparisons aren't yet possible — anyone claiming otherwise is extrapolating. If you have a real workload, running two or three of them on your own data is the only comparison that counts, and at one forward pass per query it's cheap to do.

Worth running locally?

If you have a 16GB Mac or a 12–16GB GPU and a routing, triage or grading job, the 9B is a sensible local pick: Apache 2.0, 256K context, one command to try. That's what we'd start with.

The 35b's 26GB download is for image decisions or bigger machines. Before betting a production pipeline on the publisher's AUROC, run it on your own data — the same advice we'd give for every model in this wave.

And if you'd rather not dedicate hardware to it, decision-style tasks can also be served through an API — and if you have a spare GPU that can hold the 9B, hosting a model like this is a way to earn from it while it sits idle.

Questions people ask

What is autotrust-jev?

It's AutoTrust's decision model family, on the Ollama library as of 4 November 2026 under Apache 2.0. You supply a question — with choices, a yes/no ask or a rating scale — and it returns the decision plus a probability distribution, never prose.

Models in this post — live on Inpherio

Have a GPU, a Mac or a spare PC?

Let it earn while you sleep.

Run open models for people who need them. You set the price and keep everything but the 15% fee.

Become a host

Building with AI?

Every open model, one API.

OpenAI-compatible. Priced by the people who run the hardware.

Start free See the marketplace

Read “autotrust-jev on Ollama: AutoTrust's decision model, first look” at https://inpherio.co.uk/blog/autotrust-jev-on-ollama-autotrust-s-decision-model-first-look