Meet Jev: The Non-Generative 'System One' Model Replacing LLMs in Agent Loops
TypeSafe AI's Jev drops text generation for parallel, typed decisions; the company claims it is 40x to 200x faster on quick decision tasks, based on its own tests.
For the past four years, the entire artificial intelligence industry has operated under a single architectural dogma: every problem should be solved by autoregressively predicting the next token in a string. We have forced massive text-generation transformers to serve as classification switches, fuzzy routers, output validators, and conditional logic gates.
Diogo Almeida—who says that at OpenAI he helped build the methods that made language models good at following instructions, the research behind ChatGPT—just released the counterargument. After two years in stealth, his startup TypeSafe AI launched Jev, inaugurating what they describe as a fundamentally new architectural category: System One Foundation Models.
Jev makes a radical trade-off that runs directly counter to current frontier trends: it completely abandons free-form string generation. It cannot chat, it cannot draft essays, and it cannot write explanations. Instead, it ingests unstructured or structured system state and outputs type-safe, schema-enforced probabilistic decisions. TypeSafe says that makes it 40x to 200x faster than frontier LLMs on the quick decision tasks it targets, and far cheaper. Those figures come from TypeSafe's own tests.
The Problem with LLMs as Software Glue
Modern agentic workflows and automated pipelines spend the vast majority of their compute cycles on decisions rather than creative generation. In an average multi-agent loop, a model is repeatedly queried to answer simple programmatic questions:
- Does this customer inquiry require human escalation?
- Which downstream tool should be invoked next?
- Did the generated SQL query satisfy safety guardrails?
- Is this code patch ready for deployment?
When developers use frontier chat models (frontier LLMs from OpenAI, Anthropic or Google) to perform these tasks, they inherit the fundamental inefficiencies of autoregressive text generation. Every decision requires sequentially sampling dozens of tokens, adding latency. TypeSafe puts end-to-end response times for frontier models at 3 to 329 seconds, which it calls a big bottleneck when a model is called from code. Furthermore, developers must construct complex JSON schemas, parse markdown output blocks, handle occasional schema drift, and manage non-deterministic refusals.
As Almeida points out, using a 100-billion-parameter conversational agent to evaluate a boolean conditional is the computational equivalent of driving an eighteen-wheeler to the corner store to buy milk.
Traditional Agent Loop (Sequential Autoregressive LLM):
[State] ──> [Token 1 ──> Token 2 ──> Token N (JSON String)] ──> [Parser / Regex] ──> [Branch]
Latency: seconds | Output: free-form text that must be parsed | Cost: per-token for input and output
System One Loop (Jev Parallel Decision Sampler):
[State] ──> [Direct Parallel Tensor Evaluation] ──> [Typed Output: {is_urgent: 0.999}]
Latency: 70ms – 500ms (TypeSafe's figure) | Output always fits the schema | Cost: $0.042 / MTok input, output free
Under the Hood: RLCD and Non-Autoregressive Sampling
The name "System One" is drawn from Daniel Kahneman’s dual-process cognitive framework. While frontier reasoning models (such as OpenAI's o-series or DeepSeek-R1) leverage RLVR (Reinforcement Learning with Verifiable Rewards) to execute slow, deliberative "System 2" chain-of-thought generation, Jev is purpose-built for instantaneous "System 1" intuition.
To build Jev, TypeSafe AI replaced the standard LLM training and inference stack with three distinct innovations:
- Reinforcement Learning for Calibrated Decisions (RLCD): Modern chat LLMs are optimized via RLHF (Reinforcement Learning from Human Feedback), which trains models to produce verbose, pleasing text. RLCD instead optimizes the model’s internal logits to reflect calibrated, epistemically honest probabilities. The aim is that when Jev assigns an 85% probability, it is right about 85% of the time.
- Hardware-Aware Parallel Sampler: Because Jev does not condition token N on token
N-1, it bypasses sequential KV-cache decoding entirely. When an application passes multiple questions against a single state context, Jev evaluates all queries in parallel in a single forward pass. LangChain's write-up says adding questions barely changes the response time. - Typed Output Primitives: The model exposes three native output primitives declared prior to execution:
Noul: a yes-or-no question, returning the probability that the statement is true.- A choice among pre-declared options (cardinality up to 255), returning probabilities for each option.
- A score: rating an input against ordered levels such as low, medium and high, returning a continuous score, the distribution and a confidence value.
Because the output surface is bounded by the predefined schema, TypeSafe says type errors are mathematically impossible: an answer always fits the form. That does not mean the answer is right. TypeSafe's own post says its 0% chart value is "not empirical", it just follows from the schema guarantee.
What TypeSafe Claims, and Its Own Caveats
TypeSafe's launch post makes these claims about Jev against frontier LLMs:
- Latency: end-to-end response time of 70ms–500ms, against 3 to 329 seconds for frontier models. TypeSafe says this ranges from 40x to 200x faster for the same level of intelligence on "System One shaped queries". It adds that its published evals are generally run from its team's laptops on the West Coast, where the service is based.
- Unit economics: input tokens at $0.042 per million ($42 per billion), with output tokens free ("too cheap to meter"), against $0.20 to $10 per million input tokens for frontier models. TypeSafe adds that it can't prove the pricing isn't subsidized.
- The headline figures: the 193.6x faster and 444.6x cheaper numbers on TypeSafe's home page come from its own "workflow evals". Its post says it expects these to be on the higher end of real-world gains, and notes the workflows were written by people on its own model capabilities team, so some bias could exist. The reference answers are the average of GPT-6 Astra and Fable 5.1.
- Access: Jev is in early access, and TypeSafe is bringing developers off a waitlist.
The Ecosystem Integration: LangChain and Beyond
LangChain published an integration, langchain-typesafe, whose TypeSafeClassifier returns classification results instead of a chat response. LangChain describes Jev as a promising complement to the model driving an agent, not a drop-in replacement for an LLM.
from langchain_typesafe import Noul, TypeSafeClassifier
# Instantiate the System One decision engine
classifier = TypeSafeClassifier()
response = classifier.invoke({
"state": "The primary database connection pool exhausted on worker node 4. Alerts triggering.",
"questions": {
"is_p0_incident": Noul(instructions="Does this indicate immediate production customer downtime?"),
"requires_security_team": Noul(instructions="Is this related to an unauthorized intrusion attempt?")
}
})
print(response.nouls["is_p0_incident"].noul) # Output: 0.984
LangChain also shows two experimental middleware examples: a model router that lets Jev assess a request and choose a cheaper or more capable model based on criteria you define, and a guardrail that checks tool calls for risky decisions and blocks them before the tool runs.
TypeSafe's own demos include a real-time Doom controller, and it pitches Jev for scoring, judging and verifying LLM outputs and detecting jailbreaks.
The Bifurcation of AI Architectures
For years, the industry operated under the assumption that a single, unified general-purpose model would eventually handle every stage of the software stack. Jev suggests one possible shape for production AI, a dual-tier architecture:
- Generative & Reasoning Engines (System 2): Massive autoregressive models deployed sparingly for high-context human interaction, creative drafting, and long-horizon verifiable problem-solving.
- Deterministic Decision Engines (System 1): Ultra-fast, type-safe models like Jev operating as the compiled "smart if-statements" and nervous systems of modern software.
By treating classification and decision-making as first-class architectural primitives rather than a side effect of chat generation, TypeSafe AI is betting that software often needs a model to decide, not to talk. Whether its speed and cost claims hold up outside its own tests is the open question: ask what Jev was compared with, and who ran the test.
Sources
- Introducing System One Models & Jev typesafe.ai
- What Is Jev? A Guide to TypeSafe AI's System One Model langchain.com
- Jev: System One models for Prod, not God — with Diogo Almeida latent.space
The stories that matter for people who build with AI, with the source for every claim. Free, no spam.
Feed, daily deep-dive and bytes — readable offline, with push alerts for the topics you follow.