[ Guide ] # Jev on Ollama: can you run it on your own computer? Can you run Jev on Ollama? Not Jev itself, but Ollama now serves open decision models through Jev's API. Commands, limits and accuracy. Checked 29 October 2026. Published 29 October 2026By Jev Hub [Back to Learn](https://jevhub.io/learn) [ TLDR ] - Not Jev itself. - Jev's weights are closed, so there is nothing to download and run. - What Ollama added in version 0.35 is an endpoint, /v1/systemone, that speaks the same API as Jev, and open decision models to answer it. - The main one is nimble, a 9 billion parameter model from Bespoke Labs under the Apache 2.0 licence. - Because the request format is the same, TypeSafe's Python SDK can talk to it by changing its base address. - Nimble is close to Jev 1.13 on the maker's own tests, but not equal, and it has stricter limits. ## Jev and Ollama, at a glance | | What to know | Where it is documented | | --- | --- | --- | | Can Ollama run Jev? | No. Jev's weights are not published | Our open-source guide, from TypeSafe's blog and GitHub | | What Ollama added | POST /v1/systemone, in Ollama 0.35.0 or later; the cloud models need 0.40.5 | Ollama's API documentation | | Models | nimble (Bespoke Labs, 9B, Apache 2.0), and tev1 and tev1:0.8b (Together AI, marked experimental) | Ollama's blog post and the nimble page | | Question types | choice, noul (yes or no) and score, the same three Jev has. No Box type is documented | Ollama's API documentation | | Per request | 1 to 64 questions; a choice takes 2 to 255 options (the model's own limit applies) and a score 2 to 10 levels | Ollama's API documentation | | Use TypeSafe's SDK | Yes. Set TYPESAFE_BASE_URL to the local address, TYPESAFE_API_KEY to ollama and TYPESAFE_DEFAULT_MODEL to nimble | Ollama's blog post | | Not supported | Streaming, video, tools and generation controls | Ollama's API documentation | | Cost | No per-call charge for local models; you supply the hardware. Cloud models need a paid plan or credits | Ollama's blog post and API documentation | Read on 29 October 2026 from Ollama's blog post, API documentation and nimble model page. Ollama has said more models are coming, so check the pages for the current list. Nothing here was run by JevHub. ## Can you run Jev on Ollama? No, not Jev. TypeSafe has not published Jev's weights, so there is no file for Ollama, or anyone else, to run on your own machine. Jev is used through TypeSafe's API. What you can do is run a different model that answers the same kind of request. Ollama describes its decision models as "based on TypeSafe's Jev API": they take the same input and return the same shape of answer, so code written for Jev often needs only a new address. - [Is Jev open source?](https://jevhub.io/is-jev-open-source) ## What did Ollama add? Ollama's blog post, dated 29 September 2026, announced support for decision models in version 0.35. The new endpoint is `POST /v1/systemone`. You send some text as `state` and a set of named questions, and the model answers all of them in one request. Each question is one of three types, choice, noul (yes or no) or score, and each answer carries probabilities and a confidence value, as Jev's do. Ollama names three models. **nimble** is a 9 billion parameter model made by Bespoke Labs, fine-tuned from Qwen3.5-9B and released under the Apache 2.0 licence. **tev1** and **tev1:0.8b** are smaller models from Together AI, which Ollama marks as experimental. Ollama says more models are coming, including ones served from its own cloud. Hosted Jev and a local model, side by side. From TypeSafe's models page and Ollama's blog, documentation and nimble page, read 29 October 2026. ## How do you try it? These are the commands from Ollama's own blog post and documentation. First download the model: Download the model (9 GB or so) ``` ollama pull nimble ``` Then ask it a question. This example is Ollama's own: Ask one question ``` 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"}}}}' ``` In Ollama's documentation the answer picks `bug` with a probability of 0.9781 and a confidence of 0.8906. If you already use TypeSafe's Python SDK, Ollama's post says you point it at the local server with three settings: Use the local server ``` export TYPESAFE_BASE_URL=http://localhost:11434 ``` Any key text works locally ``` export TYPESAFE_API_KEY=ollama ``` Choose the local model ``` export TYPESAFE_DEFAULT_MODEL=nimble ``` Same code, a different address. From Ollama's blog post. The request format stays the same; three settings change. - [How to use Jev](https://jevhub.io/how-to-use-jev) ## How close is nimble to Jev? Close on the maker's own tests, not equal. The figures below come from Bespoke Labs, as shown on Ollama's nimble page, and compare nimble with Jev 1.13, not the newer Jev 1.14. Treat them as the vendor's claims. - **13 public datasets.** Mean accuracy of 75.7% for nimble and 76.0% for Jev 1.13. - **A held-out set.** Nimble agreed with the reference labels 90.12% of the time, against 93.21% for Jev 1.13.0. - **A warning from the same page.** "A probability of 0.9 doesn't mean the answer is right 90% of the time on your data." Ollama's documentation adds that confidence measures how concentrated the probabilities are, not how often the answer is correct. - [Jev benchmarks: every public test](https://jevhub.io/jev-benchmarks) ## What are the limits? Several limits matter before you swap a local model in for Jev: - **Short inputs.** Nimble's model page says each prompt must fit in an 8,192-token context. Jev's default is 64,000 tokens per request. - **Text only by default.** Images need a vision model such as Clef; nimble is a text model. Ollama's documentation does not mention a Box question type. - **No streaming, video, tools or generation controls.** The answer is one JSON object. - **Local size limits.** The text and question schema must fit in 64 KiB, and the whole request in 32 MiB. - **Cloud models.** They need a paid plan or purchased credits. - **Your hardware.** Ollama says nimble averaged 91 milliseconds per decision on an Apple M5 Max laptop. That is Ollama's own number from one demo, and speed will differ on your machine. ## Which should you use? Based on what is published today: - **Use Ollama and nimble** if the text must stay on your own machine, you want no per-call charge, or you want to build and test offline. You provide the computer, and you should check accuracy on your own data. - **Use Jev** if you want the best published accuracy, long inputs, image experiments or no hardware to run. You pay TypeSafe per token and your text goes to its servers. - **Try both on the same sample.** Because the request format matches, you can run one labelled sample through each and compare accuracy, speed and cost before you choose. - [Jev vs open models: can you skip Jev?](https://jevhub.io/jev-vs-open-decision-models) - [Jev pricing](https://jevhub.io/economics) ## Our read This matters because it makes Jev's request format a shared standard rather than one company's API. Your code stays the same whether the answer comes from TypeSafe or from your own laptop. It also means Jev now has a free local stand-in for development and testing, which lowers the cost of trying the whole approach. Whether nimble is accurate enough to replace Jev in production is something only a test on your own data can show. ## Common questions No. Jev's weights are not published, so Ollama cannot run it. Ollama serves other open decision models, such as nimble, through an endpoint that uses the same request format as Jev. Ollama 0.35.0 or later for local models, and 0.40.5 or later for cloud models, according to Ollama's documentation. nimble, a 9B model from Bespoke Labs under Apache 2.0, and tev1 and tev1:0.8b from Together AI, which Ollama marks as experimental. Ollama says more are coming. Yes, according to Ollama's blog post. Set TYPESAFE_BASE_URL to http://localhost:11434, TYPESAFE_API_KEY to ollama and TYPESAFE_DEFAULT_MODEL to nimble. Close on Bespoke Labs' own tests: 75.7% against 76.0% for Jev 1.13 across 13 public datasets. Those are the vendor's figures and compare with Jev 1.13, so test on your own data. Ollama's documentation says images need a vision model such as Clef, and it does not document a Box question type. nimble is a text model. Local models have no per-call charge, and Ollama lists "no additional costs" as a feature. You supply the hardware, and Ollama's cloud models need a paid plan or credits. ## Sources Written by Jev Hub from the sources below and checked against them on 29 October 2026. Where a figure is a company's own claim, the article says so. - [Ollama blog: Ollama now supports Jev-style decision models (post dated 29 September 2026, read 29 October 2026)](https://ollama.com/blog/ollama-now-supports-jev-style-decision-models) - [Ollama docs: the /v1/systemone API (read 29 October 2026)](https://docs.ollama.com/api/systemone) - [Ollama library: nimble, a 9B decision model from Bespoke Labs (read 29 October 2026)](https://ollama.com/library/nimble) - [TypeSafe docs: models and limits (read 29 October 2026)](https://docs.typesafe.ai/models) ## Related content - [Confidence routing](https://jevhub.io/confidence-routing) - [Intent routing](https://jevhub.io/intent-routing) - [Fan-out](https://jevhub.io/fan-out)