Jev AI: The Complete Guide to TypeSafe's Decision Model

Quick answer

• Jev AI is TypeSafe AI’s hosted decision model. It returns typed choices, scores, and yes/no probabilities instead of generated text.
• Pricing is listed at $0.042 per million input tokens with no output charge; TypeSafe reports 70-500 ms latency.
• Jev reads text and JSON, accepts images behind an opt-in preview header, and evaluates every declared question in parallel.
• It is strongest at routing, triage, guardrails, verification, and reranking. It is weak at generation, arithmetic, dates, and multi-hop reasoning.
• It is one option among Laya (local, open source), Clef (multimodal, Cloudflare), and OpenAI’s Decisions API.
• Production use needs a confidence threshold, a fallback path, a pinned model version, and evaluation on your own labeled inputs.

What is Jev AI?

Jev AI is a decision model from TypeSafe AI. You send it a state, which can be a support ticket, a document, a chat message, or a JSON record, plus a set of typed questions about that state. It returns one answer per question: a choice from your options, a score on your rubric, or a probability that a yes/no statement is true. Every answer is already in a schema your code can use, so there is no generated prose to parse.

TypeSafe calls Jev a System One model, after the fast, automatic mode of thinking in Kahneman’s framing. The label is a useful guide to the design: Jev is meant for many small judgments inside a request path, while a language model handles the slower reasoning and the language. Jev is not a chatbot, does not write text, and does not hold a conversation. It is a classifier-shaped service with a deliberately narrow contract.

Jev at a glance

The facts that decide most integrations are the model type, the input modality, the output shape, the context, and the commercial model. Jev is a hosted decision model with three production question types, a fourth image-localization type in preview, and a per-token price. The table below is the short version; the sections after it explain what each row means in practice.

Jev AI at a glance

  Vendor            TypeSafe AI
  Model type        hosted decision model (System One)
  Input             text/JSON; images behind a preview header
  Output            choice, score, noul (yes/no), box (preview)
  Confidence        returned for choice, score, and box; noul is a probability
  Context           64k request / 32k per question; 262k opt-in long context
  Pricing           $0.042 per million input tokens, output free
  Latency           vendor-reported 70-500 ms end to end
  Access            TypeSafe API, official Python/JS SDKs, HTTP endpoint
  Fine-tuning       none (shared weights; no customer tuning)
  Best fit          routing, triage, guardrails, verification, reranking

What does Jev return?

Every Jev request contains a state and a dictionary of questions. A Choice question picks one of several options and returns the chosen option, a probability for every option, and a confidence value. A Score question places the state on an ordered rubric and returns a probability-weighted position, the level probabilities, and confidence. A Noul question returns a single probability between zero and one that the statement is true; it does not carry a separate confidence value.

The questions are evaluated independently and in parallel against the same state. That matters for both cost and design: adding a second or third question to the same call barely changes latency, so it is usually better to ask three atomic questions than one compound question. Compound questions hide which factor drove the answer, and they make the confidence value harder to threshold.

How much does Jev cost?

TypeSafe lists Jev at $0.042 per million input tokens, with output tokens free. Cost per decision is therefore the number of input tokens in the state and questions, multiplied by that rate. A short ticket with a few questions is a tiny fraction of a cent; a long document with many questions is more, and the difference is large enough to model before a high-volume launch.

Use the arithmetic rather than the headline rate. A request with 400 input tokens costs about $0.0000168, so 10,000 such requests cost about $0.17. That is cheap enough to judge every tool call, but it is not zero: retries, long contexts, and a large fallback path all add up. The comparison that matters is total cost per resolved decision, including the human review and the LLM calls the decision model avoids.

How fast is Jev?

TypeSafe reports 70-500 ms end-to-end latency, with the variation coming from model load, state size, and network path. That is fast enough to sit inside many request paths, but it is not a guarantee for your deployment. The percentile you care about is p95, not the median, because a small share of slow calls determines whether a user waits.

Measure latency with your own average state and question set. A single large state with many questions costs more than several small ones, and a hosted call adds the network round trip that a local model does not. If the decision is on a user-facing path, set a timeout and a fallback; if it is in a background job, measure throughput rather than the single-call median.

What is Jev good at?

