Short answer, as of 22 September 2026: you cannot call Jev through apimodels.app yet. We checked the model lists of every upstream provider we use that day and none of them carry it; we are working on access and will update this page the day it changes. Until then, Jev is available from TypeSafe itself through early access at console.typesafe.ai, which has a waitlist, and OpenRouter announced it in beta on 17 September.
Jev is TypeSafe's "System One" model, released on 15 September 2026. It does not generate text. You send your application's state plus a set of typed questions, and it returns one answer per question — a choice, a score or a probability — each with a calibrated probability. That is why it is priced so differently from a language model: $0.042 per million input tokens, and output tokens are free.
If you want to see what people have actually built with it — browser agents, trading bots, game players, classifiers — with the costs they reported, see the curated collection at /jev-use-cases.
These come from TypeSafe's model and API documentation, checked on 22 September 2026. The rate limit is described by TypeSafe as being adjusted dynamically while demand is high, so treat it as a ceiling rather than a guarantee.
| Item | Value |
|---|---|
| Input price | $0.042 per million tokens |
| Output price | Free |
| Model | jev-latest (points to jev-1.13.0) |
| Endpoint | POST https://api.typesafe.ai/v1/systemone |
| Per-request budget | 64k tokens; state + longest question up to 32k |
| Rate limit | 250,000 tokens/s or 1,200 requests/min |
| Input | Text only — no images, audio or video |
| Latency | 70–500 ms end to end (TypeSafe's claim) |
A Jev call is not a chat completion. The request carries three things: the model name, a state (a string, JSON object or array describing the situation), and a map of questions keyed by names you choose. Each question is one of three types — Choice picks one option out of up to 255, Score places the state on a scale of 2 to 10 levels you describe, and Noul returns the probability that a statement is true.
The response mirrors that map: for each question id you get the answer, the full probability distribution for Choice and Score, and a confidence. Every question is evaluated in parallel against the same state, which is why adding questions barely changes the response time — and why the builders in our collection routinely ask a dozen or more questions per item. We describe this from TypeSafe's documentation; we have not called the API ourselves.
The closest thing you can run on apimodels today is a fast language model with a forced function call. Put your options in an enum on the function's parameter and set tool_choice so the model must call that function; the answer then has to be one of your options. The sample below is exactly the request we ran on 22 September 2026 against gemini-3.8-flash: three runs, three times {"queue": "billing"}, in 1.9 to 2.9 seconds, at about $0.0002 each.
Be clear about what this is not. It is an order of magnitude slower than Jev's claimed latency, tens of times more expensive per decision, and it gives you no calibrated probability to route on. It is a reasonable way to prototype a decision point now; it is not a substitute you should benchmark against Jev and call equivalent.
| Jev (TypeSafe) | gemini-3.8-flash + forced tool call (apimodels) | |
|---|---|---|
| Latency | 70–500 ms (vendor claim) | 1.9–2.9 s (our 3 runs) |
| Cost per ~100-token decision | ≈ $0.000004 | ≈ $0.0002 |
| Calibrated probability | Yes | No |
| Can also write text | No | Yes |
| API shape | /v1/systemone (its own) | OpenAI-compatible /v1/chat/completions |
| On apimodels today | No | Yes |
Most models on apimodels can be swapped by changing the model string. Jev cannot, because its API is a different shape: you will rewrite each decision as a state plus typed questions, and read answers and probabilities back instead of a tool call. The work is small if your prompt already ends in a fixed list of labels — those labels become the criteria of a Choice question — so it is worth structuring your prototype that way from the start.
cURL
# 同类决策今天在 apimodels 上的做法:枚举 + 强制函数调用(2026-09-22 实测 3/3 通过)
curl https://api.apimodels.app/v1/chat/completions \
-H "Authorization: Bearer $APIMODELS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "gemini-3.8-flash",
"messages": [
{ "role": "system", "content": "Route the support ticket to exactly one queue." },
{ "role": "user", "content": "Ticket: I was charged twice for my September invoice and need one of the payments refunded." }
],
"tools": [{
"type": "function",
"function": {
"name": "route_ticket",
"description": "Send the ticket to one queue",
"parameters": {
"type": "object",
"properties": {
"queue": { "type": "string", "enum": ["billing", "bug", "feature_request", "account_access", "other"] }
},
"required": ["queue"]
}
}
}],
"tool_choice": { "type": "function", "function": { "name": "route_ticket" } }
}'
# → choices[0].message.tool_calls[0].function.arguments == "{\"queue\":\"billing\"}"Python
import json, os
from openai import OpenAI
client = OpenAI(base_url="https://api.apimodels.app/v1", api_key=os.environ["APIMODELS_API_KEY"])
QUEUES = ["billing", "bug", "feature_request", "account_access", "other"]
resp = client.chat.completions.create(
model="gemini-3.8-flash",
messages=[
{"role": "system", "content": "Route the support ticket to exactly one queue."},
{"role": "user", "content": "Ticket: I was charged twice for my September invoice and need one of the payments refunded."},
],
tools=[{
"type": "function",
"function": {
"name": "route_ticket",
"description": "Send the ticket to one queue",
"parameters": {
"type": "object",
"properties": {"queue": {"type": "string", "enum": QUEUES}},
"required": ["queue"],
},
},
}],
tool_choice={"type": "function", "function": {"name": "route_ticket"}},
)
queue = json.loads(resp.choices[0].message.tool_calls[0].function.arguments)["queue"]
print(queue) # billingNo. As of 22 September 2026 none of our upstream providers offer Jev. We are working on access and will update this page the day it is available; until then we will not route any other model under the Jev name.
No. It has its own endpoint, POST /v1/systemone, where you send a state and a map of typed questions and get answers with probabilities back. An OpenAI SDK pointed at it will not work; TypeSafe provides its own Python and JavaScript SDKs.
For a decision with about 100 input tokens, Jev's list price works out to roughly $0.000004, because output is free. The same routing decision on gemini-3.8-flash through apimodels cost us about $0.0002 including its reasoning tokens — around fifty times more. The gap narrows if your state is large, since Jev bills every input token.
TypeSafe has not published criteria; developers are being let in over time from the waitlist at console.typesafe.ai. If you need something you can build on this week, prototype the decision with a forced function call on a model you can already call, and structure it so the labels map straight onto Jev's question types later.
