Ollama Decision Models: Run Nimble, Clef, pplx-decider and AutoTrust Locally (/v1/systemone Guide)

Ollama can now run decision models: small local models that do not chat at all. You give them some text (or an image) and a few typed questions, and they return probabilities straight away, such as “billing: 0.98” or “is this spam: 0.03”.

They are a free, local version of the hosted Decisions APIs that OpenAI and Google launched this month. Bespoke Labs says its Nimble model answers in under 100 ms on an M5 Max MacBook Pro.

This guide explains what decision models are, compares every model in the Ollama library (Nimble, Clef, Clef Flash, pplx-decider, d1, AutoTrust JEV and Tev1), and shows the CLI, the /v1/systemone API and Python code, with real use cases, limits and fixes.

What a Decision Model Is

A normal LLM answers “Which team should handle this ticket?” by writing a sentence. You then have to parse that sentence, and the model might ramble, refuse, or invent a team that does not exist.

A decision model never writes. It reads the input (Ollama calls it the state), looks at your fixed list of options, and returns a probability for each one. Your code can branch on "billing": 0.98 without any parsing.

Three things make them useful:

• Speed: one forward pass instead of generating tokens. Nimble averaged 91 ms per decision in Ollama’s Pac-Man demo on an M5 Max.
• Calibration: the probabilities are trained to mean something. A 0.70 answer should be right about 70% of the time, so you can send low-confidence cases to a human or a bigger model.
• No hallucinated options: the answer is always one of your keys.

Ollama added the feature in v0.35.0 on 29 September 2026, following the same request format as the hosted Jev API from TypeSafe. The AutoTrust JEV family arrived in Ollama 0.40.15 in early November.

Every Decision Model in Ollama

Sizes and figures below are from each model’s Ollama library page, and the scores are reported by the makers.

A few reported results worth knowing:

• Nimble scored 75.7% mean accuracy over 13 public datasets, close to Jev 1.13 at 76.0%.
• pplx-decider scored 85.7% across 11 benchmarks, versus 84.5% for Jev and 74.8% for its Qwen3.8-27B base.
• Clef beat Jev on BANKING77 (94.2 vs 79.7) and CLINC150+OOS (97.4 vs 89.3), with a median latency of 209 ms. Clef Flash was the fastest Cloudflare measured at 38.8 ms.
• AutoTrust JEV 9B reports a yes/no AUROC of 0.996 on its own held-out set.

These numbers come from the makers, on their own tests. Run your own examples before trusting any of them for real work.

Note on AutoTrust: Ollama’s release notes say autotrust-jev runs only on Apple silicon in this release. On Windows or Linux, start with Nimble, Clef or pplx-decider.

Which One Should You Use?

Not sure what your card can hold? Our VRAM guide explains it, and the model file size is a good first estimate.

The Three Question Types

A score is a probability-weighted average of the levels counted from 0. With three levels, 0.8 means “between routine and soon, closer to soon”.

confidence shows how strongly the model prefers one answer. It is not a guarantee of being right.

Using the CLI

First pull a model:

ollama pull nimble

Ask a yes/no question about a file:

ollama run nimble --ask "Is the customer asking for a refund?" < ticket.txt

Pick one of several options:

ollama run nimble "My parcel never arrived and tracking stopped." \
  --ask "Which team should handle this?" \
  --choice billing="Payments and refunds" \
  --choice shipping="Delivery and tracking" \
  --choice technical="Bugs and app problems"

Score with ordered levels:

ollama run nimble --ask "How urgent is this?" \
  --level "Routine" --level "Soon" --level "Urgent" < ticket.txt

Useful flags:

• Repeat --ask to ask several questions in one go.
• --format json prints the full response with all probabilities.
• Put a JSON field name in backticks inside the question to point at it.
• ollama run nimble with no --ask opens an interactive mode: the first message is the state, then each line is a yes/no question. /clear resets it.

Using the API (curl)

The endpoint is POST /v1/systemone on the normal Ollama port. This example is from the Ollama API reference:

curl http://localhost:11434/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "nimble",
    "state": "Our checkout has returned 500 errors since 9am.",
    "questions": {
      "label": {
        "type": "choice",
        "instructions": "Which label fits this ticket?",
        "criteria": {
          "billing": "Payments and refunds",
          "bug": "Software errors",
          "account": "Login and account access"
        }
      }
    }
  }'

The response:

{
  "model": "nimble",
  "answers": {
    "label": {
      "type": "choice",
      "choice": "bug",
      "probabilities": { "billing": 0.0125, "bug": 0.9781, "account": 0.0093 },
      "confidence": 0.8906
    }
  },
  "usage": { "input_tokens": 174, "output_tokens": 1 }
}

Request fields:

• model: a decision model name.
• state: text, a JSON object or an array. It is not treated as chat messages.
• questions: 1 to 64 named questions. Answers are not passed between questions.
• images: optional raw base64 images (no URLs).
• keep_alive: how long to keep the model loaded, for example "10m".

If you already use the normal Ollama API, our Ollama API guide covers the chat and generate endpoints alongside this one.

Using Python

Install or update the official library (0.6.3 or newer):

pip install -U ollama

Then ask three questions about one ticket in a single call:

import ollama

ticket = "I was charged twice this month. Please refund the extra payment."

