Developer notes
Jev AI — the model that returns decisions instead of words
Jev AI is TypeSafe’s System One decision model: you send state + typed questions, and it returns calibrated probabilities — not paragraphs.
This site is an unofficial developer handbook for people who want to use Jev AI in production. For a bilingual “what is Jev” encyclopedia, see jev101.com. We focus on shipping: API shapes, cost math, and when a decision model beats a chat LLM.
What Jev AI is for
Chat models generate words. Jev AI returns typed decisions. That sounds like marketing until you wire a support inbox, a fraud queue, or an agent router and realize the expensive part is not writing the reply — it is deciding what kind of work this is before you spend tokens on prose. System One is built for that first hop: classify, route, score, then hand off to code, a human, or a chat model.
Current public facts (from TypeSafe / OpenRouter materials, centralized in jev-facts): context window 32,000 tokens; text-only input; model string jev-latest; input $0.042/M tokens with free output; claimed P50 around 0.23s. Vendor speed/cost claims: 193.6x Faster and 444.6x Cheaper.
Three primitives
- Noul — yes/no with a probability of “yes”.
- Choice — pick one of up to 255 labeled options.
- Score — ordered scale (2–10 levels) with a distribution.
Keys in the questions map are your names; answers return under the same keys. Keys do not participate in reasoning. Batch many questions in one request — that is the posture TypeSafe documents, and the cookbook claims 13 questions in one call can be about 12.2× cheaper and 10× faster than asking them separately.
30-second triage example
One System One call can ask several questions at once. The JSON below is an illustrative example from the TypeSafe docs, not a measured production run.
{
"state": "Customer email: My invoice charged twice this month and I cannot download the PDF.",
"model": "jev-latest",
"questions": {
"is_support": {
"type": "noul",
"instructions": "Is this a customer support request that needs a human or bot reply?"
},
"department": {
"type": "choice",
"instructions": "Route this message to the best department.",
"criteria": {
"billing": "Payments, invoices, refunds, subscriptions",
"technical": "Bugs, outages, API errors, product failures",
"sales": "Pricing questions, upgrades, new purchases"
}
},
"urgency": {
"type": "score",
"instructions": "How urgent is a reply?",
"criteria": [
"low",
"medium",
"high"
]
}
}
}Hard numbers (official claims)
- 193.6x Faster · 444.6x Cheaper (TypeSafeAI 1.1 comparison on typesafe.ai)
- Input $42 / billion tokens · output free
- P50 latency about 0.23s · context 32,000 tokens
- ~300 input tokens ≈ $0.0000126 per request
Where teams actually use it
- Support triage — noul for “needs human?”, choice for department, score for urgency, then confidence gates whether a bot replies or a ticket opens.
- Agent routing — let a chat model draft, then ask Jev AI whether the draft is ready, on-policy, or should escalate (official patterns include confidence-gated routing and intent routing).
- Rubric judging — score or choice over fixed criteria when you need a distribution, not a paragraph of self-justification. OpenRouter traffic leaders include apps such as sel-jev-rubric-judge, Waura, mirasim, JeVinci, clara jev triage.
Naming rule on this site: always say Jev AI in titles and first mentions. Bare “jev” in English search often maps to Japanese encephalitis virus. Do not target “jev model” as a headline — that phrase pulls veterinary “animal model” results.
How a production call usually looks
Keep API keys on a server. Send state (string, object, or array), set model to jev-latest, and pass a questions map. Prefer batching related questions in one HTTP request over chat-style loops. Official error codes to plan for: 401 auth failure, 422 validation failure, 429 rate limit, and 529 overload — the last two should use exponential backoff (official SDKs already do). On OpenRouter, Jev AI rides the Decisions API, not chat completions, so “drop-in OpenAI client” integrations will fail in confusing ways.
instructions can also be structured data: put the question in one field and keep references in sibling fields, then cite those fields with backticks inside the question text. That keeps payloads machine-readable while the decision model still sees the relationship between the question and the data.
Architecture patterns worth copying
TypeSafe documents four composition patterns we summarize on the comparison page: Speculative fan-out, Confidence-gated routing, Composite scoring, Intent routing. In practice most teams start with intent routing (choice) plus a confidence gate. If confidence is low, escalate to a human or a slower LLM judge; if high, execute the cheap path. Speculative fan-out and composite scoring show up once you have multiple signals to fuse — for example a noul safety check plus a score for business urgency.
Pairing models is normal: the chat LLM writes the customer-facing sentence; Jev AI decides whether that sentence should send, which template to use, or which queue owns the case. That split keeps creative generation and decisioning from fighting inside one prompt.
What this handbook is not
We do not mirror the official docs page-for-page, we do not host TypeSafe branding, and we do not claim measured benchmarks unless we say so. Example JSON on this site is illustrative unless labeled otherwise. We also are not trying to replace jev101.com’s “understand Jev” encyclopedia — that site covers bilingual conceptual onboarding. Jev Notes is the “ship with Jev AI” companion: endpoints, field rules, cost math, and decision-vs-chat tradeoffs.
Language roadmap: English first. Japanese and Korean are next because those markets are thinner than English/Chinese for this topic. We intentionally are not bulk-publishing machine-translated /zh-CN/ mirrors on a brand-new domain.
Tools on this site
- Pricing calculator — day/month cost at official rates
- Request builder — copy-paste noul / choice / score JSON
- API quickstart — Python + multi-question call
A practical mental model
Treat Jev AI like a typed function, not a conversation partner. You prepare the state once — a ticket body, a transcript slice, a JSON feature bag — then ask several independent questions against that same state. The response is a map of answers you can branch on in code: if answers.needs_human.noul > 0.8, route to a queue; match answers.department.choice, assign an owner. There is no assistant message to parse, no “final answer” prose to regex, and no temptation to prompt-engineer a JSON schema into a chat model that still drifts.
That is why batching matters. Asking thirteen related questions in one call is not a parlor trick; it is how you keep the decision layer cheap while a chat model (if you still need one) only runs on the paths that require language. Official cookbook numbers claim about 12.2× cheaper and 10× faster for 13 questions in one request versus asking them separately — same answers, less round-trip tax.
Confidence is the second control plane. Probability tells you how mass is distributed across options; confidence tells you whether the model thinks that distribution is trustworthy enough to act on. Low confidence should not be “pick the argmax anyway.” It should be “escalate, sample another signal, or defer.” That two-signal pattern is what keeps calibrated outputs from becoming overconfident automation.
FAQ
Is Jev Notes affiliated with TypeSafe AI?
Unofficial developer resource. Not affiliated with TypeSafe AI. We cite public docs; we do not sell access or imply partnership.
Is this an OpenAI-compatible chat API?
No. System One is a Decisions API (https://api.typesafe.ai/v1/systemone). Chat-completions SDKs will not speak it. See the API quickstart.
Can Jev AI see images?
Not today. Input is text only (string / JSON object / array).
Does “calibrated probability” mean every answer is correct?
No. Official materials describe calibration over a population. Prefer confidence thresholds and human fallbacks for high-cost mistakes.
When should I still use a chat LLM?
Writing, brainstorming, tool-using agents that must emit prose, and any task where the artifact is language. Use Jev AI for the decision hop; see Jev AI vs LLM.
Where do I get an API key?
From TypeSafe’s console at https://console.typesafe.ai. Keep keys on a server; never ship them in a browser bundle.
How do I estimate cost before integrating?
Use the pricing calculator with your expected tokens per request and daily volume. Public list price is $0.042/M input tokens; output is free.
All 7 pages
- Home — Developer notes for Jev AI: typed decisions with probabilities, not chat completions. Quickstart, primitives, pricing, and when to use a decision model.
- TypeSafe AI — Who TypeSafe AI is, founder Diogo Almeida, System One naming, published speed/cost claims, and official docs links.
- API quickstart — POST /v1/systemone with noul, choice, and score in one call. Auth, errors, backoff, and why chat-completions SDKs will not work.
- What is Jev AI — Jev AI is not a chat model. Learn noul, choice, score, confidence vs probability, and when not to use it.
- Pricing — Estimate daily and monthly cost at $0.042 per million input tokens. Output tokens are free. Compare against a chat LLM.
- Primitives — Field reference for noul, choice, and score plus a request builder that copies valid System One JSON.
- Jev vs LLM — Parallel sampling vs autoregression, latency, calibrated probabilities, and using LLM write + Jev judge together.