What Is Jev? TypeSafe's System One Model That Returns Decisions, Not Text (2026 Guide)

What Jev Is, and Who Built It

Jev is a proprietary AI model from TypeSafe AI, a San Francisco company founded in 2024 by Diogo Almeida (CEO) together with Erik Gafni and Sasha Sheng. Almeida spent about four years at OpenAI working on RLHF and co-authored the InstructGPT paper that led to ChatGPT before leaving to start the company. TypeSafe built Jev in stealth for roughly two years and opened limited early access on 15 September 2026, the same day it announced a US$40 million seed round led by DCVC (Forbes put the valuation at about US$200 million).

The name comes from William Stanley Jevons, the 19th-century economist behind the "Jevons paradox": when a resource gets cheaper, people end up using more of it, not less. TypeSafe chose the name to signal that once machine decisions become hundreds of times cheaper, software will call them everywhere that today is a hard-coded if-else rule or a human clicking a dropdown.

When	Milestone
2024	TypeSafe AI founded in San Francisco after Diogo Almeida leaves OpenAI
2024–2026	About two years in stealth; the team develops RLCD (Reinforcement Learning for Calibrated Decisions) so that returned probabilities are trustworthy, not just accurate on average
15 September 2026	Jev opens in limited early access alongside a US$40 million seed round led by DCVC
16 September 2026	Available through Vercel AI Gateway with no waitlist
September 2026	Stable release jev-1.13.0; integrations from LangChain, Pydantic AI, LiteLLM and OpenRouter appear within the first week

How a "System One Model" Differs From an LLM

The category name borrows from Daniel Kahneman's Thinking, Fast and Slow, which splits human thinking into System 1 (fast, automatic, intuitive: you glance at an email and know it is urgent) and System 2 (slow, deliberate, step by step). Large language models doing chain-of-thought sit on the System 2 side. TypeSafe's bet is that most of what software actually needs from AI is a System 1 answer: which one, how much, yes or no, so the program can move on. No essay required.

Technically, an LLM generates text one token at a time (autoregressive) and your code then has to parse that text, which is where both the latency and the format errors come from. Jev instead takes a "state" (a string, a JSON object, or an array of text) plus one or more typed questions, evaluates every question in parallel in a single pass, and returns answers that are guaranteed to fall inside the schema you supplied. There is nothing to parse and nothing to validate.

Aspect	Typical LLM (GPT / Claude / Gemini)	Jev (System One)
Output	Free-form text (must be parsed)	Typed values: a choice, a score, or a probability, with confidence
Processing	Token by token, step by step	All questions evaluated in parallel in one pass
Latency	Seconds to tens of seconds	70–500 ms end to end (per TypeSafe)
Input price	Dollars per million tokens	$0.042 per million input tokens; output tokens are free
Out-of-schema answers	Possible (hallucination, malformed output)	Structurally impossible, though a wrong choice within the schema still is
Explains its reasoning	Yes, in prose	No, only values and probabilities
Best for	Writing, summarising, multi-step reasoning, research	Classifying, ranking, screening, routing, high-volume repeated decisions

The Three Question Types Jev Answers

Jev does not accept open-ended questions. Every question must be one of three types, and TypeSafe's documentation recommends keeping each one "atomic": narrow enough that a knowledgeable person could answer it in a few seconds.

Type	The question	What you get back	Example in a business system
Choice	"Which of these options?"	choice (the selected option), probabilities for every option, confidence; up to 255 options per question	Which team should this email go to: Accounting / Procurement / IT / Other
Score	"Where on this rubric?"	score, probabilities per level, confidence; the score can land between levels according to the weights	Incident severity from 0 = minor to 3 = act immediately
Noul	"Is this statement true?"	noul, a single value from 0 to 1 (named after the Bernoulli distribution); no separate confidence because the number is the uncertainty	Does this message request a refund? → 0.96

