Stop paying chatbot prices for the yes-or-no decisions inside your AI workflows

Most AI calls in your production workflows are not writing content. They are making small yes-or-no decisions (routing tickets, validating outputs, checking brand rules), and you are paying frontier LLM prices and latency for every one of them. A new class of decision model can handle those calls at a fraction of the cost and return type-safe answers in milliseconds.

Look inside any production AI workflow and count the calls. Most of them are not writing anything. They are deciding. Which team gets this ticket? Is this lead a fit? Did the output pass the brand rules? Should the agent retry, or escalate to a human? Should this command run at all?

Teams send every one of those small decisions to a large language model built for chat. Each call waits seconds for a reply, costs output tokens, and returns free text that code then has to parse. Sometimes the model answers "probably" when the workflow needed a clean yes or no. Multiply that by thousands of calls a day and the decision steps, not the writing, become the slowest and most fragile part of the system.

The shift: Separate decisions from generation

The shift is to split the stack into two jobs. Language models reason and generate. A separate decision model answers the typed questions in between.

In September 2026, TypeSafe AI (founded by Diogo Almeida, a former OpenAI researcher who worked on RLHF and InstructGPT; $40M raised, led by DCVC) launched Jev, the first of what it calls "System One models", named after Kahneman's fast, intuitive thinking. Jev does not generate text. You send it the program state and a set of typed questions, and it returns structured answers with probabilities in one parallel pass:

• Choice: pick one option from up to 255 (route this ticket to billing, technical or sales)
• Score: place the input on a defined scale (how frustrated is this customer)
• Noul: a single probability that a statement is true (this message is urgent)

TypeSafe's published figures: 70 to 500 ms response times, $0.042 per million input tokens, and output tokens free. Frontier LLM pricing runs from about $0.20 to $10 per million input tokens, with output usually around five times the input price. Every answer carries a calibrated confidence, so the software can act on its own when confidence is high and hand off to a person when it is low. That is the property that makes automation safe to switch on.

A useful mental model from the launch discussion: Jev decides, code computes, the LLM reasons and writes, Jev verifies, tools execute.

What this is not

Be clear-eyed about the claims. The benchmarks are TypeSafe's own, self-run and not yet independently reproduced. The product is in early access. It handles text only (no images or video), has a 64k-token context limit, and is poor at counting, arithmetic and date logic. It does not replace your LLM. It replaces the LLM calls that were only ever making a decision.

How to execute this in two weeks

Three steps any engineering team can run in a fortnight:

Audit your calls

Log every LLM call in one production workflow for a week and tag each one as "generates content" or "makes a decision" (classify, route, filter, validate, approve). In most agent and automation pipelines, decisions are the majority of calls. The coding-agent analysis in the "Jev Engineering for Coding Agents" note found reading and searching take roughly two thirds of processed tokens, and writing code under a tenth. Microsoft's fastcontext project reports reading and searching at 56.2% of tool-use turns in GPT-5.4 trajectories.

Move the decisions to a decision layer, cheapest-first

Use the cascade pattern: ask the decision model first, let plain code handle the obvious cases, send only the complex or low-confidence cases to a frontier model, and send the rest to a human. Set a confidence threshold per action based on the cost of getting it wrong: low for tagging, high for refunds or deletes. Keep the state you send small and relevant: accuracy drops when the context is padded with noise.

Measure before you switch

Pin the model version (for example jev-1.13.0, not latest) so thresholds stay stable. Run the decision model in shadow mode next to your existing LLM calls, compare answers against a labelled sample, then switch over one decision point at a time. Log the model version with every answer for auditability.

Where this pays off first

Support and ops triage: Routing, urgency and sentiment in a single sub-second call. Stop waiting three seconds for a frontier model to route a ticket.

Content pipelines: Duplicate detection, category tagging and brand-rule checks before anything publishes. Your publishing workflow needs binary answers, not prose.

Agent guardrails: Allow, ask or deny on every tool call or command an agent wants to run. This is the control layer that stops agents from running destructive commands.

Evals and quality gates: Scoring outputs against a rubric at a fraction of LLM-as-judge cost. DeepEval has announced a Jev integration for its evaluation metrics.

Bulk classification: Early users report classifying 1,018 research papers for $0.08 and analysing 4,367 Meta ads in 39 seconds for $0.27. One commenter noted the ad analysis could not see the images, which shows why the text-only limit matters.

The business outcome

Decision steps get faster by one to two orders of magnitude, and their cost falls close to zero. Illustration: a 2,000-token routing decision costs about $0.00008 on Jev against roughly $0.0017 on a mid-tier model such as Gemini Flash, about twenty times less, before counting latency. Output becomes type-safe, so malformed answers stop breaking workflows. Every decision carries a confidence score, so teams can automate the confident cases and route the rest to people instead of trusting a free-text guess. The frontier-model budget goes where reasoning and writing earn it.

The practical step for this quarter

Audit one workflow, move its three highest-volume decisions onto a decision layer in shadow mode, and compare cost, speed and accuracy before making the change permanent.

You will find the calls that are decisions in disguise. You will see which ones cost the most, take the longest, and fail the most often. Move those first. The rest of the stack will follow.

Want to know which calls in your AI stack are decisions in disguise? Talk to The WrightyMedia Agency about a decision-layer audit of one production workflow.