All questions answered in a single parallel pass

Every question is evaluated in parallel and in isolation against the same state in one go, so adding questions barely changes the response time. TypeSafe says end-to-end response time is 70ms-500ms for TypeSafe versus 3 to 329 seconds for frontier LLMs. The independent developer guide notes that a tenth question costs tokens but almost no time, which inverts the usual instinct to make a cheap call first.

Workflow outcome: speculative fan-out becomes practical because extra questions are nearly free in latency.

Type-safe structured outputs your code can depend on

Possible outputs and structure are defined in advance, so the model never makes type errors. TypeSafe states this is mathematically impossible to falsify with a single counter-example. The docs frame the mismatch plainly: LLMs are designed to produce text for humans, so coercing them into structured decisions means parsing results back into something your code can depend on.

Workflow outcome: no parsing layer and no hallucinated tool calls buried in a dependency chain.

Confidence scores you can architect around

Jev is trained with Reinforcement Learning for Calibrated Decisions (RLCD), which optimises probabilities against outcomes rather than human preference. Choice and Score both return confidence, and the docs say higher confidence means higher accuracy. The independent guide calls confidence-gated routing the pattern that changes your architecture, because you can write one threshold per action scaled to what being wrong costs.

Workflow outcome: low-stakes reads proceed automatically while money-moving actions demand a higher bar.

Choice, Score and Noul cover every question type

Choice picks one option from a list of up to 255 and returns choice, probabilities and confidence. Score places the state on two to ten ordered levels and returns a score that can land between levels, plus probabilities and confidence. Noul answers yes or no as a single 0-1 probability and has no confidence field because the number already is the belief. All three can be mixed in a single API call.

Workflow outcome: one call can classify, rate and verify the same state without context-rot between questions.

Decompose fuzzy judgments into reliable gut-checks

TypeSafe's docs advise treating each question as a gut-check determination — the kind of judgment a knowledgeable person could make in a few seconds given the right context. If a question would require extended reasoning or weighs multiple independent factors, you decompose it and combine results with logic in your code. The composite scoring pattern scores each dimension atomically and combines with weights you control, so re-weighting becomes a code change rather than a re-prompt.

Workflow outcome: you A/B your own weighting formula instead of rewriting prompts.

Pricing built for high-volume decision workloads

TypeSafe states input tokens cost $0.042 per million ($42 per billion tokens) and output tokens are free — described as too cheap to meter. The launch post is candid that the company cannot prove the price is not subsidised and will need the long term to prove sustainability, though it expects pricing to go down rather than up. The independent guide notes a 13-question regulatory briefing batched into one call is reported 12.2x cheaper and 10.0x faster than asking one at a time.

Workflow outcome: decision layers that would be uneconomical on per-token LLM pricing become viable.

Smart if-statements in production code

Teams replace brittle hand-written branching with typed decisions that slot into ordinary software. A support platform can classify, route, score, or extract where rules engines break down, while the surrounding code constrains the model's freedom. The independent guide's cascade pattern shows one branch handling order status with pure code and never touching a model at all.

Confidence-gated customer support routing

A ticket arrives, Jev returns intent and complexity with confidence scores, and code decides what happens next. Low-confidence intents route to a human, simple lookups run as pure code, and complex complaints escalate. The independent guide estimates that on a million tickets, using TypeSafe's per-case figures, this costs roughly $6,480 instead of $30,400, with around 800,000 answered in under half a second instead of ten.

Guardrails and verification of LLM output

Because Jev returns calibrated probabilities rather than prose, it can act as a judge over another model's prompt, reasoning trace, or output. Teams score, verify, and detect jailbreak attempts without parsing free text. This is one of the use cases TypeSafe names directly in its launch post under "verify everything."

Real-time applications and game agents

At 70ms-500ms per call, Jev fits inside interfaces where UX depends on responsiveness. TypeSafe's own demos include a Doom bot that reacts to structured game state — the engineer behind it was worried about 10 queries per second costing roughly $7/hour — and a Wikiracing demo where the model picks among hundreds to thousands of links per step. TypeSafe notes the Doom demo runs on structured state as a data structure with text, not on images.

• Latency that fits inside softwareTypeSafe reports 70ms-500ms end-to-end versus 3 to 329 seconds for frontier LLMs, which is the difference between a human-facing tool and a code-facing primitive.
• Type safety removes a whole class of bugsBecause possible outputs are defined in advance, the model never makes type errors — a hallucinated tool call several layers deep in a dependency chain is the failure mode this eliminates.
• Confidence is meaningful in aggregateRLCD trains probabilities against outcomes rather than human preference, so higher confidence really does mean higher accuracy, which makes per-action thresholds viable.
• Parallel sampling makes extra questions nearly freeAdding questions barely changes response time and does not create context-rot, because each question is evaluated independently against the same state.
• Cost structure suits high-volume decisionsFree output tokens and $0.042 per million input tokens mean decision layers that would be uneconomical on per-token LLM pricing become practical.

• Text only, no multimodal inputJev accepts strings, JSON objects, or arrays of text — images, audio and video must be transcribed or captioned first.
• It cannot write prose at allGiving up string generation is the source of its speed and type safety, but it means Jev is a complement to a chat LLM, never a replacement.
• Context limits work differentlyThe docs specify 64k tokens for state and all questions together, and 32k tokens for state plus the single longest question.
• Accuracy falls as state fills with irrelevant materialThe independent guide notes TypeSafe's own guidance is to retrieve and filter in code first and send only the fields the question needs.
• The DealbreakerEvery headline number — 193.6x faster, 444.6x cheaper, 0% structured-output errors — is TypeSafe's own, self-run and unreproduced, and the maker itself notes the reference answers come from averaging GPT-6 Astra and Fable 5.1, the workflows were built by TypeSafe's own capabilities team, and the price cannot yet be proven sustainable. If your procurement process requires independently verified benchmarks, they do not exist yet.

Get an API key. Early access is waitlisted, so request access and get a key from console.typesafe.ai/settings/keys, or obtain one through the Vercel AI gateway. Then export it as TYPESAFE_API_KEY in your environment.

Install an SDK. Python 3.10+ uses pip install typesafe-sdk (or uv add typesafe-sdk); JavaScript/TypeScript on Node 20+ uses npm install @typesafe-ai/sdk. Both read TYPESAFE_API_KEY from the environment and default to jev-latest.

Understand the one endpoint. If you would rather call it directly, there is a single endpoint at POST https://api.typesafe.ai/v1/systemone. The SDKs are convenience wrappers around it.

Send state plus typed questions. State can be a string, a JSON object, or an array of text — use an object when there is more than one piece of context. Define your questions using the three primitives: Choice for picking from a list, Score for a position on an ordered scale, and Noul for a yes/no probability.

Read the answers. Choice returns .choice, .probabilities and .confidence; Score returns .score (which can land between levels), .probabilities and .confidence; Noul returns .noul, a single 0-1 number with no confidence field because the number already is the belief.

Branch on confidence in your own code. Start with a floor — route to a human below 0.5 — then set higher thresholds for higher-stakes actions. The independent guide's cascade pattern is the fastest route to a first meaningful result: classify intent, score complexity, and let code decide whether to answer directly, call a specialist LLM, or escalate.