Published: October 2026
TL;DR
The Jev decision model, from TypeSafe AI, doesn’t write text. It answers questions that have set answers (pick one, give a score, or yes or no) and tells the LLM how likely it is with code. That makes it a cheap, fast helper for the small choices inside your AI agent, like which tool to use or whether a human should approve.
The hard part of running an AI agent usually isn’t the prompting. An agent is an AI assistant that takes actions for you, like sending email. Every turn (each request it handles) hides dozens of small choices, like picking a tool or deciding whether a request needs my approval. Most of us hand all of them to a large language model (LLM), the kind of AI built to write text.
My Hermes Agent runs tool calling logic in the background, and without a fronteir model trips up often without explicit directions. I asked it to send an email, but a tool search feature, which keeps tools out of view until the agent looks for them, had hidden the AgentMail tools I gave it. So it grabbed the terminal instead, the window where you type commands straight to the computer. The send failed.
That’s why the Jev decision model caught my eye in September. A decision model is a smaller, faster AI built only for helping agents making choices.
What Is the Jev Decision Model?
Jev is the first model from TypeSafe AI, a San Francisco startup co-founded by former OpenAI researcher Diogo Almeida. It launched in early access on September 15, 2026 (TypeSafe’s launch post). TypeSafe calls it a “System One” model, after the fast, gut-check thinking in Daniel Kahneman’s Thinking, Fast and Slow.
TypeSafe sums it up as “unstructured state in, typed probabilistic decisions out.” In plain words, you send in messy information, like a chat message or a block of JavaScript Object Notation (JSON), the labeled format apps use to pass data around. You get back one answer from a set list, with odds attached.
The Three Question Types
Each answer comes with a probability, a number from 0 to 1 for how likely it is to be right (0.9 means 90%). Jev handles three kinds of questions:
- Choice: pick one option from your list, with a probability for each option and an overall confidence number.
- Score: rate the input on a scale you define, from worst to best.
- Noul: TypeSafe’s name for a yes or no question, which returns a single probability.
Cost and Speed
AI models charge by the token, a small chunk of text, often part of a word. Jev’s output is free, so you pay only for what you send in (TypeSafe Models page). TypeSafe also claims each call takes 70 to 500 milliseconds, half a second at most, measured from its own laptops on the West Coast.
How a Decision Model Works as a Sidecar
Picture a motorcycle sidecar, which rides alongside and never steers. Your main LLM stays the brain that plans and writes. The decision model answers small questions at three points:
- Before the turn: does this message need a tool, and if so, which one?
- Before a tool runs: does the tool the agent picked match what I asked for?
- After the work: is the result good enough, or should it retry?
Every answer comes back as a number, so your code can act on it with a simple if-then rule.
When to Trust the Answer
A reasonable starting point is the 90%/60% rule: let your code act on its own above 90% confidence and send anything under 60% to a human. In between, retry with a stronger model or more information.
Jev vs. OpenAI vs. Microsoft
OpenAI built its own version, the Decisions API, announced at its DevDay developer event on September 29 (OpenAI’s DevDay 2026 recap). An API (application programming interface) is the doorway your code uses to reach a service. This one runs on GPT-6 Luna and entered beta, a wider test before full release, on October 6 (OpenAI API changelog). It uses the same three question types, charges only for input, and also accepts images, which Jev doesn’t (OpenAI Decisions guide).
Microsoft followed with Microsoft-Decision-1. Version one runs on Qwen3.5-9B, an open-weight model from Alibaba, meaning anyone can download and run it (Microsoft’s announcement). Here’s how the three line up:
| Jev (TypeSafe) | OpenAI Decisions API | Microsoft-Decision-1 | |
|---|---|---|---|
| Launch | Early access, September 15 | Announced September 29, beta October 6 | October 9 |
| Yes or no question type | noul | predicate | noul |
| Input price per million tokens | $0.042 | $0.10 | $0.042 |
OpenAI’s Decisions guide now lists decisions as their own kind of output, next to filled-in JSON records and tool requests. Deciding has become its own building block with its own price.
Why Everyone Is Building One
The idea isn’t brand new. Classifiers, models trained for one sorting job like spam or not spam, have returned probabilities for years, as The Register’s coverage of Microsoft-Decision-1 points out. Jev made it general purpose: one API for almost any question with set answers, instead of a classifier per job. As I see it, that’s what kicked off the wave of decision models that followed.
On October 9, TypeSafe raised $870M at a $7.5B valuation, led by Andreessen Horowitz (TechCrunch on the TypeSafe raise). TypeSafe says about a third of the Fortune 500 already use Jev.
The Register counted more than 100 decision models, from Cloudflare, Perplexity, Liquid AI, Snowflake, and others. Kai Williams at Understanding AI notes that Amazon and OpenAI have built the same basic design too.
The Model Context Protocol (MCP) Pattern
MCP is a shared standard for connecting AI agents to tools and data. I wrote about what MCP is and why it matters when it was new. It took about a year to become a standard:
- November 2024: Anthropic releases MCP as open source, free for anyone to use and build on (Anthropic’s announcement).
- March 2025: OpenAI adopts its rival’s standard (TechCrunch on OpenAI adopting MCP).
- December 2025: MCP moves to the Linux Foundation’s new Agentic AI Foundation, with more than 10,000 published servers (add-ons that connect it to a tool or data source). It works in Claude, ChatGPT, Gemini, Microsoft Copilot, Cursor, and VS Code (Linux Foundation press release).
Decision models are moving through the same early steps, only faster. Rivals already follow the same design. Microsoft reuses TypeSafe’s “noul” name and its request format, the layout of a question when your code sends it (Microsoft Learn guide to Microsoft-Decision-1).
Developer tools work across vendors too. Vercel AI Gateway routes AI requests to many providers through one connection and accepts decision requests in TypeSafe’s format or OpenAI’s. The AI SDK (software development kit), a toolkit for building AI apps, has a decide function that works with TypeSafe, OpenAI, Anthropic, and Google. Only TypeSafe and OpenAI return native probabilities, straight from the model. Anthropic and Google models are asked to estimate their own odds.
The big difference from MCP is who’s in charge. MCP is an open protocol, a shared set of rules, with a neutral home at the Linux Foundation. Decision APIs use at least two request formats, and the AI SDK still labels its decision spec (its written rules) as experimental. I’d bet a standard protocol comes next. For how agents talk today, see my post on MCP and Agent2Agent (A2A).
What a Decision Model Won’t Do
- No writing or planning: search queries, file locations, email text, and multi-step work stay with your LLM.
- Wrong answers: it can’t return an option you didn’t offer, but it can pick the wrong one. Armin Ronacher told TechCrunch that you still have to decide what to do with a 50% answer versus a 95% one.
- Prompt injection: text in the input that tries to give the model orders. TypeSafe’s Jev 1.13 jaggedness notes, its list of Jev’s weak spots, flag this, along with math, counting, and comparing dates. If it reads web pages or email, treat it as one safety check, not the only one, and keep a human in charge of risky tools.
- Option order: the same notes say Jev tends to favor the first option in a Choice. Shuffle your list or test a few orders.
- Vendor test scores: treat published scores as marketing until you test on your own examples.
- Data leaving your machine: every hosted option, meaning one that runs on another company’s computers, sends your agent’s information to that company.
How to Get Started
If your agent rarely makes a wrong call, skip this for now. If it stumbles the way my locally-run Hermes agent did, start here:
- Pick one small decision your agent repeats. Tool choice is a good first one.
- Write down 30 to 50 real examples with the right answers, then count how many your current agent gets right. That’s your baseline, the score to beat.
- Run the same examples through a decision model, starting with the TypeSafe Models page or the OpenAI Decisions guide.
- Start with the 90% / 60% rule, then adjust the cutoffs until the results on your examples look right.
- Lock in one model version. Names like
jev-latestalways point to the newest version, so the model can change under you. - Run your examples again, and rip the decision model out if the results didn’t improve.
Want the follow-up with my before-and-after numbers? Subscribe to the Schema Sauce newsletter.
FAQ
How Is a Decision Model Different from an LLM?
An LLM writes and plans. A decision model only chooses, and hands your code a number instead of text.
Can I Trust the Confidence Number?
Treat it as a signal, not proof, until it holds up on your own examples.
