Jev API: What TypeSafe's System One Model Is, What It Costs, and When to Use It

What Jev actually is

TypeSafe introduced Jev on September 15, 2026 as the first "System One model." The framing comes from Kahneman's Thinking, Fast and Slow: current LLMs behave like a reasoning, deliberative system, and TypeSafe is building the fast, intuitive half — except "intuition" here means a calibrated probability distribution over answers, not a gut feeling rendered as text.

The name is a Jevons reference, and the pitch is that a fast, low-cost decision primitive gets called far more often than an expensive one.

The mechanical differences from an LLM are what matter for engineering:

• The output is typed. You declare the shape of the answer up front — a Choice over enumerable options, a Score over descriptive levels, or a Noul (yes/no) with a probability. There is no free-form text to parse, and matching the schema is a property of the architecture rather than something you hope the model complies with.
• You get probabilities, not just a pick. A Choice returns the selected option plus a probability for every option and a separate confidence value. That is what lets you route on uncertainty: act above a threshold, fall back to a bigger model below it.
• Questions run in parallel. Jev ingests the state once and evaluates every question in the request against it at the same time. Asking thirty questions instead of one adds very little wall-clock time, which is what makes the batch-classification use cases below possible.
• It is narrow on purpose. TypeSafe's guidance is to keep control flow in your code and give Jev atomic, structured decisions rather than one large judgment call.

A minimal request looks like this:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Help! My payouts have been failing for 3 days.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "Does this convey urgency?" }
    }
  }'

Jev specifications at a glance

Specification	Jev 1.13
Model ID	jev-1.13.0
Aliases	jev-latest, jev-preview (both resolve to 1.13 today)
Endpoint	POST https://api.typesafe.ai/v1/systemone
Price	$42 per billion input tokens / $0.042 per 1M
Output pricing	Free — billed on input only
Rate limits	250,000 tokens/s and 1,200 requests/minute, stated as dynamic
Context length	64k per request (state plus all questions); 32k for state plus the longest question
Input types	Text: string, JSON object, or array. No image, audio, or video
Output	Typed Choice, Score, and Noul answers with probabilities and confidence
Client SDKs	Python typesafe-sdk, JavaScript @typesafe-ai/sdk
Custom weights per account	No. Jev is not fine-tuned or LoRA-adapted with customer data
Training data from customers	No. Requests and responses are not used for training

Where Jev fits, and what TypeSafe says to keep in code

TypeSafe also publishes the scope of jev-1.13 in detail: nine areas, each with the pattern it recommends instead, last reviewed September 17, 2026.

#	Area	TypeSafe's guidance
1	Literal reading — it answers the question you wrote, not the one you meant	State the exact condition; put boundary cases in the criteria
2	Math and numbers — it is not a calculator and does not count reliably	Keep arithmetic and counting in code
3	Date and time comparison — dates are read as text, not ordered quantities	Extract components; compare in code
4	Indirection — double negatives and multi-hop questions cost accuracy	Reduce hops; point directly at the relevant state
5	Large state full of irrelevant detail	Filter first; send only what the question needs
6	Adversarial content	Write precise instructions and test edge cases before deploying
7	Contradictory instructions and criteria	Align the instruction and the criteria
8	Common-sense structural invariants	Ask each decision one way; enforce identities in code
9	Generation	Use a generative model

Two of these matter most in practice. First, counting: the documentation states plainly that jev-1.13 "does not count reliably" — characters in a word, occurrences in a passage, items in a long list — and that the error grows with the size of the thing being counted. Second, generation: Jev will not write your summary, your reply, or your commit message. It decides; something else writes.

TypeSafe's own recommended pattern for counting shows the intended division of labor: iterate over candidates in code, ask one Noul per candidate, and add up the answers yourself.

Where the headline numbers come from

Two numbers travel with almost every Jev discussion. They come from different sources and describe different things.

0.7 seconds. Every published a piece titled "TypeSafe's Jev Judged Everything I've Written in 0.7 Seconds." Build indexes that catalog that write-up describe it as 777 judgments across 37 articles. We could not load the full article body to confirm its cost figure, so treat the per-run cost quoted around that demo as the author's own measurement rather than a published rate.

724 ads, 40 seconds, about 9 cents. This one is documented twice. The build page madewithjev.com — 724 competitor ads, broken down states that 724 live ads from 37 brands were analysed in about 40 seconds. The author's post on X (September 17, 2026) adds the cost — "used 9 cents of tokens" — and lists the dimensions extracted per ad: hook, format, offer, CTA, awareness stage, and landing-page mismatch.

The distinction between the two is worth keeping: 0.7 seconds is the model's evaluation time on a paragraph-scale corpus, while 40 seconds covers fetching and processing 724 live ads. Neither number is a throughput guarantee for your workload.

What the community is building with it

Jev's adoption is unusually easy to inspect, because almost everything published in the first week is open source. Star counts below were read from the GitHub API on September 20, 2026.