Jev is strongest when the output is a branch rather than a paragraph. Support triage, intent routing, model routing, moderation, citation checks, retrieval reranking, policy verification, and tool-call judgment are all in scope. In each case the input is text you already have, the answer is a small set of options, and the cost of a wrong answer can be bounded by the next layer.

It is also useful as a guardrail beside a coding agent or an LLM feature. Before a tool call, send the task, the stated plan, and the pending action, and ask whether the action is irreversible, off-task, or outside the declared scope. The model returns probabilities; your code decides whether to hold, review, or allow. That separation is the pattern that makes the decision layer governable.

The question set is the part you control most directly. How to Write Decision Questions for Jev and Laya covers option boundaries, score rubrics, and thresholds. Jev Images and Box Questions: What the Preview Can Do covers the opt-in image path and its limits.

Can you fine-tune Jev?

No. TypeSafe does not fine-tune or LoRA-adapt Jev with customer data; the same weights serve every account. You shape its answers through the state, the instructions, and the criteria, not through a per-customer training job. That is a real constraint if your task depends on a private taxonomy or a writing style the base model has never seen, and it is why the question set and the labeled evaluation matter so much.

There is also no public self-hosted checkpoint to train. If fine-tuning is a hard requirement, Laya is the Apache-2.0 option with laya-train, and Clef offers a vendor fine-tuning service. For Jev, the practical alternative is to put the domain rules and examples in the state and criteria, then measure whether the base model can separate the cases. If it cannot, the honest answer is to use a model you can adapt.

Where does Jev fail?

Jev cannot generate text, explain its answer, write code, or summarize a document. It is not reliable for arithmetic, counting, or date comparison, which belong in ordinary code. Multi-hop reasoning and tasks with indirect references are also a poor fit, because the model evaluates the state you supply rather than searching for more context. TypeSafe’s own limitations page also notes literal readings and distraction from large amounts of irrelevant state.

The schema guarantee is narrower than the marketing phrase suggests. Jev cannot return an option outside the schema you declared, so it cannot invent a department or produce an invalid score. It can still choose the wrong valid option. That is the failure mode that matters, and it is why a labeled test set, a confidence threshold, and a fallback path are part of the integration rather than optional refinements.

How does Jev compare with Laya, Clef, and OpenAI?

Laya is the local, Apache-2.0 option: no per-call fee, data stays on your hardware, and you can fine-tune it, but you own the operations and its zero-shot quality is lower on harder semantic tasks. Clef is Cloudflare’s open-weight decision model with image input, a 64k context, and Workers AI hosting. OpenAI’s Decisions API puts the same idea behind GPT-6 Luna and is the shortest path if the rest of the app already uses OpenAI.

The choice is usually a constraint decision rather than a quality decision. Data residency points to Laya or self-hosted Clef. Reliable production image input points to Clef or OpenAI; Jev’s image path is still preview-grade. An existing Cloudflare deployment points to Clef. An existing OpenAI integration points to the Decisions API. If none of those applies, Jev is one of the cheapest hosted options for text, though Clef-flash is slightly cheaper per token; it is also the least work to try. The full comparison is linked below.

How do you set up Jev?

Create a TypeSafe API key, keep it in a server-side environment variable, install the Python or JavaScript SDK, and send one state with a few questions. The first call should answer something you can check by eye, such as which department a ticket belongs to. Read the typed answer and the confidence, then add a threshold: above it, act; below it, route to a human or a stronger model.

The setup guide linked below includes a complete Python example, a raw HTTP call, a confidence-gated decision function, and the production checklist. The short version is: one atomic question per decision, a pinned model version, a timeout, a fallback, and a test with both a clear input and an ambiguous one. Do not ship a guardrail or a routing branch without the ambiguous-input test, because that is where the threshold does its work.

How do you run Jev safely in production?

Keep the policy in code. Authentication, permissions, spend limits, allowed destinations, and irreversible actions must not depend on a probabilistic answer. The model recommends a branch; the handler validates it again and performs the side effect. Treat a high-confidence answer as evidence, not authorization. Log the model version, question-set version, input hash, answer, probabilities, confidence, latency, and the outcome.

Send only the state the questions need. Support tickets can contain names, order IDs, and credentials; a decision model does not need all of it. Check the vendor’s data-retention terms for your plan, redact where possible, and avoid putting secrets in the state. Finally, pin a model version, re-run your evaluation when it changes, and keep a fallback for timeouts and rate limits rather than treating every failure as a low-confidence answer.