Three pieces of advice from the docs worth remembering: always include an "other" option in a Choice so the model is not forced to jam an unusual case into the wrong bucket; define Score levels as observable situations rather than vague words like "low / medium / high"; and batch several questions in one request, because latency barely moves (you only pay for the extra question tokens). The catch is that every question is evaluated independently. If question B depends on the answer to A, you need a second request with an updated state.

A condensed example of a call (adapted from the docs and the DataCamp and LangChain write-ups; the result values are the illustrative ones used in the documentation):

POST https://api.typesafe.ai/v1/systemone
{
  "model": "jev-latest",
  "state": "Customer emailed twice this week about a refund that has not arrived ...",
  "questions": {
    "team":      { "type": "choice", "options": ["billing", "technical", "account", "other"] },
    "is_urgent": { "type": "noul",   "instructions": "The message conveys urgency or a deadline" }
  }
}

// response
{
  "team":      { "choice": "billing",
                 "probabilities": { "billing": 0.58, "technical": 0.37, "account": 0.05, "other": 0.00 },
                 "confidence": 0.61 },
  "is_urgent": { "noul": 0.96 }
}

How Fast, How Cheap, and How Much to Trust It

TypeSafe's published figures are 70–500 milliseconds end to end (one early user reported agent routing in 145–271 ms), $0.042 per million input tokens with output tokens free, a limit of 64k tokens for state plus questions and 32k for state plus the longest single question. The company claims Jev is 40 to 200 times faster and 40 to 400 times cheaper than frontier LLMs on comparable tasks, with peaks of 193.6× and 444.6× on its internal workflows.

Model	Accuracy	Cost per case	Latency
Jev	67.8%	$0.0004	0.4 s
GPT-5.6 Terra	67.9%	$0.0304	10.1 s
GPT-5.6 Sol	74.1%	$0.0836	23.3 s
Claude Opus 5	73.1%	$0.1761	37.8 s

Source: TypeSafe's internal benchmark as reported by DataCamp (September 2026). Vendor-reported numbers.

What Jev Is Used For: 8 Jobs That Fit

The shortest suitability test in the docs: can you phrase the job as "given this state, tell me X", where X is a choice, a score, or a probability? If yes, Jev is a candidate. If not, use ordinary code, an LLM, or a reasoning model instead.

Job	Question type	Example
Routing tickets, emails, and chats	Choice	Should this go to Accounting, Procurement, or IT, then open the task for that team immediately
Scoring leads or urgency	Score	Should this request enter the normal, urgent, or top-priority queue, using levels defined as concrete situations
Classifying documents at volume	Choice	Is the incoming file an invoice, a purchase order, a quotation, or something else
Trust and safety checks	Noul	Does this text contain personal data that must not leave the organisation
Screening applications	Score	How complete is this submission against the checklist before a person reviews it
Branching a workflow	Noul	Is the supplier's message a delivery confirmation or a delay notice, then take a different path
Inside an AI agent: model routing	Choice	Send simple prompts to a cheap, fast model and complex ones to a large model, cutting the cost of the whole system
Inside an AI agent: a gate before acting	Noul	Is this tool call risky before it runs; does the fetched page contain prompt injection; does the citation the agent produced match the source

The last two rows are where developer attention concentrated in the first week. LangChain shipped langchain_typesafe so Jev can act as middleware in an agent loop: instead of calling the LLM for every small judgement such as "is this urgent" or "is this dangerous", Jev answers in a fraction of a second and the LLM is reserved for work that genuinely needs reasoning or writing. Other early projects include reranking search results and classifying tens of thousands of crawled documentation pages in one pass.

Limitations to Know Before You Use It

• No text, code, or summaries. For those, use an LLM.
• No multi-step reasoning. Anything that needs chain-of-thought is not a Jev job.
• No external lookups. It knows only what is in the state you send.
• Questions in one request are independent. Dependent decisions need several round trips.
• Closed system. No paper, no public weights, trained entirely on synthetic data with RLCD, and still in waitlisted early access.
• Confidence thresholds must be validated on real data. High-cost mistakes should demand stronger evidence than routine ones.

