Jev, examined

At a glance

The spec sheet

What it is

A function call with a probability attached

A language model produces strings for people to read. When software needs a decision from one, somebody has to coax the string into JSON, parse it, validate it, and retry when it comes back wrong. Jev skips all of that. Its output space is fixed by the request, so an answer outside your schema is not rare. It is impossible.⁵

TypeSafe calls this a System One model, after Kahneman's fast, intuitive mode of thinking. The model itself is named after William Stanley Jevons: the company expects cheaper machine judgement to create more demand for it, the way efficient steam engines did for coal.⁵ Its own shorthand is a smart if-statement. The AI is one small component inside ordinary software, and the surrounding code stays in charge.

The contract

Three question types, one endpoint

Sources for the table: the API reference and the primitive pages.²³

request

POST https://api.typesafe.ai/v1/systemone
{
  "model": "jev-1.13.0",
  "state": { "tier": "enterprise",
             "text": "DB latency over 1200 ms since the migration. Webhooks are dropping." },
  "questions": {
    "is_outage": { "type": "noul",
      "instructions": "Does this describe a production outage?" },
    "team": { "type": "choice",
      "instructions": "Which team should triage this?",
      "criteria": { "database": "Storage, pools, query latency",
                    "networking": "Ingress, webhooks, TLS",
                    "application": "Business logic, auth, UI" } },
    "severity": { "type": "score",
      "instructions": "How severe is the incident?",
      "criteria": ["Cosmetic", "Degraded, workaround exists", "Blocking, no workaround"] }
  }
}

The keys under questions are yours and never reach the model. instructions and criteria accept strings, objects or arrays, so when two options keep getting confused you can give each one fields such as what, not_for and examples. The model never sees a Score level's number, only its description. Levels written as bare numbers perform badly for that reason.³

Confidence describes the distribution. It does not vouch for the answer.

Confidence is computed from how peaked the returned probabilities are, and the formula is unpublished. TypeSafe's documentation is careful about this. A confidence of 1.0 means all the mass sat on one option. It is a statement about the model's answer and no guarantee that the answer is correct. The docs also warn that if rewording a question raises confidence, you have learned nothing yet about which wording is better.³ Hold on to that. It matters in the independent results.

Ask everything at once

All questions in a request run in parallel against one reading of state. Extra questions cost their own tokens and add almost no latency. TypeSafe's cookbook puts a 13-question regulatory briefing at 12.2 times cheaper and 10.0 times faster when batched than when asked one at a time, with identical answers.²² This inverts the habit language models taught us, which was to save tokens with small sequential calls. Here the recommended pattern is to ask every question your code might need and ignore the answers it doesn't.

Novelty

What is new, and what is only renamed

The Jev column and the language-model ranges are as TypeSafe states them.⁵

The interface is the real contribution. The idea underneath is older. Encoder classifiers such as GLiNER and GLiClass score labels against text in one pass. Cross-encoder rerankers return a relevance scalar for a pair. Grammar-constrained decoding has forced schema conformance out of language models for years. Jev's claim over all of them is breadth (zero-shot judgement against any rubric you write at request time) plus calibration from a training method TypeSafe calls Reinforcement Learning for Calibrated Decisions.

About the architecture, TypeSafe has said three things: it is new, it uses a hardware-aware parallel sampler, and it was trained with RLCD.⁵ There is no paper and no model card. TechCrunch reports the model is transformer-based, that outside observers suspect an open-weight base model, and that Almeida says it was trained only on synthetic data, which he called his best strategic bet.¹⁰ None of that can be checked. What can be checked is that at least seven open reimplementations of the interface appeared within four days, which says something about how much of the design is secret. More on those below.

Vendor evidence

The vendor's numbers

TypeSafe built four workflows: security incident response, review of support-agent traces, invoice processing, and customer service. Each is a fixed decision graph in code. Every model answers the same Noul, Choice and Score questions, and code makes the final call. The reference answers are the average of GPT-6 Astra and Claude Fable 5.1, both at high thinking. TypeSafe says outright that it is not measuring against ground truth, so "accuracy" below means agreement with two large models. Scored models run at their provider's default reasoning setting, and the language models go through TypeSafe's own adapter. The mean weights the four workflows equally.⁵⁶

