Jev is TypeSafe AI's "System One" model, launched September 15, 2026: instead of generating text, it returns typed decisions — a choice, a score, or a yes/no probability — for questions you attach to a piece of text or JSON state. Founder Diogo Almeida (ex-OpenAI, worked on ChatGPT research) built it after two years in stealth; the company came out with a $40M seed round led by DCVC. It answers in roughly 70–500 milliseconds at $0.042 per million input tokens with output free — and the reason it's viral is the economics, not just the speed: when a decision costs a fraction of a cent, software starts making far more of them.
llm-typesafe plugin for his LLM CLI the next day.
Current model facts (September 2026). The production alias jev-latest resolves to jev-1.13.0. Context: 64K tokens per request (32K for state plus the longest single question). Input is text only — a string, a JSON object, or an array. TypeSafe states Jev is not trained on customer requests and is not fine-tuned per account; you shape behavior with instructions in the request.
| Primitive | What it returns | Example |
|---|---|---|
| Choice | Picks exactly one option from up to 255, with a probability per option | "Is this support ticket critical?" → Critical / Normal / Low |
| Score | A numeric rating on a defined scale | Churn risk on 0.0–1.0 |
| Noul | Yes/No with a probability | "Does this text contain personal data?" → 0.92 |
All three can be combined in one API call and evaluated in a single forward pass — ask 20 questions about the same input and get 20 typed answers back at once. No token-by-token generation, no autoregressive loop. That's the source of the speed. Week-one builders used it to route support tickets, classify papers, and play Doom.
Honesty note on the big numbers. The "20–200x faster, 40–400x cheaper than LLMs" figures are TypeSafe's own launch evaluations and have not been independently validated across broad production workloads. Treat them as the company's claim, not a benchmark.
| Top answer | What it lacks |
|---|---|
| Medium — "What Is Jev? TypeSafe AI's Decision-Only Model, Explained" (Sept 22, 2026) | Good plain-English explainer; reports the 140k waitlist and GitHub reimplementations. No code, no production pattern, no pricing math, no payment layer. |
| dev.to — "TypeSafe AI Jev: An AI model that doesn't generate text" (Sept 18, 2026) | Best primitives table of the bunch. Repeats the 20–200x / 40–400x claims without noting they're the company's own evals. No DIY, no economics. |
| KuCoin — "What Is Jev AI? TypeSafe's System One Model Explained" | Encyclopedic; pins jev-1.13.0 and the 64K context correctly. No code, no dated claims, no confidence-gate pattern, no economics of decision pricing. |
| codewithnishant — "Jev by TypeSafe AI: The AI That Decides, Not Writes" (Sept 21, 2026) | Best week-one recap; the $0.042 vs GPT-5 Nano $0.05 comparison is useful. No production code, no payment angle — the part that actually matters to builders. |
Here's the angle every explainer misses. Jev is named for the Jevons-paradox insight its own launch materials lean on: make a decision cheap enough and software starts making far more of them. A 1,000-token decision at $0.042/M input tokens costs about $0.000042 in model cost — a fraction of a cent per call, exactly as the launch coverage puts it.
That flips the business model. When each decision is a sub-cent event, subscriptions and API keys stop making sense — every decision is a billable event, and the native way to charge for it is per-call micropayments with no accounts, no keys, and no checkout. That is precisely the job x402 was built for: the server answers an unpaid request with a 402 Payment Required challenge (price, asset, network, payTo), the buyer's wallet signs and retries, a facilitator settles on-chain.
curl https://squeezeos-api.onrender.com/.well-known/x402 → operator SCRIPTMASTERLABS, network eip155:8453, asset USDC, payTo 0xc29185fa176357612f3194735753e520e91adc46, facilitator https://api.cdp.coinbase.com/platform/v2/x402, PAYMENT-REQUIRED / PAYMENT-SIGNATURE / PAYMENT-RESPONSE headers. (Verified live September 22, 2026.)The pattern every serious Jev integration converges on — it's in TypeSafe's own launch materials and it's how builders are actually wiring it:
confidence >= 0.80 → AUTO-ACT (no human in the loop)
0.50 – 0.79 → ADVISORY (show a human the decision + evidence)
< 0.50 → ESCALATE (a human decides; log it for review)The same banding shows up in the wild: an open-source voice-marketplace project gates allow/challenge/block at 0.9+ / 0.4–0.7 / <0.4, and Vercel's AI Gateway pitch for Jev is exactly "automate high-confidence cases while sending uncertain ones for review." In code:
def route(decision):
c = decision.confidence
if c >= 0.80:
return auto_act(decision) # no human in the loop
if c >= 0.50:
return advisory(decision) # human sees decision + evidence
log_for_review(decision) # < 0.50: your future training data
return escalate(decision)Production note: pin jev-1.13.0, don't float on jev-latest — the alias moves when TypeSafe ships new models, and your tuned thresholds move with it.
curl -X POST "$TYPESAFE_API_URL" \
-H "Authorization: Bearer $TYPESAFE_KEY" \
-H "Content-Type: application/json" \
-d '{
"state": {"ticket_text": "Checkout 500s after I pay", "plan": "pro"},
"questions": {
"severity": {"type": "choice", "options": ["critical","normal","low"]},
"churn_risk": {"type": "score", "scale": [0.0, 1.0]},
"mentions_billing":{"type": "noul"}
}
}'payTo, and expiry; verify the buyer's signature through a facilitator; settle on-chain; return the decision with a payment receipt. Pricing math: ~$0.000042 model cost per 1K-token decision means 2–10x cost pricing still lands under a tenth of a cent per decision. Seller walkthrough: how to monetize an MCP server with per-call x402 billing.Q: What is the Jev model?
A: Jev is TypeSafe AI's "System One" decision-only model, launched September 15, 2026. You send it text or JSON state plus questions with predefined answers; it returns typed decisions — Choice, Score, or Noul (yes/no) — with probabilities, in roughly 70–500ms. No text generation, no token stream.
Q: How much does Jev cost?
A: $0.042 per million input tokens; output is free. A 1,000-token decision costs about $0.000042 in model cost — which is why per-decision x402 micropayments are the natural billing unit.
Q: Is Jev an LLM?
A: Not a generative one. TypeSafe calls it a "System One" model: it reads language but only makes fast, structured decisions software can branch on. Simon Willison calls the category "decision models" — and flags the tradeoff: all you get back is a floating-point number, which is hard to interrogate.
Q: How do you use Jev in production?
A: With a confidence gate: ≥0.80 auto-act, 0.50–0.79 advisory to a human, <0.50 escalate and log. Pin jev-1.13.0 rather than floating on the jev-latest alias.
Q: How do you charge per decision for a decision model?
A: Per-call x402 billing: unpaid requests get a 402 challenge with price, asset, network, and payTo; the buyer's wallet signs and retries; a facilitator settles on-chain. At sub-cent model costs, per-decision prices in the 2–10x cost band are still under a tenth of a cent.
Truth First. Proof Always. Pay Only for Accepted Delivery.