Short answer: yes, you can call Jev through apimodels.app. Send POST https://api.apimodels.app/v1/systemone with your apimodels key and "model": "jev". The request body and the response are exactly TypeSafe's, so code written for the official API — including TypeSafe's Python SDK — works after you change the base URL and the key.
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: you pay only for input tokens, and output is free.
If you want to see what people have built with it — shipped product features, business workflows with measured savings, independent evaluations including the unflattering ones, and week-one experiments — see the curated collection at /jev-use-cases.
Jev on apimodels costs $0.05 per million input tokens — TypeSafe's $0.042 list price plus 20% — and output is free on both. We bill the exact token count TypeSafe reports, with no per-call minimum: the two-question request below came to 385 input tokens, which is $0.0000193. A call that fails upstream, or that we reject before it reaches TypeSafe, is not charged.
Limits are TypeSafe's, taken from its model documentation and checked on 22 September 2026. Rate limits apply to our shared upstream capacity; if they are hit you get HTTP 429 with code rate_limited, and you should retry with exponential backoff — TypeSafe asks the same of its own customers.
| Item | apimodels.app | TypeSafe (official) |
|---|---|---|
| Input price | $0.05 per million tokens | $0.042 per million tokens |
| Output price | Free | Free |
| Billing | Exact tokens, no per-call minimum; failed calls free | Per token |
| Endpoint | POST https://api.apimodels.app/v1/systemone | POST https://api.typesafe.ai/v1/systemone |
| Model name | jev (jev-latest also accepted) → jev-1.13.0 | jev-latest → jev-1.13.0 |
| Per-request budget | 64k tokens; state + longest question up to 32k | Same |
| Input | Text only — no images, audio or video | Same |
| Same key also calls | LLM, image, video and audio models | Jev only |
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, so adding questions barely changes the response time. The example below is a real request we sent on 22 September 2026, with the response exactly as it came back.
One trap worth knowing: TypeSafe's documentation writes the question types as Choice, Score and Noul, but its API only accepts lower case and answers "Choice" with a bare 400 that does not say which field is wrong. We lower-case the type for you, so both spellings work on apimodels.
Jev works best next to a language model, not instead of one: the builds that hold up in production let Jev make the frequent decisions and send the uncertain or open-ended cases to an LLM. On apimodels both sit behind one key and one balance, so the fallback path is a different endpoint on the same account rather than a second vendor. The site is reachable from mainland China and accepts card and Alipay payments.
Go direct to TypeSafe if Jev is the only model you need and your volume is large: its list price is 16% lower than ours, and at a billion input tokens a month that is $8 of difference. You also get TypeSafe's own rate-limit allocation rather than a share of ours.
From TypeSafe's API or SDK, change two things: the base URL to https://api.apimodels.app and the key to your apimodels key. The SDK also reads TYPESAFE_BASE_URL and TYPESAFE_API_KEY from the environment, so in many projects the switch is two environment variables and no code change.
From an LLM prompt that ends in a fixed list of labels, it is not a one-line change: Jev has its own request shape. Rewrite each decision as a state plus typed questions — your labels become the criteria of a choice question — and read answers and probabilities back instead of generated text. Keep the LLM for anything Jev scores below your confidence threshold.
cURL
curl https://api.apimodels.app/v1/systemone \
-H "Authorization: Bearer $APIMODELS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev",
"state": "Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
"questions": {
"queue": {
"type": "choice",
"instructions": "Which support queue should handle this ticket?",
"criteria": {
"billing": "Payments, invoices, charges and refunds",
"bug": "Something in the product is broken",
"account_access": "Login, password or permission problems",
"other": "Anything else"
}
},
"urgent": {
"type": "noul",
"instructions": "The customer needs a response within the hour."
}
}
}'
# → {"model":"jev-1.13.0",
# "answers":{"queue":{"type":"choice","choice":"billing","confidence":1.0,
# "probabilities":{"bug":0.0,"other":0.0,"account_access":0.0,"billing":1.0}},
# "urgent":{"type":"noul","noul":0.29}},
# "usage":{"input_tokens":385,"output_tokens":63}} # 385 input tokens ≈ $0.0000193Python
# pip install typesafe-sdk (TypeSafe's official SDK — only base_url and the key change)
import os
from typesafe_sdk import Choice, Noul, TypeSafeClient
with TypeSafeClient(
base_url="https://api.apimodels.app",
api_key=os.environ["APIMODELS_API_KEY"],
) as client:
result = client.system_one(
state="Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
questions={
"queue": Choice(
instructions="Which support queue should handle this ticket?",
criteria={
"billing": "Payments, invoices, charges and refunds",
"bug": "Something in the product is broken",
"account_access": "Login, password or permission problems",
"other": "Anything else",
},
),
"urgent": Noul(instructions="The customer needs a response within the hour."),
},
)
print(result.choices["queue"].choice) # billing
print(result.nouls["urgent"].noul) # a probability, e.g. 0.28Yes. Send POST https://api.apimodels.app/v1/systemone with your apimodels key and "model": "jev". The request and response are identical to TypeSafe's API, so TypeSafe's own SDK works once base_url points at https://api.apimodels.app. You do not need a TypeSafe account.
We charge $0.05 per million input tokens and TypeSafe lists $0.042; output is free on both. A typical 400-token decision costs $0.00002 with us, and a million such decisions cost $20 with us versus $16.80 direct. We bill exact tokens with no per-call minimum, and failed calls are free.
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; use TypeSafe's SDK with our base URL, or plain HTTP as in the cURL example.
For a decision with about 100 input tokens, Jev on apimodels costs about $0.000005, because output is free. The same routing decision on gemini-3.8-flash with a forced function call cost us about $0.0002 including its reasoning tokens — around forty times more. The gap narrows when your state is large, since Jev bills every input token.
You are not charged. Problems with your request (HTTP 400 or 422) come back with TypeSafe's own error message so you can fix them. Rate limiting returns 429 with code rate_limited: retry with exponential backoff. Upstream outages return 502 and are safe to retry.
No. TypeSafe removed its waitlist on 20 September 2026, and on apimodels there was never one: sign up, create an API key in the console, top up, and call /v1/systemone.