Where this bites vibecoders

The assistant will happily turn a branch into another chat completion: a prompt, a JSON schema, a parser, and a retry when the JSON is malformed. That works until the model returns a valid label that is wrong, or the parser breaks on a code fence. A decision model removes the parsing layer, but it does not remove the judgment. Write the branch as a typed question, gate on confidence, and keep the action in code.

Where AI coding assistants get this wrong

• Treating Jev as a cheaper LLM and sending it a prompt instead of typed questions.
• Asking one compound question and losing the ability to see which factor drove the answer.
• Using jev-latest in production and being unable to reproduce a past decision.
• Assuming a schema-valid answer is a correct answer.
• Putting permissions or irreversible actions behind a model answer.
• Choosing from a vendor benchmark instead of testing the inputs the app receives.

Checklist

• Write the decision as one or more atomic choice, score, or noul questions.
• Give every option a description that distinguishes it from the others.
• Calculate cost at your average state and question size.
• Set a confidence threshold and a fallback path.
• Pin the model version and log it with every decision.
• Keep permissions, arithmetic, and side effects in ordinary code.
• Evaluate on 100-300 labeled inputs from your own traffic.

FAQ

What is Jev AI in one sentence?

Jev AI is TypeSafe’s hosted decision model: you send a state and typed questions, and it returns choices, scores, and yes/no probabilities that your code can consume without parsing generated text.

Is Jev free?

No. TypeSafe lists $0.042 per million input tokens with no output charge, and has offered free credit at times. Check the console for the current plan, credit, and rate limits. The cost per decision is small at short inputs, but it is a metered service rather than a free local model.

Does Jev support images?

Yes, in preview. Jev 1.13 and 1.14 accept images when you send the TypeSafe-Danger-Zone-Images: true header, and Jev 1.14 adds Box questions that return a bounding box. TypeSafe labels images and Box as dreamer-ready rather than production-ready: formats, limits, and accuracy can change between releases. For a production image workload, validate on your own images and keep Clef or OpenAI’s Decisions API as a fallback.

How accurate is Jev?

Accuracy depends on the question, the option descriptions, the state, and the domain. TypeSafe publishes benchmarks and a decision index, but those are not a substitute for your own labeled set. Measure accuracy, calibration, and the share of low-confidence answers on inputs that resemble production, then compare with the rules or LLM you are replacing.

Can I self-host Jev?

No public self-hosted Jev weights are available. It is a managed API. If self-hosting or data residency is a hard requirement, Laya is the Apache-2.0 local option, and Clef has open weights that can be run outside Workers AI.

Can I fine-tune Jev on my own data?

No. TypeSafe does not fine-tune or LoRA-adapt Jev with customer data; the same weights serve every account. You adapt it through the state, instructions, and criteria, and you evaluate the result on your own labeled set. If you need per-customer training, Laya’s laya-train workflow or Clef’s vendor fine-tuning are the alternatives.

What is a noul?

A noul is Jev’s yes/no question type. It returns a probability between zero and one that a statement is true, such as the probability that a message conveys urgency. There is no separate confidence value, so you threshold the probability directly and choose the threshold from the cost of a false positive versus a false negative.

What is Jev’s context window?

TypeSafe documents a 64k request context and a 32k per-question context for Jev 1.14, with an opt-in long-context header that raises both to 262k tokens. Long context costs the same per token but is slower and less accurate, so send the relevant passage rather than the entire knowledge base.

Related topics

• What Is Jev? TypeSafe’s Decision-Only Model Explained
• How to Set Up Jev in Your App (API Key, SDK, and First Decision)
• Jev Use Cases: 15 Decisions Worth Replacing an LLM Call For
• Jev Pricing: What a Decision Actually Costs
• How to Use Jev as an LLM Guardrail
• How to Write Decision Questions for Jev and Laya
• Jev Images and Box Questions: What the Preview Can Do
• Jev vs Laya vs Clef: Which Decision Model Should You Use?

Sources

• TypeSafe Documentation
• TypeSafe Documentation
• TypeSafe Documentation
• TypeSafe Documentation
• TypeSafe AI