Most teams building with language models start from the same assumption: the model’s job is to produce text, and anything structured has to be recovered afterward through parsing, validation, and retries. The hosted decision model known as jev takes the opposite approach. Built by TypeSafe AI and often referred to as TypeSafe Jev or Jev AI, it accepts application state plus typed questions and returns typed decisions rather than generated prose — a design choice that changes how the surrounding system is architected.
What Jev Does: Typed Decisions Instead of Generated Text
The core idea is simple to state but consequential in practice. You pass in application state — a support ticket, a JSON record, a payload from an internal service — alongside questions that have a declared answer type. The model does not reply with a paragraph. It replies with a value that conforms to the requested type.
There are three answer types. A choice selects exactly one option from a set of up to 255 candidates, and the response includes probabilities across the options together with a confidence value. A score places the input on one of two to ten ordered levels, which makes it useful for graduated judgments like severity or quality. The third type is a yes/no probability, referred to as the noul type, which answers binary questions with a single number that a caller can threshold however it likes.
That distinction between generated text and typed output is where most of the engineering value sits. When a model returns prose, every downstream step depends on parsing succeeding and on the schema staying stable across edge cases. When it returns a typed decision, the application can act immediately: compare a confidence value against a cutoff, rank a queue by score, or branch on a probability. Validation becomes a question of bounds and thresholds rather than a question of whether the model followed instructions.
TypeSafe describes Jev as a “System One” model, a reference to fast, instinctive judgment rather than extended deliberation. The framing matches the intended workload, which is short, high-volume classification and scoring rather than long-form reasoning. The documented use cases cluster around the operational layer of an application: routing, intent classification, urgency and risk scoring, lead quality assessment, policy checks, and guardrails that run before an AI agent is permitted to take an action.
A support pipeline illustrates the pattern well. The same ticket can be scored for urgency on an ordered scale, classified into an intent category, routed to the correct queue via a choice question, and evaluated against an escalation policy as a yes/no probability. That is four typed questions over a single piece of state, each with its own answer type and each feeding a different part of the application logic. Because the outputs are typed, the routing table, the priority sort, and the escalation rule can all be expressed as ordinary code rather than as prompt engineering.
The same structure applies outside support. Lead quality scoring, policy compliance checks ahead of an agent action, and risk scoring on transactions or records all follow the same shape: state in, typed judgment out, deterministic logic downstream.
Inside the Spec Sheet: Pricing, Limits, and Production Considerations
According to TypeSafe’s documentation, checked in October 2026, the current release is Jev 1.13. The published commercial details are worth reading carefully, because several of them shape architecture decisions more than they first appear to.
Pricing is $0.042 per 1M input tokens with free output. That inversion is unusual and matters: because the decisions themselves carry no token cost, spend is driven almost entirely by how much state you send with each request. A team that passes an entire ticket thread, full metadata, and a long history will pay far more than a team that sends a distilled record containing only the fields the questions actually require. Cost optimization here is a data-shaping exercise rather than a prompt-tuning exercise, and the cheapest change is usually trimming the payload before it reaches the model.
The context window is 64k tokens, which is generous enough for large JSON records — order payloads, document extracts, or multi-field case data. Input is limited to text and JSON; images are not supported. That constraint deserves attention early. If the state you want to reason over includes screenshots, scanned forms, or visual UI evidence, Jev cannot see it, and any pipeline that depends on those artifacts needs a different component in front of or instead of the decision layer.
Throughput is documented at 80 requests a second per key. Because the limit is expressed per key, capacity planning has to account for how keys are distributed across services, environments, and tenants. A single shared key in front of several high-traffic services will saturate long before any individual service does, so the allocation of keys is a design decision rather than an operational afterthought.
Official Python and JavaScript SDKs are available, which covers the two runtimes most application teams will reach for first. There is no listed free tier, so evaluation has to be budgeted from the start — another reason to build a small, well-labeled test set before running anything at volume rather than experimenting against live traffic. Finally, TypeSafe states that customer requests are not used for training, a commitment that matters for teams passing through regulated, proprietary, or personally identifying data.
Benchmarks and Alternatives: How Jev Compares on Structured Decision Tasks
Choosing a decision model is not the same as choosing a chat model, and the comparison set is narrower. The most direct alternative documented in independent comparisons is DecisionNode, from Bynn Intelligence, Inc., which also answers typed questions with probabilities — but extends further in several directions. DecisionNode 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. Jev’s scope is deliberately tighter: text and JSON in, typed decisions out.
The preliminary benchmarks published in October 2026 give a more granular picture than a single headline number. Across a mean of 15 text suites, Jev scored 0.803 against 0.816 for DecisionNode MoE — close enough that the two are effectively comparable on general text decision accuracy, and close enough that suite composition will decide the winner for any particular workload. The gaps are more interesting than the average.
On prompt injection, Jev scored 0.600 against 0.764. That is a meaningful spread for anyone feeding untrusted input into the model. Support tickets, user-submitted forms, scraped content, and inbound email are all attacker-influenced surfaces, and a decision model that sits in front of an agent’s actions is precisely the component an injection attempt would target. A guardrail that can be talked out of its judgment is not much of a guardrail, so teams whose state includes free-text from external parties should treat this dimension as a first-class evaluation criterion rather than a footnote.
On knowledge questions, the relationship reverses: Jev reached 0.820 on MMLU-Pro against 0.698. For decision tasks that lean on domain knowledge — policy interpretation, classification against a taxonomy the model must actually understand, judgments that require background rather than pattern matching — that advantage is worth weighing seriously. It suggests Jev is the stronger choice when questions probe what the model knows, and the weaker choice when the risk is what the model can be persuaded to do.
Because these numbers are preliminary, the sensible approach is to treat them as directional and build a local evaluation. Assemble a labeled set drawn from real production state, score each question type separately rather than averaging them together, weight errors by their actual business cost rather than by frequency, and include adversarial examples alongside ordinary ones. Pair that with the operational checks — payload size against the input-token price, key allocation against the 80 requests per second ceiling, and whether any part of the state is visual — and the comparison resolves into a specific answer for a specific pipeline rather than a general ranking.
A Dublin cybersecurity lecturer relocated to Vancouver Island, Torin blends myth-shaded storytelling with zero-trust architecture guides. He camps in a converted school bus, bakes Guinness-chocolate bread, and swears the right folk ballad can debug any program.
