TypeSafe AI launched Jev on September 15, 2026, a new class of model that evaluates predefined questions against text and returns typed answers with probability scores instead of generating text. The San Francisco lab, founded by former OpenAI and Google Brain researcher Diogo Almeida, positioned Jev as a faster and cheaper alternative to reasoning-focused large language models (LLMs) for structured decision-making tasks. However, Jev itself is a closed-weight, US-hosted API with no local or open-source version planned. The real news for self-hosted AI enthusiasts: the core pattern Jev uses can be replicated today on your own hardware using Ollama and smaller models.

What Makes Jev Different From Traditional AI Models?

Jev is not a language model in the traditional sense. Instead of writing sentences or code, it functions as a decision engine. You provide a block of text and a list of predefined questions, and Jev returns typed answers with probability distributions for each option. This is fundamentally different from how ChatGPT or Claude work. The model evaluates questions in parallel against the same input, meaning adding more questions barely increases response time. TypeSafe's documentation describes three question types: Choice (pick one option from a list), Score (rate against ordered levels), and Noul (answer yes/no with a probability between 0 and 1).

TypeSafe claims Jev responds in 70 to 500 milliseconds and costs $0.042 per million input tokens, with output tokens free. The company also reports speedups of up to 193.6 times faster and cost reductions of up to 444.6 times cheaper compared to reasoning-focused models like GPT-6 Astra and Fable 5.1, though these figures come from TypeSafe's own workflow evaluations and may not reflect all real-world use cases.

Can You Actually Run Jev Locally?

No. Jev is a hosted API behind an early-access waitlist with closed weights. TypeSafe has published no self-host or open-weight path, and there is nothing to download. Every decision round-trips to TypeSafe's US-based servers, meaning your data leaves your network with each request. The company's privacy policy, dated November 19, 2025, states it will not train or fine-tune models on customer input and will not disclose input to third parties beyond service providers. However, the dependency remains: if TypeSafe's service closes or pricing changes, your application breaks.

How to Replicate Jev's Decision Pattern Locally with Ollama?

• Choose a Small Instruct Model: A 4B to 12B parameter model is sufficient for decisions a knowledgeable person could make in seconds. Gemma 4 E4B works on 8 to 12 GB graphics cards, while Gemma 4 12B requires 16 GB. Both are Apache 2.0 licensed and load directly into Ollama or llama.cpp. A 12 GB RTX 3060 class card remains the most affordable entry point.
• Set Up Parallel Slots in Ollama: Start the Ollama server with the -np flag to set the slot count. Batching and prompt caching are enabled by default, allowing multiple questions to be evaluated against the same input simultaneously without significant latency increases.
• Configure Token Probability Output: Set n_predict to 1 (return only the next token), n_probs to at least your option count, and post_sampling_probs to true so the response carries plain probabilities between 0 and 1. Use a negative temperature to sample greedily while still reporting the raw softmax of the model's internal scores.

The pattern is open; what TypeSafe sells is the calibration training and the parallel sampler on top of it. TypeSafe's method, called RLCD (Reinforcement Learning for Calibrated Decisions), trains the returned probabilities to be honest: higher confidence is supposed to mean higher accuracy. Chat models trained on human preference often report inconsistent confidence levels. If RLCD holds up under independent testing, calibration is the primary reason to pay for Jev. Everything else you can build yourself.

What's the Catch With Running Jev Locally?

You give up two things: RLCD calibration and true parallel question evaluation. TypeSafe's showcase, a smart home assistant demo, uses a pattern called speculative fan-out, asking every question you might need in one call and letting code discard irrelevant answers. This is efficient, but it also means each command in your home is decided in someone else's data center. Running locally, you lose the calibration that makes TypeSafe's probability scores reliable, and you must manage parallel inference yourself. However, your data stays on your network, and you avoid vendor lock-in.

TypeSafe AI raised approximately $40 million in seed funding led by DCVC and left stealth the same day Jev shipped. Diogo Almeida, the company's founder, announced the launch on X (formerly Twitter) with claims of 20 to 200 times faster performance and 40 to 400 times cheaper costs. The company was candid in its launch materials, including nuance sections that explain the limits of these claims. For example, TypeSafe's 0 percent hallucination figure is not empirical; it is guaranteed by schema matching, a technique that has been available in grammar-constrained decoding since 2023.

The broader implication is clear: structured decision-making is becoming a distinct category within AI, separate from text generation. TypeSafe's approach trades generality for speed and cost predictability. For developers building applications that need fast, reliable answers to predefined questions, the local Ollama pattern offers a privacy-first alternative, though without the calibration guarantees TypeSafe provides. The choice between cloud and local depends on whether you value calibrated probabilities and vendor support over data privacy and independence.