Jev AI: Capabilities, Limitations and How To Use

Every team that has wired a chat model into a workflow knows the routine. The model writes a fluent answer, and then your code has to pull a decision out of it with parsing, retries, and validation, hoping the format holds this time. Jev exists to remove that middle step. You send it messy input and a set of questions you define, and it returns typed answers with probabilities that your code can act on directly. This guide explains who built it, how it works, what it is good at, where it falls short, and how to start using it.

Who made Jev

Jev comes from TypeSafe AI, a San Francisco lab founded in 2024 that spent roughly two years in stealth before launching on September 15, 2026. The chief executive is Diogo Almeida, who previously worked on InstructGPT and RLHF at OpenAI, and he started the company with Erik Gafni and Sasha Sheng. The launch was backed by a $40 million seed round led by DCVC at a reported valuation of around $200 million.

The naming reflects the ambition. The broader model family is called System One Models after Daniel Kahneman's fast, intuitive System 1 thinking, and Jev is named after the economist William Stanley Jevons, whose paradox holds that making something more efficient tends to increase how much it gets used. TypeSafe's bet is that automation needs models built for machines to consume, not for people to read, and Jev is the first product of that thesis.

How Jev was trained

Jev was trained with Reinforcement Learning for Calibrated Decisions, or RLCD. Where RLHF trains a model to produce answers people prefer, RLCD trains a model whose confidence matches reality. A claim of 70 percent confidence should be correct about 70 percent of the time when measured across many decisions.

That objective is what makes Jev usable inside automation. Calibration turns confidence from decoration into a control you can set and test. You decide that scores above some level act automatically, scores in the middle get flagged for review, and scores below a floor go to a human, and you fit those bands on your own labeled examples. Readers who want the full comparison with RLHF can read our companion piece on how the two training methods differ.

One honest caveat: TypeSafe has not yet published a paper, a reward-function description, or an independent calibration chart on ground-truth data. The calibration story is plausible and the reported numbers are consistent with it, but until outside evaluations appear, treat the strongest claims as the vendor's account of its own system.

What Jev does

Jev does not chat, write prose, generate code, or explain itself. It takes a piece of state, which can be plain text, a JSON object, or an array, and answers a set of typed questions about it in one call. A support ticket, a log line, a transcript plus a policy document, or a JSON blob of measurements are all fair game as input.

Each question you ask takes one of three forms. A choice question asks which of up to 255 options fits best and returns the winner along with a probability for every option. A score question asks how strongly something rates on levels you describe, such as calm, frustrated, or very angry, and returns a weighted result. A yes-or-no question returns a single probability between zero and one. Every question in a call shares one reading of the same state, so asking five questions costs barely more time than asking one, and every answer arrives in a shape your code already expects.

Why it is fast

A conventional language model produces its answer one token at a time, with each token depending on all the ones before it. That sequential process is why pulling structured data out of a large document through a frontier model can take many seconds. Jev produces all of its answers in a single parallel pass instead, which is why typical calls finish in about a tenth of a second, with published figures ranging from 70 to 500 milliseconds.

Cost follows the same pattern. Typesafe charges $0.042 per million input tokens and nothing for output, since there are barely any output tokens to bill. Against frontier models on equivalent structured tasks, the company reports speedups of roughly 20 to 200 times and cost reductions of 40 to 400 times. Small independent tests confirm the direction of those numbers, even if nobody outside the company has reproduced the headline peaks yet.

What makes Jev different from other LLMs

The table below summarizes the practical differences. The short version is that a frontier model is built to satisfy a human reader, while Jev is built to give software a value it can branch on.

Area	Frontier LLM	Jev
Built for	A person who reads and judges the answer	Code that acts without a human in the loop
Output	Text that must be parsed into decisions	Typed values with probabilities, ready to use
When wrong	Still sounds confident and fluent	Returns a low probability so code can escalate
Confidence	Rough estimates you prompt for, usually overconfident	Native per-answer probabilities meant to be calibrated
Latency	Seconds, longer with reasoning	Around a hundred milliseconds
Cost shape	Input plus expensive output tokens	Input only, output is free
Scope	Open-ended, anything goes	Bounded choices, up to 255 options per question

In practice the two complement each other. Jev handles the judgment calls at volume, and a generative model steps in for the moments that genuinely need prose, code, or explanation.

Capabilities and best use cases

Jev earns its place wherever the possible answers are known in advance, volume is high, and waiting seconds is not an option. The recurring pattern is to let Jev judge, let plain code compose and compute, and bring in a large model only when generation is actually needed.

Smart branching inside workflows is the natural home: classifying tickets, routing requests, scoring content, extracting fields, approving standard cases, and handing the rest to people. Because one call can carry several questions at once, a single pass over a ticket can determine its urgency, its owning team, and the customer's frustration level, after which ordinary code applies policy and acts.

Large-scale extraction is a second strong fit. Running one state per row through the same question set turns sprawling corpora into typed features, and the economics work because output is free and each row's state is sent once. Early reports include over a thousand research papers classified for cents and tens of thousands of listings processed in minutes.

Real-time paths are a third. Routing, guardrails, and inline classification that must finish in about a hundred milliseconds simply cannot wait on a reasoning model. TypeSafe's own demonstration ran around ten decisions per second for roughly seven dollars an hour, which makes per-turn verification of other models affordable too: scoring outputs, checking tool-call consistency, or screening for jailbreaks on every turn stops being a cost debate at a fraction of a cent per check.

Limitations

