# Jev by TypeSafe AI: A New Approach to Machine Decision-Making for Software
## What Jev Is and Why It Matters
The release of ChatGPT in 2022 marked a turning point in how artificial intelligence communicates with people. Now, a team from TypeSafe AI believes the next frontier lies in how AI communicates with software itself. Their creation, called Jev, is built on a transformer architecture — but it is not a large language model in the traditional sense. It does not produce prose, summaries, or free-form text. Instead, developers send it a data state and a set of structured questions, and it returns typed answers accompanied by probability scores that code can branch on directly.
This fundamental shift — from generating language to delivering calibrated decisions — opens up a new category of AI tooling. Jev is currently available as a hosted API in early access, accessible through a waitlist. The company has not yet released the model’s weights, disclosed its parameter count, or offered a self-hosting option.
## Understanding the System One Model Philosophy
The name “System One” draws inspiration from psychologist Daniel Kahneman’s framework, which distinguishes between fast, intuitive thinking and slower, deliberate reasoning. The TypeSafe team observed that reinforcement learning from human feedback (RLHF), the technique widely used to align models with human preferences, produces systems optimized for conversation. While effective for chat interfaces, this approach introduces two significant problems: overconfidence in its outputs and a tendency to lose itself in certain modes — what practitioners call mode dropping. Both of these flaws create a dependency on keeping a human in the loop.
Jev is built on an entirely different technical stack. It employs a novel architecture (whose specifics have not been disclosed), a parallel sampling mechanism, and a training paradigm called Reinforcement Learning for Calibrated Decisions. The goal is to produce outputs where the confidence level is itself a reliable signal — something developers can use to automate workflows or escalate uncertainty to human reviewers.
## How the Jev API Structures Its Input and Output
The entire Jev interface is handled through a single endpoint: `POST https://api.typesafe.ai/v1/systemone`. Each request carries three components: a `state` (the data context), a `model` identifier, and a map of `questions`. The documentation defines three primitive question types that can be mixed and matched in a single call.
### The Three Question Primitives
| Primitive | What It Does | What It Returns |
|———–|————-|—————–|
| **Choice** | Asks the model to pick one option from a defined list | A selected choice, a probability distribution over all options, and a confidence score |
| **Score** | Rates the input against a set of ordered levels | A numeric score, a probability distribution across levels, and a confidence score |
| **Noul** | Asks whether a statement is true or false | A binary judgment expressed as a probability between 0 and 1 |
A key design decision is that all questions within a single request execute in parallel and in isolation against the same state. TypeSafe reports that adding more questions has a negligible effect on response time. The Choice primitive supports up to 255 options per question.
Developers can integrate Jev using the Python SDK (`pip install typesafe-sdk`, requiring Python 3.10 or later) or the JavaScript SDK (`@typesafe-ai/sdk`). The documentation also provides examples for cURL and an agent skill compatible with Claude Code.
## Why Confidence Is the Core Metric
Every response from the Choice and Score primitives includes a confidence value ranging from 0 to 1. This value is derived from the shape of the returned probability distribution. For example, if a department classification returns “billing” at 0.84 but “technical” still holds 0.159, the overall confidence will be relatively low — in this case, 0.596 — because the answer is not decisively isolated.
The recommended workflow from the documentation outlines three paths based on confidence thresholds:
– **High confidence** — Act on the decision automatically.
– **Medium confidence** — Route the decision to a human review queue.
– **Low confidence** — Send the decision to a person for handling.
The critical insight is that thresholds should be calibrated against the cost of a wrong action. For low-stakes decisions, aggressive automation may be appropriate. For high-stakes scenarios like financial transactions or legal matters, a more conservative threshold makes sense.
## Pricing, Speed, and Interpreting the Benchmarks
Jev is priced at $42 per billion input tokens, with no charge for output tokens. For context, the team behind Jev has cited existing large language models as costing between $0.20 and $10 per million input tokens. In their recorded side-by-side demonstration, Jev completed a request in 0.114 seconds for $0.000081, while a comparable LLM took 8.566 seconds and cost $0.013880.
This yields claimed speed and cost advantages of 193.6x and 444.6x respectively. However, several caveats apply to these figures:
– The reference answers used for evaluation come from the average of two other models (not the ones Jev competes against directly in the claim).
– The evaluation workflows were written by the TypeSafe capabilities team.
– The company expects these gains to represent the upper end of real-world performance.
– The company has not confirmed whether the pricing is subsidized or reflects true production costs.
Additionally, the claim of “zero hallucinations” refers to schema matching — the output always conforms to the requested type structure — rather than factual correctness. An answer can still be wrong even if it is well-typed.
## What Developers Are Building With Jev
Within days of its release, the community began building applications on top of Jev. Notable projects include:
– **Command safety verification**: Vercel’s CEO reported that Jev processed safety reviews up to 18 times faster at the 95th percentile compared to a leading competitor, while delivering higher accuracy. An engineer shared the benchmark publicly.
– **Email triage**: A CTO at a startup found a competing AI model slightly more accurate for sorting inboxes, but at 10 to 20 times the operational cost.
– **Browser-based agents**: One project completed a flight search across two European cities in just over seven seconds.
– **Mobile phone agents**: Another project drove ride-hailing and other actions on a real Android device, completing nine discrete actions in roughly 21 seconds.
– **Video scoring**: A tool was built that evaluates each sentence in a debate for approximately five cents per session.
– **Live typing integration**: A developer created an interface that updates judgment results in real time as a user types, processing 16 simultaneous assessments.
– **Gaming**: Jev was used to complete the first combat mission in a real-time strategy game and to control guard characters in a heist-themed game.
– **Agent guardrails**: A tool rates each tool call proposed by an AI agent as deny, ask, or allow.
– **Database and smart home integrations**: Extensions were created to add plain-language filtering to a popular SQL database, and another turns AI responses into smart home automation entities.
## Known Limitations to Consider
The development team has published a candid list of Jev’s failure modes. Developers should be aware of the following constraints:
1. **Literal interpretation**: Jev answers the question exactly as written, not as intended. Negations and implied conditions are taken at face value. The recommendation is to state exact conditions and include boundary cases in the criteria.
2. **No arithmetic capability**: Counting, basic math, hex color handling, and interpolation between score levels are unreliable. Developers should keep calculations in code and use multiple binary questions (Noul) to count items.
3. **Dates are treated as text**: Determining chronological order or whether a date falls within a window is unreliable. The suggested fix is to extract date components as separate Choice questions and compare them in application code.
4. **Multi-hop reasoning degrades accuracy**: Questions involving double negatives or properties of properties are harder to answer correctly. These are more akin to deliberate, System Two-style thinking and should be decomposed into direct questions combined in code.
5. **Context rot with large inputs**: Accuracy drops as irrelevant content grows in the state. The hard limit is 64,000 tokens per request. Filtering in code before sending a request is strongly recommended.
6. **Vulnerability to adversarial state content**: The model treats all state as data, not as potentially hostile input. Injected instructions can shift results. Explicit criteria and pre-deployment edge case testing are advised.
7. **No text generation**: Jev was not trained to write. Attempting to chain multiple choices into a narrative is slow and produces poor results. For text output, developers should use a generative model, or reframe the problem as a Choice over candidate values.
## Frequently Asked Questions
**What exactly is Jev?**
Jev is a transformer-based decision engine developed by TypeSafe AI. It is not a generative language model — it does not produce text. Instead, it takes a structured data state and typed questions, then returns typed answers with probability distributions and confidence scores.
**How is Jev different from ChatGPT or similar models?**
ChatGPT and similar models are designed to generate human-readable text through autoregressive token-by-token generation. Jev uses a fundamentally different architecture and training process (RLCD — Reinforcement Learning for Calibrated Decisions) to produce discrete, typed decisions that code can act on directly, without a parsing or validation step.
**Can I host Jev myself?**
Not currently. Jev is only available through TypeSafe’s hosted API, which is in early access behind a waitlist. There is no option to download weights or run the model on your own infrastructure.
**How much does Jev cost?**
Jev charges $42 per billion input tokens. Output tokens are free. For a typical workload of one thousand input tokens per call and a million calls per day, the daily cost would be approximately $4.20.
**What are the three question types?**
The primitives are Choice (selecting one option from a list), Score (rating against ordered levels), and Noul (a true/false probability). All three can be used simultaneously in a single API call.
**Is Jev’s confidence score reliable?**
The confidence score is derived from the shape of the probability distribution and is designed to be a useful heuristic for routing decisions. However, it is not a guarantee of correctness. Developers should validate confidence thresholds against their own domain-specific accuracy requirements.
**What are the limits of Jev?**
The input state is capped at 64,000 tokens. Jev cannot reliably count, do math, compare dates, handle multi-hop logic, or generate text. It also interprets input literally, which means ambiguous phrasing can produce unexpected results.
**What is being built on top of Jev today?**
Community projects span command safety for code execution, email sorting, browser-based web agents, mobile phone automation, video debate scoring, live typing interfaces, game AI, agent guardrails, and database/home automation integrations.
## Conclusion
Jev represents a genuinely different paradigm in AI tooling — one that shifts the focus from text generation to structured, typed decision-making with explicit confidence signals. For developers building systems where reliability, cost, and speed are critical, this approach offers a compelling alternative to traditional large language models. The speed and cost advantages claimed by the team are significant, though independent validation of the benchmarks is still pending. The known limitations are real and well-documented, and they point to a clear role for Jev as a component in a larger system rather than a standalone replacement for generative AI. As the ecosystem of community-built tools grows, it will become clearer exactly where this model fits in the broader AI landscape. The early access stage means that pricing, performance, and capabilities are still evolving, making this a project worth watching closely.
Thank you for reading
