TypeSafe AI's flagship System One model — send a state and a batch of typed questions, get back structured answers with calibrated probabilities. Your code branches directly. No parsing. A fraction of LLM cost.
The name comes from Kahneman's Thinking, Fast and Slow. LLMs are System 2 — brilliant at generation, slow and costly when used as classifiers, and their output must be parsed. Jev is the first System One model: it only makes fast, structured judgments, with probabilities that are calibrated (events it scores 0.8 happen about 80% of the time).
RLHF produced chatbots, RLVR produced reasoners. TypeSafe trained Jev with RLCD (RL for Calibrated Decisions) to output "decisions + calibrated probabilities" instead of text. CEO Diogo Almeida co-invented RLHF (InstructGPT).
All questions in a request are evaluated in parallel and in isolation in a single forward pass. Output tokens are free and latency is measured in milliseconds. In the wild: 11 questions, one call, ~0.3s and ~$0.0002.
TypeSafe's bet: 99% of future AI automation is machine-to-machine. Questions must be atomic (what an expert judges in seconds); complex judgments split into many questions, with weighting logic living in your code.
Every question has three parts: an id (for your code only, never sent to the model), instructions (what to judge), and criteria (the options or scale). Mix all three types in one request — adding questions barely changes latency.
Selects one option from a fixed list. Returns choice + probability per option + confidence. Built for routing and classification: ticket dispatch, document types, intent detection. Answers are always constrained to your options.
Positions the state along an ordered scale. Returns a score (can fall between two levels) + distribution + confidence. Fits severity, frustration, quality grading — you define what each level means.
Returns the probability of yes (0–1). Ideal when the probability itself is the signal: is this a refund request, does this contain a bug report. Note: Noul has no separate confidence field — the probability is the signal.
Current version jev-1.13.0, alias jev-latest. You pay for input tokens only; output is free.
| Item | Spec |
|---|---|
| Price | $42 / Btok ($0.042 / Mtok), input-only billing, output free |
| Rate limits | 250,000 tokens/sec · 1,200 requests/min (officially "adjusting dynamically") |
| Context | 64k total budget; state + longest question ≤ 32k (~150k chars of English) |
| Input | Text only: string / JSON object / array; no image, audio or video |
| Languages | English is most accurate; CJK including Chinese works but with lower accuracy — test on your own data |
| Customization | No per-customer fine-tuning; domain adaptation via state content, criteria rules, and code-side weights |
Grab an API key at console.typesafe.ai — one POST and you're running.
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" -d @- <<'EOF'
{
"state": "Our Stripe integration has been
failing for 3 days and we can't ship
any orders!",
"model": "jev-latest",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should
handle this",
"criteria": {
"billing": "Payment issues",
"technical": "Bugs / integration",
"sales": "Pricing questions"
}
},
"is_urgent": {
"type": "noul",
"instructions": "Does this convey
urgency?"
},
"frustration": {
"type": "score",
"instructions": "How frustrated is
the customer",
"criteria": ["Calm", "Frustrated",
"Very angry"]
}
}
}
EOF
# Response: typed answers, ready for code
{
"answers": {
"department": {
"choice": "technical",
"probabilities": {
"technical": 0.93,
"billing": 0.05, "sales": 0.02 },
"confidence": 0.88
},
"is_urgent": { "noul": 0.999 },
"frustration": {
"score": 1.62, "confidence": 0.79 }
},
"usage": { "input_tokens": 312 }
}
High-frequency recipes from the official Patterns docs — split big judgments into atomic questions, keep composition in code.
Send every question you might need in a single call (including speculative ones) and let code pick what's relevant. They run in parallel and cost pennies — err on the side of more.
Confidence is a second decision axis: high → act automatically, medium → ask for confirmation, low → escalate to a human. Thresholds scale with risk — 0.9+ for transfers, 0.5 is fine for read-only.
Split complex ratings into several Scores (bug severity × customer sentiment × reproducibility) and combine with weights in code. Tune weights by editing code, not prompts.
Choice-classify the user's intent, then route to deterministic code, a specialist LLM, or a human — so 90% of simple requests never touch a big model.
TypeSafe publishes the jaggedness list for jev-1.13 — rare candor in this industry, and essential reading for using it well.
Projects that appeared within a month of launch (stars snapshotted mid-September 2026).
Semantic ifs from open models, running on a local 3090. Independent project.
Official curated list: use cases, patterns, prompts and starter code.
Staged code-review workflow and local dashboard built on Jev.
Jev agent playing Super Mario Bros. from structured emulator state.
Postgres extension: ask your tables questions in plain language.
Browser automation driven by Jev — operation and target in one round trip.
Ongoing public tracking of Jev and the System One space.
SemIf, pg-jev, jev-review, typesafe-mario, foreman and more appear in quick succession; open-source replicas follow (mini-jev, Qwen-2.5-1B-RLCD).
lindfors.no ran 24 Norwegian hearing letters through Jev: 0.31s, ~$0.0002 per call. Key finding: the questions it got wrong were precisely the ones with lowest confidence — the uncertainty signal is trustworthy.
"Introducing System One Models and Jev" tops Hacker News. The real-time Doom demo sparks debate alongside latency-comparison critiques. Official response: coding scenarios (state engineering) not yet started.
jev-1.13.0 ships at $42/Btok with free output, alongside docs, Python/JS SDKs, four Patterns and a Playground.
No — and it isn't trying to. It complements the generative layer: LLMs generate, Jev handles routing, verification, scoring and gating — the thousands-of-times-per-second micro-judgments. Confidence gating decides when to escalate to an LLM or a human.
Three words: fast, cheap, calibrated. Single forward pass returns in milliseconds; $0.042/Mtok undercuts the cheapest chat models by an order of magnitude; probabilities are the training objective, not a byproduct — with a ready-made confidence score for gating.
Intent routing, moderation, ticket triage, RAG re-ranking, risk scoring, agent action gating, extraction validation — any judgment point too fuzzy for rules and too expensive for LLMs.
English is by far the most accurate. Other languages including CJK work but with lower accuracy — validate against your own data before production, and lean on confidence thresholds for fallback routing.