Most AI features in production today return prose. That is fine for chat, summarization, and drafting, but it is awkward when the thing your software actually needs is a label, a ranking, or a threshold decision. Jev, the hosted decision model from TypeSafe AI, was built around the opposite assumption: the model should return a structured decision rather than generated text. This article explains what Jev does, how its output types shape the way teams design prompts and pipelines, what its cost and throughput profile means for production workloads, and how to evaluate it fairly against the alternatives now available.
What Jev Does: Choices, Scores, and Probabilities Instead of Prose
Jev takes application state — a support ticket, a JSON record, an API payload — together with a typed question, and returns a typed decision. TypeSafe defines three answer shapes. The first is a choice: one selected option from a set of up to 255, returned with probabilities across the option space and a confidence value. The second is a score: a level on an ordered scale of 2 to 10 levels, useful whenever the answer is a matter of degree rather than category. The third is noul, a yes/no probability that expresses how likely a condition is to hold.
TypeSafe describes Jev as a “System One” model, borrowing the psychology term for fast, reflexive judgment rather than slow deliberation. In practice that framing maps to the job the model is asked to do: look at a compact description of a situation and commit to a judgment that downstream software can act on immediately. The output shape is the important part. A routing table can consume a choice directly by index. A risk pipeline can compare a score level against a threshold. An agent framework can gate a tool call on a noul probability without any parsing step in between. Because the answer space is declared up front, the model cannot wander outside it, and there is no free-text output to validate, retry, or coerce.
The typical production uses follow from that design. Teams apply Jev to routing incoming requests to the right queue or owner, intent classification on user messages, urgency and risk scoring on incidents and tickets, lead quality assessment on inbound forms, and policy checks that determine whether an action is permitted. The guardrail use case is especially relevant to agentic systems: an AI agent that can send emails, issue refunds, or modify records needs a checkpoint before it acts, and a yes/no probability with a tunable threshold is a natural fit for that checkpoint.
Input handling is deliberately narrow. Jev accepts text and JSON only — no images — with a 64k token context. Official SDKs exist for Python and JavaScript. The current version is Jev 1.13. That restriction is worth internalizing early: it means Jev is well suited to ticket bodies, structured records, transcripts, logs, and policy documents, and fundamentally unsuited to workflows where the evidence is a photograph, a screenshot, or a video frame.
Cost, Throughput, and the Economics of Putting Decisions in a Hot Path
Jev is priced at $0.042 per 1M input tokens with free output. The asymmetry is the story. Since only input is billed, the cost of a decision scales with how much application state you send, not with how much the model returns. Two consequences follow. First, payload design becomes a cost lever: forwarding a full ticket with months of comment history is materially more expensive than sending a trimmed JSON projection containing the fields that actually influence the decision. Second, teams are incentivized to write focused questions and compact state representations, which tends to improve accuracy at the same time.
Throughput is documented at 80 requests per second per key. That is a concrete concurrency ceiling to design around. Workloads that spike — bulk re-scoring of a backlog, a marketing send that drives support volume, an incident that floods the queue — need a queue or batch layer in front rather than a direct call from a request handler. There is also no listed free tier, which matters for budgeting: evaluation, staging, and load testing all consume paid capacity, so the cost of deciding whether Jev is right should be factored into the pilot rather than discovered during it. On the data side, TypeSafe states that it does not train on customer requests, which is the kind of commitment security and procurement reviewers will ask for in writing.
Accuracy is where the conversation becomes comparative. Preliminary benchmarks dated October 2026 place Jev at a mean of 0.803 across 15 text suites, against 0.816 for DecisionNode MoE, a measured alternative. On prompt injection the gap widens: 0.600 for Jev versus 0.764 for DecisionNode. On knowledge questions, the ordering reverses, with Jev leading on MMLU-Pro at 0.820 versus 0.698. Read together, these numbers suggest a model that is close to parity on aggregate text classification, strong on tasks requiring broad world knowledge, and noticeably more exposed when untrusted text reaches the model’s input. That last point deserves weight in any pipeline where the state being classified is user-supplied — support tickets, contact forms, scraped pages, and agent-visible content all qualify. Benchmarks are a starting filter, not a verdict, and preliminary results should be re-verified against your own labeled data before a production commitment.
Evaluating Jev and Its Alternatives for Structured Decisions
The most reliable way to choose a decision model is to build a small evaluation set from your own history. Pull a few hundred past cases where the correct outcome is known — tickets that were escalated, leads that converted, incidents that turned out to be severe — and run them through each candidate using the same typed questions. Measure accuracy per answer type rather than in aggregate, because a choice question and a noul question fail differently. Check calibration too: if the model reports confidence, does low confidence actually correspond to more errors? That determines whether a human-review threshold is worth building. Finally, compute cost per decision from real payload sizes, not from a token estimate, since input volume is the only billed dimension on Jev.
Adversarial testing belongs in the same harness. Feed the model inputs that contain instructions, prompt-like text, or deliberately confusing formatting, and see whether the decision flips. Given the published injection results, teams deploying Jev on user-controlled text should test this explicitly and consider input sanitization, structural separation of instructions from state, or an additional check before consequential actions. The same harness should test the alternatives, so the comparison stays honest.
Alternative models differ most sharply on modality and answer vocabulary. DecisionNode, from Bynn Intelligence, Inc., also answers typed questions with probabilities, but additionally reads images and video frames, supports number, point, and box answer types, and offers batch discounts, WebSocket streaming sessions, and a free tier. For a workflow where the evidence is a damage photo, a scanned document, or a frame from a camera feed, Jev’s text-and-JSON-only input is a hard constraint rather than a tradeoff, and no amount of accuracy on text suites compensates for it. Conversely, if the state is already structured and the questions lean on world knowledge, Jev’s MMLU-Pro lead is directly relevant.
A practical evaluation sequence looks like this: confirm the input modality matches your data, verify the answer types you need exist, run your labeled set through both candidates, stress-test with adversarial inputs, then model cost at your real request volume and peak rate. For teams working through that comparison, an independent Typesafe JEV guide tracks version changes, documented pricing, throughput limits, and benchmark results in one place, which shortens the background research considerably. What none of that replaces is your own test set — the decisive evidence is always the labeled cases from your own queue, scored the same way for every candidate model.