The mean hides the interesting part.

Invoice processing means reconciling a bill against a purchase order and a delivery note, with amounts. That is multi-document arithmetic, and TypeSafe's own documentation lists numbers and indirection among the things Jev does badly. The benchmark and the limitations page agree with each other, which is more than most launches manage.

Where 193.6× and 444.6× come from

TypeSafe's home page says 193.6 times faster and 444.6 times cheaper, and its launch post says these sit at the high end of what it expects in practice.⁵ It does not say which model each ratio is measured against. The published means allow a guess:

The speed headline fits Sonnet 5 and the cost headline fits Opus 5: the slowest Anthropic model and the dearest one. Against Terra, which TypeSafe itself calls the closest match in intelligence, the figures are 25 and 76. Against Luna, the cheap one, the cost advantage is eight.

The biases TypeSafe discloses

• Its own capabilities team wrote the workflows.
• Reference labels from OpenAI and Anthropic models favour OpenAI and Anthropic models. TypeSafe thinks Jev and DeepSeek are understated as a result.
• The adapter asks language models for probability distributions, which makes them slower and dearer than asking for a bare label.
• Latency was measured from laptops on the US West Coast, where the service runs.
• The 0% type-error figure is a property of the design. Nobody measured it, and nobody needs to.

There is no public benchmark card, and that is policy. TypeSafe says it chose not to publish against public benchmarks and argues against optimising for them. Fair enough, but it leaves third parties as the only route to a comparison you can trust.

The finding TypeSafe buried: decomposition helps everyone

This matters more than the headline ratios. The pattern (narrow typed questions, deterministic code around them) carries much of the benefit, and you can apply it today with any model, including one running on your own hardware.

Independent evidence

What outsiders measured

Four days after launch there is a surprising amount of third-party work, some of it pre-registered with raw outputs committed. Speed and cost hold up. Accuracy is good and depends heavily on the task. Calibration is contested, and that is the one that matters.

Evaluations with artefacts

Two failure probes worth remembering

A poker test with solver ground truth showed Jev the opponent's exact cards, a made flush, and asked what to do. A solver checks every time. Jev went all-in 16 times out of 16. Relabelling the same hand moved its answers by 15 to 30 points.¹⁷ A separate probe found it no better than random at picking a chess move from a board position, while scoring F1 0.96 on working out which game character a line of dialogue was addressed to.¹⁷

Both failures are on TypeSafe's own list: formal, numeric state and literal reading. Neither task looks hard, which is the uncomfortable bit.

Practitioner reports

These carry less weight: no artefacts, and some come from people quoted in launch coverage.

• Vercel swapped GPT-5.6 Luna for Jev in a classifier that decides whether an agent's shell command is safe. 5× to 18× faster, and more accurate.¹⁰
• Bryo AI classifies incoming business email. Jev was 10× to 20× cheaper than Gemini, and Gemini was slightly more accurate. The CTO wanted the probability more than the last point of accuracy.¹⁰
• Near Here, 50 real event-validation records: Jev 48 of 50, with Mistral Small 4 and Gemini Flash-Lite in the mid-80s. $0.043 per thousand decisions against $0.370 and $2.496.¹⁷
• Good Start Labs, 6,003 rubric checks: 91.5% agreement with Claude Fable 5.1 at about $160 per million graded answers, against about $260 for DeepSeek V4.1 Flash.¹⁸
• Every ran 21 questions over 37 articles: 777 judgements in under 0.7 s for about a quarter of a cent. On 12 passages with planted defects Jev caught six of seven and Claude Fable 5.1 caught all seven, at 25 times the latency and an estimated 580 times the cost. Mike Taylor, who ran it, wanted a fuller accuracy check before production.¹³

The calibration ledger

Calibration looks decent on tasks close to what Jev is good at and unreliable off that path. It is also sensitive to how you phrase the question. A feature that is supposed to tell you when to trust the model should not behave like that, and it means you measure it yourself, on your data, again after every rewrite.

Limits

Where it breaks

