If you have ever watched an AI agent run, you have seen the same pattern. It spends most of its time answering questions that have a yes-or-no, a category, or a number: should I retry, is this a billing email or a tech-support email, how urgent is this ticket on a 0-to-2 scale. None of those need a paragraph of prose. They need a typed, calibrated answer, fast. This week Ollama, the local model runner, and OpenAI, a frontier lab, both put out the same primitive aimed at exactly that mismatch.
What a decision model actually is
TypeSafe AI calls the primitive a System One decision: “decisions, not strings.” You hand the model a state object and a set of named questions; it answers with typed fields and a confidence number, in a single round trip. The decisions come back in three shapes. choice returns a label plus a vector of probabilities, with a confidence. noul is a yes-or-no numeric probability. score returns a number mapped to a legend of strings. There is no streaming prose and no chat UI to render.
TypeSafe’s first public model is Jev, built on a new training method the company calls RLCD - “Reinforcement Learning for Calibrated Decisions.” The claim TypeSafe makes is that every Jev decision includes a calibrated confidence, so a downstream agent can route, escalate, or abstain. On TypeSafe’s own published numbers (vendor-reported, not independently verified), Jev completes a workflow in 0.114 seconds at $0.000081, against 8.566 seconds and $0.013880 for an unnamed LLM baseline. The company’s homepage frames that as “193.6x Faster, 444.6x Cheaper” on its own System One workflows, and lists an input price of $42 per billion tokens, which it says is 238x lower than Claude Fable 5.1’s input price. The TypeSafe docs (docs.typesafe.ai) describe Jev as TypeSafe’s first System One model and confirm the three primitives: choice, noul, and score.
The pragmatic framing is that this is what classifiers were always supposed to be: typed, calibrated, machine-consumable, and fast enough that an agent can call them inside an inner loop.
Two ships in twenty-four hours
On September 29, 2026, the Ollama blog announced that Ollama 0.35 supports “decision models, based on TypeSafe’s Jev API for fast, typed decisions” (the v0.35.0 release was tagged on GitHub late on September 28 UTC). Three decision models are available at launch: nimble (an open-source 9B model from Bespoke Labs), tev1 (an experimental 4B model from Together AI), and tev1:0.8b (an experimental 0.8B model from Together AI). Ollama reports, from its own demo, that “Nimble 9B averaged 91ms per decision in the Pac-Man example below when running locally on an M5 Max”; that is a vendor figure for one example, not an independent benchmark. The endpoint is /v1/systemone; the blog’s Python example uses TypeSafe’s typesafe-sdk package pointed at the local Ollama server.
The same day, at OpenAI’s DevDay in Fort Mason, Simon Willison’s live blog recorded OpenAI previewing a Decisions API that gives the Luna model “a predefined set of options to choose from” and answers “in a fraction of a second.” Willison wrote that it “Sounds like their response to Jev, which came out of stealth less than two weeks ago!” The Decisions API sat in the same keynote as Dots, GPT-6.1 Sol, Codex moving “fully in the cloud”, and the OpenAI Marketplace launch.
The next day, TechCrunch called the Decisions API a “Jev clone” in its headline and pointed to agent monitoring as one likely use: after a series of incidents where OpenAI’s agents misbehaved on the open internet, one of the lab’s new security measures is using a separate model to watch for bad actions at “significant compute cost.” TypeSafe did not respond to TechCrunch’s questions about OpenAI’s product, but its CEO Diogo Almeida, described by TechCrunch as a former OpenAI engineer, had earlier told the publication: “Fast and cheap is very easy, you know. If you want it really fast and cheap, use dice, right? Intelligence is the hard part, and my North Star is always pushing the intelligence-per-dollar Pareto curve.” According to TechCrunch, he also joked on X about the beginning of the clone wars.
What the API actually looks like
The Ollama example is concrete enough to copy. The request is a JSON POST to /v1/systemone with a model field, a state, and a questions object of named questions. Each question has a name, an instructions string, and a criteria payload. For a support-ticket triage:
- a
choicequestion namedteamwith criteria{billing: "...", technical: "...", other: "..."} - a
noulquestion namedrefundwith criteria asking whether the customer is asking for one - a
scorequestion namedurgencywith a legend{0: "Routine", 1: "Soon", 2: "Urgent"}
A single response returns all three, each with a probability or value and a confidence. The Ollama example reports {"input_tokens": 841, "output_tokens": 4} for one of these calls - four output tokens because the answer is a structured payload, not a paragraph of reasoning.
The pricing difference is the part that should land. TechCrunch reported that Shapor Naghibzadeh of QueryStory built a hackathon demo that uses Jev to check each agentic action against its task, and that monitoring of that kind costs $2.94 with Jev versus $372 with a frontier LLM (figures as reported by TechCrunch; the workload behind them is not published). At DevDay, Sam Altman framed OpenAI’s version of the same trade-off: “By focusing the model on that choice, we can make it extremely fast while keeping capabilities like image understanding, broad language support, and safety protections.”
Why This Matters
The local-AI angle is the part that matters for readers who run their own models. You can now pull a 9B decision model, point a Python SDK at localhost:11434, and get typed decisions locally; Ollama’s own example reports about 91 milliseconds per decision on an M5 Max. For local AI, three things change. First, latency: a decision in the inner loop of an agent no longer needs to go to the cloud, so a local agent can stay fully local. Second, cost: Ollama lists “No additional costs” for local decision models, and its example call returns four output tokens. Third, the Ollama example uses TypeSafe’s own typesafe-sdk, with the server set through TYPESAFE_BASE_URL, so the same client code can in principle point at a local Ollama server or TypeSafe’s hosted Jev.
The frontier-lab angle is also worth naming. OpenAI’s Decisions API exists because the agent-control problem is now concrete enough that a frontier lab is willing to ship a specialized endpoint rather than ask customers to keep using a general chat model for classification. The Decisions API sits in the same DevDay keynote as Dots, GPT-6.1 Sol, Codex moving “fully in the cloud”, and the OpenAI Marketplace.
The catch is that decision models are not a substitute for a reasoning model. They are a complement. A reasoning model is the right tool for “find the right answer”; a decision model is the right tool for “given a small set of options, pick one with calibrated probability, fast.” Mixing them - reasoning for planning, decisions for gating - is where the actual workload savings show up.
The Bottom Line
Ollama, the local model runner, and OpenAI, a frontier lab, put out the same primitive within twenty-four hours. Ollama 0.35 added the /v1/systemone endpoint with three decision models from Bespoke Labs and Together AI; OpenAI previewed the Decisions API for Luna the same day. Both return typed, calibrated decisions, fast. For local-AI readers, the practical line is: pull nimble from the Ollama library, point the typesafe-sdk at your local server, and test whether the classification calls in your agent’s inner loop can become typed, locally hosted decisions.