Your Model Talks Too Much. Make It Decide.

TypeSafe shipped Jev, a non-generative System One model that does not write. You send it a piece of state and a typed question, and it returns a typed decision with a probability distribution in roughly 150 milliseconds, at $0.042 per million input tokens, with no charge at all for output.

One developer clocked a real clothing mockup app at $0.0011 per decision and about 620 milliseconds, according to The Register. That figure is not a token rate. It is the cost of one complete end-to-end inference pass, question in and typed answer out, so do not stack it against a per-million-token price and call it a comparison. Your chat model charges you for prose you never wanted so that it can arrive at a judgment you only needed as a yes, a score, or a pick from a list. That is the line on your agent bill nobody audits.

PhantomByte Note #187 built a confidence layer from a model's internal representations. Note #195 showed your harness paying for planning it does not need. This note is the next rung down the same ladder. When the answer is a decision, stop asking for text at all. Give it a name so you can argue about it with your team: the Typed Decision Layer.

THE THREE PRIMITIVES YOU ACTUALLY NEED

Jev ships exactly three question types, and TypeSafe calls them AI primitives because they behave like functions.

• Choice. Picks one option from a set you define.
• Score. Rates the state against a rubric.
• Noul. Returns a probability between 0 and 1 that a statement is true.

Choice and Score come back with a probability for every option and a confidence level, which is what lets your code decide whether to act on the answer or route it to a human. Noul answers with a single number. All three can be mixed in one call, and every question is evaluated in parallel against the same state, so adding questions barely changes response time. TypeSafe's own documentation makes the design point bluntly: ask whether a message conveys urgency rather than asking the model to analyze the message and determine the best course of action.

Those three primitives map onto the three judgments your agents make constantly. Route, rank, verify. The hard work moves out of prompt engineering and into schema design, because you now have to decide what judgment you actually want. That was always the hard part. Generation just hid it from you.

THE COST MATH ON ONE SCREEN

Write two numbers next to each other. Frontier output tokens run $20 to $25 per million. A typed decision runs at $0.0011 in the one measured app and zero marginal cost for output anywhere.

The labs are telling you the same thing this month. OpenAI cut GPT-6 Sol and Luna API pricing to half the 5.6 series and attributed the drop to caching and inference improvements, while Anthropic priced Claude Opus 5.5 output at $20 per million, down from $25, describing it as roughly 40 percent cheaper to serve than Opus 5. The Decoder read that release as a price story rather than a capability story, and it is right. When both frontier labs spend a launch talking about serving cost and output shape, they are telling you where the expensive part of your system lives.

The expensive part is generation. So generate less.

YOU MAY NOT NEED A NEW MODEL

Here is where it gets interesting for anyone who already runs open weights. A demo hit Hacker News on September 23 showing a trained KV cache bank converting an existing LLM into a classifier-style model that returns typed decisions instead of prose. The demo classifies customer support requests into billing, support, sales, or other, and it runs an eight-case suite with concurrent requests.

The premise matches Jev's premise exactly. A model can compute decision probabilities directly from internal representations instead of writing its way to an answer. If that holds up, structured decisions are not the private property of a purpose-built model, and you can get the low latency and repeatability without paying frontier token prices.

Caveat this honestly, because the demo is thin. It is an early proof of concept rather than a benchmarked product, and it makes one narrow claim: an existing model can be induced to answer in typed decisions. Treat it as a direction, which is exactly what an engineer should do with it. The same pattern shows up in the ecosystem that grew around Jev in one week, where developers have already posted local alternatives and open classifiers that mimic the typed output without the model.

THE PATTERN IS ALREADY IN YOUR TOOLS

Two more data points make this a layer stack rather than a model story.

What's Next is a small Claude Code plugin by the team at kvit that ends a working turn with a short report plus a keyboard-selectable card of two to four next steps. It hooks the AskUserQuestion tool and only fires at the final stop of a reply, not between tool calls, which is the whole design. Its author describes it as reverse Jev, and the description is exact: the same thesis, pointed at a human instead of a parser.

ReAdapt is the research version. The paper, arXiv 2609.25284, augments the standard ReAct loop with an explicit structured social state and a typed Adapt step that emits continue, switch, abandon, or clarify before the agent takes its next action. With Gemini-3-Flash on 150 stratified queries per task, warm introduction accuracy moved from 37 percent to 51 percent and reaction selection from 69 percent to 77 percent, with the model, tools, and environments held fixed. The only change was forcing a decision through a defined space before acting.

Read those three together and the layer stack is obvious. Decision type at the model. Output shape at the interface. Typed control steps in the loop. Same move at three different layers, and none of them required a smarter model.

WHERE TYPED DECISIONS BITE BACK

A frozen schema is a commitment, and commitments go stale.

The habit formation paper on arXiv, 2609.25299, measured what happens when a deterministic path replaces reasoning. Its guard admitted work it should have deferred on 2.6 percent of natural paraphrases and 26 percent of inputs near its boundary, and 11 of 13 of those failures were invisible to the trace-conformance gate at any threshold. Deterministic errors repeat exactly, which is the paper's sharpest line. A bad habit is as reliable as a good one, and that reliability is the price you pay for the property that makes the system auditable.

There is a second failure mode worth naming, and it is the reason typed state beats better prompting. The clarification paper on arXiv, 2609.25337, shows that an ambiguous early turn collapses into a single hidden interpretation, and later clarification gets filtered through that commitment rather than correcting it. The authors call it early posterior collapse. Coding tasks are the most vulnerable, because early assumptions get embedded in interfaces and control flow where they are expensive to remove.

So the rule is narrow and it is the whole game. Type the decisions that are stable. Generate where the space is genuinely open. When the world shifts and your option set does not, you get fast, cheap, confident wrongness, and you will not see it in the trace.

WHAT TO DO TODAY

1. List every point in your agent where the model writes prose that a human or a parser immediately converts into a pick, a score, or a yes or no.
2. Pick the three most frequent of those and define each one as a Choice, a Score, or a Noul.
3. Route those through a typed decision mechanism, whether that is Jev, a classifier head, or your own schema-gated call, and measure latency and cost per decision for a week. Cost per decision is the only number that matters here, not tokens and not agent runs.
4. Keep generation for the genuinely open spaces, and write down which ones those are. If that list is longer than five items, you are lying to yourself.

THE UNCOMFORTABLE QUESTION

Your model's prose is the most expensive possible way to say yes. So why is almost every decision in your stack still written in paragraphs?