TypeSafe publishes a page it calls jaggedness, last reviewed 17 September 2026, listing nine ways jev-1.13 goes wrong.⁴ It is the most useful page in the docs.

What follows from the design

• No reasons. You get probabilities and a legend. Where a regulator or an auditor needs a written rationale (credit, health, hiring) Jev cannot be the whole answer.
• 255 options. Larger taxonomies need a hierarchy. TypeSafe's cookbook runs a beam search over Choice probabilities, level by level.²²
• Tools. Jev can pick a function and fill arguments drawn from closed sets. Free-form arguments need a language model. In Pydantic AI a hand-off resends the whole step to the fallback model as if Jev had never run, so you pay for a request whose answer is thrown away.²⁰
• The cascade tax. Set thresholds too high and most traffic escalates. Then you pay for Jev and the fallback, and wait for both.
• Simulators only. The Doom demo (ten decisions a second, about $7 an hour) reads structured text state. TypeSafe notes a conventional bot would play better.⁵

Application

Where it fits

The test TypeSafe suggests is a good one: could a knowledgeable person answer this in about a second? If so, and you need the answer a million times, Jev is a candidate.

Poor fits

• Anything that needs text out: replies, summaries, code, explanations.
• Anything code can compute exactly: counts, sums, date logic, things a regex finds.
• Multi-hop reasoning and reconciliation across several documents. See invoice processing.
• Formal or numeric state, such as board positions, hex values or encodings.
• Decisions about people that need a stated reason. In the EU, CV screening is a high-risk use under the AI Act, and a model that offers no rationale, is weaker outside English and has contested calibration is a poor basis for it.
• Problems where you already have plenty of labelled history. A fine-tuned encoder will usually be cheaper and at least as good.
• Tiny volumes. If you make a hundred decisions a day, the cost of a language model is noise and you keep the rationale.

The pattern you will end up building

TypeSafe documents four more patterns that go with it: speculative fan-out, composite scoring (one Score per dimension, normalised and weighted in your code), intent routing, and a structured-extraction cascade from small model to verifier to reasoning model.²²

Practicalities

Getting it running

1. Join the waitlist at typesafe.ai. Keys are issued at console.typesafe.ai, which also has a playground. If you would rather not wait, OpenRouter accounts can reach Jev today, according to developers who have wired it up.²¹
2. Install an SDK. Both read TYPESAFE_API_KEY, default to jev-latest, and retry 429 and 529 with backoff.²³
3. Pin jev-1.13.0 wherever a threshold has been tuned, and log the model field that comes back. Aliases move on release, and your answers move with them.¹

terminal

# Python, sync and async clients
$ uv add typesafe-sdk        # or: pip install typesafe-sdk
# JavaScript and TypeScript
$ npm install @typesafe-ai/sdk

python

from typesafe_sdk import TypeSafeClient, Noul, Choice

with TypeSafeClient(model="jev-1.13.0") as client:
    r = client.system_one(
        state=ticket_text,
        questions={
            "billing": Noul(instructions="Is this ticket about billing?"),
            "tone": Choice(instructions="What is the customer's tone?",
                           criteria={"calm": None, "frustrated": None, "angry": None}),
        },
    )
if r.choices["tone"].confidence < 0.5:
    send_to_person(ticket_text)

Errors: 401 bad key, 422 validation failure with the offending field named, 429 rate limit, 529 overloaded.² Frameworks: Pydantic AI has a TypeSafeModel that maps bool and bounded float to Noul, Literal and Enum to Choice, and documented IntEnum to Score, with a FallbackModel hand-off for what Jev cannot express.²⁰ LangChain ships a classifier wrapper. TypeSafe publishes an agent skill for Claude Code and Codex, and an MIT-licensed adapter that runs the same request contract over OpenAI and Anthropic chat models. That adapter is how you run an A/B test, and how you leave.⁵

Economics

What it costs, and what the token price hides

Only input is billed: state tokens, plus question tokens, plus a little request overhead, at $0.042 per million. TypeSafe says it cannot prove the price is unsubsidised and expects it to fall.⁵ Some anchors:

