Ollaya runs the model that does not write. Jev Router still calls a chatbot.

Decision model vs chatbot: Ollaya returns a labeled slot; Jev Router still calls a writer; Apple-white thick Claude blue
2026-09-26

A program can pick a slot without writing a sentence. That is the whole idea underneath three names that landed on top of each other this weekend, and the names are not interchangeable.

On 15 September 2026 TypeSafe AI published Jev, a hosted model that returns a choice you listed in advance instead of a paragraph. On 25 September 2026 OpenRouter, a gateway (one key that forwards your request to many model companies), listed a product called Jev Router that still returns written text. Around the same two days, Ollaya, a local runner for small open models of the first kind, sat on the front page of Hacker News (a news site where working programmers vote on links) at about 526 points and 128 comments. If you only remember one test, use this one. Does the thing you are calling return a label, or does it return sentences? Jev and the models inside Ollaya return a label. Jev Router returns sentences, after a label has been used to choose a writer.

Here is the split in one pass. The facts you already have go into either a decision model (Jev, or a model inside Ollaya) or into Jev Router. A decision model returns a slot you defined, plus a probability. Jev Router hands the work to a normal chat model, and that writer returns sentences.

  • Decision model path: state → Jev / Ollaya model → a labeled slot + probability.
  • Jev Router path: state → router picker → a chat model → prose.

A chat model is a writer. Start there, before any new product name.

A large language model (a program trained to continue text) does not look up an answer in a table. It guesses the next token (a small chunk of text, often a piece of a word) and then guesses the one after that. That habit is called autoregressive (each new chunk is chosen only after the earlier chunks exist). It is why a reply takes as long as the reply is long, and why the bill grows when the answer grows. Nothing in that loop forces the reply to be one of three words you wrote down. Ask whether a ticket is billing or technical, and the model can answer with a paragraph that says both. Your program then has to read English and guess which word was the decision. That guess is a second program, and it is where a lot of automation quietly fails.

Think of a typewriter that commits one character, then the next. A chat model works the same way: one token at a time. Most software does not need that paragraph. A ticket router needs a slot. A refund check needs a yes or a no. A queue needs a place on a scale you invented, such as low, normal, high. The input is state (the facts you already hold: the email, the JSON, the log line). The output is one of the answers you allowed. A classifier (a model whose job is to put an input into a bucket you named) has done this job for years. On the Ollaya thread, several engineers said the quiet part: a decision model is a classifier wearing a product shape. That criticism is right about the idea. It is incomplete about the last ten days. What changed is a shared call shape, so the bucket comes back as data, not as a sentence you have to parse.

Sorting mail into labeled slots is the job. Writing a letter back is not. TypeSafe’s launch post says Jev gives up string generation and is optimized for structured outputs. OpenRouter’s guide for the model id typesafe/jev-1.13 says it more bluntly: it is not a drop-in replacement for a chat model, and it does not return reasoning, explanations, or free-form text. The same guide names the only three questions the API accepts. They call them primitives (the allowed shapes of a question, not free prompts).

Read the primary source first: TypeSafe’s Introducing System One Models and Jev, then the OpenRouter guide for the three primitives.

  • choice (pick one option from a list you supply). You get the picked option, a probability for every option, and a confidence value.
  • noul (a yes-or-no question; the name is TypeSafe’s, not an ordinary English word). You get the probability that the answer is yes.
  • score (place the state on an ordered scale you supply). You get a probability-weighted position, a probability for each level, and a confidence value.

OpenRouter lists that model’s context length (the maximum amount of text you may send) at 32,000 tokens. TypeSafe’s launch post prices input at USD 0.042 per million tokens and says output is free, which fits a model that barely emits text. The same post puts end-to-end time at 70 to 500 milliseconds and claims roughly 40 to 200 times faster than frontier chat models on this shape of question. Those multiples are the company’s own evals. The post notes that the harness used to wrap ordinary chat models can make them look slower, and that the workflows were built by the same team. Read the milliseconds as a vendor claim. Time your own call before you repeat the multiple.

One ticket can ask three boring questions in one read of the state: which queue (choice), whether they are locked out (noul), and how urgent it is (score). The state is the customer message. The model reads it once and fills the slots.

The same ticket, three times

Mind map — decision model: label vs sentences, Jev primitives, Ollaya socket, Jev Router, which door, what not to ship, FAQ

State: “My invoice lists two seats, but only one of us can sign in, and the login page keeps timing out.”

You do not ask the model to help this customer. You declare the slots before the call.

  • choice, named queue, options billing and technical. The instruction is which team should touch this first.
  • noul, named locked_out. The instruction is whether the customer is unable to sign in.
  • score, named urgency, levels low, normal, and high.

What comes back is data, not a paragraph. A serious implementation also reads the probability (a number from 0 to 1 that is supposed to mean how often this pick would be right) and, if it sits near a tie, sends the ticket to a person. I did not call any model for this draft. The shape is the lesson. A made-up score would be a worse lesson.

