What is Jev? TypeSafe's decision model, explained in plain English

Jev is TypeSafe AI's hosted decision model. You send it a piece of text or JSON plus typed questions (pick one option, rate on a scale, or true/false), and it returns a structured answer to each with probabilities. It does not write text or chat. TypeSafe calls this category System One models.

Jev is the first model in what TypeSafe AI calls the System One category. TypeSafe's docs describe it as "Jev is TypeSafe's flagship model and the first System One model. Send state and typed questions; get structured answers your code can use directly."

In practice, you POST a state (a string, JSON object or array) together with a map of typed questions to https://api.typesafe.ai/v1/systemone. You get back one typed answer per question:

• a Choice picks one option from a set you define and returns a probability for each option;
• a Score rates the state on an ordered rubric and returns a probability-weighted value;
• a Noul returns the probability that a yes/no statement is true.

Jev does not write replies, produce code or explain its reasoning. TypeSafe's launch post calls it "a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out." The docs are explicit that it is not a chat or coding-agent LLM: "There is no model: "jev-latest" setting that turns your coding agent into a Jev-powered agent."

This page is a neutral explainer written by Laya Studio. Laya Studio is an independent service powered by the open-source Laya model. It is not affiliated with or endorsed by TypeSafe AI. We link every claim to its source. Where TypeSafe does not publish something, we say "not publicly documented" rather than guess.

Jev is built by TypeSafe AI, which describes itself on its home page as "an AI lab building machine-native intelligence infrastructure."

The launch post, Introducing System One Models & Jev, is dated September 15, 2026 and signed by Diogo Almeida, founder, TypeSafe. In it he writes: "At OpenAI, I helped build the methods that made language models useful at following instructions and talking with people. That work ended up as the research behind ChatGPT." The post also says the company spent "two years in stealth" and that Jev is "available today in early access."

According to the post, TypeSafe built three things for this model class:

• "a new model architecture";
• a "parallel sampler for maximum efficiency";
• a "training method we call Reinforcement Learning for Calibrated Decisions (RLCD)."

The launch materials give no further architecture detail. Jev's parameter count, backbone and layer structure are not publicly documented. Nor is any way to self-host it: Jev is offered as a hosted API, directly from TypeSafe and through at least one third-party platform, Cloudflare Workers AI, which lists the model as typesafe/jev.

On data handling, TypeSafe's models page states: "Jev is not trained on customer requests or responses." Zero data retention (ZDR) is offered to enterprise customers.

The name comes from Daniel Kahneman's Thinking, Fast and Slow, as TypeSafe's docs note: "System 1 thinking is fast and intuitive. System 2 is slower and more deliberate. Here, the emphasis is on fast, focused judgments." For more on the distinction in AI systems, see /learn/system-1-vs-system-2-ai.

TypeSafe's launch post contrasts System One models with LLMs on a few axes:

RLCD (Reinforcement Learning for Calibrated Decisions) is TypeSafe's name for training against outcomes, so that the model's probabilities reflect uncertainty. TypeSafe's AI primer frames it as a third path next to RLHF (human preference) and RLVR (verifiable rewards): "Reinforcement learning for calibrated decisions trains TypeSafe to return decisions and calibrated probabilities instead of generated text." TypeSafe's own caveat also matters: "Calibration is measured across groups of predictions; it does not guarantee that an individual answer is correct."

TypeSafe has not published the exact reward function, scoring rule or training data mix behind Jev's RLCD. Those details are not publicly documented. (Laya, the open model discussed at the end of this page, uses the same name for its own published recipe: a log plus spherical proper scoring rule with REINFORCE. That is Laya's method, not necessarily TypeSafe's. See /learn/rlcd-reinforcement-learning-calibrated-decisions.)

"Parallel" sampling means Jev emits every answer at once rather than decoding token by token. That is the defining property of a non-autoregressive model, covered in /learn/non-autoregressive-models.

TypeSafe's API reference defines a single evaluation endpoint:

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer <API_KEY>
Content-Type: application/json

Request body

Question types

instructions and criteria values can be strings, objects or arrays. That lets you put reference data inside a question and refer to it by name in backticks.

A curl request from TypeSafe's quick start:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Help! My payouts have been failing for 3 days.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": {"type": "noul", "instructions": "Does this convey urgency?"}
    }
  }'