• The smallest examples in TypeSafe's docs use 310 to 590 input tokens. So the floor is about $0.000013 to $0.000025 per request.³
• At 250 tokens a decision, a million decisions cost $10.50. At 2,000 tokens, $84.
• TypeSafe's benchmark workflows average $0.0004 a case, because a case is many questions and sometimes several dependent calls. Invoice processing averages $0.0011.⁶
• A figure doing the rounds, 50 million rows scored for $20, implies 9.5 tokens per row. It does not survive contact with the docs. Expect hundreds of dollars. Still cheap.

Against hosted language models Jev wins by one to two orders of magnitude. Against an embeddings-plus-logistic-regression stack or a self-hosted encoder it loses by about as much. What you pay the premium for is rubric-following with no training data, plus probabilities out of the box.

The token bill is rarely the number that matters

The formula worth using prices the escape hatch and the mistakes:

total = N × c                     # tokens
      + N × h × c_review          # escalated to a person or a bigger model
      + N × (1 − h) × e × c_fail  # wrong answers nobody caught

where h is the share escalated and e is the error rate inside the automatic band. Move the sliders. At almost any realistic setting the purple sliver is invisible.

A five-point cut in the escalation rate, at a dollar per review, is worth $50,000 per million decisions. No change in token price comes close. Optimise the escape curve.

An evaluation you can defend

1. At least 1,000 representative decisions, each labelled by two or three people. Their agreement with each other is your ceiling.
2. Measure label agreement, expected calibration error over ten bins, Brier score, AUC, p50 and p95 latency, and cost per call.
3. Sample at least three thresholds and plot accuracy against coverage. An accuracy figure without coverage hides the size of the review queue.
4. Baselines, all with frozen prompts: your current system, a cheap small language model, and a supervised encoder if you have labels.
5. Write down the go and no-go criteria before you look. The two public evaluations that did this both came back ambiguous. Be ready for that.
6. Break-even is the one-off evaluation and integration cost divided by monthly saving. Swapping out Haiku 4.5 at a million decisions a month saves a few hundred dollars in tokens. The case is made at ten million, or by the escalation rate.

Data protection

Your data goes to California

The Privacy Policy (last updated 19 November 2025) and the Data Processing Addendum (24 April 2026) were both read in full for this dossier.⁷⁸ What they say:

For ordinary personal data the scaffolding is conventional and would pass most procurement reviews: SCCs, a DPA, a no-training commitment. It still means inference leaves the EU, retention is open-ended by default, and improvement and debugging are permitted uses. If your client's position is that personal data stays in the EU, Jev is unavailable to you today, and a gateway does not change that.

Risk

Safety and reliability

• Good structural properties. A bad answer can only ever be a wrong branch, since output is limited to your schema. Low confidence can route to a person. For composing AI into larger systems, that is a real improvement over free text.
• No published safety evaluation, red-team result or third-party audit.
• Injection through state is a documented weakness.⁴ TypeSafe's guardrail cookbooks use Jev to detect injection, and the independent benchmark says it does that well. The detector still shares the weakness it polices. Treat state as untrusted, and test with hostile input.
• The automation hazard is specific. A confident wrong answer in the automatic band is executed and nobody sees it. Gating on confidence is the designed defence, and confidence is the least verified property of the model.
• Availability. One region, one vendor, no SLA, rate limits that TypeSafe says will change without notice. Under launch demand the company briefly lost the ability to serve its API.¹⁰
• Drift. jev-latest will change under you. Thresholds tuned on 1.13 mean nothing on 1.14 until re-measured.

Local-first

If the data cannot leave

There are no weights to download. There is, however, a well-evidenced substitute, and it starts from the dumbbell chart above: the workflow pattern lifts every model, so keep the pattern and change the engine.

All of these reproduce the interface and none of them is Jev, as their authors say. You lose TypeSafe's trained calibration and you have to add your own, by temperature or Platt scaling on a held-out labelled set. Given what the independent work says about that calibration, you are giving up less than the launch material suggests.

The moat looks modest for the same reason. Bespoke Labs already ships Nimble, a model described as nearly identical in design: non-autoregressive, reading probabilities over answer tokens, same three primitives, and it publishes its own comparison against Jev. Armin Ronacher told TechCrunch he expected competitors quickly.¹⁰ It took about three days.