What “cannot hallucinate” leaves untouched

A hallucination (a fluent statement that was not in the source and not in the answers you allowed) needs a place to put the invented words. If the model is forbidden from writing words outside your schema (the fields and the allowed values you declared), it cannot invent a fourth queue. TypeSafe says this makes type errors impossible by construction, and they say the zero is a guarantee of the shape, not a score on an exam. The failure that remains is the one your users feel. The model can still put the ticket in the wrong slot. A wrong label is not a made-up sentence. It is a bad decision, and your code will obey it unless you wrote a threshold that refuses low confidence.

Two failure modes sit next to each other:

  • Chat failure: a sentence that invents a fact — your code must guess what was meant.
  • Decision-model failure: the right kind of answer, the wrong slot — your code acts, because the type was valid.

The number next to the slot is a separate question, called calibration (the habit of being right about as often as the stated probability: if it says 90 percent across many cases, about 90 percent of those cases should be right). TypeSafe trains for that with a method they named RLCD (Reinforcement Learning for Calibrated Decisions: practice that rewards an honest probability on a closed question). Chat models are usually trained with RLHF (Reinforcement Learning from Human Feedback: practice that rewards a reply human raters prefer to read) or with rewards for answers a program can check. A paragraph people like is not the same objective as a probability you can threshold. A vendor probability is still not your probability. Until you score the model on a few hundred of your own labeled tickets, you do not know whether 0.90 means 0.90 in your queue.

If the model says 90 percent, count how often it was right. About 90 of 100 is calibrated. About 60 of 100 is overconfident — and a threshold of 0.80 will still fire on that noise.

Why one call should ask every boring question

A parallel sampler (a design that scores every question against a single read of the state, instead of writing answers one after another) is what TypeSafe says Jev uses. If that holds, a tenth question costs the tokens in the question, not a second reading of a long document and not a second essay. On 26 September a builder described 13 bounded questions on one long document: one batched call at 0.27 seconds, against 13 separate calls at 2.71 seconds and about 12 times the input cost. That is one published run, and sending the 13 calls at the same time would shrink the time gap. It would not shrink the repeated-input bill. The useful habit is to ask every boring question about the same state in one call, then let ordinary code combine the slots. Do not ask the model to write the policy.

One document, one decision-model call with many questions: the document is read once. Thirteen separate chat calls: the document is paid for thirteen times.

Ollaya is the socket, not a smarter brain

Ollama (the local app many people already use to run a chat model on their own machine) is the analogy in Ollaya’s README: run open decision models locally, the way Ollama runs chat models. Ollaya is not Ollama, and its FAQ says it is not affiliated with TypeSafe. It is a daemon (a small server that stays running in the background) on your computer. The README says its /v1/systemone, /v1/decisions, and /v1/models routes match TypeSafe’s wire format (the exact shape of the request and the response), and that TypeSafe’s official Python SDK 0.7.1 works unchanged if you point TYPESAFE_BASE_URL at http://localhost:11435. The runner’s license is Apache-2.0. It does not copy the weights (the large files of numbers that are the model) onto its own hub. It reads each author’s files from that author’s own repository, pinned to a commit and checked with sha256 (a fingerprint; if the file changes, the fingerprint does not match).

If you already looked at Laya as a local picker, that thread continues here — Ollaya is the socket those open decision models plug into. We measured the base English checkpoint earlier in Is Laya Worth It for Routing Code?; this piece is about which door you open once you know you need a label, not a paragraph.

The socket can hold very different models. This is the README’s own list, not a leaderboard I ran.

  • laya:en, English, ModernBERT-large (a 2020s encoder, a model that reads the whole passage and emits scores rather than typing), 421 million parameters (the count of learned numbers; smaller usually means faster and less capable). The README calls it the fastest: about 8 to 10 milliseconds for five questions on an RTX 4090.
  • laya:multilingual, 322 million parameters, for 100 plus languages.
  • decider at about 2 billion parameters, listed at 0.591 on a set the README calls typed-decisions.
  • kev:9b, listed at 0.722 on that same set, and described as the highest among models that were not trained on it.
  • Also decision, qwen3guard, nli, gliclass, von, and winnow, each with its own license.

Ollaya’s site also prints a hosted-Jev median of 236 to 276 milliseconds and warns that this includes the network, that the setups differ, and that you should read the gap as an order of magnitude. Do not subtract 10 from 250 and publish a winner. The author, writing as cobanov on the Hacker News thread, said Laya is a lot weaker than Jev on harder queries, that the small size is the reason it is fast, and that models closer to Jev are bigger. Ollaya’s FAQ says the same thing without the thread: the small encoders fall well below Jev on harder questions, and decider is more accurate and slower. That is the product. Short, obvious tickets, and a rule that the text cannot leave the building: try the local small model, then measure it. Subtle judgments, or a judge sitting on top of another agent’s claim: do not assume the 421 million parameter model is good enough because the call returned in 10 milliseconds.