r = ollama.systemone(
    model="nimble",
    state={"ticket": ticket},
    questions={
        "team": {
            "type": "choice",
            "instructions": "Which team should handle this ticket?",
            "criteria": {
                "billing": "Payments and refunds",
                "technical": "Bugs and integrations",
                "other": "None of the above",
            },
        },
        "refund": {
            "type": "noul",
            "instructions": "Does the customer explicitly ask for a refund?",
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgent is this ticket?",
            "criteria": ["Routine", "Soon", "Urgent"],
        },
    },
)

print(r.answers["team"].choice)      # e.g. billing
print(r.answers["refund"].noul)      # e.g. 0.99
print(r.answers["urgency"].score)    # e.g. 0.8

A simple safety net: act automatically only when the top probability is high, and send the rest to a person or a bigger model.

team = r.answers["team"]
if max(team.probabilities.values()) >= 0.85:
    route_to(team.choice)
else:
    send_to_human(ticket)

The JavaScript library has the same call: ollama.systemone({...}).

Image Decisions

Models with image input (Clef, Clef Flash, pplx-decider, pplx-decider-flash, d1 and AutoTrust 35B) accept base64 images in a top-level images array, shared by all questions. You still need a state that says what the image is.

import base64, ollama

img = base64.b64encode(open("receipt.jpg", "rb").read()).decode()

r = ollama.systemone(
    model="clef-flash",
    state="A photo uploaded as an expense receipt.",
    images=[img],
    questions={
        "is_receipt": {"type": "noul", "instructions": "Is this a real receipt?"},
        "readable": {"type": "score", "instructions": "How readable is the total?",
                     "criteria": ["Unreadable", "Partly readable", "Clear"]},
    },
)

On the CLI, pass an image path with a vision model and it is sent with the question. Locally, the whole request can be up to 32 MiB.

Real Use Cases

• Support triage: team, refund yes/no and urgency in one call.
• Model routing: ask “Does this need deep reasoning?” and send only hard prompts to a big model. This can cut API bills.
• Moderation: spam, abuse or off-topic checks on comments before they go live.
• Document sorting: invoice, contract or CV, before running the right extraction step.
• Grading: score an answer against a rubric, or check whether a RAG answer is backed by the source text.
• Agent guards: “Is this tool call safe to run?” before an agent acts. Pair it with MCP security practices.

Local vs OpenAI and Gemini Decisions APIs

A common pattern is to run a small local model first and only call a hosted API when local confidence is low.

Limits to Know

• No text output, streaming or tools. Use a normal chat model for that.
• Input is never truncated. If it does not fit the loaded context window, you get a 400 error. Nimble’s notes say prompts must fit in 8,192 tokens even though the tag lists more.
• Local size limit: text and schema up to 64 KiB, whole request up to 32 MiB.
• Cloud limits: 65,536 tokens, up to 4 images of 4 MiB each, and a paid plan or credits.
• Repeated context costs time: shared input is counted again for each question the model scores separately, so many questions on a long document are slower.
• English first: most of these models are tuned on English.

Troubleshooting

404 on /v1/systemone

Your Ollama is older than 0.35.0. Update it, then run ollama -v to check the version. A 404 with a model name means the model is not pulled yet: run ollama pull nimble.

400 “unsupported model”

You sent a chat model such as llama3 or qwen3.8. Only decision models work on this endpoint.

400 “exceeds the context window”

Your state is too long. Shorten it, send only the relevant part, or pick a model with a larger working context.

413 “text and schema must not exceed 64 KiB”

The text plus questions are too big. Trim the input or split it into several requests.

Image questions fail or are ignored

Use a vision model such as clef-flash, update to Ollama 0.35.1 or newer, and send raw base64, not a URL or a data URL.

autotrust-jev will not run on Windows

That release is Apple silicon only. Use pplx-decider or Clef on Windows and Linux.

AttributeError: module ‘ollama’ has no attribute ‘systemone’

Your Python library is old. Run pip install -U ollama to get 0.6.3 or newer.

Slow or high-latency answers

The first call loads the model. Set keep_alive to keep it in memory, and check it is running on the GPU with ollama ps. Our Ollama guide covers GPU problems.

FAQ

Are Ollama decision models free?

Yes, local models are free to run. Only the :cloud versions need a paid Ollama plan or credits.

Can I use a normal LLM like Llama or Qwen on this endpoint?

No. Only models built for decisions work with /v1/systemone.

How many questions can I ask at once?

Up to 64 per request.

Which is the most accurate?

On the makers’ own tests, the 27B models (pplx-decider and Clef) lead. Test on your own data, because results vary a lot by task.

Do the probabilities mean the answer is correct?

No. They show how likely the model thinks each option is. They are trained to be calibrated, but you should still check results on real examples.

Can I use these with Open WebUI?

Not as a chat. They are meant to be called from code. Use them inside your scripts, and keep Open WebUI for normal chat models.

Do they work offline?

Yes. Once the model is pulled, local decisions need no internet.

Sources

• Ollama docs: Decision models
• Ollama API reference: /v1/systemone
• Ollama blog: decision models (29 September 2026)
• Ollama library: autotrust-jev, clef, clef-flash, pplx-decider, pplx-decider-flash, nimble, d1
• AutoTrust JEV-35B model card