Most AI systems in production are asked to write. A smaller, more consequential set of tasks asks for the opposite: not prose, but a verdict. Should this support ticket go to billing or to security? Is this lead worth a sales call? How urgent is this incident, on a scale? Should an automated agent be allowed to take the next action at all? These are decision-shaped questions, and they call for decision-shaped answers — a label, a level, a probability — not a paragraph that some downstream script has to parse.
Jev is TypeSafe AI’s hosted model built specifically for that second category. Rather than generating text, it accepts application state plus typed questions and returns typed decisions. The current version is Jev 1.13, and TypeSafe describes it as a “System One” model: fast, reflexive judgment rather than slow deliberation. That framing matters, because it explains the whole design — narrow inputs, narrow outputs, and a price and throughput profile tuned for the high-volume, low-latency moments where a system has to commit to an answer.
What Jev Actually Returns: Choices, Scores, and the Noul Type
The clearest way to understand Jev is to look at its output types, because they define what it can and cannot be used for. Every request supplies state — a support ticket, a JSON record, a transcript rendered as text — alongside one or more typed questions. The model then answers within the type declared for each question, in three possible forms.
The first is a choice: one option selected from up to 255 candidates, returned with probabilities across the options and a confidence value. This is the workhorse type for classification problems. Routing a ticket into one of a dozen queues, tagging an inbound message with an intent, or assigning a category to a record all map cleanly onto a bounded option set. Because the answer arrives as a validated option rather than free text, application code can branch on it directly, with no string matching and no fallback parser for the model’s creative rewording.
The second is a score: a level on a scale of 2 to 10 ordered levels. Ordered scales are the natural fit for anything that will later be thresholded — urgency, risk, escalation severity, lead quality tiers. A ten-level scale gives more resolution than a yes/no flag while keeping the output bounded enough that a policy layer can act on it without interpretation.
The third is the noul type, a yes/no probability. It is the right shape for binary gates: is this message a policy violation, is this record complete enough to process, does this request require human review. Returning a probability rather than a hard label lets the surrounding system choose its own threshold and maintain a calibrated abstain zone for uncertain cases.
That combination of types is what makes Jev useful in the seams of an application rather than at its center. TypeSafe positions it for routing, intent classification, urgency and risk scoring, lead quality, policy checks, and guardrails that run before an AI agent takes an action. In each case the output feeds a decision path rather than a user-facing reply, and in each case a typed answer is worth more than a well-written sentence.
Pricing, Context, and Throughput: The Operational Profile of Jev 1.13
The economics of Jev are unusual enough to deserve attention. Per TypeSafe’s documentation, checked in October 2026, the model costs $0.042 per 1 million input tokens, with output free. That asymmetry has a practical consequence: because answers cost nothing, spend is driven almost entirely by what is fed in. Teams optimizing cost should therefore focus on trimming the state payload — sending the relevant fields of a record rather than the whole object, or the salient portion of a ticket rather than the entire thread — rather than on shortening the responses, which carry no charge.
The input surface is deliberately narrow. Jev accepts text and JSON only, and does not process images. It supports a 64k token context, which is generous enough to hold a long ticket thread, a full JSON record, or several supporting documents alongside the typed questions. The absence of image input is a real constraint rather than a footnote: any workflow that depends on screenshots, scanned forms, or video frames falls outside the model’s scope, and must either be converted to text upstream or handled by a different system.
Throughput is specified at 80 requests per second per key. For capacity planning, that figure defines both the ceiling for a single credential and the shape of any horizontal scaling strategy — high-volume deployments will typically distribute load across multiple keys rather than queue behind one. Official Python and JavaScript SDKs cover the common integration paths, so wiring Jev into a backend service does not require hand-rolling an HTTP client, though the underlying request pattern remains straightforward enough to implement directly in another language if needed.
Two policy details shape adoption decisions more than they might first appear. First, there is no listed free tier, which means evaluation requires a budget line from the outset; sandbox testing is a real cost, not a free trial, and that tends to favor teams that already know what they want to measure. Second, TypeSafe states that there is no training on customer requests, a point that matters for organizations whose tickets and records carry regulated or sensitive content. Because the model ships as a versioned release — currently 1.13 — teams should also pin the version they have validated and re-test after upgrades.
Benchmarks, Trade-offs, and How to Evaluate Jev Against Alternatives
Jev is not the only hosted model answering typed questions with probabilities. DecisionNode, from Bynn Intelligence, Inc., occupies the same category, and an independent, measured comparison is more useful than a feature checklist. Preliminary October 2026 benchmarks across a mean of 15 text suites put Jev at 0.803 against DecisionNode MoE at 0.816 — close enough that the aggregate figure alone should not decide the choice. What matters is the distribution beneath it. An independent guide to jev and its alternatives documents that breakdown alongside pricing and capability differences.
The per-suite splits are more instructive than the mean. On prompt injection, the numbers are 0.600 for Jev versus 0.764 for DecisionNode. If Jev is deployed as a guardrail in front of an agent that can take actions, that gap is the single most relevant result on the list, because adversarial resistance is precisely the property a guardrail exists to provide. On knowledge questions, the pattern inverts: MMLU-Pro shows 0.820 for Jev versus 0.698. Where classification depends on policy knowledge or domain facts baked into the model, Jev carries an advantage. Neither result is universally decisive; they point to different deployment profiles.
Capability differences amplify that split. DecisionNode also returns typed decisions with probabilities, but it reads images and video frames, adds number, point, and box answer types beyond choice, score, and yes/no, and offers batch discounts, WebSocket streaming sessions, and a free tier. Those features change what is possible: box and point answers enable spatial grounding that a text-only model cannot attempt, streaming sessions suit interactive workloads, and a free tier lowers the cost of initial experimentation. Conversely, Jev’s strength is a tightly scoped text-and-JSON decision surface with free output and strong knowledge-question performance.
The honest way to choose between them is to stop reading benchmarks and start building a labeled set from your own traffic. Pull several hundred real records, have humans assign the correct choice or score, and run both models against identical questions. Then look past raw accuracy at calibration — whether a stated confidence of 0.9 really corresponds to roughly nine-in-ten correctness — because a guardrail’s threshold is only as good as the probabilities behind it. Measure performance separately on the hard slices: adversarial inputs, long-context records, edge cases near the boundary between two options. Test at the throughput you actually expect, since a per-key rate limit behaves differently under a burst than under a steady load. Finally, model total spend against your real token volumes, remembering that Jev’s free output shifts the optimization target to input trimming while competitors’ discount structures may reward batching instead. A model that wins on an aggregate suite can still lose on the slice your product depends on, and only your own labeled data will reveal which one that is.
