Skip to content

Jev

Summary

Jev is the first "System One Model" from TypeSafe AI (founder Diogo Almeida, ex-OpenAI; released in early access September 15, 2026). It cannot chat, write, or explain — that is the product. You POST unstructured state plus typed questions; it returns typed decisions with calibrated probabilities in one parallel round trip (70-500ms) at $0.042 per million input tokens, output free. Three primitives cover everything: choice (pick from up to 255 options, full probability distribution), score (2-10 level ordered rubric), and noul (calibrated yes/no, 0-1). The bet: most LLM calls in software are small judgments — route this, score that, gate this — that should have been bounded decisions with explicit uncertainty, not parsed prose.

Evaluation

  • Why it's better: Replaces a generative LLM call + parse + validate loop for closed-outcome judgments. Type-safe by construction (output can't break the declared schema — a structural guarantee, not an empirical one), calibrated confidence for abstention policies, latency/cost in the range where high-volume and real-time uses become practical. Independent SREGym-Lite evaluation showed +8 points agent reliability (40% → 48% pass rate) using Jev as a plan-ranker and submission gate.
  • When it fits: Closed outcome sets a human could label quickly: classification/routing, scoring/ranking, guardrails and gates, retrieval relevance, corpus-scale labeling, real-time action selection over text-represented state. The sweet spot: high frequency, low consequence-per-call, fuzzy semantics that a hand-written if can't express.
  • When it does not fit: Anything generative (no prose, code, or summaries); multi-step hidden reasoning (split into atomic questions or use a reasoning model); arithmetic, counting, date comparison, exact string ops (do them in code); extracting unknown values (Jev only chooses among candidates you supply). Irrelevant context degrades accuracy — send minimal state.