Recommendation

What to do with it

Trial it, off the critical path, on data that is allowed to leave

Pick one high-volume triage decision with a written rubric and a cheap failure mode. Pin the version. Run the evaluation in the cost section with the encoder baseline included. Adopt if you see an order of magnitude on cost and latency, accuracy inside your tolerance, and calibration holding within about five points per confidence bucket on your data.

Keep side effects in code

An answer from Jev is a candidate. Permissions, approvals and anything irreversible stay behind ordinary checks. Set one threshold per action. Report accuracy with coverage. Watch the escalation rate. Re-run the calibration suite before moving the pin, and after rewording any question.

Build the probe set from its known failures

Numbers, dates, negations, long noisy state, hostile state, board-like formal input, and anything that needs two documents read together. If your workload is mostly those, you have your answer without spending anything.

For regulated or residency-bound data, use the pattern locally

Decomposed workflow, open model or encoder, your own calibration layer. Come back to Jev if TypeSafe ships an EU region, a VPC deployment or weights.

What would change this

Jev is a good idea, well executed and honestly documented, sold on the one property that has not been shown to hold. Buy it for the speed and the type safety. Earn the calibration yourself.

Sources

What this leans on

Primary sources first, then reporting, then independent evaluations. Everything was read on 19 September 2026. Claims that rested only on aggregator blogs, forum counts or unattributed figures were left out.

1. TypeSafe AI, Models. Version, aliases, price, limits, context, language support, data handling.
2. TypeSafe AI, API reference. Request and response shapes, error codes.
3. TypeSafe AI, Score and Choice. Level limits, the 255-option cap, the 1.3 worked example, confidence semantics, token usage in examples.
4. TypeSafe AI, Jev 1.13 jaggedness, reviewed 17 Sep 2026.
5. Diogo Almeida, Introducing System One Models & Jev, TypeSafe AI blog, 15 Sep 2026.
6. TypeSafe AI, Workflow evals. All chart data.
7. TypeSafe AI, Privacy Policy, last updated 19 Nov 2025.
8. TypeSafe AI, Data Processing Addendum, last updated 24 Apr 2026.
9. TypeSafe AI, Legal. ZDR for enterprise customers.
10. TechCrunch, A new kind of AI model from a ChatGPT inventor is thrilling developers, 18 Sep 2026.
11. SiliconANGLE, TypeSafe AI exits stealth with $40M, 16 Sep 2026. Carries the Forbes valuation report.
12. Business Wire via Yahoo Finance, TypeSafe AI Emerges From Stealth With $40M, 15 Sep 2026.
13. Mike Taylor, Every, Mini-Vibe Check: TypeSafe's Jev.
14. ickma2311/jev-baselines-eval. Pre-registered, hash-pinned.
15. AbdelStark/jev-benchmarks. Apache-2.0, artefacts with SHA-256 provenance.
16. zhuyansen/jev-zeroshot-vs-bert.
17. OmniJev/awesome-jev, index of independent evaluations: Lindfors, jev-sec-bench, jev-rerank-bench, the search rerank eval, calibre, the poker and chess probes, Near Here, the research-loop comparison and the open reproductions. Figures taken from the linked repositories' summaries.
18. The Cherry Creek News, TypeSafe's Jev claims 193x faster and 444x cheaper. Good Start Labs figures.
19. us/jev-local. Open server for the System One contract.
20. Pydantic AI, pull requests #8450, #8501, #8542.
21. OpenRouter: TypeSafe and Vercel changelog.
22. TypeSafe AI, documentation index. Cookbook summaries: parallel questions, reranking, hierarchical classification, patterns.
23. TypeSafe AI, Python SDK.

Colophon

In case you were wondering

This dossier was researched and drafted with the assistance of various agents and models, and checked against the sources above. Four earlier research passes were reconciled first, and the claims that failed the check were dropped. The charts are drawn from the numbers on TypeSafe's evals site as they stood on 19 September 2026, which TypeSafe can change. Every figure here is somebody else's measurement, labelled as such. None of it replaces a test on your own data.

The model is four days old at the time of writing. Expect parts of this to date quickly.