Decisions Are Becoming Data

In the month since TypeSafe AI introduced Jev, a new kind of AI model has gone from one startup's launch to something almost every major AI platform now offers. These models make decisions rather than write text, and how quickly they've spread says a lot about where agent systems are heading.

TypeSafe introduced Jev on September 15 as the first of what it calls System One models. On October 1, Cloudflare released Clef and Clef-flash as open-source models, AWS released Strands Decider 2B, and Perplexity launched an open-weight decider along with its own Decisions API. The vLLM Semantic Router team followed its September release with Decision 2.0 on October 2. OpenAI opened its Decisions API to all developers in public beta on October 6, and Microsoft launched Microsoft-Decision-1 a few days later. Investment has followed just as quickly, and on October 9 TypeSafe raised $870 million at a $7.5 billion valuation in a round led by Andreessen Horowitz.

This post explains what these models do, why so many companies are building them at once, and how they fit into the agent systems people are building now.

What a decision model does

A decision model takes in a description of a situation, answers questions you define about it, and returns probabilities instead of prose. Most of these releases support three kinds of question.

• Choice picks one option from a list, such as which team should handle a support ticket. It returns the top pick along with a probability for every option.
• Noul answers a yes-or-no question with a probability, such as how likely it is that a command touches production data.
• Score places something on a scale you define, such as rating urgency from "can wait" to "blocking revenue."

Most of these models also share a request format, which TypeSafe calls System One. You send the situation and a set of named questions, and the model answers all of them in one call without generating any text. Cloudflare, Perplexity, and vLLM Semantic Router follow it closely, and OpenRouter and Vercel's AI SDK now offer decision calls in a very similar shape, so in practice it is becoming a shared standard. OpenAI's Decisions API works the same way under its own names, which it calls predicates, choices, and scores. It runs on GPT-6 Luna, accepts text and images, and OpenAI says it makes decisions up to 10 times faster than calling Luna through its regular API.

Why the space is heating up

Decision models are spreading quickly because they make each judgment nearly free and nearly instant. Since they don't generate text, providers charge only for the input a model reads, and the going rate is now a few cents per million tokens. Jev and Microsoft-Decision-1 both cost $0.042 per million input tokens, and OpenAI charges $0.10. At those prices, a team can afford to check every step an agent takes instead of spot-checking a few. The models are also fast enough to sit inside an agent's loop without slowing it down. Microsoft reports a median response time of 85 milliseconds for Decision-1, compared with about three seconds for GPT-6 Sol in the same comparison, and Cloudflare reports about 39 milliseconds for Clef-flash in its own tests.

Quality is harder to pin down, because nearly every comparison so far comes from the company that built the model. Microsoft reports Decision-1 at 83.5 percent average accuracy across 36 benchmarks, slightly ahead of Jev at 82.3 percent and OpenAI's Decisions API at 79.4 percent, while Jev still scores highest on calibration. Those results come from JevBench, a benchmark TypeSafe itself maintains, which is also where H2O.ai's 4-billion-parameter open model recently ranked first among more than 100 open-weight systems. The useful takeaway is that open models you can run yourself are now close to the hosted leader, and that any of them is worth testing on your own work before you rely on it.

The other reason is how often agents need to make small decisions. While working on a single task, an agent system might decide which model should handle each step, whether a tool call is risky, whether an answer is backed by evidence, and when to hand off to a person. Today, most systems make those calls by asking a general-purpose model a question and reading a verdict out of its written reply. A decision model returns a number the software can act on directly, so each of those checks becomes cheaper and faster.

Where decision models are already in use

The first real applications cluster around the moment just before an agent acts.

• Vercel published a guide for using Jev to review each shell command an agent proposes. Commands that only read ordinary files run automatically, while anything that changes files, touches credentials, or reaches the network pauses until a person approves it. If the review itself fails, the command waits for a person as well.
• In AWS's launch example, Strands Decider checks a proposed weather lookup before it runs and asks whether the city actually came from the user. When the agent has guessed the city, the application sends it back to ask.
• LangChain tested Jev as a judge for agent evaluations. In a narrow test of five examples repeated 100 times, Jev matched human labels on every pass-or-fail decision at a total cost of $0.34, compared with $28.17 for Claude Sonnet 4.6. The authors describe the result as promising but early.
• Cloudflare built Clef partly for its own needs, and describes applying it to work such as classifying suspicious domains for threat intelligence and triaging support requests.

In each case, the decision model makes a fast judgment and the surrounding code decides what to do with it.

What an agent pipeline starts to look like

As these pieces mature, an agent pipeline starts to look like a set of specialized models working together. A language model does the main work, such as writing code or drafting a document. A router picks which model handles each step, based on how difficult the step is. A decision model approves or blocks actions before they run. A guardrail classifier screens inputs and outputs for risky content. A memory store supplies context from earlier work. With decision models now offered by almost every major provider, these parts will often come from different vendors.

Each of these parts earns its place, because each makes the pipeline faster, cheaper, or safer. Each also produces its own outputs, uses its own thresholds, and changes version on its own schedule. None of them keeps track of how the others are behaving. When something goes wrong, the team has five separate logs to reconcile, and none of them explains the full sequence of events or the rule that should have applied.

That is why a pipeline built from more models also needs a system underneath it. The system holds the rules every component answers to, keeps a versioned history of how those rules change, carries state across sessions and tools, and records each decision alongside the evidence and the rule it was made under. Decision models make individual judgments cheaper, and the system is what makes the pipeline accountable as a whole.

How we approach it at 5thDev

5thDev is that system, built for coding agents. It isn't a model, and it doesn't compete with decision models. It sits underneath the agents you already use, including Claude Code, Codex, Cursor, and other supported tools, and does three things.

• It governs the work. Your rules live alongside the project context, and an agent's proposed change can be checked against them before it's written. When a mistake reveals a repeatable problem, the fix is saved as a new rule. When an agent reaches the limit of what it has evidence for, it says it doesn't know instead of guessing.
• It carries the work forward. Each session ends with a summary and a note for the next one, so any supported agent can pick up where the last one left off, even in a different tool.
• It records the work. Every governed answer comes with a receipt that shows the evidence it used, the rules it was checked against, and the limits of what it can support. Each record has a content-based identity, so a changed record can't pass as the original.

Beta users report savings of up to 60% through removal of repetition and re-visiting incomplete code.

Where this is heading

Decision models are quickly becoming a standard part of agent pipelines, because typed probabilities are cheaper and easier to act on than written answers. The more of them a team adds, the more it needs one set of rules and one record that every model answers to.

If you're adding decision calls to an agent workflow, start with a single approval step and log the situation, the probabilities, the question version, and your threshold together. If you want that system in place for your coding agents, 5thDev Local is free and runs on your machine. You can find it at 5thdev.ai.