Jev AI: TypeSafe AI’s Non-Autoregressive System 1 Model Explained
Jev AI is a proprietary System 1 model from TypeSafe AI that returns typed, calibrated decisions with probabilities instead of generating text, released in limited early access on 15 September 2026. Its founding team includes researchers formerly at OpenAI, ensuring deep expertise in frontier model architectures. This guide covers what Jev is, its non-autoregressive architecture, how it compares to standard conversational models on speed and cost, its API primitives and pricing, real-time demos, and the company behind it.
It also adds fresh reporting on early developer adoption, funding percentile rank and measured speedups that competitor pages do not cover. The release marks a distinct shift toward structured decision layers in production environments.
What Is Jev AI?
Jev is a proprietary System 1 model developed by TypeSafe AI that evaluates a block of state and returns typed decisions with calibrated probabilities instead of generating text, released in early access on 15 September 2026. This non-autoregressive model directly targets programmatic environments rather than chat interfaces. As a result, it competes with any Large Language Model attempting to perform structured decision-making inside continuous software loops.
Jev in one sentence
At its core, a System One Model acts as a frontier-intelligence function call that takes unstructured state in and outputs typed probabilistic decisions. It represents TypeSafe AI’s first public System 1 model and represents a fundamental departure from conversational workflows.
Unlike a traditional LLM, it does not produce natural-language strings, meaning it simply cannot output conversational text. It is constrained purely to the schema defined by the software interacting with it.
- It takes unstructured text or data as state.
- It processes the data in a single pass.
- It returns probability distributions across defined choices.
System 1 vs System 2 thinking
The fundamental concept draws heavily from Daniel Kahneman’s Thinking, Fast and Slow, illustrating the divide between different cognitive approaches. System 1 represents fast, intuitive decisions, while System 2 involves slow, deliberate reasoning typically associated with chain-of-thought prompting.
Jev targets the fast, structured decisions that software consumes directly, prioritizing immediate programmatic routing over step-by-step reasoning. By focusing on intuition-like classification, the model bypasses the massive latency overhead associated with traditional text generation.
Who Developed Jev? TypeSafe AI and Diogo Almeida
Jev was developed by TypeSafe AI, a San Francisco company founded in 2024 by Diogo Almeida, Erik Gafni and Sasha Sheng, with Almeida a former OpenAI researcher and co-creator of ChatGPT and RLHF. The team set out to build an intelligence layer that addresses the latency limitations they observed while developing traditional frontier models.
The founding team
TypeSafe AI was founded in 2024 by Diogo Almeida, Erik Gafni and Sasha Sheng. Diego Almeida spent approximately four years at OpenAI working on RLHF, InstructGPT, ChatGPT and GPT-4 before leaving in 2024 to found the company.
Following his departure, the TypeSafe AI founders worked quietly on a completely different architecture. Diogo Almeida developed Jev in stealth for roughly two years before its release, focusing on removing the autoregressive bottleneck entirely.
Funding and valuation
DCVC led a major seed round for TypeSafe AI, which Forbes reported valued the company at US$200 million. This influx of capital allowed the team to secure the necessary compute for synthetic training runs.
TypeSafe AI’s seed round ranks in the 99th percentile of all-time AI seed rounds, based on a vast sample of deals.
| Metric | Detail |
|---|---|
| Founded | 2024 |
| Founders | Diogo Almeida, Erik Gafni, Sasha Sheng |
| Seed Funding | US$40 million (led by DCVC) |
| Valuation | US$200 million |
How the Non-Autoregressive System 1 Architecture Works
Jev’s architecture is a non-autoregressive model: instead of generating one token at a time, a parallel sampler evaluates every typed question against the state in a single pass and returns calibrated decisions, acting strictly as a System 1 layer. This approach fundamentally contrasts with how a standard Large Language Model processes prompts.
Parallel sampling instead of token-by-token
Sequential autoregression requires each token to be conditioned on the last, slowing down execution proportionally to the output length. Typesafe AI’s Non-Autoregressive System-1 Model uses a single-pass parallel sampler that returns all outputs at once, vastly reducing latency.
The model cannot hallucinate text or make type errors because its outputs are strictly constrained to the supplied schema. Jev has a context window of 32,000 tokens, supports a cardinality up to 255, and returns the model identifier jev-1.13.0 in evaluation responses.
RLCD training and synthetic data
The model is optimized using Reinforcement Learning for Calibrated Decisions (RLCD), which aligns probabilities against outcomes rather than human rater preference. This differs significantly from standard RLHF methods used by older chat bots.
- The system ingests purely synthetic datasets for training purposes.
- RLCD optimizes the output probabilities strictly against logical outcomes.
- The parallel sampler processes these weights during inference to yield calibrated confidence scores.
TypeSafe AI trains Jev exclusively on synthetic data, and outside observers suggest it may be built on an open-weight LLM. For internal benchmarks, workflow evaluation reference probabilities were derived from the average of GPT-6 Astra and Fable 5.1.
- Training relies heavily on synthetic data rather than human annotations.
- RLCD replaces traditional human-in-the-loop preference tuning.
- Reference probabilities leverage frontier LLM consensus for accuracy.
Jev API: State, Questions, and the Noul/Choice/Score Primitives
A Jev request sends a block of state plus one or more typed questions, taking advantage of its non-autoregressive model architecture, and the API returns answers using three primitives — Noul (yes/no probability), Choice (pick one option with per-option probabilities) and Score (rate against ordered levels) — each with a confidence value within its 32,000 tokens context window.
The three question primitives
The API exposes three exact question formats to enforce typed outputs. The Noul primitive returns a probability between 0 and 1 indicating if a statement is true, completely eliminating the need for yes/no text parsing.
The Choice primitive returns a selected option alongside per-option probabilities and a confidence score, while Score returns a continuous score and per-level distribution. All questions in one request are evaluated in parallel, and extra questions cost only their added tokens, which makes batching highly efficient.
Request shape and limits
A minimal request requires specifying the target model, such as jev-latest or typesafe/jev, a state string, and a structured questions object. Developers submit the unstructured text as the state and define exactly what they want to extract via the TypeSafeClassifier payload.
Developers must be mindful of the 32,000-token context window when passing large state strings like document logs. The API responses report input_tokens and output_tokens usage and explicitly return the model identifier jev-1.13.0.
Getting Started: LangChain, Cloudflare and Framework Integrations
You call Jev through provider integrations — LangChain exposes it as TypeSafeClassifier via langchain-typesafe, and Cloudflare Workers AI serves it as typesafe/jev — by passing a state and questions and reading back typed classification results, as officially supported by TypeSafe AI.
Using Jev with LangChain
To integrate with LangChain, developers install the langchain-typesafe package and set their TYPESAFE_API_KEY environment variable. Once configured, they instantiate the TypeSafeClassifier class to begin building.
From there, calling the invoke method with the required state and Noul, Choice, or Score questions executes the evaluation. The ecosystem also supports ModelRouterMiddleware for intelligent model routing and AutoModeMiddleware for gating risky tool calls before execution, providing a strong safety net compared to a generic Claude integration.
Using Jev on Cloudflare Workers AI
For serverless applications, Cloudflare Workers AI provides direct access to the model. Developers simply call env.AI.run(‘typesafe/jev’, {state, questions}) or utilize the provided REST endpoint for external HTTP requests.
The platform lists the model with a 32,000-token context window, matching the official specifications. All responses via Cloudflare correctly return calibrated answers with precise probabilities and confidence scores, enabling instantaneous edge routing.
Jev vs LLMs: Speed, Cost and Performance Benchmarks
Jev is faster than a Large Language Model and is cheaper than a Large Language Model: TypeSafe reports a response time of 70ms-500ms end-to-end versus 3–329 seconds for LLMs, and claims it is 40–200x faster and 40–400x cheaper, peaking at 193.6x faster and 444.6x cheaper on its own workflows.
Response time and throughput
The architecture eliminates the sequential generation bottleneck found in text models. End-to-end response time is 70ms-500ms (70 to 500 milliseconds) for TypeSafe / Jev, compared to 3 to 329 seconds for existing frontier LLMs.
Third-party benchmarks have already validated massive improvements in production scenarios. Vercel reported running safety classifiers 5 to 18 times faster (and with greater accuracy) using Jev compared with OpenAI’s ChatGPT Luna 5.6.
Speed and cost multipliers
When evaluating System 1 vs LLM setups, the theoretical limits of non-autoregressive parallel processing become clear. TypeSafe AI claims Jev is 40 to 200 times (around 100 times, peaking at 193.6x) faster and 40 to 400 times (around 100 times, peaking at 444.6x) cheaper than comparable frontier LLMs.
These frontier LLM comparison figures are self-tested on the company’s own workflow environments and are described as high-end estimates. Nevertheless, even conservative real-world deployments show generation delays are almost entirely removed.
Pricing head-to-head
Standard conversational models charge heavily for both reading and writing data. Existing LLM input tokens range from $0.20 to $10 / MTok, with output tokens being approximately 5x more expensive than input tokens, making them incredibly costly for heavy programmatic loops.
By contrast, TypeSafe AI input tokens for Jev cost $0.042 / MTok ($42 per billion tokens), while output tokens are free. Jev meters input by the billion rather than the million, underscoring its design for high-volume, low-latency API traffic against models like GPT-4 or Claude.
| Model Category | Input Cost | Output Cost | Generation Speed |
|---|---|---|---|
| Jev AI | $0.042 / MTok | Free | 70ms – 500ms |
| Frontier LLMs | $0.20 to $10 / MTok | ~5x input cost | 3 – 329 seconds |
Jev Pricing: What It Costs to Run
Jev input tokens cost $0.042 / MTok ($42 per billion) and output tokens are free, meaning high-frequency real-time calls that would be uneconomical on standard per-token pricing become viable, proving it is significantly cheaper than a Large Language Model.
Token pricing
The token pricing model deliberately shifts the economic scale for agentic workflows. Jev input tokens are metered by the billion rather than by the million, and output tokens are free.
- Input cost is set at $42 per billion tokens.
- Output generation incurs absolutely zero cost.
- Metering targets extreme high-volume API utilization.
This billing structure fundamentally changes how developers design software architectures. Rather than minimizing prompts, engineers can evaluate state continuously in tight loops.
LangChain is a framework for building agents and LLM-powered applications. It helps you chain together interoperable components and third-party integrations to simplify AI application development — all while future-proofing decisions as the underlying technology evolves.LangChain
Real-world cost examples
Testing in simulated environments reveals just how cheap continuous classification can be. A two-minute Minecraft bot session using Jev consumed a significant amount of tokens at a negligible cost, making 10 queries a second in the Doom demo cost ~$7/hour, and a 15-minute simulated drone navigation cost roughly 10 cents.
Because outputs are free, the cost scales strictly linearly with the state size provided in each request. If developers keep the context payload trim, real-time applications can run perpetually with minimal financial overhead.
Real-Time Use Cases and Demonstrations
Jev is used inside tight real-time applications — game bots, driving and drone simulators, browser and email agents, model routing and tool-risk gating — where a decision is needed in milliseconds because its response time is 70ms-500ms, achieved through its non-autoregressive model design. It serves primarily as a fast decision layer.
- Game and simulator agents process environments instantly.
- Production agent workflows manage live triage.
- Safety middleware blocks risky tool actions before they execute.
The gaming and simulation space has seen the most rapid prototyping. Developers built the early Minecraft, driving, and drone demos in under an hour, sometimes in as little as 15 minutes. The Minecraft bot successfully flees zombies without relying on a single hand-coded rule, operating purely on structured state rather than image data, alongside similar setups for a Doom demo and a Subway Surfers-style game.
For production agent workflows, Kyle Jeong from Browserbase used Jev to power browser use agents for fractions of a cent. Other engineers are deploying it for live algorithmic trading and instantaneous email triage. Demand was so high after launch that TypeSafe AI briefly lost the ability to serve users through its API.
Why the Name Jev? The Jevons Paradox
Jev is named after William Stanley Jevons, the 19th-century English economist whose Jevons paradox holds that cheaper, more efficient use of a resource increases its total consumption, reflecting TypeSafe’s expectation that cheaper machine intelligence will unlock wider use.
From coal to compute. The name draws a direct analogy to the historical relationship between fuel and steam engines. Just as increased engine efficiency raised the overall demand for coal, making the system cheaper to run did not decrease fuel usage.
Intelligence as a raw resource. Every order-of-magnitude drop in the cost of intelligence is expected to unlock orders of magnitude more use cases. TypeSafe AI believes that driving inference costs near zero will paradoxically cause global compute consumption for AI to skyrocket as it becomes embedded in every real-time software loop.
FAQ
What is the origin of the name Jev?
Jev is named after William Stanley Jevons, a 19th-century English economist famous for the Jevons paradox.
How much does it cost to run Jev?
TypeSafe AI charges $0.042 per million input tokens, which equals $42 per billion tokens, while all output tokens are completely free. This makes tasks like running a two-minute Minecraft bot session cost about 1 cent.
Is Jev available to the general public?
Jev was released in limited early access on 15 September 2026 rather than being open to everyone immediately. Following the launch, high demand briefly caused TypeSafe AI to lose the ability to serve users via its API.
How fast is Jev compared to traditional frontier LLMs?
Jev delivers an end-to-end response time between 70 and 500 milliseconds, whereas traditional frontier LLMs require between 3 and 329 seconds. Overall, TypeSafe AI benchmarks indicate Jev operates 40 to 200 times faster.
Can Jev be used to control real-time autonomous systems?
Yes, Jev has been demonstrated powering low-latency applications including simulated drone navigation, driving, and browser agents. For instance, developers built early real-time navigation prototypes in under an hour.
Is Jev simply a smaller standard LLM?
No, Jev relies on a distinct System 1 non-autoregressive architecture trained entirely on synthetic data. Outside observers suggest it may be built on top of an open-weight foundation rather than functioning like a standard scaled-down LLM.