Ollama Decision Models: Run Nimble Locally with --ask

Ollama v0.40.4 lets you run a Jev-style decision model from the terminal with one line: ollama run nimble --ask "Is a refund being requested?" < ticket.txt. You pipe in text, ask a question, and get an answer with a probability instead of a paragraph. This is the "run a Jev model locally" path with no API key, no separate server and no Python.

Last updated: October 15, 2026

Search interest tells you why this is worth a post. On a 30-day Google Trends comparison pulled today, "jev model" averaged 19 on the index against 7 for "claude code skills", while "ollama nimble" and "ollama decision model" registered nothing yet. People know the category; almost nobody has found the local, one-command route.

What Ollama shipped#

Decision support arrived in Ollama 0.35, announced on the Ollama blog on September 29 as a new /v1/systemone endpoint that follows TypeSafe's Jev API. You send text as state plus named questions, and a model on your machine answers all of them in one request. Three models launched: nimble (9B, Bespoke Labs), tev1 (4B, Together AI) and tev1:0.8b.

The v0.40.4 release notes add the piece that makes it a daily tool:

• A "Decision models in the CLI" section: ollama run now takes --ask, --choice and --level flags.
• Kev decision models are supported by the MLX runner on Apple silicon, and llama.cpp was updated with native decision model support.
• ollama launch codex now lists your locally installed Ollama models in its picker, with /model to swap inside Codex. That pairs with the profile setup in our Codex custom providers guide.

One catch worth knowing: the Nimble model card still says decision models "aren't in the Ollama CLI or the Ollama Python and JavaScript libraries yet." That line is stale. The Ollama decision docs document the CLI flags, so trust the docs and the release notes over the card.

Run it#

These commands are copied from the Ollama docs and release notes. I did not run them here, since this environment has no GPU and no Ollama install, so the output below is the documented shape, not my own capture.

ollama pull nimble

# Yes/no
ollama run nimble --ask "Is a refund being requested?" < ticket.txt

# Pick a label
ollama run nimble --ask "Which team should handle this?" \
  --choice billing="Payments and refunds" \
  --choice technical="Software problems" < ticket.txt

# Score on a scale, lowest level first
ollama run nimble --ask "How urgent is this?" \
  --level "Routine" --level "Soon" --level "Immediate" < ticket.txt

The docs show the output as one line per question:

Is a refund being requested?    yes      97%
Which team should handle this?  billing  91%
How urgent is this?             Soon     64%  1.2 / 2

Add --format json to get the full response, and pass a JSON file as the state to refer to its fields in backticks. The docs require Ollama 0.35.0 or later for decision models, so the flags above need 0.40.4 or newer.

For code, the same model sits behind POST http://localhost:11434/v1/systemone. The card says local requests need no key, and TypeSafe's Python SDK works if you point TYPESAFE_BASE_URL at http://localhost:11434 with any value for the key. Our guide to calling Jev covers the same request shape against the hosted API.

The numbers, labelled#

Everything here is vendor-reported by Bespoke Labs and Ollama, not independently reproduced.

• Nimble is a 9B model fine-tuned from Qwen3.5-9B under Apache 2.0. The library entry lists 9.3 GB to 9.5 GB for the 9B tag.
• Speed: the card claims under 100 ms per answer on a MacBook Pro with an M5 Max, and the Ollama blog reports 91 ms per decision averaged over a Pac-Man demo on the same machine.
• Accuracy: across 13 public datasets with human labels (3,880 decisions), Nimble scores 75.7 percent on Ollama against 76.0 for Jev 1.13, 73.3 for Tev1 4B and 63.5 for Tev1 0.8B. The Jev figure comes from Bespoke Labs' own run, not from TypeSafe.
• The average hides a split. In Bespoke's tables Nimble leads Jev on entailment (85.3 vs 82.9) and on prompt-safety guardrails (81.2 vs 80.4), but trails on moderation (70.3 vs 81.0) and on boolean questions overall (80.2 vs 84.6).

That last pair matters if you plan to use it as a gate. The model card's own example of "tool call moderation" asks Could this tool call cause harm? about run_shell(command="rm -rf ~") and reads the probability that the answer is true. It is a reasonable first filter and a poor sole defense.

What a builder does Monday#

The honest use is as a cheap router in front of an expensive model, not as a replacement for one:

1. Triage and labels. Pipe issues, support tickets or CI failure logs through --choice and route on the label. Keep a "no match" option, because the card warns the model can only pick from the answers you give it.
2. Threshold on probability, then test it. The card is explicit that a 0.9 probability does not mean the answer is right 90 percent of the time on your data. Run 50 labelled examples through before you wire in a cutoff.
3. Mind the limits. The prompt has to fit in an 8,192-token context, request bodies cap at 64 KiB, and you get up to 64 questions per request, each scored independently. If two answers must agree, check that in your own code.
4. Gate agent actions only as a first pass. A local classifier in front of shell calls is cheap, but see fail-open vs fail-closed hooks before deciding what happens when the model is down or unsure.

If you serve other local models, the 0.40 line also changed how Ollama stores them, which we covered in Ollama 0.40 and the disk doubling. Check free space before you pull a 9 GB decision model.

What people are actually saying#

The community read is mixed, and the skeptics have a point.

On Hacker News, the thread for Ollaya, an Ollama-style runtime for decision models, argued that Jev has no moat once open versions copy its synthetic-data recipe. One commenter predicted Ollama would add native support at any time, which it did a few weeks later. Another said a generic model without your data amounts to a very long prompt, and that fine-tuning on your own task data is the real route, a view our Jeff write-up backs with its own fine-tune numbers.

On Reddit, a r/LocalLLM post titled around testing 14 decision models on 56 triage tasks reports that plain Qwen3.5-9B beat every decision model it tried. I could only read the title and snippet, so I cannot vouch for the method, but it is the counter-case you should test yourself: a generic small LLM with a good prompt is the baseline Nimble has to beat. A r/LocalLLaMA thread argues Jev is just normal classifier behavior with new marketing. And the thread asking what people are doing with these models shows one early adopter using one for eval testing and asking what else it is good for, which fits the "still finding its use cases" picture.

The practical resolution: Nimble's value is latency and a typed, probability-bearing answer in one pass, not superior judgment. If a small general model with structured output already meets your accuracy bar, you may not need it.

FAQ#

How do I run a Jev-style model locally?#

Install or upgrade Ollama to 0.40.4 or newer, run ollama pull nimble, then ollama run nimble --ask "your question" < input.txt. Decision models need Ollama 0.35.0 or later, and the CLI flags arrived in 0.40.4.

Is Nimble as accurate as Jev?#

On Bespoke Labs' 13-dataset benchmark it scores 75.7 percent against Jev 1.13's 76.0, but that comparison is vendor-reported and uses Bespoke's run of Jev. It trails Jev on moderation and boolean questions, so test it on your own data.

Does Nimble need an API key?#

No. The model card says local requests need no key. TypeSafe's Python SDK asks for one, but Ollama ignores the value, so any string works.

Can Nimble look at images?#

Nimble is text only. The docs say the Clef and Clef Flash models in the Ollama library can judge images, and they require Ollama 0.35.1 or later.

Continue Reading#

• Jeff: Jev-Style Decision Models Trained at Home - an open fine-tune route and where benchmarks stop matching real work
• How to Use Jev - every way to call the hosted model and the open alternatives
• TypeSafe Jev Pricing and Benchmarks - what the original decision-only model costs and where it fails
• Ollama 0.40 and the Disk Doubling - the storage change to know before pulling more models
• Codex Custom Model Providers - pointing Codex at local Ollama models

Sources#