Pros Cons
Type errors impossible by construction; answers carry calibrated probabilities + confidence Closed weights, hosted only — no self-hosting, early-access gated
70-500ms end-to-end; $0.042/MTok input, output free — makes 10 queries/sec demos cost ~$7/hour Cannot generate; every use must decompose into choice/score/noul questions
All questions in one round trip, evaluated in parallel and in isolation (no context-rot) "Cannot hallucinate" ≠ always right — it can pick a wrong valid option with high confidence
Code owns the branching: thresholds, escalations, and abstention live in your program Naming trap: jevtypesafeai.com is an unofficial reseller site (higher pricing); official = typesafe.ai
Ecosystem already thick: awesome-jev lists, jev-mcp, LangChain middleware, gateway routes, local clones Calibration is self-reported; must be re-verified on your traffic (RLCD training does not transfer a guarantee)
  • Common Use Cases: Support triage and ticket routing; content moderation gates; LLM guardrails (prompt-injection screening, tool-call risk classification before execution); model routing for agents (fast vs frontier); retrieval relevance filtering ahead of generation; resume/lead scoring; corpus-scale semantic enrichment; SRE agent decision support (SREGym's jev_plan/jev_submit pattern).
  • Licensing & Commercial Use: Closed weights, hosted API only (early access). Pay-per-token: $0.042/MTok input, output free (confirmed by TypeSafe's blog, Vercel AI Gateway listing, and independent write-ups). An unofficial community site (jevtypesafeai.com) resells hosted keys at $0.25-$0.42/M — not official pricing.
  • Ecosystem & Data Connections: Open tooling: awesome-jev curated lists (yibie, 1.3k+ stars), jev-mcp MCP server (jkudish, 290 stars), LangChain Jev integration (guardrail middleware), pi-jev model routers for the Pi coding agent, TypeSafe's system-one-adapter-python. Gateway routes: Vercel AI Gateway (typesafe-ai/jev), with OpenRouter/Cloudflare reported. AnyJev (Nokia Applied Research, Apache-2.0) turns any open LLM into a Jev-style decision model over logit readout with label-free debiasing — the credible self-hosted counterfactual. Simpler clones (von, mini-jev, verdict, go-system-one) mimic the interface without the calibration work. Beacon (Asymptote Labs) uses Jev to rank agent traces for cross-harness skill extraction.
  • Compatibility & Requirements: HTTPS API (api.typesafe.ai/v1/systemone); state is a string, JSON object, or JSON array of text — text only, no images/audio/video. Budgets: ~64K tokens shared across state + all questions; ~32K for state + longest single question. Choice up to 255 options (2-stage scoring above that cardinality's sweet spot); Score 2-10 levels.
  • Latest Versions: Model jev-1.13.0 current; jev-latest (SDK default) tracks stable, jev-preview for previews — responses report the versioned ID, so log and pin it. First release September 15, 2026.
  • Alternatives: LLM structured outputs/JSON-schema modes (flexible, generative, no calibration guarantee); classic ML classifiers (cheap, need labeled training data per task); embeddings similarity (finds related text, doesn't decide relevance); AnyJev — any open LLM + logit readout with cyclic-shift and prior corrections (self-hosted, Apache-2.0; on Laya's benchmark a Qwen3-32B + AnyJev L1 lands 2.8 accuracy points behind Jev 1.13.0 with 4x better calibration); simpler clones (von sub-15ms non-autoregressive, mini-jev on a local LLM, verdict on llama-server) — raw-logit readouts without the debiasing work; sibling System One models emerging (CUA-S1 for computer use).
  • Migration & Lock-in Risks: Questions/criteria are program logic — version them like code for replay. Lock-in is real but softer than it looks: the interface (state + typed questions + distributions) is now reproduced by AnyJev over any open LLM — Nokia's measurements put an AnyJev L1 Qwen3-32B within ~3 accuracy points of Jev 1.13.0 with materially better calibration, at the cost of K prefills per choice and your own serving stack. Pin model versions; thresholds tuned on one version may not transfer.
  • Community Health: Fast-growing and contested. TypeSafe ships unusually honest nuance (subsidy caveats, eval-bias disclosures, per-version "jaggedness" pages). Latent Space interview (Diogo Almeida), independent deep dives (flaviocopes, forkast), skeptical posts (poker-table analogy), local clones within weeks. 1,100+ stars on Beacon; curated lists crossing 1k stars within a month. Watch: independent calibration studies are still thin.

FAQ

  • Is Jev just a small LLM? TypeSafe says no — new architecture with a parallel sampler that emits all answers in one hardware-aware query, trained with RLCD rather than RLHF/RLVR. The FAQ on the announcement post rebuts the "smaller LLM" framing directly; the architecture is not published in detail, so this remains a vendor claim.
  • Can it replace my LLM calls? No — it replaces the judgment-shaped subset: closed-outcome questions that need a calibrated answer. Anything generative, arithmetic, or multi-step stays with your LLM and your code. The architectural trade (DDDS): the LLM plans and writes; Jev routes, gates, checks, escalates.

  • Why "Jev"? William Stanley Jevons — the Jevons paradox: cheaper intelligence (like cheaper steam-engine coal) increases total demand. The model class name comes from Kahneman's System 1 / System 2 distinction.

  • Can I run it locally or offline? Jev itself: no — closed weights, hosted only. For a self-hosted equivalent, AnyJev reproduces the interface over any open LLM with proper debiasing/calibration (within ~3 accuracy points of Jev 1.13.0 on Nokia's benchmark, better calibrated); simpler clones (von, mini-jev, verdict, go-system-one) mimic the API shape without the calibration work.

Notes In This Folder

  • Architecture — System One concept, RLCD, primitives, parallel sampling, type-safety guarantee, workflow evals
  • Operations — API quickstart, gateways, patterns (routing, guardrails, SRE gates), rollout procedure, limits
  • Security — schema-safety vs judgment, calibration drift, supply chain and the reseller trap, data flow

Sources

All URLs verified HTTP 200 on 2026-09-23.

Questions

  • Does RLCD-trained calibration hold on third-party traffic at scale? (Only self-reported + one SREGym experiment so far — TBD)
  • Will OpenRouter/Cloudflare gateway routes reach parity with the Vercel route? (reported, not yet independently confirmed)
  • Can the reseller ecosystem (jevtypesafeai.com and similar) be trusted with API keys and state payloads? (TBD — treat as untrusted)
  • How does Jev behave as a prospective safety reviewer for destructive agent actions? (SREGym lists it as unrun future work)