Browser and computer use. browser-use/jev-ultrafast (★10,113) comes from the browser-use organization and is the project that set the tone. It exposes a fixed action space (CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, BLOCKED) and asks Jev to choose both the operation and the target element. Both decisions go into a single TypeSafe request, with the target question marked speculative. Only TYPE_TEXT calls a text model, and the README's own example uses a small one. Its demonstration task — Zürich to London on Google Flights — is quoted at 7.1 seconds including text generation and page loads. There are no site-specific scripts.

Coding-agent context compression. tamaratran/fast-jev-compaction (★4,544) decides which tool results in a coding-agent transcript are still worth keeping, so a long session can be compacted without a full summarization pass. Ports and variants exist for other agent harnesses.

Agent guardrails. DevMortimer/pi-warden (★99) and shiftynick/jev-axi (★17) both put a judgment in front of every command or tool call: ask first, block the dangerous ones. This is the pattern where "calibrated probability plus a threshold in your own code" is genuinely better than a text answer you have to interpret.

Model routing. vinilana/jev-gateway (★61) routes simple requests to a low-cost tier and escalates only the hard ones. It is the most direct expression of TypeSafe's own argument — that a decision can cost a fraction of the generation it gates.

Games and control demos. fhshaik/typesafe-mario (★289) plays Super Mario Bros. from structured emulator state, and RomanSlack/jev-drone (★81) runs a drone control loop in MuJoCo. These spread far faster than they ship; treat them as demonstrations of the interface, not as evidence about production reliability.

Open reproductions. This is the most interesting thread for anyone who wants the capability without a new vendor. TheoLeeCJ/SemIf (★2,123) runs an open model on a single RTX 3090 at home and is explicit that it is independent of TypeSafe. TianyuCodings/NanoJev (★1,175) is a small-scale reproduction. convaiinnovations/laya is an Apache-2.0, commercially usable encoder with RLCD-trained decision heads, published under the system-one and calibrated-decisions tags, with an accompanying runner in receptron/laya. None of these are Jev, and the benchmark charts they publish are their own; the point is that the shape of the model is reproducible.

Batch classification. The ad teardown above is the flagship example, and it is the pattern most likely to survive contact with production: hold the state fixed, ask many narrow questions in one request, and read probabilities.

Is Jev actually cheaper than a low-cost LLM?

Not per input token, and this is the part most write-ups skip. Jev charges $0.042 per 1M input tokens. On APIMaster, gpt-5.6-luna is on sale from $0.022 per 1M input tokens — roughly half of Jev's input rate — with glm-5.3-flash at $0.105 and deepseek-flash at $0.15. The cheapest hosted generative models already undercut Jev on input price.

Jev's cost argument rests on three other things:

• No output tokens. The cheapest generative model still emits text for every judgment, and output is priced several times higher than input. Jev returns a probability and stops.
• Latency. TypeSafe publishes end-to-end response times of 70ms to 500ms and describes the comparison against frontier models on System One-shaped queries as 40× to 200× faster. Speed is what lets a decision run inside a request path instead of behind a queue.
• Marginal questions are nearly free. Because questions fan out in parallel over one state, the tenth question costs a fraction of what a tenth API call would.

Whether that wins depends on your workload. If your judgments are few, long, and benefit from reasoning, a low-cost LLM with structured output is the better buy. If you make many short judgments per unit of work, or you need the answer before a user notices a pause, the arithmetic changes.

Can you call Jev with an OpenAI-compatible key?

Not against TypeSafe's own endpoint, and the difference is structural rather than a matter of configuration:

• Different route. TypeSafe documents one evaluation endpoint, /v1/systemone, and a /v1/models listing. There is no documented /chat/completions.
• Different body. The request carries state and a map of typed questions. An OpenAI-style body carries messages and expects generated text back.
• Different response. You receive probabilities and confidence values keyed by the question names you chose, not a completion string.

Against the vendor API, making an OpenAI-compatible client talk to Jev means writing a translation layer for both directions — which is what the community gateways in the routing section above do. Jev is in onboarding on APIMaster, and this page will be updated once the integration is live. Until then, the live option for a fast judgment on an OpenAI-compatible endpoint is one of the low-cost tiers below.

What to run today when you need fast judgments

If what you actually need is a judgment call from an existing OpenAI-compatible endpoint, the practical question is which low-cost tier to send it to. Live APIMaster routes as of September 20, 2026:

Model ID	On-sale routes	From (input / output per 1M)	Reference list price	Approx. discount
gpt-5.6-luna	3	$0.022 / $0.134	$0.20 / $1.20	~89% off
glm-5.3-flash	3	$0.105 / $0.35	$0.15 / $0.50	~30% off
deepseek-flash	1	$0.15 / $0.60	Same as DeepSeek off-peak	No markup
gpt-5.6-terra	15	$0.12 / $0.72	$2.00 / $12.00	~94% off
gemini-3.8-flash	7	$0.20 / $1.00	$1.50 / $7.50	~87% off

