TypeSafe Jev: $0.042/1M Decision Model vs Auto-Regressive LLMs and MDLM
Contents
TypeSafe AI, co-founded by former OpenAI researcher and RLHF (Reinforcement Learning from Human Feedback) co-inventor Diogo Almeida, emerged from stealth on September 15, 2026, and announced its first model, Jev.
The startup raised a $40 million seed round led by DCVC.
Jev drops natural language text generation altogether. Instead of conversing with humans in a chat UI, it operates as a “System 1 model” dedicated to internal software branching and routing.
Based on public documentation and release materials, this post breaks down its closed API model, pricing, and how its architecture differs from auto-regressive Transformers and diffusion language models.
Availability and Pricing
Jev is not an open-weights model; it is delivered exclusively as a closed, managed API.
TypeSafe AI is currently accepting early access waitlist signups on its official console and issuing API keys to approved developers in batches.
There is currently no way to self-host or deploy Jev inside a private VPC or on-premises environment.
On Hacker News, developers highlighted the lack of open weights as an adoption blocker for financial and security environments that cannot send data externally.
For developers waiting on API access, an adapter library (system-one-adapter-python) is available on GitHub to simulate Jev’s typed schema on top of existing LLMs like OpenAI.
Pricing comparison with conventional LLMs:
| Metric | Price | Comparison with Frontier LLMs |
|---|---|---|
| Input tokens | $0.042 / 1M tokens ($42 / 1B tokens) | ~1/60th of GPT-4o ($2.50), ~1/3.5 of GPT-4o mini ($0.15) |
| Output tokens | $0 (completely free) | Frontier models charge 3–5x more for output than input; Jev does not bill for output |
Output tokens are free because the model does not generate text sequentially. Computation completes in a single forward pass over the input to produce fixed probability distributions, so there is no token generation phase to bill for.
In an accompanying demo, TypeSafe AI ran Jev in a 10 Hz (100 ms) decision loop to play the classic FPS DOOM.
The game feeds internal engine state to the API and receives action decisions (such as moving forward or firing). Running this loop costs about 7 per hour.
That works out to roughly \0.000194 per request—tens to hundreds of times cheaper than running the same loop on standard LLMs.
Designed Without Natural Language Generation
TypeSafe AI frames its architecture around Daniel Kahneman’s dual-process theory, categorizing Jev as “System 1.”
| Cognitive System | Characteristics | Corresponding AI |
|---|---|---|
| System 2 (Slow thinking) | Deliberate, step-by-step reasoning that generates text sequentially | Conventional frontier LLMs |
| System 1 (Fast thinking) | Instinctive and reflexive, picking immediately from defined options and weights | Jev |
In enterprise systems and web backends, most AI tasks do not need customer-facing prose. They need internal routing decisions, like triaging support tickets or flagging fraudulent invoices.
Coaxing traditional LLMs into structured outputs via JSON mode often yields unwanted preamble text or malformed JSON that requires retries.
Jev eliminates text generation entirely, returning strictly typed decision values to avoid those round-trip failures.
The name “Jev” references the 19th-century economist William Stanley Jevons and the Jevons paradox—the observation that as technological efficiency lowers resource consumption costs, overall consumption surges rather than drops.
By cutting decision latency down to double-digit milliseconds and pushing costs near zero, TypeSafe AI aims to make AI decisions cheap enough to replace arbitrary if statements throughout codebases.
Parallel Sampler: No Autoregressive Generation Loop
The fundamental architectural difference between autoregressive Transformers and Jev is the inference loop.
When a standard LLM produces structured output or classifications, it decodes token by token: first {, then ", and so on.
This autoregressive decoding is memory-bandwidth bound on GPUs. Even when the payload is just a few lines of JSON, latency climbs to hundreds of milliseconds or multiple seconds.
Jev eliminates the token generation loop. Its Parallel Sampler processes the input context and computes the probability distribution across all defined choices in a single forward pass.
Because it finishes in one pass, end-to-end latency stays between 70 ms and 500 ms.
The API defines three output primitives:
| Primitive | Description | Output Values |
|---|---|---|
Choice | Picks one option from an enum of up to 255 choices | Selected option, full probability distribution, confidence score (0.0 to 1.0) |
Score | Evaluates against a rubric with 2 to 10 discrete tiers | Score, probability distribution, confidence score (0.0 to 1.0) |
Noul | Binary Yes/No decision based on a Bernoulli distribution | Float from 0.0 to 1.0 (probability of Yes) |
Because the model has no mechanism to emit text outside these schema boundaries, syntax errors and schema-mismatch hallucinations cannot occur by construction.
How Jev Differs from Diffusion Language Models
Diffusion language models (such as Masked Diffusion Language Models / MDLM and dLLM) also avoid left-to-right autoregression by processing sequences in parallel.
Diffusion models initialize a sequence entirely with mask tokens ([MASK]) or noise, then iteratively unmask tokens across multiple denoising steps (reverse diffusion).
While bidirectional context allows parallel decoding, they remain generative models designed to produce text.
Removing noise requires 10 to 50 forward passes through the full network, making inference latency comparable to or higher than autoregressive models.
Key differences between Jev and diffusion language models:
| Dimension | Diffusion Language Models (MDLM, dLLM) | TypeSafe Jev |
|---|---|---|
| Primary Goal | Natural language text generation | Structured decisions and classification |
| Output Format | Token sequence (text) | Probability values for Choice, Score, Noul |
| Inference Passes | 10 to 50+ iterative denoising steps | Single forward pass (1 pass) |
| Latency | Hundreds of milliseconds to seconds | 70 to 500 ms |
| Model Category | Discrete diffusion generative model | Large-scale decision and classification model |
Comparisons between Jev’s Parallel Sampler and diffusion models stem from the shared concept of parallel evaluation without autoregression.
In practice, Jev does not run iterative denoising. It functions more like a parallel classification head that maps an encoder-style internal representation directly onto a predefined schema in one shot.
Probability Calibration via RLCD
Integrating Jev into production code relies heavily on the reliability of its reported confidence scores.
When conventional LLMs undergo RLHF, they are incentivized to produce assertive, human-pleasing answers. This often leads to sycophancy and overconfidence, where models report high certainty on incorrect answers.
To counter this, TypeSafe AI trains Jev using a proprietary reinforcement learning technique called RLCD (Reinforcement Learning for Calibrated Decisions).
Instead of human preference ratings, RLCD uses verifiable ground-truth data and proper scoring rules, such as the Brier score, to compute rewards.
When the model reports an 85% confidence score, the probabilities are statistically aligned so that it is correct 85% of the time.
This calibration lets application code branch directly on confidence thresholds:
# Fully automated routing above 95% confidence; fall back to human review below that
if result.answers["department"].confidence >= 0.95:
route_ticket(result.answers["department"].choice)
else:
escalate_to_human(ticket_id)Practical Applications for Calibrated Probabilities
Because Jev outputs calibrated probabilities and structured choices rather than text, it targets different workloads than conversational LLMs.
Emotion and Reaction State Machines for Conversational Bots
Jev cannot compose character dialogue on its own.
Instead, it acts as a low-latency state machine, taking user utterances and recent conversation history as input to compute an internal emotional state and next-action probability distribution.
Application code can query Choice or Score to determine how a character feels (joy, anger, sadness, or amusement) and sample reactions—such as empathizing, teasing, or playing coy—based on that distribution.
Prompting an autoregressive LLM to “reply angrily while concealing affection” often leads to repetitive phrasing and introduces latency before the first token streams.
Placing Jev upstream resolves emotion parameters and action paths in 70 to 500 ms. Developers can then pipe those decisions into lightweight generation models or canned voice clips to keep interactions fast and character behavior consistent.
Qualitative Signal Extraction for Financial Markets and Disclosures
Regression forecasting on numerical time-series data like stock prices is better suited for specialized quantitative models than NLP classifiers.
However, Jev fits pipelines that extract market signals from unstructured text: breaking news, regulatory filings, earnings reports, and social posts.
A monitoring pipeline can ingest high volumes of regulatory filings, using Noul (probability of Yes) to detect red flags like fraud or sudden solvency risks, and Score (1 to 10) to quantify business impact.
At $0.042 per million input tokens, systems can continuously monitor news feeds across thousands of tickers at minimal cost.
Because confidence scores are calibrated, risk policies can be coded directly into execution logic—for example, automatically trimming exposure or canceling open orders only when an alert clears a 98% confidence threshold.
Quantifying Qualitative Data in Pari-Mutuel Racing
Pari-mutuel betting markets—such as horse racing (up to 18 runners) and boat racing (6 boats)—match Jev’s output primitives: Choice handles up to 255 candidates to pick a winner, and Noul models place/show probabilities.
Pipelines can feed textual inputs—historical records, track conditions, pedigree notes, paddock observations, and trainer quotes—to estimate win probabilities and expected values.
In practice, quantitative features like speed figures and odds movements across hundreds of thousands of historical races drive baseline accuracy. Gradient-boosted decision trees (such as LightGBM) remain superior for tabular outcome prediction.
Jev fits this workflow as a fast preprocessing engine: it objectively scores unstructured, human-written text—such as morning-line commentary and trackside reports—and feeds those scores as fresh features into quantitative tabular models.