Jev model
TypeSafe returns typed choices, scores and truth estimates from text. Your application decides how to use the result. It does not write an email or click a desktop button.
Read the model documentation
System One decision model review · Model documentation checked 18 September; integration update 22 September 2026
Jev Review 2026: The TypeSafe System One Decision Model
Jev is TypeSafe AI's System One model. It does not write text. You send it a state and a set of typed questions, and it returns structured decisions with calibrated probabilities that your code can branch on directly. This page covers what Jev actually returns, what it costs, and how to test whether it beats the rule or the LLM you already use.
Direct answer
Jev is best for developers who need a decision, not a paragraph. If your code has to classify, route, score, or verify something and you are currently doing it with a hand-written rule that keeps breaking, or by asking an LLM for JSON and hoping it parses, Jev is aimed squarely at that gap. TypeSafe describes the shape as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.
It is a poor fit for anything a person has to read. Jev gives up string generation entirely, so it cannot draft an email, explain its reasoning, or write code. Treat it as one component inside a workflow, not as a replacement for the assistant your team already uses.
AI Tool Finder has not run an independent benchmark of Jev. The model speed and pricing figures are quoted from TypeSafe's own documentation or blog, with the source named, and the vendor-claim section below separates what is verifiable from what is not.
Jev model, Jev Review plugin, or browser agent?
These are different parts of a workflow. Choose the component that solves your task rather than treating every Jev integration as the same product.
Jev Review MCP plugin
This community integration gives coding agents structured quality feedback. The coding agent diagnoses issues and changes code. A score alone does not prove that a bug was fixed or tests passed.
View Jev Review source and setupBrowser or desktop executor
A browser integration may use Jev to select an action, but separate software reads the page and executes it. Installing a review plugin does not grant desktop control or inherit your mail application's sender settings.
Compare agent tools by workflowBefore connecting it to Codex or Claude Code
- Check which integration you installed and which tools it actually exposes.
- Start with a small, non-sensitive example and an independently checkable result.
- Keep execution checks separate from model scores: verify the changed code, rendered page or actual action result.
Integration sources checked 22 September 2026. This is a documentation-based guide, not a completed comparative benchmark.
For repository review products, see our AI code review tools comparison.
Best for
Ticket triage and routing, lead scoring, content or document classification, retrieval ranking, claim verification against a fixed evidence block, and guardrails that gate what an agent is allowed to do next. The common thread is a decision your software has to make thousands of times, where you want a probability rather than a yes.
When to skip
Skip Jev if you need generated text, multi-step reasoning, tool calling, or anything multimodal. The documentation states input is text only, with no image, audio, or video support. Skip it too if your workload is not English-language and you have not tested accuracy on your own content.
Pricing note
TypeSafe lists $42 per billion input tokens, or $0.042 per million, and states that output tokens are free because there are effectively none to meter. Jev was still in early access when we checked, so treat the rate card as current-as-of, not contractual.
What Jev actually returns
The interesting part of Jev is not the model itself but the interface. Instead of asking for JSON and validating the response afterwards, you declare the output shape in advance and the model is constrained to it. The TypeSafe documentation exposes this as three primitives, and you can mix all three in one call against the same state.
| Question type | What you ask | What comes back |
|---|---|---|
| Choice | Pick one option from a list you define | A chosen label, a probability for each label, and a confidence value |
| Score | Rate the state against a rubric | A numeric score, a legend mapping index to label, and a confidence value |
| Noul | Is this statement true? | A single value between 0 and 1 |
Questions are evaluated in parallel and in isolation against the same state, so adding more of them barely changes response time and does not cause the context-rot you get from piling instructions into one prompt. That is what makes the decomposition strategy work: instead of one vague question like rate this lead, you ask three specific ones and combine the outputs with your own weights in code.
Source: TypeSafe AI documentation, Introduction and Quick start, checked 18 September 2026.
How you call it
The API surface is deliberately small. One endpoint, a model name, and a map of questions.
- Endpoint:
POST https://api.typesafe.ai/v1/systemonewith a bearer token. - Model:
jev-latestresolves tojev-1.13.0. Ajev-previewalias also exists and currently points at the same version. - Python SDK:
pip install typesafe-sdk, which requires Python 3.10 or newer and reads your key from the environment. - Agent skill: TypeSafe publishes an official skill you can install into a coding agent, so the agent knows the request shape and the decomposition patterns.
- Playground: a hosted console where you can paste a state and add questions without writing code.
One operational detail worth pinning before you build on it: an alias moves whenever a new release ships, so the answers behind jev-latest can change without anything changing on your side. The response reports the versioned model that actually answered. If you tune confidence thresholds against a specific version, the documentation recommends pinning that version instead of the alias.
Source: TypeSafe AI documentation, Models and Quick start, checked 18 September 2026.
Decision matrix
| Evaluation question | How Jev fits | What to verify |
|---|---|---|
| Does it produce text? | No, by design. It returns typed values and probabilities. | Confirm every consumer downstream can handle a probability, not just a label. |
| Does it handle uncertainty? | Yes. Every answer carries a confidence or probability value. | Check calibration on your own data before you trust a threshold. |
| Can it read images or audio? | No. Input is text only. | Pre-process non-text inputs into text or structured fields first. |
| Can I self-host or fine-tune it? | No. TypeSafe states the same weights serve every account and it is not fine-tuned on customer data. | Plan to shape behaviour through the state and question definitions instead. |
| Does it fit agent frameworks? | Partly. There is an official TypeSafe agent skill and a third-party MCP server. | Review the skill or server source before granting it access to your systems. |
| Is it production-stable? | It was in early access at the time of writing, with dynamically adjusting rate limits. | Ask about limit stability and enterprise terms before committing a critical path. |
TypeSafe's claims versus what we could verify
Jev launched to a lot of attention, and most of the numbers circulating are the vendor's own. We read the primary sources rather than the coverage, and this is the honest split.
| Claim | Where it comes from | Status |
|---|---|---|
| Typed outputs with no type errors | TypeSafe docs and launch blog | Supported as a design property. The output schema is fixed in advance, so a type error is structurally impossible. This says nothing about whether the judgement is correct. |
| 193.6x faster and 444.6x cheaper | TypeSafe home page, derived from its own four published workflows | Vendor result. TypeSafe states these are likely on the high end of real-world gains. |
| Zero hallucinations | TypeSafe launch blog | TypeSafe states the figure is not empirical and follows from guaranteed schema matching rather than from measurement. |
| Lower input price than a named frontier model | TypeSafe home page | Vendor comparison against one competitor at one point in time. |
| Independent third-party benchmark | Not performed for this guide | Not performed for this guide. The speed and cost figures above remain vendor results; compare tools on your own workload. |
To TypeSafe's credit, the launch blog volunteers most of these caveats itself, including that the workflows were built by its own capabilities team and that its reference answers average two competing frontier models, which it says likely understates its own position. That is more transparent than most launches. It still is not an independent benchmark.
Sources: TypeSafe AI home page and the launch blog post dated 15 September 2026, checked 18 September 2026.
How to check Jev on your own task
The only question that matters is whether Jev beats what you already do. That is a measurement you can run in an afternoon, and it is the step most teams skip.
- Pick a decision you already make. Choose one with a known correct answer, such as routing a ticket to the right team, and one that happens often enough to matter.
- Collect 30 to 50 real past cases where you already know the right answer. Do not write new examples for this; use production history so the test reflects the inputs you actually receive.
- Express the decision as one Choice question using the exact labels your team already uses, not a tidier taxonomy you invented for the test.
- Run the same cases through your current method and through Jev. If your current method is an LLM prompt, use TypeSafe's own adapter so both are answering in the same typed format.
- Compare accuracy and calibration separately. Sort the Jev answers into confidence bands and check the accuracy within each band. A model that is 90 percent accurate and says so is more useful than one that is 92 percent accurate and always claims certainty.
- Only then set your thresholds. Decide what confidence is high enough to act autonomously and what gets escalated to a person, then write those numbers into your code rather than into a prompt.
If Jev does not clearly beat your existing rule on step five, the honest answer is to keep the rule. The value of a decision model is not that it is AI; it is that it is measurably better than the alternative at a cost you can defend.
Cost, limits, and what to confirm before you build
These figures come from TypeSafe's documentation as of 18 September 2026. Confirm them yourself before you budget, because the company was still in early access and states plainly that its limits are moving.
- Price: $42 per billion input tokens, or $0.042 per million. Output tokens are free. You are billed on input only.
- Rate limits: 250,000 tokens per second and 1,200 requests per minute. Exceeding either returns a 429. TypeSafe says these adjust dynamically and can change without notice while it brings on more capacity.
- Context: 64,000 tokens per request, covering the state plus all questions combined. The state plus your single longest question is capped at 32,000 tokens.
- Input type: text only, as a string, a JSON object, or an array of text values.
- Language: English is the primary training language and where accuracy is currently best. Other languages, including CJK scripts, are handled but not equally well, so test before relying on Jev for a non-English workload.
- Your data: TypeSafe states that Jev is not trained on customer requests or responses, and that zero data retention is available for enterprise customers.
- Versioning: aliases move when a new release ships. Pin the versioned identifier if your thresholds depend on a specific build.
Source: TypeSafe AI documentation, Models, checked 18 September 2026.
What we could not verify
We would rather write UNKNOWN than fill a gap with a guess. The following were not confirmed from primary sources when we checked on 18 September 2026:
- We have not run an independent benchmark of Jev against general-purpose LLMs on a neutral task.
- Whether the published price is sustainable or currently subsidised. TypeSafe itself says it cannot prove that it is not.
- A free tier or trial credit. No free allowance is stated in the documentation we read.
- General availability beyond early access, or a published service-level commitment.
- Availability through third-party gateways and routers. Some listings exist, but we did not confirm the terms on those platforms directly.
Alternatives and companion tools
Jev is a component, so the useful comparison is against the other ways you could make the same decision, not against a chatbot.
Your existing rule
The cheapest baseline and the one to beat. If a regular expression or a lookup table already gets 95 percent of cases right, a model has to clear that bar to be worth the latency and the bill.
A general-purpose LLM
The default choice today. It works, but you pay for output tokens you do not want, wait for generation you will discard, and still have to validate the structure you asked for.
TypeSafe's own LLM adapter
TypeSafe publishes an open adapter that runs the same typed evaluation API on top of OpenAI and Anthropic models. It is the fairest way to compare Jev against an LLM, because both sides answer in the identical format.
The official agent skill
TypeSafe maintains an MIT-licensed skill for coding agents that encodes the request shape and the decomposition patterns, so an agent does not have to rediscover them.
A third-party MCP server
A community MCP server wrapping Jev exists, exposing evaluation, ranking, verification, and agent control-flow tools. It is not published by TypeSafe and we have not audited its source, so review it before granting access.
Classical machine learning
If your labels are stable and plentiful, a small supervised model you train and own may beat all of the above on cost, latency, and control. Jev's probabilities can also be used as features to train one.
Sources and check date
The original model overview was checked against the following primary sources on 18 September 2026. The integration comparison above was checked on 22 September 2026. Where a figure is the vendor's own claim rather than a measured result, the page says so.
- TypeSafe AI documentation, Introduction, Models, and Quick start: docs.typesafe.ai
- TypeSafe AI launch blog, Introducing System One Models and Jev, published 15 September 2026: typesafe.ai/blog
- TypeSafe AI home page and published workflow evals: typesafe.ai and evals.typesafe.ai
- Official agent skill, MIT licence, release v0.5.7 dated 12 September 2026: github.com/typesafe-ai/skills
- Official LLM comparison adapter: github.com/typesafe-ai/system-one-adapter-python
The product overview follows official documentation; the separate small MCP test reports our own limited invocation results. It is not an endorsement, and we do not guarantee that Jev will improve any specific workflow. If a figure here is wrong or has changed, tell us and we will correct it.
FAQ
What is Jev best for?
Jev is best for classification, routing, scoring, and verification decisions that your code consumes directly, such as triaging a support ticket, gating an agent action, or ranking candidates against a query. It is not a chat model.
Does Jev generate text?
No. Jev does not generate strings. It returns typed values and probability distributions that your code can branch on, sort by, or route with, without parsing free text.
How much does Jev cost?
TypeSafe lists $42 per billion input tokens, or $0.042 per million, and states that output tokens are free. Jev was in early access when we checked the documentation on 18 September 2026, so confirm current pricing before you budget.
What are the three Jev question types?
The TypeSafe documentation describes three primitives. Choice picks one option from a list, Score rates the state against a rubric, and Noul answers a true-or-false statement with a value from 0 to 1. All three can be mixed in a single API call.
Can Jev replace an LLM?
No. Jev gives up string generation, so it cannot write prose, code, or explanations. It is designed to sit next to an LLM inside a workflow, handling the decisions while the LLM handles anything a person has to read.
Should I trust the speed and cost claims for Jev?
Treat them as vendor results rather than independent benchmarks. TypeSafe publishes its methodology, says the 193.6x and 444.6x figures come from its own four workflows and are likely on the high end, and notes that its reference answers come from averaging two competing frontier models. Measure Jev on your own task first.
Is there an official Jev agent skill?
Yes. TypeSafe publishes the typesafe-ai skill under an MIT licence, installable with npx skills add typesafe-ai/skills --skill typesafe-ai or as a Claude Code plugin. A third-party MCP server also exists, but it is not published by TypeSafe.
Can I use Jev for images or audio?
No. The documentation states that input is text only, as a string, a JSON object, or an array of text values. Non-text inputs have to be converted to text or structured fields before they are sent as state.
Jev Review MCP: a small live test
On 22 September 2026, we called the installed third-party jev_review MCP tool twice with a synthetic JavaScript retry policy. No customer data or private repository code was sent. This is one controlled example, not a comparative benchmark or a test of browser automation.
Contract and deliberate defect
For valid HTTP status codes, retry only 429 or 500–599. The attempt number counts attempts already made; the maximum includes the first attempt. A retry is allowed only while attempt < maxAttempts. The initial implementation deliberately used <=, allowing an extra attempt when the budget was exhausted.
Initial expression: (status === 429 || status >= 500) && attempt <= maxAttempts. Corrected expression: (status === 429 || status >= 500) && attempt < maxAttempts.
What the tool returned
The initial correctness score was 4.4 with reported confidence 0.50. Its feedback referred generically to an insufficiently handled edge case; it did not identify the exact operator or provide a reproducing input. After we changed the operator and supplied the previous evaluation, correctness rose to 9.0 with confidence 0.71.
What we independently checked
Our Node.js check enumerated all 500 valid HTTP status codes, maximum attempt budgets from 1 through 5, and attempt counts from 1 through 6: 15,000 cases. Against an independently expressed expected result, the initial version failed 505 cases; the corrected version failed 0. This confirms the boundary correction within that input range. It does not validate the tool's scores as calibrated probabilities.
Limits and buying advice
We intentionally knew the defect beforehand. The second request disclosed the correction and included the first evaluation, so this was not a blind or independent retest. Cognitive-complexity scores also moved from 4.8 to 9.0 despite essentially unchanged structure. We did not test repeatability, real-repository accuracy, competing tools, billing, or model identity behind the installed server. Treat these numbers as this integration's returned feedback, not a verified benchmark of the underlying Jev model.
Our conclusion: the integration ran and reacted to the supplied change, but a deterministic test established whether the fix worked. Use review scores to guide inspection; keep tests and human judgment as the acceptance gate.