Jev, OpenAI, and Amazon all shipped a model that picks instead of writes

Let me catch you up on a shift that happened fast. For two years, the default move was to point a big chatty model at every problem, even the small ones. Now a new class of model does the opposite. It doesn't write. It picks. You hand it text and a list of answers you wrote, and it hands back a verdict with a confidence number. No prose, no parsing, no retry loop. TypeSafe shipped the first one. Within weeks, OpenAI and Amazon shipped their own. Here's where we are, and what it means for your roadmap.

The deep cut

• A chatty model is the wrong tool for a verdict. Jev, Strands Decider, and OpenAI's Decisions API all turn one-word answers into fast, typed picks.
• The model gives evidence; your code makes the call. A Laya fraud test failed until the dev asked "is this account takeover?" and let code decide what to do.
• Cheap review on every step beats one gate at the door. Jev checking each agent action cost $2.94 versus $372 for a frontier model.

The novelist stamping forms

Somewhere in your stack, a reasoning model is doing a classifier's job. It reads a ticket, writes {"team": "billing", "urgent": true} one token at a time, and your code prays the JSON parses. One writer put it plainly: it's like hiring a lawyer to flip a coin. You pay for three seconds of thinking to get back a single label.

Decision models close that gap. TypeSafe's Jev takes your text plus questions with three shapes: pick one option, score on a scale you define, or answer yes/no with a probability. It returns a value from the set you wrote. It literally can't invent a fourth team or misspell the third. The pricing is $0.042 per million input tokens, with output tokens free.

The win that surprised people: every question runs in parallel. Ask ten and it costs about the same time as asking one. That flips the old habit of asking the cheap question first. Now you ask everything up front and let your code ignore what didn't matter.

Three giants shipped the same idea in one week

This stopped being one startup's bet fast. At Dev Day, Sam Altman revealed a Decisions API that gives OpenAI's Luna model a fixed set of options to pick between. Latent.Space, the first podcast to cover it, confirmed it's a Luna wrapper for now, built in a one-week sprint by a team willing to clone a pattern they thought was good.

Amazon went open. Distinguished engineer Marc Brooker built a homebrew version after seeing Jev, and it hit the top of the Jevbench ranking for its size, so AWS cleaned it up and shipped Strands Decider 2B as open weights you can run locally. His framing is the clearest reason to care: these are a good "decider for a workflow step," answering "what is the next thing for me to do here?"

The lesson for you: this is not vendor lock-in to one startup. You have a hosted option, a frontier-lab option, and an open-weights option already. Pick on calibration and cost, not logos.

The sandwich that keeps it safe

The easy mistake is asking the model to decide the action. A developer testing Laya for fraud first asked whether to approve, review, or hold an order. That's a policy call dressed up as a semantic one. The fix: ask "does this look like account takeover?" and let your code decide what happens next. The model supplies evidence. Your code owns thresholds and side effects.

This matters because "zero hallucination" is a half-truth. Jev can't return an answer outside your list, but it can absolutely return the wrong valid answer. TypeSafe's own launch post admits the 0% figure is not empirical. So treat confidence as an input to a rule you can audit, not a verdict you act on blind. If a wrong answer is expensive or hard to undo, code makes the call.

A few hard limits: these models are weak on dates and math, so keep that logic in code. And a good probability in aggregate does not mean any single answer is right. Build a golden set of a few hundred labeled examples, plot accuracy against confidence, and set your own threshold. Don't copy 0.85 from a blog post.

Cheap enough to check every move

The number that should reach your roadmap is about guardrails. A security engineer built a demo that uses Jev to check each agent action against its task, blocking high-confidence bad moves and flagging the rest. The cost of watching an agent that way ran $2.94 with Jev versus $372 with a frontier model. That gap changes what's possible. You can afford a check on every hop, not just at the front door.

The other proven use is context compaction. Instead of asking a model to summarize old turns, which loses exact error messages and file paths, Jev gets two yes/no questions per tool call: does this still matter, and is the full result still needed. One reported session dropped from nearly a million tokens to 86,000 in about a second. Nothing got rewritten, so nothing important blurred into a vague sentence.

One warning before you wire these in everywhere. The ease of building is also how messes start. Nielsen Norman's study of non-engineers found AI makes building feel free, so people overbuild into fragile systems they no longer understand. A cheap decision model invites a thousand tiny calls. Pin your version, since the "latest" alias can move under you and quietly break every threshold you tuned.

Three questions for your team

• Open your agent traces and count the LLM calls that return a single word. Which of those are decisions you could move to a typed model this quarter, and what would that save per month?
• For each decision you move, who owns the threshold and the action? Confirm the model supplies evidence and your code makes the call, so a wrong valid answer gets caught.
• Before you point a chatbot or agent at your corpus, can you trace a wrong answer back to its source and tell whether the model fabricated or just repeated stale data? If not, fix the data lifecycle before you blame the model.