Stop Paying LLM Prices for an if Statement: A Field Guide to Decision Models in Late 2026
I keep coming back to one small question: why do we ask a model to write a paragraph when all our software wants is a yes, a no, or a number?
This is my notebook on how Jev answered it, who answered back, and what I would try first. Written 19 November 2026.
The short version
On 15 September 2026, TypeSafe AI released Jev, a model that never writes text. You hand it some state (text or JSON) plus typed questions, and it hands back a choice, a score or a probability.
What drew me in is how ordinary the problem is. Agent loops pay frontier-LLM prices, and wait seconds, for tiny calls like routing, gating and relevance checks that software then turns back into an if statement.
In about eight weeks, Cloudflare, OpenAI, Microsoft, AWS, Google and PostHog shipped their own decision models or APIs, and at least seven open-source projects showed up.
I also want to be fair about the numbers. The headline figures (up to 193.6x faster, 444.6x cheaper) come from TypeSafe's own four workflows. Outside checks are more modest, and one viral demo did not survive being measured. So I read them as a hypothesis to test, not a result.
Why this needed to exist
Picture an agent harness as a loop: the model proposes, the harness checks, the model carries on. When I look at what the harness actually checks, it is all small stuff.
Which skill should handle this? Is this bash command safe? Is that tool result relevant? Should a human see this? Is the agent really done?
Each of those is a bounded judgment, and the usual answer was to ask a general LLM and parse whatever came back. Every decision then carries a model request, output parsing, recovery code for malformed answers, and waiting in line behind the previous call.
LangChain's post on building a harness with Jev makes the same argument I find convincing: let the generative model plan and write, and move the small decisions somewhere cheaper.
TypeSafe's founder, Diogo Almeida, is a former OpenAI researcher and co-author of the InstructGPT paper. His bet is that autoregressive text generation is an awkward fit for software that only needs an answer from a fixed menu.
The company calls this class System One models and describes the product as a function call: unstructured state in, typed probabilistic decisions out. The name nods to the Jevons paradox, which I find charming: make a judgment cheap enough and people will start making it constantly.
Most of what an agent harness asks a model is not "write me something". It is "which one?"
This is the launch thread most explainers link to, with the 20-200x faster and 40-400x cheaper framing:
// Detect dark theme
var iframe = document.getElementById('tweet-2099925682726002904-384');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2099925682726002904&theme=dark"
}
How Jev works, in plain words
Input: a state (any text or JSON) and a map of typed questions you define in code. Version 1.14 added image input.
Output: only values from the options you declared, so the answer can never come back malformed. It can still be wrong, and I will keep repeating that.
Primitives:
choice(pick one of N)score(rate against an ordered rubric)noul(the probability that a yes/no statement is true)
Parallel, not sequential: every candidate and every question in a request is evaluated together instead of token by token.
Calibration: TypeSafe says it trains with Reinforcement Learning for Calibrated Decisions (RLCD), so a stated 0.8 should be right about 80% of the time for that kind of question.
Access: a hosted API at POST /v1/systemone, $0.042 per million input tokens, free output. The weights are not public.
The eight weeks that followed
Eight weeks, six vendors and at least seven open-source projects. If you blinked in October, you missed three launches.
Every launch, date by date
- 15 Sep - TypeSafe AI emerges from stealth with a reported $40M seed and releases Jev (v1.13) in early access.
- 17-18 Sep - LangChain publishes Building a Harness with Jev and ships
langchain-typesafewith a guardrail middleware. - 23 Sep - DataCamp roundup of seven open-source Jev alternatives: Laya, Nimble, Kev, SemIf, Rizzo Flow, Von, NanoJev.
- 29 Sep - OpenAI announces the Decisions API at DevDay. PostHog releases Jeeves, a 9B open model that reasons before it decides.
- 1 Oct - Cloudflare releases Clef (27B) and Clef-flash (9B) with Apache 2.0 weights and an RL fine-tuning service. AWS releases the open Strands Decider 2B.
- 6 Oct - OpenAI opens the Decisions API in public beta.
- 9 Oct - Microsoft-Decision-1 becomes available in Microsoft Foundry. Cloudflare adds Clef-omni.
- 22 Oct - OpenAI Decisions API generally available. TechCrunch reports TypeSafe is valued at $7.6B.
- 11 Nov - Google launches the Gemini Decisions API with Gemini Decision 1.
How the field answered
1. The contract became the standard
State plus typed questions, returning probabilities. Cloudflare's Clef is described as API-compatible with Jev. Google's codelab shows djev-run, a server that reimplements Jev's /v1/systemone endpoint on top of the open DiffusionGemma model.
Kev can run behind a local Jev-compatible server, and Pydantic AI added a TypeSafeModel so a decision agent can be swapped between Jev and an LLM. LangChain's day-zero support for Google's API shows how far the contract travelled: it shares a base class with its TypeSafe classifiers.
// Detect dark theme
var iframe = document.getElementById('tweet-2120612277812625492-86');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2120612277812625492&theme=dark"
}
2. Several recipes competed for the same dish
- Purpose-built: Jev.
- Small bidirectional encoders with a decision head: Laya and Von, a few hundred million parameters, runnable locally.
- LLM fine-tunes with decision heads or LoRA: Nimble, Kev, NanoJev, Microsoft-Decision-1.
- Pointer heads on a small LLM torso: AWS Strands Decider 2B swaps the text head for a tiny scoring head. PostHog Jeeves does the same on a 9B model, with a reasoning chain first.
- Training-free wrappers reading option logits from an existing LLM: SemIf and Rizzo Flow.
- A repurposed general model: OpenAI's first Decisions API version constrained GPT-6 Luna to structured answers and tuned it for fast first output. Its team has credited Jev as the inspiration, which I think is a lovely thing to admit.
3. The fight moved to benchmarks and fine-tuning
Cloudflare reports Clef scoring highest on 7 of 10 decision benchmarks. Google reports Decision 1 beating Jev 1.14 on 5 of 7 shared benchmarks.
Independent tracker Artificial Analysis paints a tighter picture: Decision 1 and Jev 1.14 tie at 66 on its Decision Index, and Jev was faster (about 92 ms vs 211 ms per task) and cheaper per million tasks in that run.
Artificial Analysis shared that head-to-head on X:
// Detect dark theme
var iframe = document.getElementById('tweet-2120582049522127205-331');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2120582049522127205&theme=dark"
}
Meet the challengers
"Everyone copied Jev" is the lazy summary. When I read the launch notes one by one, each team made a different bet. Here they are in the order they shipped.
PostHog Jeeves: the one that thinks first (29 Sep)
The bet: think before you decide, and give the weights away. The model: an open 9B model built on Qwen3.5-9B with a LoRA adapter and a pointer head. It credits Kev as its inspiration.
The twist: it writes a short reasoning chain for each question before scoring the options, then returns calibrated probabilities through a Jev-compatible API.
Score (self-published): 93.5% on the public JevBench tier, against 86.6% for Jev.
The price of thinking: roughly 0.3 seconds without reasoning, and a 3.3-second median (17.1 seconds at p90) with full reasoning chains.
Openness: Apache-2.0 weights, MIT code, and training code and data in the repo. You will need a CUDA GPU.
OpenAI Decisions API (announced 29 Sep, beta 6 Oct, GA 22 Oct)
The bet: you already have a giant model, so teach it to answer like a small one. How it was built: it runs on GPT-6 Luna. OpenAI's API product lead has said it was not on the roadmap four weeks before release.
The first version used Luna without extra training: constrained to structured answers, answering several questions at once and tuned to return the first decision faster. He credited Jev with inspiring it.
What you get: text and image input, preset options, true/false conditions and scores. Latency is reported at 100-180 ms, down from 1-3 seconds, and up to 10x faster than calling Luna through the Responses API. Input is $0.10 per million tokens and output is not charged.
Who tried it: early customers included Box, Datadog, Ramp and Speak. Speak's CTO said the time between actions fell from 1.4 seconds to 0.13 seconds.
How it stacks up: at its October launch, TechCrunch reported Jev ranking 3rd and OpenAI's model 14th on the Artificial Analysis Decision Index, so the pitch is speed and multimodality more than raw accuracy.
For scale: Vercel said nearly 13% of its paid teams tried Jev within a day of it reaching AI Gateway.
OpenAI's developer account announcing general availability (it quotes the earlier beta post):
// Detect dark theme
var iframe = document.getElementById('tweet-2113346645463081418-837');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2113346645463081418&theme=dark"
}
Cloudflare Clef and Clef-flash (1 Oct)
The bet: the same API as Jev, open weights, and a way to fine-tune on your own traffic. The models: the first models trained by the Workers AI team, at 27B (Clef) and 9B (Clef-flash), built on frozen Qwen backbones. Weights are Apache 2.0 on Hugging Face and both run on Workers AI.
Same API as Jev: switching means changing the endpoint and model name. Clef takes up to 64 questions per call, a 64K context (Jev's is 32K) and up to 4 images in the request.
Speed and price (vendor-reported): median latency of 209.3 ms for Clef and 38.8 ms for Clef-flash, against 524.1 ms for hosted Jev including network. Clef costs $0.24 per million input tokens and Clef-flash $0.09, versus Jev's $0.042.
Benchmarks (vendor-reported): a Clef model leads on 7 of 10 decision benchmarks, while Jev wins on When2Call and BRIGHT. On Cloudflare's Decision Index, Clef scores 61.21 to Jev's 57.91.
A real use: Cloudflare's threat intelligence team classifies domains with Clef and Browser Run in 2.2 seconds, versus 4.7 seconds for gpt-oss-120b, which returned only two categories.
The bigger idea: an RL fine-tuning service. AI Gateway captures your traffic, Workers AI runs rollouts, Containers act as sandboxes, a new Trainer updates the weights and bring-your-own-model redeploys the result. It starts with forward-deployed engineers.
Caveats: the numbers are vendor-reported, no calibration figures have been published for Clef, and it costs more per token than Jev. Clef-omni and cheaper, faster variants followed around 9 Oct.
Cloudflare's own launch post for Clef:
// Detect dark theme
var iframe = document.getElementById('tweet-2105747536510099540-772');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2105747536510099540&theme=dark"
}
AWS Strands Decider 2B (1 Oct)
The bet: small enough for a laptop, with everything open. The model: a roughly 2B open model on a Qwen3.5-2B torso. The text-generating head is removed and replaced by a pointer head of about 1M parameters that scores the answer options. Later checkpoints added Gemma 4 models up to 26B.
Where it runs: locally only, with no hosted API. About 106-115 ms median on an RTX 3090 and about 153 ms on an M3 MacBook for small tasks.
How it scores: 72.3% of 231 public JevBench tasks, with documented weaknesses on long multi-step documents and unfamiliar scoring rubrics. A rival open model, Mapika decider-2b, reportedly scored 76% on the same benchmark.
Openness: Apache 2.0, with weights, training data and scripts released.
The demo I like: before an agent calls a weather tool, Decider notices the location is missing, so the agent asks instead of guessing. AWS calls this "hybrid agents": a decision model chooses and an LLM reasons.
The AWS developer account introducing it:
// Detect dark theme
var iframe = document.getElementById('tweet-2106097135179423965-651');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2106097135179423965&theme=dark"
}
Microsoft Decision-1 (9 Oct)
The bet: Jev's price, inside Azure, with your data kept in region. The model: Qwen3.5-9B, post-trained by Microsoft for fast, single-pass decision scoring. It returns choices, scores and yes-probabilities with confidence.
Where it runs: Microsoft Foundry on Azure, with an option to keep processing inside a data zone. OpenRouter listed it the same day with a 32K context.
Price and inputs: $0.042 per million input tokens like Jev, with free output. Text or JSON only, no images.
Claims (Microsoft's own): top accuracy in a 36-benchmark comparison of nearly 150,000 questions, an 85 ms median, and 4.5x faster than the runner-up. One independent JevBench ranking shared on X put it sixth among API-offered decision models, two places behind Jev.
My read: the "already on Azure, keep my data where it is" option.
Microsoft Developer's launch thread (the benchmark figures in it are Microsoft's own):
// Detect dark theme
var iframe = document.getElementById('tweet-2108637165693608252-950');
if (document.body.className.includes('dark-theme')) {
iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2108637165693608252&theme=dark"
}
Google Gemini Decision 1 (11 Nov)
The bet: send it anything, and ask a thousand questions at once.
Inputs: the most multimodal of the bunch: text, image
Comments
No comments yet. Start the discussion.