# Ollama decision models reach the command line, and LM Studio’s Bionic adds the same /v1/systemone endpoint

URL: https://onticpost.com/ollama-decision-models-systemone/
Published: 2026-10-15
Updated: 2026-10-15
By: Hill, Onticpost

> Ollama decision models answer typed questions with probabilities, not text. Version 0.40.4 adds them to the CLI, and LM Studio's Bionic adds the endpoint.

Ollama put decision models on its command line on October 12, 2026, with version 0.40.4, two weeks after version 0.35.0 added a `/v1/systemone` endpoint for them on September 28. Ollama decision models do not write a reply. They take a piece of text and a set of named questions, and they return a probability for every allowed answer. Ollama now lists four of them: Nimble from Bespoke Labs, Tev1 from Together AI, and Clef and Clef Flash from Cloudflare. On the same day, October 12, LM Studio’s Bionic app reached version 1.1.8 with its own `/v1/systemone` endpoint, so two local runtimes now answer the same request format.

**Takeaway points**

- Ollama 0.35.0 added decision models through `/v1/systemone` on September 28, and version 0.40.4 brought them to `ollama run` on October 12, the same day LM Studio’s Bionic 1.1.8 added the endpoint.
- Ollama’s own API schema says the confidence figure each answer carries is “Not calibrated correctness”, and Together AI says its Tev1 weights have no final licence yet.
- The context limits in the documents do not match, from 8,192 tokens on Nimble’s model card to 256K on Ollama’s model pages, and we have not run any of these models.

## What are Ollama decision models and what do they return?

They are small models that answer typed questions about a text with probabilities, not prose. The 0.35.0 release notes put it in one line: “Decision models return choices, probabilities, and scores instead of text.” Ollama says the format is based on TypeSafe’s Jev API, and its blog post of September 29 names ticket triage, model routing and content or safety moderation as the uses it has in mind.

A request carries a `state`, the text to be judged, and 1 to 64 named `questions`, according to the API schema. Each question has a type, an instruction and usually a set of criteria, and Ollama’s decision guide lists three types.

| Question type | What you supply | What comes back |
| --- | --- | --- |
| choice | 2 to 26 named options with descriptions | The most likely option and each option’s probability |
| noul | Optional descriptions for false and true | The probability of true, from 0 to 1 |
| score | 2 to 10 levels, lowest first | The probability-weighted average of the levels, counted from zero |

A noul is a yes or no question, but the answer is a number. The schema describes it as the “Probability of true among the false and true candidates. This is a number, not a Boolean.” A score is not rounded to a level. On a three-level urgency scale the guide’s worked example returns 0.8308 on a scale of 0 to 2, where 0 is routine and 2 is immediate.

Choice and score answers also carry a `confidence` figure from 0 to 1. The schema defines it as how concentrated the probabilities are, calculated from their entropy, and the decision guide warns that “A higher value does not guarantee the answer is correct.”

## Decision model vs chat model: what comes back from the same request?

A chat model writes text that the program then has to read, while a decision model hands back fixed fields with numbers in them. The Clef model card states the difference plainly: “There is no free-form text generation and no output parsing.” The card says Clef produces one score for each allowed option of each question and that applying a softmax per question turns those scores into probabilities. Ollama’s readme for Nimble says the model reads the prompt once per question and scores the answer tokens directly, with no reasoning step.

Ollama’s blog post shows one support ticket, “I was charged twice. Please refund the extra payment.”, asked three questions in one request. The answers it prints are below, next to the answers Ollama’s Nimble model page prints for the same request.

| Question | Ollama blog post | Ollama’s Nimble model page |
| --- | --- | --- |
| Which team (choice) | billing, 0.985 | billing, 0.984 |
| Refund asked for (noul) | 0.997 | 0.997 |
| Urgency, 0 to 2 (score) | 0.815 | 0.693 |
| Urgency confidence | 0.046 | 0.068 |
| Output tokens reported | 4 | 3 |

The two pages give different urgency scores for the same text, which fits the decision guide’s line that “Results can vary with the model and configuration.” The output token count is not the length of the answer either. The schema says it counts tokens “generated internally for scoring” and may exceed the number of questions.

Cloudflare’s announcement of October 1 draws the same line, calling large language models “largely non-deterministic” and decision models a source of bounded, structured outputs.

## Which decision models does Ollama list, and how large are they?

Ollama lists four model families, and the largest download is under 48 GB. The sizes below are the ranges on Ollama’s model pages, and every accuracy and speed figure in this section is a maker’s claim.

| Model on Ollama | Maker | Parameters | Ollama download | Base model, per the maker |
| --- | --- | --- | --- | --- |
| nimble | Bespoke Labs | 9B | 9.3GB to 9.5GB | Qwen3.5-9B |
| tev1 (4B) | Together AI | 4B | 4.4GB to 4.6GB | Qwen3.5-4B |
| tev1:0.8b | Together AI | 0.8B | 834MB to 1.5GB | Qwen3.5-0.8B |
| clef | Cloudflare | 27B | 18GB to 20GB | Qwen3.8-27B |
| clef-flash | Cloudflare | 9B | 11GB to 12GB | Qwen3.5-9B |