Jev itself is still in onboarding at the time of writing; the tier below is what to run in the meantime. Three notes on reading that table. Prices are the lowest route on sale at the time of checking, and different routes for the same model carry different prices — open the model card before you commit volume. deepseek-flash is priced at DeepSeek's own off-peak rate, so the honest statement is "no gateway markup," not a discount. And a lower input price is not automatically the cheaper choice: output length, cache-hit behavior, and retry rate usually dominate the final bill.

A workable division for a Jev-style pipeline on a single key:

1. Put the narrow, high-frequency decision on a small, low-cost tier and gate on your own confidence threshold.
2. Escalate only the cases that fall below that threshold to a stronger model.
3. Keep counting, arithmetic, and date comparison in your own code — the same advice TypeSafe gives, and it applies to every model in the table.

Create an APIMaster account, add pay-as-you-go credit from $1, create a key in the console, and point an OpenAI-compatible client at https://apimaster.ai/v1 with any of the model IDs above. One key covers the GPT, GLM, DeepSeek, Gemini and Claude families, so the escalation path in step 2 stays on the same integration. Validate a route with the model tester before you move production traffic.

FAQ

What is Jev? Jev is TypeSafe AI's System One model. It takes a state plus a map of typed questions and returns calibrated probabilities — Choice, Score, and Noul answers — instead of generated text.

Is Jev a language model? Not in the way the term is normally used. It does not generate prose. It evaluates text you provide and returns structured decisions with probabilities and confidence values.

What is the Jev model ID? jev-1.13.0. The aliases jev-latest and jev-preview currently resolve to the same version; the SDKs default to jev-latest.

How much does Jev cost? $42 per billion input tokens, which is $0.042 per 1M input tokens. Output tokens are free, and billing is on input only.

Is Jev OpenAI-compatible? Not on TypeSafe's own API. It uses a dedicated POST /v1/systemone endpoint with a state plus questions body and returns probabilities rather than completions, so an OpenAI-style client cannot call it unchanged. Jev is in onboarding on APIMaster, and this page will be updated once the integration is live.

Is Jev available on APIMaster? Not on sale yet — Jev is in onboarding on APIMaster, and this page will be updated once the integration is live. In the meantime, the low-cost text tier you would pair with a decision layer is already available; see the live cards for gpt-5.6-luna, glm-5.3-flash and deepseek-flash.

Does Jev support Chinese and other non-English languages? TypeSafe states that English is the primary training language and where accuracy is currently best, and that other languages including CJK are handled but not equally well. The documentation tells you to test on your own content and to watch the confidence values when routing.

Can I fine-tune Jev on my own data? No. TypeSafe does not fine-tune or LoRA-adapt Jev per customer, and does not train on customer requests or responses. Domain behavior is shaped through the state, instructions and criteria in each request.

Which tasks should I keep out of Jev? TypeSafe publishes nine: literal reading, math and numbers, date and time comparison, indirection, large states full of irrelevant detail, adversarial content, contradictory criteria, common-sense structural invariants, and generation. Counting and arithmetic belong in your code.

Can I self-host an alternative? There are open reproductions — SemIf, NanoJev, and the Apache-2.0 laya encoder among them — but they are independent projects with their own benchmarks, not Jev. Treat published comparisons as the projects' own measurements.

When should I use Jev instead of a low-cost LLM? When the decision is narrow and typed, you make it often, and you need it back in hundreds of milliseconds rather than seconds. For long-context reasoning, generation, or anything requiring arithmetic, a low-cost generative model is the better choice.

Sources and further reading

• TypeSafe — Models — model ID, aliases, $42/Btok pricing, rate limits, context budget, language support and data handling
• TypeSafe — Jev 1.13 jaggedness — the areas TypeSafe scopes out, with the recommended pattern for each, reviewed September 17, 2026
• TypeSafe — API reference and Quick start — endpoint, request and response shapes, SDK usage
• TypeSafe — Introducing System One Models and Jev — launch post, the 70–500ms end-to-end figure and the 40×–200× comparison
• Hacker News discussion — 1,918 points on the launch thread
• browser-use/jev-ultrafast — action space, the single-request operation-and-target design, and the Google Flights demonstration
• Made with Jev — 724 competitor ads, broken down — the ad-analysis build page, with the author's post
• Every — TypeSafe's Jev Judged Everything I've Written in 0.7 Seconds
• Hugging Face — convaiinnovations/laya and TheoLeeCJ/SemIf — open, independent reproductions

TypeSafe's model documentation and scope notes were checked on September 20, 2026; star counts and APIMaster route prices were read on the same day. Jev's APIMaster onboarding is in progress and this page will be updated as it advances. Pricing, rate limits, and project status change — verify on the live card or the vendor's own page before committing a workload.