Response body

The documented response has three top-level fields: model (the versioned id that answered, e.g. "jev-1.13.0"), answers (keyed by your question ids) and usage (input_tokens, output_tokens). TypeSafe's docs example for a Choice answer looks like this:

{
  "model": "jev-1.13.0",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "technical",
      "confidence": 0.78,
      "probabilities": {"technical": 0.85, "sales": 0.0, "billing": 0.15}
    }
  },
  "usage": {"input_tokens": 392, "output_tokens": 65}
}

Some details are easy to miss:

• confidence appears on Choice and Score answers only. In the docs' words: "Noul answers don't carry one." A Noul answer is just {"type": "noul", "noul": 0.95}.
• confidence is derived from the distribution. TypeSafe's interactive example approximates it for three options as (3 × largest probability − 1) / 2, and the docs encourage computing your own measure from probabilities if it suits you better.
• output_tokens is non-zero in TypeSafe's examples (e.g. 20 or 65), even though output is not billed.
• Rate-limit errors return 429 Too Many Requests. The SDKs retry with backoff and honour retry-after.

TypeSafe's recommended patterns build on this shape: "speculative fan-out" (many questions in one call), "confidence-gated routing", "composite scoring" and "intent routing". /learn/choice-score-noul explains the three primitives in more depth.

TypeSafe's models page lists one current model:

Aliases. jev-latest is "the most recent stable, official release" and the SDK default. jev-preview is "the most recent release, whether or not it is an official one." Both currently point to jev-1.13.0. Because an alias moves when a new release ships, TypeSafe advises: "If you have tuned confidence thresholds against a specific version, pin that version's ID instead of the alias." GET /v1/models lists the names your account can use.

Customisation. "Jev is not fine-tuned or LoRA-adapted with customer data… the same weights serve every account." You shape answers through state, instructions and criteria, not through training.

Languages. "English is the primary training language and where accuracy is currently best. Other languages, including CJK scripts, are handled but not equally well." TypeSafe publishes no per-language accuracy benchmark, so per-language performance is not publicly documented.

Latency. The launch post gives "End-to-end response time is 70ms-500ms" and "40x-200x faster" than frontier LLMs "for System One shaped queries". It notes that TypeSafe's evals were "generally run from our laptops on the West Coast (this is where our service is currently based)." No latency SLA or percentile guarantee is publicly documented.

Pricing context. The launch post says TypeSafe "can't prove it isn't subsidized" and expects prices "to go down, not up." Whether there is an official free tier or free-credit amount is not publicly documented by TypeSafe. Third-party sites have made claims, but we could not verify them against TypeSafe's own pages.

Cloudflare. Cloudflare Workers AI lists typesafe/jev with a 32,000-token context window. Cloudflare's docs do not list its pricing and say it is available through the dashboard.

TypeSafe publishes a page titled Jev 1.13 jaggedness (last reviewed 2026-09-17) that lists failure modes and the recommended workarounds. It is worth reading before you design around any System One model:

Two quotes stand out. On literal reading: "jev-1.13 answers the question you wrote, not the one you meant." On score questions: "jev-1.13's score levels are weak in numerical calibration." So you can threshold a score's expected value, but you should not interpolate exact magnitudes from it.

The page also says state is not treated as hostile by default: "Content written to adversarially steer the model … can move the answer." If you use Jev (or any decision model) as a guardrail, treat it as one layer among several.

These caveats are specific to Jev's documentation, but most apply to the whole category. Laya's model card lists a similar set of honest limits, covered in /learn/what-is-laya.

TypeSafe maintains two official SDKs, and the community has written more.

Python: typesafe-sdk (MIT license, Python 3.10 or later). The client reads TYPESAFE_API_KEY from the environment and defaults to jev-latest:

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()
response = client.system_one(
    state="Hi, I've been trying to connect my Stripe account for 3 days and it keeps failing.",
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={"billing": "Payment issues", "technical": "Bugs or integrations", "sales": "Pricing"},
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=["Calm", "Frustrated but civil", "Very angry"],
        ),
        "is_urgent": Noul(instructions="The message conveys urgency"),
    },
)
print(response.answers["department"].choice)

JavaScript / TypeScript: @typesafe-ai/sdk, which exposes TypeSafeClient and choice(), score() and noul() helpers:

