Jev for AI engineers: what it can do and what it costs

Jev, TypeSafe AI's decision model, answers a question about text with a value your software can use: one option from a list, a score, or a yes/no probability. That suits the small, repeated decisions in the middle of this work.

These are the jobs on this site that fit AI engineers best. Each has its own page with the questions to ask, the pitfalls and a worked example.

• Pick the next action in an agent loop in milliseconds. Agents spend much of their time picking the next action from a known list.
• Drop irrelevant and poisoned passages before they reach the answering model. Between retrieval and the answering model, one Jev request per passage can ask whether it is relevant, whether it holds usable evidence, whether it contradicts the question's assumption and whether it hides a prompt injection.
• Score a shortlist against the query and put the best result first. A fast search such as keyword matching builds a shortlist, and Jev then scores every shortlisted result against the query and puts the best first.
• Check every message and reply for jailbreaks and hazards before the LLM acts on it. One Jev request per message can check it against several hazards at once, such as jailbreaks, requests for harm, medical advice and self-harm, and rate how much harm answering would do.
• Catch made-up quotes and claims the source does not support. A string match first catches quotes that do not exist in the source.
• Find the right value in messy text without letting a model make one up. For values such as emails, phone numbers and amounts, a pattern match finds the candidates and Jev picks the one the question asks for, so it cannot invent a value.

• Jev for agent and browser decisions
• Jev for filtering RAG passages
• Jev for re-ranking search results
• Jev for LLM guardrails
• Jev for checking citations
• Jev for extracting dates, emails and amounts

Jev lists $0.042 per million input tokens with output free, so the cost depends on how much text you send and how many questions you ask about it. At the typical volumes the use-case pages assume, the calculator estimates:

• Steps (agent and browser decisions): about 4.5¢ per 1,000, at 2 questions and about 900 tokens each.
• Passages (filtering RAG passages): about 2.1¢ per 1,000, at 4 questions and about 350 tokens each.
• Results (re-ranking search results): about 1.3¢ per 1,000, at 1 question and about 250 tokens each.
• Messages (LLM guardrails): about 2.3¢ per 1,000, at 5 questions and about 300 tokens each.
• Citations (checking citations): about 3.2¢ per 1,000, at 1 question and about 700 tokens each.
• Documents (extracting dates, emails and amounts): about 2.9¢ per 1,000, at 3 questions and about 500 tokens each.

• Cost calculator
• Jev pricing and real runs

A plain way to begin, in order:

• Find the step in your pipeline that is really a pick from a list or a yes/no, such as the next agent action or whether a passage is relevant.
• Replace only that step with a Jev call and keep the language model for planning and writing.
• Ask several independent questions about the same text in one request, as TypeSafe recommends, and combine the answers in your own code.
• Log Jev's answer and its probability next to the final outcome, so you can see when to trust it.

• How to use Jev

Keep questions small. TypeSafe's guidance is that a question needing slow reasoning is a sign to split it, or to pass it to a reasoning model. Agent steps in particular are only a partial fit: Jev picks the action, something else plans.

From the use-case pages, Jev is not the right choice when:

• The step requires writing, coding or multi-step reasoning. Jev can't plan.
• Your corpus is small, clean and written by you. A plain similarity search may be enough.
• Your keyword search already puts the right result first most of the time.
• You need the reason a message was blocked written out for the user. Jev returns probabilities, not explanations.

• What Jev can't do

The pattern that works is a small, fast decision model inside a loop run by a bigger model. You get typed values your code can test and a cost per step measured in fractions of a cent, at the price of writing the questions carefully.

The figures above are list-price estimates, not measured bills, and the accuracy claims on the linked pages are the published runs' own. Test Jev on a labelled sample of your own data before you rely on it.

• What is a decision model?