What Is Jev? A Beginner's Guide to TypeSafe's System One Model

By the RunLocalModel editorial team · September 23, 2026

A simple example

Imagine you receive a support email that says, "Stripe has been failing for three days and I am losing sales." A chat model could read it and write a response. Jev does something narrower: it can choose between billing, technical, sales, and other, then return a probability for each option. Your code can send a clear result to the right team and leave an uncertain one for a person.

That narrow job is the easiest way to understand Jev. It is useful when your program already knows the possible answers. If you need a paragraph, an explanation, or a new idea, you still need a language model.

Where the name came from

TypeSafe introduced Jev in mid-September 2026 and calls it a System One model, borrowing the term for quick, intuitive judgment. The name Jev comes from economist William Stanley Jevons. TypeSafe's idea is that when small decisions become cheap enough, developers will use many more of them.

The company says it trained Jev with a method called Reinforcement Learning for Calibrated Decisions (RLCD). Its performance claims are promising, but they are still vendor claims from a new product. The useful part for an application is less dramatic: Jev returns a small, predictable result instead of generating text.

TypeSafe says Jev cannot hallucinate because it does not generate prose. That wording needs a qualification: Jev can still make the wrong choice. It simply fails differently from a chatbot—you get a bad classification rather than an invented paragraph.

What you send to Jev

POST https://api.typesafe.ai/v1/systemone
Authorization: Bearer $TYPESAFE_API_KEY

The body has three fields:

• state — the thing being judged. A string, a JSON object, or an array of text. Text only. Images, audio, and video have to be turned into text or fields first.
• model — jev-latest while you explore. The response tells you the concrete id. On September 23, 2026 that alias points at jev-1.13.0.
• questions — a map of questions. You pick the keys. The keys are not shown to the model. The full question has to live in instructions.

Every question is scored against the same state, in parallel, in isolation. Adding questions barely changes latency, and one question cannot contaminate another. The context budget on Jev 1.13 is 64k tokens for the state plus all questions, and 32k for the state plus the single longest question. Published rate limits are 250,000 tokens per second and 1,200 requests per minute. TypeSafe says both can move without notice while they add capacity. A 429 or a 529 means back off. The official SDKs retry those for you.

Input is $0.042 per million tokens. Output tokens are not billed. A few hundred tokens of ticket text is a fraction of a cent even if you ask ten questions.

The three question types

Mix them in one call. Pick the type from the shape of the answer your code needs, not from how you would phrase the question to a person.

confidence on Choice and Score is derived from how peaked the distribution is. A choice of "billing" at 0.51 with confidence 0.2 is a different situation from "billing" at 0.92 with confidence 0.85. Act on the first only if your product is fine being wrong. Send the second through. Tune the floor on labeled examples. A floor you liked on a Noul does not transfer to a Choice: they are different questions, and a Noul plus its negation are not required to sum to 1.

Try it before you install anything

1. Open the TypeSafe playground and sign in. Early access is still a waitlist plus a key from the keys page.
2. Paste a support message as the state. The docs use a Stripe integration that has been failing for three days.
3. Add one Noul: "Does this message express urgency?"
4. Add a Choice for the team and a Score for frustration in the same request. You should see all three answers together.

When the playground answer looks right, move the same body to HTTP.

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d @- <<'EOF'
{
  "state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
  "model": "jev-latest",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this",
      "criteria": {
        "billing": "Payment or subscription issues",
        "technical": "Bugs or integration problems",
        "sales": "Pricing or account questions",
        "other": "None of the teams above clearly owns this"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "How frustrated the customer appears",
      "criteria": [
        "Calm, just stating facts",
        "Frustrated but civil",
        "Very angry, strong language"
      ]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "The message conveys urgency or time-sensitivity"
    }
  }
}
EOF

The quickstart's published sample response, on jev-1.13.0, picks technical (probability 0.85, confidence 0.78), a frustration score of 1.0, and urgency 1.0, for 392 input tokens. Your numbers will move if the alias moves. Log response.model.

Give every Choice an escape option such as other or unclear. If none of the real labels fit, the model still has to pick one. An explicit leftover bucket is how you notice that, instead of silently misrouting.

The same call from Python or JavaScript

Python 3.10 or newer:

pip install typesafe-sdk

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()  # reads TYPESAFE_API_KEY

ticket = (
    "Hi, I've been trying to connect my Stripe account for 3 days "
    "and the integration keeps failing. I'm losing sales. Please help ASAP."
)