import { TypeSafeClient } from '@typesafe-ai/sdk';

const client = new TypeSafeClient();
const models = await client.models.list();
for (const model of models) console.log(model.name, model.release_date);

Both SDKs retry with backoff by default. Third-party benchmark code notes that the Python SDK also honours TYPESAFE_BASE_URL and TYPESAFE_DEFAULT_MODEL.

Community clients. hs-jev is a Haskell client, "typed, batched Choice/Score/Noul over http-client". Questions compose applicatively and go out in one batched call, a Choice maps onto a closed Haskell enum, and the client has a configurable baseUrl. Other Haskell projects include realbogart/jev and jev-dsl.

Because every client targets the same /v1/systemone shape, any client with a configurable base URL can talk to another server that implements that shape. That is how the open-source Laya server stays compatible with them (see below).

TypeSafe publishes its own "workflow evals", which use GPT-6 Astra and Fable 5.1 answers as the reference. The launch post acknowledges that this "biases answers towards OpenAI and Anthropic's models" and that the workflows were written by TypeSafe staff. Two independent public benchmarks are more useful for outside comparison.

AbdelStark/jev-benchmarks (300-example pilot, resolved model jev-1.13.0)

On DAIR Emotion the study reports Jev "substantially worse calibrated" than the comparison model: Brier 0.846, NLL 5.588, and "zero probability on the true label for 16% of examples." Jev was called as a hosted service from France. The authors call the result "deliberately mixed" and the pilot "not a leaderboard".

nibzard/decision-model-benchmark (DMB)

• Banking 77-way: 76.3%, mid-pack among the contenders. The best LLM, gpt-oss-120b, scored 81.3%.
• Spam: 93.0%.
• Option cap: 100% on a synthetic code-word task up to 255 options. At 256 or more the API returns 400 Too many choices.
• Latency: p50 264–276 ms, "flat from 2 to 255 options". DMB calls it the fastest measured contender, "not 40-200x".
• Cost: $0.07 per 1,000 decisions on the banking suite, the cheapest measured. The cheapest LLM cost $0.19.
• Uncertainty: on forced-uncertainty items Jev admitted uncertainty on 49.7%, against 97.3–100% for the LLMs, with ECE 0.246 (LLMs 0.039–0.122).
• Order stability: permuting the options changed 13% of Jev's choices. The worst LLM changed 37%.

Together, these results show Jev as fast, cheap per call and strong on large label sets. Its calibration on hard or ambiguous items is weaker than the marketing implies, and its accuracy is competitive with LLMs but does not beat them outright. For how these numbers compare with the open Laya model, see /compare/laya-vs-jev. For a broader list of options, see /compare/jev-alternatives.

Laya is an Apache-2.0 decision model from Convai Innovations that follows the same System One idea: state plus typed choice/score/noul questions in, probabilities out, in a single non-autoregressive forward pass. It is not Jev and is not related to TypeSafe. It is a separate model with a published architecture (a ModernBERT-large or mmBERT-base encoder plus an option-marker decision head) and published weights.

Laya's package ships laya-serve, which exposes the same POST /v1/systemone request and response shape. Its source says a Jev client "(for example the hs-jev Haskell client) can point its baseUrl at this server and keep working unchanged." A model field such as "jev-latest" is ignored there, and Laya's router picks the checkpoint instead.

Laya Studio hosts those open checkpoints as a managed API. Switching an existing Jev integration is a base-URL and key change:

# Jev
curl https://api.typesafe.ai/v1/systemone -H "Authorization: Bearer $TYPESAFE_API_KEY" ...
# Laya Studio (same body)
curl https://api.laya.studio/v1/systemone -H "Authorization: Bearer lsk_live_..." ...

The two models are not interchangeable in accuracy, so compare them on your own data. The Laya model card reports these results, with Jev figures taken from third-party publications:

The latency rows are not like-for-like, because one is measured end-to-end over a network and the other in-process. Choose Jev when you need 50+ options per question, a 32k-token state, or TypeSafe's managed service. Choose Laya when you need open weights, on-premise deployment, automatic multilingual routing, or the option to fine-tune. The full breakdown, including a migration guide, is at /compare/laya-vs-jev. To try Laya on the same requests you send to Jev, get a free key at /signup and read /docs.