Jev: what it is and how to work with it

A practical guide to the first System One model from TypeSafe · for @aizvestia · September 2026

What it is

Jev is the first public System One model from TypeSafe. It's not a chat model and not 'yet another LLM with a JSON mode': Jev doesn't generate text at all. You send a state (context: text, JSON, or an array) and a list of typed questions, and you get machine-native decisions back: the chosen option, a score on a scale, or the probability of 'yes' - plus a probability distribution and confidence for every answer. The creators describe it in one phrase: 'smart if-statements' - clever if-else for your code. The clearest example is email: Jev skims every message and rules 'junk, 94% sure', 'needs a reply', 'can wait'. It writes nothing back - it just sorts: 1,700 emails for 18 cents.

The System One name comes from Kahneman (Thinking, Fast and Slow): the model is built for fast intuitive judgments, not slow reasoning. Fun fact: TypeSafe co-founder Diogo Almeida co-invented RLHF - the very method used to train ChatGPT. Now he's betting that automation needs a different training method.

How it differs from 'the previous things'

Post-training of language models has gone through three approaches:

The point of calibration: when the model says 0.8, roughly 80% of such answers will be right over a long series. Probability becomes a number you can build logic on.

Practical difference from an LLM 'forced' to output JSON:

• Output is typed by construction. The model physically cannot answer outside your options - not 99.99%, but 100%. No parsing, no retries on broken JSON.
• Every answer is a probability distribution, not just a choice. You can see when an option won confidently and when the model was torn between two near-equals.
• Questions are evaluated in parallel and independently: adding a dozen questions barely changes response time (sub-second latency) and causes no 'context rot'.
• Cheaper and faster: the console welcome page claims 20-200x faster and 40-1000x cheaper than LLMs (a company claim, but easy to verify).

The three primitives

Nuances that save hours:

• Noul has no separate confidence - the value itself is the probability. 0.5 means 'I don't know', not 'medium skill'. To measure a level, write a Score with described levels.
• In Choice, add an 'other' / 'none of the above' option in case your list doesn't cover everything.
• Question IDs are for your code - the model doesn't see them. Write the full question in instructions.
• If the state is JSON, point at exact paths in backticks in your questions: `ticket.messages[0].text`.
• One question = one fast judgment. 'Analyze this and suggest a plan of action' is a bad question. 'Does this message convey urgency?' is a good one.

Getting started in 5 minutes

0. Skip the waitlist: Jev is already live on the Vercel AI Gateway as typesafe-ai/jev ($0.042/1M input tokens) - if you're on Vercel, call it right away through the ai package, no TypeSafe waitlist needed. Also on OpenRouter: ~typesafe/jev-latest (OpenAI-compatible API).

1. Playground. Go to console.typesafe.ai/playground, paste any text as the state, add questions, hit Run. (Entry greets you with a pop-quiz 'Can you chat with Jev?' - the right answer is No.)

2. API directly. Grab a key in the console, then it's one endpoint:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Trying to connect my Stripe for 3 days, keeps failing. 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"
        }
      },
      "is_urgent": { "type": "noul", "instructions": "The message conveys urgency" }
    }
  }'

The response gives each question the chosen value, probabilities across all options, and confidence.

3. Python SDK (3.10+); the client reads TYPESAFE_API_KEY and calls jev-latest by default:

pip install typesafe-sdk

from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

client = TypeSafeClient()
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",
            },
        ),
        "is_urgent": Noul(instructions="The message conveys urgency"),
    },
)
print(response.answers["department"].choice)   # "billing"
print(response.answers["is_urgent"].noul)      # 0.999

For JS there's @typesafe-ai/sdk, and for agents (Claude Code, Codex, etc.) a ready-made skill: npx skills add typesafe-ai/skills --skill typesafe-ai. The skill specifically teaches agents to send questions in batches - agents love spending one request per question.

Four main patterns

1. Speculative fan-out. All questions sharing one state go in one request, including 'speculative' ones you won't always need. An extra question costs pennies, response time barely grows. TypeSafe's cookbook: 13 questions in one request is ~12x cheaper and ~10x faster than 13 separate calls, with identical answers.
2. Confidence-gated routing. The answer tells you 'what', confidence tells you 'whether to act'. Three zones: high - act automatically; medium - ask or flag for review; low - escalate to a human or a reasoning model. Thresholds depend on risk: showing the wrong screen is fine at 0.6 confidence; executing a payment only at 0.9+.
3. Composite scoring. Break a complex judgment into atomic Scores and combine them with weights in code. Ticket priority = severity * 0.5 + frustration * 0.3 + actionability * 0.2. Priorities changed? You tweak a coefficient, not rewrite a prompt.
4. Intent routing. Classify an incoming request and route it: deterministic code, a cheap model, an expensive reasoning model, or a human.

Pricing and limits (jev-1.13.0)

• $0.042 per million input tokens ($42/Btok); output tokens are free.
• Limits: 250k tokens/sec, 1200 requests/min (dynamic, subject to change).
• Context: 64k tokens per request; state + the longest question - up to 32k (about 150k characters of English text).
• Text only: a string, JSON object, or array. No images, audio, or video.
• The server is in us-west - latency from Europe is higher than from the US.
• jev-latest is an alias for the current version. If you tuned thresholds against a version - pin jev-1.13.0 explicitly: the alias moves with the next release.
• English is the primary training language; other languages work worse. Test separately on non-English content and watch the confidence.
• No fine-tuning - you shape your domain via state and question criteria.

Weak spots (honestly, from their own docs)

jev-1.13 has a published 'jaggedness' page - an honest list of what the model can't do:

• Not a text generator. Don't write texts with it, don't squeeze generation out of chained Choices.
• Bad at math. Arithmetic, counting items, date intervals - do it in code. The model answers semantic questions, not computational ones.
• Reads dates as text. 'Which date comes first' is unreliable. Extract components with Choices (month - 12 options + 'not stated'), assemble the date and compare in code.
• Answers literally - the question you wrote, not the one you meant. Avoid negations and double indirections.
• Context rot. Junk in the state hurts accuracy: filter before sending.
• Invariants aren't guaranteed. Noul 'asks for a refund' and Noul 'asks for something other than a refund' can return 0.72 and 0.47 - summing to 1.19, and that's normal. Don't carry thresholds between question types.
• Adversarial content can shift answers - to the model, state is data, not a threat. Test edge cases before production.

Where to apply

RAG rerankLLM guardrailscitation checkjailbreak detectticket routingmoderationcomplianceML featurescatalog matchingresume scoringlead scoring

A live example: a Bitcoin BUY/SELL/HOLD terminal on Jev - jev-terminal.vercel.app. The API returns honest probabilities, a decision arrives in a fraction of a second.

Another example - instant Generative UI: the json-render + jev experiment - Jev picks from your components, actions, and design system, and the interface renders in milliseconds.

Links

• Console and Playground: console.typesafe.ai
• Docs: docs.typesafe.ai
• Manifesto: typesafe.ai/manifesto