How to Get Started

• Direct: join the waitlist at typesafe.ai (early users reported a wait of a few hours to more than a day); documentation lives at docs.typesafe.ai; Jev is called through its own endpoint, not /chat/completions.
• No waitlist: Vercel AI Gateway as typesafe-ai/jev via the evaluate method in AI SDK 7, or OpenRouter as typesafe/jev-latest (32k tokens per request).
• Through frameworks: LangChain (langchain_typesafe), Pydantic AI, and LiteLLM pass-through.
• From the community: an MCP connector, a Claude Code plugin, a Ruby library, and a DSPy fork.

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()
response = classifier.invoke({
    "state": "The deploy failed twice and customers are seeing 500s.",
    "questions": {
        "urgent": Noul(instructions="Does this need attention now?"),
    },
})
urgency = response.nouls["urgent"].noul   # e.g. 0.999

The ERP Angle: Thousands of Small Decisions a Day

An ERP system is full of decisions whose possible answers are known in advance. Is this incoming document an invoice or a purchase order. Should this request go into the normal queue or the urgent one. Which inventory category does this free-text line item belong to. Is the supplier's message a delivery confirmation or a postponement. Today these are handled either by hard-coded rules or by a person choosing from a dropdown, and both have a cost: rules break on the case nobody anticipated, and people are slow and only as consistent as their attention that day.

Jev is designed for exactly this layer, but the principles we apply when we connect AI to a customer's systems do not change. The ERP remains the single source of truth. The model's job is to propose, not to post. Anything below the confidence threshold goes into the approval workflow where a person checks it, and every automated decision is logged with the state the model saw, the value it returned, and how confident it was, so an auditor can trace it later. The rules for choosing which work to hand to AI also still apply: start with high-volume tasks where a mistake is cheap to fix and the outcome is measurable.

Who It Suits, and Who It Does Not

A good fit	Not a fit
High-volume, repeated decisions with a known set of answers	Work that requires writing text, code, or summaries
Systems that must respond in real time, such as routing and agent guardrails	Multi-step reasoning where the rationale must be explained
Scoring millions of rows: reviews, tickets, documents	Tasks that need outside information before answering
Organisations with enough real data to set and validate confidence thresholds	Regulated decisions that require a natural-language justification every time
Teams comfortable experimenting with an early-access service	Organisations that need on-premise deployment or a production SLA today

Conclusion

Jev is not a faster LLM. It is a different kind of model that drops text generation entirely and answers only three kinds of question, which one, how much, and is it true, with calibrated probabilities attached. The result is sub-second latency and costs hundreds of times lower for work whose answer set is fixed in advance, which describes most of what enterprise software does repeatedly every day.

What is still missing is independent evidence of accuracy on real workloads, because the numbers available today were measured by the vendor. For organisations in Thailand, our advice is to treat Jev as one replaceable piece of the AI layer, placed in front of people or in front of an LLM to screen and rank, while the core system remains the source of truth and approval stays with a human. Expand its scope only after it has been measured on your own data and cleared your own bar.

The AI that earns its place in a business system is not the one that talks best, but the one that gets small decisions right, fast, and knows when it is unsure.

- The Saeree ERP team

References

• Wikipedia — Jev (AI model)
• TypeSafe AI — Documentation: Introduction to Jev and System One models
• DataCamp — Jev: TypeSafe's System One Model That Never Hallucinates (benchmark table and API example)
• KDnuggets — What Everyone Is Getting Wrong About TypeSafe AI's Jev
• LangChain Blog — What Is Jev? A Guide to TypeSafe AI's System One Model (langchain_typesafe)
• Firecrawl — What Is Jev? Decision-only model, pricing, limits and the Every.to independent test
• Tom's Hardware — TypeSafe AI's Jev claims to be 193x faster and 445x cheaper than LLMs

Sources checked on 22 September 2026.