Last updated: September 2026
Key Takeaways
- Jev is a hosted, closed-weight API in early access. There is nothing to download, and TypeSafe has published no self-host or open-weight path.
- "Can't hallucinate" means Jev cannot return a malformed or off-schema answer. It can still be wrong, and TypeSafe's own launch post says its 0 percent figure is not an empirical measurement.
- The single-pass, typed-answer-with-probabilities pattern runs today on llama.cpp or Ollama with a small local model. You give up RLCD calibration and true parallel questions; your data stays on your network.
No, you cannot run Jev locally, and TypeSafe has not said you ever will. Jev is a new class of model TypeSafe AI calls a System One model: it takes a block of text and a list of typed questions and returns answers with probabilities instead of generating text. It launched September 15, 2026 as a US-hosted API behind an early-access waitlist, with closed weights.
This page reads the launch claims against TypeSafe's own fine print, explains where your data goes, and shows how to get the same decision pattern on a GPU you own. The pattern is open; what TypeSafe sells is the calibration training and the parallel sampler on top of it.
What Jev actually is (and is not)
Jev is a decision model, not a language model. It does not write sentences, code, or JSON; it evaluates questions you define in advance against a state you supply and returns typed values with probability distributions your code can branch on.
TypeSafe's developer documentation describes three question types. A Choice picks one option from a list and returns the choice, a probability for every option, and a confidence score. A Score rates the state against ordered levels. A Noul, TypeSafe's own term, answers a yes/no question with a probability between 0 and 1. Every question in a request is evaluated in parallel against the same state, so adding questions barely changes response time. The docs tell developers to split any judgment that would need reasoning into atomic questions and combine them in code.
The launch post frames the model as a function call: unstructured state in, typed probabilistic decisions out. It quotes response times of 70 to 500 milliseconds, up to 255 options per Choice, and input priced at $0.042 per million tokens with output free, per the post dated September 15, 2026.
Who built it
TypeSafe AI is a San Francisco lab founded in 2024 by Diogo Almeida, a former OpenAI and Google Brain researcher credited with co-inventing RLHF and the research behind ChatGPT, with Erik Gafni and Sasha Sheng. It left stealth the day Jev shipped with roughly $40 million in seed funding led by DCVC, per the Business Wire release. Almeida announced it on X, @CompleteSkeptic: 20 to 200x faster, 40 to 400x cheaper.
Reading the claims against TypeSafe's own fine print
The launch post is unusually candid: each headline claim carries a company-written "Nuance" section, and most of what follows comes from those.
"Can't hallucinate"
Jev cannot produce an answer outside the schema you defined; it can still choose the wrong option inside it. TypeSafe's post says the model gives up string generation and therefore cannot hallucinate, and separately says a type error is mathematically impossible because every output is defined in advance. Those are the same claim. In its hallucination chart the company notes its 0 percent figure is not empirical: schema matching is guaranteed, so it added zero to the plot.
That guarantee is worth having, and it is not exclusive: grammar-constrained decoding has made off-schema output impossible on local runtimes since 2023, as covered below. What Jev adds is a probability per option that TypeSafe says is trained to track how often the model is right. In its own side-by-side demo the company reports one disagreement with GPT-5.6 Terra, on a churn question it calls ambiguous. A well-formed wrong answer is still wrong; the probability is supposed to warn you when the model is guessing.
"20-200x faster, 40-400x cheaper"
The largest multipliers, 193.6x faster and 444.6x cheaper, come from TypeSafe's own workflow evaluations, which the company says sit at the higher end of real-world gains. The reference answers average GPT-6 Astra and Fable 5.1, which the post admits biases the comparison toward OpenAI and Anthropic models, and the workflows were built by TypeSafe's own team. The 3-to-329-second baseline is frontier latency with reasoning on; in the Wikiracing demo against non-reasoning modes, TypeSafe says its speedups were much smaller. On cost, the post states the company cannot prove its pricing is unsubsidized; free output tokens is a pricing decision, not a property of the architecture. None of this makes the numbers wrong. They are vendor-run numbers on vendor-built workloads, and TypeSafe says so in the same document.
Calibration, the part that is new
RLCD, Reinforcement Learning for Calibrated Decisions, is TypeSafe's method for making the returned probabilities honest: higher confidence is supposed to mean higher accuracy, and similar inputs similar answers. Chat models are trained on human preference and verifiable rewards, and their self-reported confidence runs high and inconsistent. If RLCD holds up under independent testing, calibration is the reason to pay for Jev. Everything else in the pattern you can build yourself.
Where your data goes, and what the lock-in looks like
Every decision round-trips to a US-hosted API run by one vendor, with no on-prem or open-weight option in any TypeSafe material we could find. The launch post says the service is currently based on the West Coast. The company's adapter repository on GitHub, which wraps ordinary LLMs to return TypeSafe-style decisions, held one commit and a README on September 15.
The privacy terms beat the deployment model. TypeSafe's privacy policy, dated November 19, 2025, states that the company will not train or fine-tune models on customer input and will not disclose input to third parties other than its service providers. Retention runs as long as the company considers reasonably necessary; hosting is in the United States. That is cleaner than many AI APIs offer.
The dependency remains. TypeSafe's showcase, a smart home assistant demo, is a browser app that sends every request, "turn off all the lights" included, to the TypeSafe API. It uses a pattern the docs call speculative fan-out: ask every question you might need in one call and let code discard the irrelevant answers. Good pattern. It also means each command in your home is decided in someone else's data center, at a price that can change, on a service that can close.
How to run the same pattern on your own hardware
One forward pass, no generation, read the probabilities over the option tokens. That is the whole trick, and llama.cpp's server exposes every piece of it. Parameters below were checked against the llama.cpp server README on September 15, 2026.
- Pick a small instruct model. A 4B to 12B model fits a decision a knowledgeable person could make in seconds. Our local AI models by VRAM guide currently names Gemma 4 E4B for 8 to 12 GB cards and Gemma 4 12B for 16 GB, both Apache 2.0, both loadable in llama.cpp and Ollama. A 12 GB RTX 3060 class card remains the cheapest on-ramp, per our local AI hardware guide.
-
Start llama-server with parallel slots.
-npsets the slot count; batching and prompt caching are on by default. -
Ask for one token and its probabilities. Set
n_predictto 1,n_probsto at least your option count, andpost_sampling_probsto true so the response carries plain probabilities between 0 and 1. Per the README, a negativetemperaturesamples greedily while still reporting a plain softmax of the logits. End the prompt with the option list and "Answer:" so the next token is the decision. -
Make it type-safe. Pass a
grammarorjson_schemathat admits only your option strings. The sampled token then cannot be off-schema, the same guarantee TypeSafe describes, and it has been in llama.cpp since GBNF grammars landed in 2023. -
Approximate parallel questions. Send an array of prompts in one request; the server returns an array of results. Give every prompt the same state prefix and vary only the question. With
cache_prompttrue, the shared prefix is evaluated once and only the differing suffix is processed per question. Not Jev's single pass, but on a short state it is close. -
Measure, then gate. Set
timings_per_tokento true and read your own latency rather than trusting a number from this page or a vendor. Route any answer whose top probability falls below your margin to a human or a larger model. TypeSafe calls this confidence-gated routing; locally it is an if-statement.
A minimal three-option request body:
{
"prompt": "STATE: (customer message here)\nQUESTION: How urgent is this request?\nOPTIONS: low, medium, high\nAnswer:",
"n_predict": 1,
"n_probs": 5,
"post_sampling_probs": true,
"temperature": -1,
"grammar": "root ::= \" low\" | \" medium\" | \" high\"",
"cache_prompt": true
}
Ollama works too: its client library added logprobs and top_logprobs to chat and generate calls in November 2025, with Ollama's JSON-schema format option supplying the type constraint. Keep it bound to localhost as it ships, and confirm any model tag you pull is a native local entry, not a cloud-routed one.
What the local version does not give you
Three things. Calibration: the raw softmax over option tokens is not trained to match hit rates, and chat-tuned models lean overconfident. A margin threshold catches the obvious cases; temperature scaling on a few hundred labeled examples fixes more, and that work is yours. Parallelism: Jev evaluates every question in one query; the local approximation batches prompts and leans on prefix caching. Scale: a 255-way Choice is not something to hand-roll, and at millions of decisions an hour the vendor's price may beat your electricity bill. For a home, a lab, or a small business, the local version wins where it counts here: the decision never leaves the building.
The Home Assistant version
TypeSafe's smart-home demo maps cleanly onto a local stack. Run the fan-out questions against a local model: request category, target domain, device type, action. Branch in code. Hand general conversation to a local chat model, as the demo hands it to a cloud LLM. Our OpenClaw and Home Assistant guide covers the agent wiring and token handling, and the local AI security guide covers keeping the decision box on its own network segment. A classifier that can turn off your lights is a server on your network; treat it as one.
Jev vs the local pattern
| Property | TypeSafe Jev | Local pattern (llama.cpp or Ollama) |
|---|---|---|
| Where it runs | TypeSafe's US-hosted API | Your GPU or CPU, on your network |
| Weights | Closed; no self-host option published | Open weights you choose (Apache 2.0 Gemma 4 picks in our VRAM guide) |
| Output | Typed Choice, Score, or yes/no with probabilities and confidence | One constrained token plus its probability distribution |
| Type safety | Guaranteed by architecture | Guaranteed by grammar or JSON schema constraint |
| Calibration | Trained in via RLCD (vendor claim, not yet independently tested) | Not trained in; margin threshold or temperature scaling by you |
| Parallel questions | Many questions in one query | Batched prompts with shared-prefix caching |
| Latency | 70 to 500 ms, vendor-stated, plus your round trip | One prefill on your hardware; measure it |
| Cost model | Per input token; output free; subject to change | Hardware you already own plus electricity |
| Data path | Leaves your network; not used for training per policy | Never leaves your network |
Jev figures are vendor-published as of September 15, 2026. Local latency and calibration depend on your model, quantization, and hardware.
Who should actually care
Developers automating high-volume classification, routing, or scoring, who can accept a single-vendor dependency in exchange for calibrated probabilities and a very low per-call price, are who Jev was built for. TypeSafe's cookbook pages on re-ranking, guardrails, and extraction describe that buyer.
Homelab readers and small operators should build the local version first. It costs an afternoon, runs on hardware most readers already own, and answers the question that matters before any vendor conversation: is calibration the bottleneck, or is a margin threshold good enough? For most home automation it is the latter. If it is the former, Jev is worth a waitlist entry, with the understanding that you are renting the decision layer. Whether an open-weight System One model ever appears, from TypeSafe or anyone else, is the part of this story that decides who controls the infrastructure.
Frequently Asked Questions
What is Jev?
Jev is the first System One model from TypeSafe AI, released in early access on September 15, 2026. It does not generate text. It evaluates typed questions, a choice among options, a score against ordered levels, or a yes/no, against a block of state you supply, and returns structured answers with calibrated probabilities and a confidence score that software can act on directly.
Is Jev open source or open weights?
No. Jev is available only through TypeSafe's hosted API, currently behind an early-access waitlist. TypeSafe has published no model weights, no on-prem option, and no timeline for either. Its adapter repository on GitHub contained only a README when checked on September 15, 2026.
Can you run Jev locally?
No. There is nothing to download. What you can run locally is the same decision pattern: one forward pass over a small open-weight model, a grammar that restricts the answer to your option list, and the probability distribution over those options read from the response. llama.cpp and Ollama both support this today; the calibration TypeSafe trains into Jev is the part you approximate.
Can Jev hallucinate?
It cannot return an answer outside the schema you defined, which is what TypeSafe means by "can't hallucinate." It can still select the wrong option. TypeSafe's launch post states that its 0 percent figure is not an empirical measurement but follows from guaranteed schema matching, and it reports a disagreement with GPT-5.6 Terra in its own demo.
What is RLCD?
RLCD stands for Reinforcement Learning for Calibrated Decisions, TypeSafe's training method for Jev. Where chat models are trained on human preference (RLHF) or verifiable rewards (RLVR), RLCD trains the model so the probabilities it returns track how often it is right. TypeSafe claims higher confidence means higher accuracy and similar inputs give consistent answers. No independent verification has been published.
What is a System One model?
TypeSafe's name for a model built to make fast, structured decisions rather than generate text, borrowed from Daniel Kahneman's distinction between fast intuitive System 1 thinking and slow deliberate System 2 reasoning. It takes state and typed questions as input, evaluates every question in parallel, and returns typed values with probabilities. Jev is the first public model in the class.