Clef and Clef Flash came with version 0.35.1 and are the only two that read images. The 0.35.1 notes say images sent with a request are shared by all questions and scored jointly with the text. Our test machine is an Apple M4 Pro with 48 GB of memory, and every Ollama download above is smaller than that. Cloudflare’s own full-precision Clef files on Hugging Face are a different matter: its safetensors files come to 54.97 GB, more than 48 GB, while Clef Flash’s come to 19.06 GB. It is the machine from our piece [Ollama vs LM Studio on an M4 Pro: the same Gemma 4 file runs at the same speed](https://onticpost.com/ollama-vs-lm-studio-speed-m4-pro-gemma-4/).

On accuracy, Ollama’s Tev1 page prints a table it attributes to Bespoke Labs’ 13 public datasets, 3,880 decisions in all, with Nimble and Tev1 run on Ollama. It gives Nimble 9B 75.7%, Tev1 4B 73.3%, Tev1 0.8B 63.5% and Jev 1.13 76.0%, the last from Bespoke Labs’ own run through TypeSafe’s service. Ollama says Nimble 9B averaged 91ms per decision in a game demo on an Apple M5 Max. Cloudflare’s model card reports a median latency of 209.3 milliseconds for Clef and 38.8 for Clef Flash in its internal run of the Decision Index suite.

## How do you use Ollama decision models from the command line?

From version 0.40.4 you pipe a text into `ollama run` with the model name and add one or more questions with a new ask option. The release notes give the example of asking Nimble whether a refund is being requested, with a ticket file as the input. Ollama’s decision guide adds a choice option for labels and a level option for a scale, both repeated once per label or level, and a JSON format option that prints the full response.

The guide shows each answer on its own line. A yes or no question prints the likelier answer and its probability, a label prints its probability, and a score prints the most likely level, its probability and the position on the scale, such as Soon at 64% and 1.2 on a scale of 0 to 2. With Clef, an image file can be passed after the model name.

The same release added Kev decision models to the MLX runner on Apple silicon and updated llama.cpp “with native decision model support”, the notes say. The move to MLX is covered in our piece on [Ollama making MLX its default on Apple silicon](https://onticpost.com/ollama-mlx-default-apple-silicon/).

Ollama’s own pages have not all caught up. All four model pages still say that decision models are not in the Ollama command line or in its Python and JavaScript libraries yet, while the same pages open with Python and JavaScript examples that call `systemone`.

## Does LM Studio support the /v1/systemone endpoint?

Yes, in its Bionic app. The Bionic 1.1.8 changelog, dated October 12, lists support for `/v1/systemone`, described as a “Jev (TypeSafe AI) compatible endpoint”, and for `/v1/decisions`, described as an “OpenAI compatible endpoint”. The release also adds decision model inference and management through Bionic’s REST API.

The changelog says Bionic can now run alongside LM Studio and use it for local model inference while LM Studio is running, which requires LM Studio 0.4.26 or newer. It does not name any decision model or say which formats it loads. The rest of that release is covered in our piece on [LM Studio’s Bionic agent update](https://onticpost.com/lm-studio-bionic-canvas-update/).

## What has not been published about Ollama decision models?

The makers’ documents disagree on context length, option limits, licence and dates, and none of them settles which figure applies when the models run in Ollama. We have not run Nimble, Tev1, Clef or Clef Flash, in Ollama or in Bionic, and this piece has no speed, memory or accuracy figure of our own.

Context length is the widest gap. Ollama’s model pages list a 256K context window for all four models. Bespoke Labs’ model card for Nimble says its current checkpoint has “an 8,192-token context limit”. Cloudflare’s announcement and Ollama’s Clef page give Clef a 64K window, while the Clef model card’s own encoding code defaults to 16,384 tokens. We have reported before that [Ollama’s default context length for Gemma 4 31B on a 48 GB Mac is 32,768](https://onticpost.com/ollama-default-context-length-gemma-4-31b/).

| Document | Context figure |
| --- | --- |
| Ollama model pages, all four models | 256K |
| Cloudflare announcement and Ollama Clef page | 64K for Clef |
| Clef model card, encoding default | 16,384 tokens |
| Bespoke Labs, Nimble model card | 8,192 tokens |

Option limits differ too. The decision guide allows 2 to 26 options, the API schema allows up to 255 and says the limit depends on the model, and the Tev1 page says Tev1 was trained on 2 to 24. Together AI’s model card describes Tev1 as choosing one option and replying with its letter, and calls it “a Jev-inspired experiment, not a non-autoregressive Jev runtime.” It does not say how yes or no and score questions are handled, though Ollama’s page lists all three types for it.

On licence, Ollama’s pages give Nimble and both Clef models Apache 2.0. Together AI’s card says the licence for the Tev1 weights “is being finalized before public conversion”, and Ollama’s Tev1 page names only the MIT licence of the dataset builders and training scripts. Bespoke Labs publishes a later Nimble 9B v3 under CC BY-NC 4.0, which bars commercial use, and Ollama’s page does not say which Nimble checkpoint it serves.

The dates do not line up for Clef either. GitHub shows Ollama 0.35.1, the release that added Clef, as released on September 29, while Hugging Face records Cloudflare’s Clef repositories as created on September 30 and Cloudflare’s announcement is dated October 1. The commit signed for that release is dated October 2.

Ollama’s blog says more decision models are coming, including some served by its cloud. It has not said which, and the API reference says cloud models are rejected at `/v1/systemone`.

## Sources

- [Ollama release notes, v0.40.4](https://github.com/ollama/ollama/releases/tag/v0.40.4)
- [LM Studio changelog, Bionic 1.1.8](https://lmstudio.ai/changelog)