What Is Jev? TypeSafe AI's System One Model vs GPT/Claude, Pricing Math and How to Pay (2026)
Jev does not write text or chat. It answers questions you define in advance with typed values and probabilities (plus confidence for Choice and Score). Where it fits, where it does not, what it costs at the official rate, and how to pay if your card is declined.
1. What Jev is, in one paragraph
Jev is the first public System One model from TypeSafe AI, announced on September 15, 2026. The launch post describes it as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out. It does not generate text. You send a state — a support ticket, a message, a record, as text or JSON — plus a set of questions, and you define each question's allowed answers up front. Jev returns an answer inside that defined space for every question, along with probabilities: Choice and Score return a probability per option and a confidence score, while Noul returns a single probability between 0 and 1. The post is written by Diogo Almeida, TypeSafe's founder, who says that at OpenAI he helped build the methods that made language models useful at following instructions and talking with people. The names are explained too: "System One" borrows from Kahneman's fast thinking in Thinking, Fast and Slow, and "Jev" is named after the economist William Stanley Jevons.
2. How it differs from GPT, Claude and other chat models
The difference is not "smarter or dumber" — it is a different training target and a different output shape. Chat models are optimized with methods like RLHF for answers humans prefer, and they emit strings token by token; software has to parse and validate those strings, and there is always some risk of the output going off the rails. Jev is trained with TypeSafe's own method, RLCD (Reinforcement Learning for Calibrated Decisions), aimed at probabilities that are honest — in TypeSafe's words, higher confidence means higher accuracy. Sampling is parallel: one call returns every probability for every question at once. Three practical consequences follow: (1) output types are guaranteed by the schema, and TypeSafe says the model never makes type errors; (2) every answer carries probabilities (Choice and Score also return confidence), so your code can set thresholds for acting automatically versus escalating to a human; (3) adding more questions to the same call barely changes response time. The flip side: it cannot do what chat models do. TypeSafe's docs state plainly that Jev is not a drop-in replacement for the LLM behind Claude Code, Cursor and similar tools. Keep your coding assistant on an LLM, and call Jev from the software you build wherever it needs a decision.
3. Three question types, all in one call
The API exposes three question types, which the docs call primitives. Choice selects one option from your list and returns the choice, a probability per option and confidence. Score rates the state against ordered levels you write, returning a score, per-level probabilities and confidence. Noul evaluates whether a statement is true and returns a probability between 0 and 1. All three can be mixed in a single request, and each question is evaluated independently and in parallel against the same state. TypeSafe recommends atomic questions: instead of "rate this startup pitch", ask separately about market size, feasibility and differentiation, then combine the scores with your own weights in code — when priorities shift you change a coefficient, not a prompt. Below is a minimal request in the format of the official quick start; treat the official API reference as the source of truth for the endpoint and fields.
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "Order #1042 arrived damaged. I need a refund before Friday.",
"questions": {
"team": {
"type": "choice",
"instructions": "Which team should handle this message",
"criteria": {
"refund": "Refund or return requests",
"shipping": "Delivery problems without a refund request",
"other": "Anything else"
}
},
"is_urgent": {
"type": "noul",
"instructions": "The message conveys urgency or time-sensitivity"
}
}
}'4. What it is good for
TypeSafe positions Jev for AI-powered workflows, or "smart if-statements": places where hand-written rules are too brittle but generating text with an LLM is overkill. Jev makes a structured call and the surrounding code constrains and composes it. Use cases named in the launch post and docs include intent classification and routing of tickets and requests (send to deterministic logic, a specialist LLM or a human depending on confidence); scoring content on your own rubric (urgency, quality, risk); scoring retrieved RAG passages before they reach the answering model; checking whether a citation is supported by its source; guardrails and jailbreak detection on LLM inputs and outputs (TypeSafe also notes that adversarially written content can move answers — see item 5 in the next section); and map-reducing large datasets into features. TypeSafe even showed it playing Doom (on game state as structured text, not on images) in real time at 10 queries per second, which the post puts at roughly $7 per hour. High-frequency, low-latency, one-decision-per-call workloads are where it separates from chat models.
5. What it is not good for — TypeSafe's own list
The docs include a page on known jagged edges of jev-1.13 (marked as reviewed on 2026-09-17), and it is worth reading before you integrate. In short: (1) math and counting — do not ask it to do arithmetic, count items or compare hex colors; do that in code; (2) date and time comparison — it reads dates as text, so extract the parts and compare in code; (3) literal reading — it answers the question you wrote, not the one you meant, so put boundary cases into the criteria; (4) indirection and large states full of irrelevant detail both reduce accuracy — filter first; (5) adversarial content — jev-1.13 treats state as data, not as hostile by default, so injected instructions, deliberately misleading framing or text that argues for its own classification can move the answer; TypeSafe expects to improve this, and advises explicit criteria and thorough edge-case testing before deploying; (6) generation — use a generative model for writing and code. Three hard limits as well: input is text only (string, JSON object or array of text values), so images, audio and video must be converted first; context is 64k tokens per request, of which state plus the single longest question may use at most 32k; and English is the primary training language — other languages, including CJK, are handled but not equally well, so test on your own non-English data and watch the confidence scores.
6. Pricing, with a worked example at the official rate
Official pricing: input at $0.042 per million tokens ($42 per billion), output not billed. The sample request in the official quick start — one support ticket and three questions — reports 392 input tokens. At that size, one call costs about 392 × 0.042 / 1,000,000 ≈ $0.0000165, and one million such calls use about 392 million input tokens, or roughly $16.50. Your real cost depends on how long your state is and how detailed your questions are; check the usage field on your own requests before you budget. Two caveats belong next to that number. First, the homepage headline "193.6x Faster, 444.6x Cheaper" comes from TypeSafe's own workflow evals on System One tasks, and the launch post says these are expected to be on the higher end of real-world gains — do not budget from the headline. Second, on sustainability: the September 15 launch post says TypeSafe cannot prove the pricing is not subsidized, that the long term will have to prove it, and that it expects prices to go down rather than up; the homepage FAQ ("Are these prices temporary or subsidized?") now says TypeSafe can serve Jev profitably at current prices and aims to make intelligence more affordable over time.
7. Speed: the conditions behind 70ms–500ms
TypeSafe quotes 70ms–500ms end to end, and notes that its published evals are generally run from the US West Coast, which is also where the service is currently based. Calling from Europe or Asia adds network round-trip time on top, so measure from your own region. The docs list rate limits of 100K tokens per second and 40 requests per second, with a warning that limits are adjusting dynamically under heavy demand; higher limits are offered on custom and enterprise plans. For batch work, back off on 429 responses — the official Python SDK retries with backoff by default, and direct HTTP callers need to handle it themselves.
8. How to sign up
Jev launched in early access on September 15, and the launch post says TypeSafe is bringing developers off the waitlist as quickly as it can. The homepage FAQ now says Jev is available to everyone: create an account at console.typesafe.ai. The entry points you can verify on official pages: the console at console.typesafe.ai (after signing in, the Playground lets you paste text and add questions without writing code); API keys are created in the console; the endpoint is POST https://api.typesafe.ai/v1/systemone; the Python SDK installs with pip install typesafe-sdk and defaults to jev-latest. What information sign-up asks for is not published — go by what the console shows you. Billing terms can be checked in section 8.2 of TypeSafe's Master Customer Agreement (typesafe.ai/legal/mca): using the service requires Credits, which are consumed by each input you submit; Credits are not redeemable, refundable or transferable; unless your order says otherwise, Purchased Credits expire at the end of the term or 12 months after purchase, whichever comes first; and Promotional Credits are issued at TypeSafe's sole discretion, with no obligation to issue them. So do not assume a free allowance, and buy roughly what you expect to use. TypeSafe's terms also state that the site makes no representation that it is appropriate or available outside the United States, so confirm your use complies with their terms and your local laws before signing up.
9. Paying when your local card is declined
One common cause of declines at overseas SaaS and API checkouts is the card's issuing country, which the acquirer reads from the first digits of the card number (the BIN). A card issued outside the US can carry a Visa or Mastercard logo and still fail cross-border risk checks. A common approach is a US-issued virtual card: sign up for cocodot, top up your wallet, issue a US Visa or Mastercard virtual card, and move funds from the wallet onto the card — wallet balance and card balance are separate, and money not moved onto the card cannot be charged. At TypeSafe's checkout, enter the card number, expiry and CVV, and use a complete address that is genuinely yours (the card is not tied to a personal address, and there is no address on the card page to copy); keep using the same one for the same merchant account, and do not use an address found online, someone else's, or a made-up one. Charges appear on the card statement as TYPESAFE AI, INC. cocodot has a recorded successful charge at this merchant on a US-issued virtual card, but issuer and merchant risk rules change and no card can guarantee that every charge goes through. If a charge fails twice in a row, stop and check balance, address and card status rather than retrying repeatedly. Payment methods and billing cycles are whatever the TypeSafe console shows.
10. Two things to be clear about
First, cocodot's API relay does not currently include Jev — to use Jev, sign up and call it directly through TypeSafe's official console; cocodot's role here is the US-issued virtual card you pay with. Second, many claims about valuation, view counts and repository stars have circulated since launch; we could not trace them to official sources, so this page does not repeat them. Every Jev fact here comes from the launch post on typesafe.ai, the TypeSafe homepage, docs.typesafe.ai and TypeSafe's legal documents (Master Customer Agreement and Terms of Use) as of early October 2026 — prices, limits and model versions may change, so check the official pages for the latest.
Jev vs chat LLMs at a glance (every Jev cell comes from TypeSafe's own pages)
| Jev (System One model) | Chat / generative LLMs | |
|---|---|---|
| Output | Typed answer defined in advance + probabilities (Choice / Score also give per-option probabilities and confidence) | Free-form text that must be parsed and validated |
| Sampling | Parallel: all probabilities for all questions in one call | Sequential, one token at a time |
| Training target | RLCD: calibrated decisions | RLHF / RLVR: human preference, verifiable rewards |
| Billing | Input $0.042 per M tokens, output free | Input and output billed separately, varies by vendor |
| Latency | 70ms–500ms end to end | 3–329 s for frontier models, per the figure TypeSafe cites |
| Good for | Classify, route, score, extract, yes/no, guardrails | Writing, coding, chat, agents |
| Not for | Generating text, arithmetic and counting, date comparison | Many decisions inside code (TypeSafe's view: overconfident, inconsistent, a bottleneck when integrated in code) |
| Input | Text only (string / JSON / array of text), 64k tokens per request; 32k for state plus the longest question | Depends on the model |