Jev is narrow by design, and TypeSafe's own documentation lists the sharp edges. The most important one is that Jev does not generate anything. It will not draft text, write code, explain its reasoning, or hold a conversation, and trying to coax prose out of it by chaining questions together works poorly.

It is also not a calculator. Counting, date arithmetic, and numeric interpolation belong in your code, not in a question. Jev reads literally, so scoping, negation, and implied conditions need to be spelled out in the question's instructions rather than left for the model to infer. Accuracy drops when the state is large and noisy, when a question asks about a property of a property, or when a single choice must cover more than 255 options without a two-stage scoring setup.

Two limits deserve emphasis for production use. Jev carries no guarantee against prompt injection in the state it reads, so adversarial inputs can move its answers and edge cases need explicit testing. And its calibration, the headline promise, remains vendor-reported: across four internal workflow evaluations totaling 711 cases, Jev agreed with a frontier-model reference about 68 percent of the time against 74 percent for the best comparator, trailing on accuracy while winning on cost and latency. Expect capable mid-tier judgment at infrastructure prices, not frontier-beating reasoning.

Where to access Jev

Surface	Details
Direct service	API at api.typesafe.ai with keys from console.typesafe.ai, plus a playground for trying questions by hand. Currently early access through a waitlist.
Documentation	Quickstart, API reference, primitive guides, and model notes at docs.typesafe.ai.
Vercel AI Gateway	Available without the waitlist as the evaluation model typesafe-ai/jev under AI SDK 7.
Pricing	$0.042 per million input tokens, output free, through both TypeSafe directly and the Vercel gateway. TypeSafe describes pricing as potentially subsidized and expected to fall.
Rate limits	During early access, 250,000 tokens per second and 1,200 requests per minute, adjusted dynamically, with standard retry headers that the SDKs honor automatically.

On data handling, zero data retention through Vercel is available per request on Pro and Enterprise plans, while TypeSafe's direct service advertises it for enterprise customers. Do not assume retention terms beyond what your own plan states.

How to use Jev

Using Jev well is mostly about designing the questions before writing any integration code. Lay out the decision table first: each row becomes a typed question with a stable key, and the state you send should contain only the fields those questions need. A ticket pipeline might use a yes-or-no question for urgency, a choice question over billing, technical, and sales for routing, and a score question for frustration, with boundary cases written into each question's criteria.

A single call then carries one state and all of its questions together:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Hi, I have been trying to connect my Stripe account for 3 days and it keeps failing. I am losing sales. Please help ASAP.",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "Does this message express urgency or time-sensitivity?" },
      "department": { "type": "choice", "instructions": "Which team should handle this?", "criteria": { "billing": "Payments, invoicing, refunds", "technical": "Bugs, outages, integrations", "sales": "Pricing, upgrades, new accounts" } },
      "frustration": { "type": "score", "instructions": "How frustrated is the customer?", "criteria": ["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"] }
    }
  }'

The same call through the Python SDK reads naturally:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY, defaults to jev-latest

ticket = "Hi, I have been trying to connect my Stripe account for 3 days and it keeps failing."

resp = client.system_one(
    state=ticket,
    questions={
        "is_urgent": Noul(instructions="Does this message express urgency?"),
        "department": Choice(
            instructions="Which team should handle this?",
            criteria={"billing": "Payments, invoicing, refunds", "technical": "Bugs, outages, integrations", "sales": "Pricing, upgrades, new accounts"},
        ),
        "frustration": Score(
            instructions="How frustrated is the customer?",
            criteria=["Calm, just stating facts", "Frustrated but civil", "Very angry, strong language"],
        ),
    },
)

print(resp.answers["department"].choice, resp.answers["department"].probabilities)
print(resp.answers["is_urgent"].noul, resp.usage)
print(resp.model)  # log the versioned id e.g. jev-1.13.0

Once answers come back, keep the division of labor strict. Let Jev extract the raw judgments, do dates, counts, ordering, and threshold checks in your own code, apply policy and permissions there, and branch on the result: act automatically at high confidence, flag the middle band for review, and escalate the low end to a person. Log the model version, probabilities, and usage on every call, pin a versioned model identifier once your thresholds are tuned, and fit your confidence bands on labeled examples from your own workload rather than on vendor demos. For retrieval pipelines, filter Jev's input first with a relevance question so each decision sees only the passages it needs, and batch independent questions about the same state into one call instead of paying to resend long state many times.

When Jev belongs in a product stack

For teams shipping an AI agent inside a SaaS product, Jev sits at the decision points rather than in the conversation. The agent surface that talks to users stays on preference-tuned models that explain, propose, and act under your permissions and approvals. Jev handles the routing before the agent speaks and the verification after it acts: triage, entitlement checks, trust scoring, and confirmation that tool calls did what was claimed. Its typed output and confidence scores let ordinary code decide whether to proceed, ask for approval, or escalate, which is exactly the boundary that embedded-agent platforms need to make measurable.

Sources

• TypeSafe AI Blog, Introducing System One Models and Jev, September 2026.
• TypeSafe Docs, Quickstart, API reference, System One concepts, and Jev 1.13 model notes.
• TypeSafe workflow evals at evals.typesafe.ai, 711 cases across four tasks.
• OrcaRouter, Jev is TypeSafe's Decision Model, September 2026.
• Flavio Copes, A deep dive into Jev, September 2026.
• DEV Community, How to Use Jev, September 2026.
• Vercel changelog, TypeSafe AI's Jev on AI Gateway, September 2026.