⏱️ Lectura: 9 min
TypeSafe AI just launched Jev, a model that doesn’t write text: it only makes typed decisions, and it does so up to 200 times faster than a frontier LLM.
📑 En este artículo
The company, founded by Diogo Almeida (who helped design the methods behind ChatGPT at OpenAI), unveiled its first System One Model on September 15, 2026: a model category designed so that software, not a person, consumes the response directly.
TL;DR
- TypeSafe AI unveiled Jev, its first “System One Model,” in early access on September 15, 2026.
- Jev doesn’t generate text: it produces typed decisions with calibrated probabilities, with no risk of type errors.
- Training uses Reinforcement Learning for Calibrated Decisions (RLCD), distinct from RLHF and RLVR.
- Input tokens cost $0.042 per million (about $42 per billion); output tokens are free.
- Current frontier LLMs charge between $0.20 and $10 per million input tokens, up to 5x more for output.
- Jev responds in 70 to 500 milliseconds, compared to 3 to 329 seconds for a frontier LLM.
- TypeSafe reports up to 40x-200x faster performance for System One-type tasks with comparable intelligence.
- Founder Diogo Almeida worked at OpenAI on the methods that gave rise to ChatGPT.
What Happened with TypeSafe AI’s Jev
Diogo Almeida spent four years asking himself the same question: if language models have been superhuman conversationalists for years now, why has software automation remained stuck? His answer, after two years in stealth mode, is Jev, TypeSafe AI’s first public product.
Jev doesn’t compete with Claude or GPT at writing paragraphs. It takes unstructured program state as input and returns a typed value (a category, a score, a label from a fixed list) along with a calibrated probability. TypeSafe describes it as “a function call with frontier intelligence”: unstructured state goes in, a typed probabilistic decision comes out.
To achieve this, the company built a new stack: a proprietary model architecture, a parallel sampler, and a training method they call Reinforcement Learning for Calibrated Decisions (RLCD). Jev is available today in early access, with no public date for general availability.
Context and Background: From RLHF to RLCD
Today’s conversational LLMs are fine-tuned with Reinforcement Learning from Human Feedback (RLHF) or with verifiable rewards (RLVR): the goal is for a human to prefer the response, or for an automatic verifier to confirm that a result is correct. Both approaches reward free-form text: code, chat, or even a refusal to answer.
RLCD changes the objective. Instead of optimizing for human preference, it optimizes for the probability the model assigns to each option being epistemically honest. If Jev says 87% confidence in a category, that 87% should match the actual accuracy rate: that’s calibration.
The name “System One” is no accident. It refers to dual process theory: a fast, intuitive System 1, and a slow, deliberate System 2. TypeSafe positions conversational LLMs as System 2 (they reason step by step, generating text) and Jev as System 1: structured, immediate reactions, with no narrated reasoning.
Technical Details and Performance
The fundamental difference lies in how each model produces its response. An LLM is autoregressive: it generates a token, uses it as context to generate the next one, and so on until the chain is complete. Jev, by contrast, computes all output probabilities in a single parallel query, without chaining tokens.
flowchart TD
A["Unstructured input"] --> B["Traditional LLM (RLHF / RLVR)"]
B --> C["Generates token 1"]
C --> D["Token 2, conditioned on the previous one"]
D --> E["... until the chain is complete"]
A --> F["Jev (RLCD)"]
F --> G["Computes all probabilities in parallel"]
G --> H["Typed decision with confidence score"]That architectural difference is what TypeSafe reports in terms of speed and cost: a frontier LLM takes between 3 and 329 seconds to respond end to end; Jev responds in 70 to 500 milliseconds, 40 to 200 times faster for System One-shaped queries.
| Aspect | Traditional LLM (RLHF / RLVR) | Jev (RLCD) |
|---|---|---|
| Optimizes for | Human preference or verifiable rewards | Calibrated decisions |
| Outputs | Free-form text strings | Typed values with probability |
| Sampling | Sequential, one token at a time | Parallel, all in one query |
| Input cost | $0.20 to $10 per million tokens | $0.042 per million tokens |
| Output cost | Up to 5x the input price | Free |
| Speed | 3 to 329 seconds per response | 70 to 500 milliseconds |
| Ideal use case | Chatbots, copilots, coding agents | AI workflows, verification, routing |
TypeSafe highlights a point that is mathematically verifiable: because the schema of possible outputs is fixed before the query, Jev cannot return a value outside that set. This isn’t a promise about behavior, it’s a structural constraint of the system.
💡 Tip: before migrating a critical decision to a new model, run your own benchmark with your own data. TypeSafe clarifies that its published evals were run from its own laptops on the West Coast, not in a neutral environment.
A conceptual example of what integration might look like (TypeSafe’s public SDK isn’t available yet, so this is illustrative, not the official syntax):
// Conceptual example: Jev's official syntax is not yet public
type TicketDecision = {
category: "billing" | "technical" | "spam";
confidence: number; // calibrated probability, 0.0 to 1.0
};
async function classifyTicket(text: string): Promise<ticketdecision> {
return jev.decide({
input: text,
schema: "SupportTicketCategory"
});
}</ticketdecision>That function always returns one of the three defined categories, never loose text. The second block shows why calibrated probability matters in production: it lets you decide when to trust the machine and when to escalate to a person.
const decision = await classifyTicket(ticket.body);
if (decision.confidence >= 0.9) {
routeTo(decision.category);
} else {
// Low confidence: don't force the decision, escalate to a human
escalateToHuman(ticket, decision);
}With a conventional LLM, that confidence threshold has to be invented by parsing free text. With a typed, calibrated output, the threshold applies directly to a number.
How to Try TypeSafe AI’s Jev Today
Here’s the honest limitation: TypeSafe hasn’t yet published an SDK or a general-access CLI. Jev is in early access, and the only documented path in the announcement is joining the waitlist at typesafe.ai.
What you can do today is prepare your use case: identify the “fuzzy ifs” in your own code (business rules currently resolved by a human or by an LLM with a long prompt) and note what typed output schema you’d need to replace them. When access opens up, that list of schemas is exactly what Jev needs as input.
⚠️ Heads up: free output today doesn’t guarantee it stays that way. TypeSafe admits it can’t prove its $0.042-per-million-input-tokens price isn’t subsidized; only time will confirm whether it’s sustainable.
Impact and Analysis
The bottleneck TypeSafe points to is real: a frontier LLM taking up to 329 seconds per response is tolerable in a chat where a person is waiting, but it’s a serious drag when that LLM is embedded inside a software pipeline that runs thousands of times per minute.
The use cases TypeSafe proposes for Jev are concrete: AI workflows that act as a fuzzy “if” (classifying, routing, scoring, extracting fields), chained verification (judging, setting guardrails, detecting jailbreaks in other LLMs’ prompts and reasoning), map-reduce over massive datasets, and real-time applications where 100 milliseconds genuinely matters for the user experience.
None of those cases replace a coding copilot or a chatbot: they’re tasks where a team today uses a conversational LLM for lack of a better option, paying the cost and latency of generating text just to parse it afterward. That downstream parsing is also an additional point of failure: if the LLM strays from the expected format, you have to validate and retry.
💭 Key point: TypeSafe’s bet isn’t that AI will think better, it’s that it will stop needing translation between natural language and a data structure the software already understands.
What’s Next
What’s missing to judge TypeSafe AI’s Jev with independent data is, precisely, independence: the speed and cost figures today come from TypeSafe itself, run from its own laptops. A third-party benchmark on the same classification, routing, and verification tasks would be the logical next step before production teams move real traffic to it.
It also remains to be seen how broad the catalog of schemas Jev supports will be outside of early access, and whether TypeSafe releases public API documentation before the end of the year.
📖 Summary on Telegram: View summary
Try it yourself: join the waitlist at typesafe.ai and compare Jev’s response time against your current LLM’s using the same prompt.
Frequently Asked Questions
What exactly is a “System One Model”?
It’s the category TypeSafe AI created for models optimized to make fast, structured decisions instead of conversing. The name refers to the theory of fast, intuitive thinking (System 1) versus slow, deliberate thinking (System 2), the territory of today’s conversational LLMs.
Can Jev write text like ChatGPT or Claude?
No. Jev deliberately gives up generating free-form text strings. It only returns typed values, for example a category from a fixed list, along with a calibrated probability defined in advance in a schema.
Why are Jev’s output tokens free?
According to TypeSafe’s announcement, output is considered too cheap to meter. The company charges only $0.042 per million input tokens, compared to the $0.20 to $10 per million that frontier LLMs charge.
What does it mean that Jev “can’t make type errors”?
The space of possible outputs is defined before the query through a fixed schema, so the model can never return anything outside that set: it’s a structural guarantee, not a promise about behavior.
Does Jev replace conversational LLMs like Claude or GPT?
It doesn’t replace them, it complements them. TypeSafe positions Jev for tasks where an LLM was previously used as a fuzzy “if” inside code (classifying, routing, scoring, verifying), not for chatbots or copilots with direct human oversight.
How can I try Jev today?
Jev is in early access. TypeSafe hasn’t yet published an SDK or a public CLI; the only available path is joining the waitlist at typesafe.ai.
References
- TypeSafe AI blog: official announcement of System One Models and Jev, with the comparative table of costs and speed.
- Wikipedia: explanation of RLHF, the method Jev avoids by using RLCD.
- Wikipedia: what an autoregressive model is and why it generates one token at a time.
- Wikipedia: the System 1 / System 2 thinking theory that inspires the name “System One Models”.
📱 Do you like this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Milad Fakurian en Unsplash
0 Comments