A railway switch sends the same train down one of the tracks you already built. It does not invent a new track, and it does not write the timetable. That is the decision-model job in one picture.

Jev Router still calls a writer

OpenRouter’s page for typesafe/jev-router says the router picks the model and the reasoning effort (a setting for how long a chat model should think before it answers) and that it runs on Jev. The same page says the router accepts audio, files, images, text, and video, and that it returns text. A decision model does not return text. So this product is two steps. A picker chooses a writer. The writer still writes. The page lists a context window of 1,000,000 tokens. The decision model typesafe/jev-1.13 is listed at 32,000. If a screenshot says Jev has a million-token context, ask which product. The windows are not the same object.

The router page also says the price shown there is zero, so you are not charged for prompt or completion tokens on that listing. Hold that next to a same-day spot check, not a paper. Elvis, posting as @omarsar0, ran 8 support cases, 32 calls, against a fixed GPT-6 Sol baseline. He reported both sides correct on that tiny set, about USD 0.008 versus USD 0.018, and a median of 1.5 seconds versus 1.9 seconds, and he said the sample is small. A listing that shows zero and a run that still had a cost can both be true if the zero is the router’s own line and the writer is billed elsewhere, or if the page and the invoice disagree. Read the invoice. Do not quote the badge.

The router path in one line: your prompt → Jev used as a picker → a chat model plus a reasoning setting → written text.

Which door, in one pass

Use a decision model when the next line of code needs a label, a yes, or a score, and a paragraph would only get in the way. Use Ollaya when those questions are simple enough that you have measured a small open model on your own labels, and when the state should stay on hardware you control. Use hosted Jev when that measurement says the small model is wrong too often, and you accept sending state to TypeSafe. Use Jev Router, or any router, only when you still need sentences and you want help choosing who writes them. Do not point a chat client at the system-one route and expect prose. Do not point a local 421 million parameter model at a subtle safety judgment and treat a fast confidence number as a review.

What do you need back?

  • Sentences → a router in front of a chat model.
  • A slot you already listed → where may the text go?
  • It stays on our machines → Ollaya, then score it on our labels. Wrong too often on the hard cases? Move those cases to a stronger model. Otherwise keep the small model and a human threshold.
  • A vendor API is acceptable → hosted Jev, then the same score on your labels.

What I would not ship on

I would not ship on TypeSafe’s hundreds-of-times-cheaper slides. They are self-reported, and the launch post lists ways the comparison can flatter Jev. I would not ship on a rank table pasted into a Hacker News comment. A third-party bench called JevBench exists, and the figures circulating beside it were not stable enough, across readings of that page on the day of writing, to quote a rank here. I would not treat “cannot hallucinate” as “cannot be wrong.” I would not run a remote install script on a production machine without reading it. I would not quote an RTX 4090 millisecond figure as the latency of a laptop.

Bottom line: A chatbot is a writer. A decision model is a sorter with a probability. Ollaya is a local socket for open sorters. Jev Router is a sorter standing in front of a writer. The useful work is knowing which one your code is calling, and scoring the label on your own examples before that label moves money, mail, or a tool.

Common questions about decision models

What is a decision model?

A model that returns one of the answers you listed in advance — a choice, a yes/no, or a score — plus probabilities. It does not write free-form sentences. Jev and the models Ollaya runs are decision models. A chat model is a writer.

Is Ollaya the same as Ollama or TypeSafe?

No. Ollaya is a local daemon whose routes match TypeSafe’s wire format so you can point the TypeSafe Python SDK at localhost:11435. Its FAQ says it is not affiliated with TypeSafe. Ollama is the familiar local chat-model runner; Ollaya is that idea for open decision models.

Does Jev Router return a label?

No. OpenRouter’s typesafe/jev-router page says it returns text. Jev is used as a picker for which chat model (and reasoning effort) should write. That is two steps: sorter, then writer.

Does “cannot hallucinate” mean it cannot be wrong?

No. Schema-bounded output stops invented fourth queues and free-form fiction. It does not stop a wrong slot. Your code will obey a valid wrong label unless you refuse low confidence and score the model on your own tickets.

When should I use Ollaya vs hosted Jev?

Use Ollaya when the questions are simple enough that you have measured a small open model on your labels, and the state must stay on your machines. Use hosted Jev when that measurement says the small model is wrong too often and you accept sending state to TypeSafe. Use a router only when you still need sentences.

If you do one thing tonight

Pick one ticket shape you already automate with a chat model. Rewrite the call as choice, noul, or score. Run it once on a decision model and once as prose. Keep the path whose output your code can threshold without parsing English — then score a few hundred of your own labels before that slot moves money or mail.

Sources read for this draft

No model was called while writing this. Vendor numbers are labeled as vendor numbers. Where a public bench did not sit still, it is omitted rather than averaged into a fake precision.

Leave a comment