response = client.system_one(
    state=ticket,
    questions={
        "department": Choice(
            instructions="Which team should handle this",
            criteria={
                "billing": "Payment or subscription issues",
                "technical": "Bugs or integration problems",
                "sales": "Pricing or account questions",
                "other": "None of the teams above clearly owns this",
            },
        ),
        "frustration": Score(
            instructions="How frustrated the customer appears",
            criteria=[
                "Calm, just stating facts",
                "Frustrated but civil",
                "Very angry, strong language",
            ],
        ),
        "is_urgent": Noul(
            instructions="The message conveys urgency or time-sensitivity",
        ),
    },
)

department = response.answers["department"]
if department.choice != "other" and department.confidence >= 0.6:
    queue = department.choice
else:
    queue = "human-review"

print(queue, response.model)

The 0.6 floor is a starting guess, not a TypeSafe default. Measure it. Hold out a few dozen labeled tickets, count how often auto-routing is wrong above the floor, and move the floor until that error rate is acceptable. Put the questions and the floors in one module so you can edit them without hunting through the app.

Node.js 20 or newer:

npm install @typesafe-ai/sdk

import { choice, noul, TypeSafeClient } from "@typesafe-ai/sdk";

const client = new TypeSafeClient();
const response = await client.systemOne({
  state: { message: "I was charged twice. Please fix this ASAP." },
  questions: {
    category: choice("What is this ticket about?", {
      billing: "Charges, invoices, refunds",
      technical: "Bugs, outages, integrations",
      other: "Does not clearly fit billing or technical",
    }),
    isUrgent: noul("The message conveys urgency or time-sensitivity"),
  },
});

console.log(response.answers.category.choice, response.model);

If you are already on Vercel AI SDK 7, the gateway path is experimental_evaluate with model typesafe-ai/jev. That client renames Noul to boolean and returns a probability. The native API and the official SDKs still say noul. Copying a boolean question into a raw POST /v1/systemone body will fail validation. Direct TypeSafe access from the AI SDK uses typeSafeAi.evaluationModel("jev-latest") from @ai-sdk/typesafe-ai. Cloudflare Workers call env.AI.run("typesafe/jev", ...).

Where Jev struggles

Jev 1.13 is fairly literal. It often answers the exact sentence you wrote rather than the question you had in mind. In practice, a few habits prevent most avoidable mistakes:

• Ask one thing at a time. Instead of "Rate this startup," ask separately about the market, feasibility, and differentiation.
• Keep arithmetic in code. Jev is unreliable at counting, comparing dates, and exact calculations.
• Send only useful context. Unrelated fields make the decision harder, not smarter.
• Do not ask it to write. Use a language model for an email, explanation, or code.
• Test hostile and non-English input. English is currently its strongest language, and user text can try to influence its own label.

These limitations do not make Jev useless. They tell you where the boundary is: Jev handles a small judgment; ordinary code handles exact rules; a language model handles open-ended output.

Where it fits in an application

The most convincing uses are ordinary ones. A support system can choose a queue, a RAG pipeline can decide which passages to keep, and an agent can flag a proposed action for review. In each case, the possible answers already exist and code—not Jev—takes the final action.

Start with a low-risk decision where a wrong answer is easy to spot and undo. That will tell you more than a polished demo. If the task needs exact arithmetic, original writing, or an explanation, use ordinary code or a language model instead.

A good first project

Pick a stream you already have, not a new product. Support mail, agent tool calls, or retrieved passages all work. Then:

1. Write three to six atomic questions. Include an other or unclear option on every Choice.
2. Precompute anything numeric. Pass buckets and booleans, not raw counts you hope the model will redo.
3. Call once per item, with every question in that call.
4. Branch in code. Auto-act only above a floor. Everything else goes to review.
5. Start with 30–50 real rows to find obvious problems. That is a smoke test, not proof that automatic routing is safe. Use a larger labeled set before the decision has real consequences.
6. Pin jev-1.13.0 (or whatever model the response reported) once the floor is tuned. Keep using jev-latest only in the playground.

Customer requests are not used to train Jev. Enterprise accounts can ask for zero data retention. For a prototype, still send the smallest state that answers the question, and keep the API key on the server.

Related guides on this site

• How to Use Jev: a worked routing tutorial
• Using Jev with ChatGPT, Claude, and local models
• How to Run Local AI
• Best Local LLM for Coding in 2026
• Local AI Tools Explained
• Open-Weight Reasoning Models in 2026
• Best Local AI Models by Use Case