A customer-support ticket arrives. One large language model reads it, classifies it, picks a workflow, drafts the response, chooses a tool, and explains what happened.
That is convenient in a proof of concept. Repeat it across millions of tickets, claims, transactions, or agent actions, and the architecture starts to strain. Every small decision carries the latency, cost, and unpredictability of a general-purpose generative model.
TypeSafe AI just launched a model that takes a very different approach.
It is called Jev, and you cannot chat with it.
You give Jev the state of a system and a set of typed questions. It returns bounded decisions, probabilities, and confidence scores that software can use immediately. Emails, summaries, and code sit outside the job it was built to perform.
The part that got my attention is the constraint.
Jev belongs beside the LLM in your stack. It creates a new option for all the small decisions we currently force a general-purpose model to make.
For an enterprise team, that opens a bigger architecture question:
The short version
Jev is the first public System One model from TypeSafe AI. The company describes System One models as foundation models optimized for fast, structured decisions rather than free-form generation.
TypeSafe founder Diogo Almeida previously contributed to OpenAI's foundational InstructGPT and RLHF work. His new company has spent the past two years building a different training approach focused on calibrated decisions.
You send Jev context about the current situation and questions with defined answer types. It returns choices, scores, or probabilities. It can evaluate many of those questions in parallel.
- 193.6xfaster than frontier LLMs, at the high end of TypeSafe's tests
- 444.6xcheaper than frontier LLMs, at the high end of TypeSafe's tests
- 70–500 mstypical latency, depending on request and deployment
- $0.042per million input tokens; output tokens listed as free
All figures are company-reported by TypeSafe AI as of September 22, 2026.
TypeSafe reports that Jev was up to 193.6 times faster and 444.6 times cheaper than frontier language models across the System One workflows it tested. Those company-reported figures represent the high end of four selected evaluations. They do not establish a universal advantage across every workload.
A useful enterprise portfolio matches each component to the work it performs.
Jev could become one more component in that portfolio.
Jev turns model calls into typed decisions
Traditional LLMs generate one token after another. That sequential process gives them enormous flexibility. They can explain, write, reason, code, and converse.
It also means a system often has to wait for the response, parse it, validate the format, and decide what to do with it.
Jev gives up that open-ended generation.
Imagine a support request arrives from an enterprise customer. Your application might pass the ticket, account history, product tier, and recent activity to Jev, then ask:
- Which team should receive this: billing, technical support, or account management?
- How urgent is the issue on a three-level rubric?
- Is there enough confidence to route it automatically?
- Should the case be escalated to a human now?
Jev returns one of the allowed values for each question, along with probabilities and confidence. It cannot decide to write an essay instead.
"Our SSO login stopped working after this morning's update. Forty agents are locked out and we have a shipping cutoff at 2 p.m."
This sounds like a technical issue, most likely related to the SSO configuration change. I'd suggest routing it to technical support, though account management may also want visibility given the customer's tier. Urgency: urgent-ish, since agents are blocked but a workaround may exist. Here's a draft reply you could send: "Hi there, thanks for reaching out..."
- Your code has to parse prose to find the team.
- "Urgent-ish" is not one of the three allowed levels.
- No probability or confidence to set an automation threshold.
- Extra generated tokens you pay for and wait on.
That creates a different operating profile from a generative model.
| Dimension | Jev | Generative LLM |
|---|---|---|
| Primary output | Choices, scores, probabilities, confidence | Text, code, reasoning, and tool calls |
| Strong fit | Repeated, bounded semantic decisions | Open-ended reasoning, creation, and communication |
| Response pattern | Many typed questions evaluated in parallel | Tokens generated sequentially |
| System role | Decision component inside a workflow | Reasoner, creator, or operator |
| Key limitation | Cannot generate free-form output | Output can be verbose, variable, or malformed |
General-purpose models can already return structured output. Jev was designed and trained around structured decisions as the primary job. This goes deeper than a new JSON setting.
The speed and cost claims need context
TypeSafe reports some remarkable numbers.
Across four workflows built by its model-capabilities team, Jev reached the high end of a 193.6x speed advantage and 444.6x cost advantage over frontier LLMs. As of September 22, 2026, Jev input costs $42 per billion tokens, or $0.042 per million. TypeSafe lists output tokens as free because the model is not generating a conventional token stream.
The company also reports typical latency between 70 and 500 milliseconds, depending on the request and deployment conditions.
I see those figures as an invitation to test them inside a real business case.
The evaluations were designed by TypeSafe's own team, and the company acknowledges possible bias. A production comparison also needs to account for preprocessing, network time, verification, fallbacks, downstream models, and the cost of a wrong decision.
Cost per successful business outcome at the required latency and risk level should govern the decision.
That is the number an enterprise pilot should measure.
Formula: (model spend + wrong decisions × cost per error) ÷ correct decisions. Add preprocessing, verification, and human review costs for a full picture.
Jev makes the model portfolio more interesting
We have argued for a while that one model should not do everything.
Some work deserves a frontier reasoning model. Some can run on a smaller specialized model. Some belongs in a deterministic rules engine. Some requires a human decision.
Jev adds another category: a fast model for bounded semantic judgment.
A production pattern could look like this:
Where a decision model sits in a production workflow
Select any step to see what it owns.
The boundaries matter.
- Jev handles a bounded judgment such as classification, scoring, or routing.
- Deterministic code handles calculations, permissions, hard policy, and execution rules.
- Generative models handle language, synthesis, open-ended reasoning, and content creation.
- Humans retain authority where the consequence or uncertainty requires it.
This fits the same principle we use when designing AI agents: isolate judgment, tools, state, policy, and authority instead of burying the entire workflow inside one prompt.
Six enterprise use cases worth testing
The strongest Jev use cases share a pattern. They involve many bounded decisions, enough semantic complexity to make rigid rules brittle, and a measurable outcome.
| Use case | Jev's bounded decision | What the business should measure |
|---|---|---|
| Model routing Best first test | Which model or workflow should handle this request? | Quality, cost per completed task, latency, fallback rate |
| Support and operations triage | Which queue, priority, and escalation path applies? | Time to resolution, routing accuracy, transfer rate |
| Agent action verification | Does the proposed action satisfy the stated criteria? | Prevented errors, false blocks, human escalation rate |
| Compliance review | Which supplied policy conditions appear to be triggered? | Recall, false positives, reviewer time, exception rate |
| Large-scale feature extraction | Which defined attributes are present in this record? | Labeled-set accuracy, throughput, cost per record |
| Real-time personalization | Which approved experience or next action best fits this state? | Conversion, satisfaction, latency, override rate |
Model routing may be the cleanest first enterprise test.
An incoming request can be evaluated against a small set of criteria, then sent to a low-cost model, a specialist model, a frontier model, a rules-based workflow, or a human. Jev makes the decision. Your model gateway and application still own the routing, permissions, fallback, and observability.
Schema validity and decision accuracy are different checks
TypeSafe says Jev has zero hallucinations.
There is a supportable idea behind that phrase, but enterprise teams should interpret it precisely.
Jev cannot generate an answer outside the schema you provide. If the allowed choices are approve, review, and reject, it will return one of those values. It will not invent a fourth option, wrap the answer in malformed prose, or ignore the requested output type.
That is valuable.
It can still choose the wrong option.
TypeSafe's own model-jaggedness documentation says the current model can struggle with arithmetic, counting, dates, adversarial instructions, irrelevant context, conflicting criteria, and tasks that require generation. Those are exactly the kinds of limitations a responsible evaluation should expose.
A confidence score also does not create permission. Your application still needs hard controls around data access, financial thresholds, regulated actions, and irreversible operations.
In enterprise AI, valid output, correct judgment, and authorized action are three separate checks.
How I would evaluate Jev inside an enterprise
A responsible first move starts with one decision bottleneck.
1. Choose a bounded, high-volume decision
Look for a task with a fixed set of outcomes, meaningful semantic context, and a measurable ground truth. The task should occur often enough for latency or cost to matter.
A support-routing decision is a better first test than an open-ended strategy recommendation.
2. Establish the current baseline
Measure the workflow as it operates today. That may be a rules engine, a general-purpose LLM, a human queue, or a combination.
Capture:
- Decision quality against labeled examples
- p50 and p95 latency
- Cost per completed decision
- Human escalation rate
- Downstream business result
Without a baseline, a faster model call can look like progress even when the workflow gets worse.
3. Define the state, options, and criteria carefully
Jev works best when the state contains the relevant facts and the questions define the decision clearly. Keep rules and criteria explicit. Do not bury ten unrelated decisions inside one ambiguous instruction.
The quality of this interface matters as much as the model choice.
4. Build a representative evaluation set
Use real, labeled examples that cover normal cases, edge cases, conflicting signals, missing information, and adversarial inputs. Compare Jev with the current system and at least one credible alternative.
Measure calibration as well as accuracy. A useful confidence score should help the system distinguish safe automation from cases that need review.
5. Run in shadow mode
Let Jev make decisions without controlling the production outcome. Compare its recommendations with actual decisions and results. This reveals failure patterns before customers or employees depend on it.
6. Add thresholds, fallbacks, and human authority
Automate only the region where the evidence supports it. Low-confidence or high-impact cases should move to another model, a deterministic workflow, or a human.
Version-pin the model after validation. Log the model version, input state, decision, confidence, downstream action, and eventual result.
7. Roll out gradually and keep evaluating
Use a canary release, watch the operating metrics, and maintain a rollback path. Model behavior can shift as versions, prompts, data, and business conditions change.
This is the difference between a compelling demo and a production capability.
Give the technical team one narrow proof
The first technical test is small.
Step 1. Open the TypeSafe Playground and paste one representative record as the state.
Step 2. Add a Choice, Score, or true-or-false question with explicit criteria.
Step 3. Inspect the returned probabilities and confidence.
Step 4. Create an API key and keep it server-side.
Step 5. Call POST https://api.typesafe.ai/v1/systemone from a test application using the jev-latest alias during exploration.
Step 6. Compare the result with your existing rule, LLM, or human decision across the evaluation set.
Once the team has an approved baseline, pin the validated model version rather than relying on a moving alias. As of this review, jev-latest points to jev-1.13.0.
Where Jev fits in the Intelligence Layer
At HatchWorks AI, we describe the Intelligence Layer as the connective tissue across company knowledge, data, systems, models, and agents, with shared evaluation, security, observability, and governance.
Jev fits inside that layer as a specialized decision model.
It still needs:
- Trusted context from enterprise data and systems
- An orchestrator or gateway that knows when to call it
- Policy that defines what the decision is allowed to trigger
- Evaluation that measures quality and calibration
- Observability that connects the model decision to the business outcome
- A fallback path when confidence, risk, or system health falls outside the approved range
0 of 6 in place. Start with context and evaluation before adding any new model.
This is also why the conversation about Jev is bigger than a single launch.
The enterprise AI stack is splitting into more specialized components. Generative models will remain incredibly important. Their best role will vary by layer and workflow.
The real signal from Jev
It is too early to know whether Jev becomes a standard part of enterprise AI architecture. The product is new, the benchmarks are vendor-reported, and the current model has documented limits.
My read is that the architecture question is already useful.
Why pay a frontier model to generate a miniature essay when the software needs one bounded decision?
The teams that scale AI will get better at assigning each part of a system to the right kind of intelligence. Some work will be generated. Some will be scored. Some will be calculated. Some will remain under human authority.
Jev gives enterprise teams a new option for the decision layer.
Frequently asked questions about Jev and System One models
What is Jev?
Jev is an AI model from TypeSafe AI that returns typed, probabilistic decisions instead of generated text. You give it the state of a system and a set of typed questions, and it returns bounded choices, scores, or probabilities with confidence that software can act on immediately. It cannot chat or write free-form content.
What are System One models?
System One models are foundation models optimized for fast, structured decisions rather than free-form generation. TypeSafe AI uses the term for this category, and Jev is its first public System One model.
How is Jev different from an LLM?
An LLM generates tokens one after another, which makes it flexible enough to write, reason, code, and converse. Jev gives up open-ended generation and evaluates many typed questions in parallel, returning only allowed values with probabilities. That makes it a decision component inside a workflow, not a reasoner or creator.
Does Jev hallucinate?
TypeSafe says Jev has zero hallucinations, meaning it cannot return an answer outside the schema you provide. It can still choose the wrong allowed option. TypeSafe's own documentation notes the current model can struggle with arithmetic, counting, dates, adversarial instructions, irrelevant context, and conflicting criteria.
How much does Jev cost?
As of September 22, 2026, TypeSafe lists Jev input at $42 per billion tokens, or $0.042 per million. Output tokens are listed as free because the model does not generate a conventional token stream. The better metric for an enterprise is cost per successful business outcome at the required latency and risk level.
What are the best enterprise use cases for Jev?
Strong candidates involve many bounded decisions with enough semantic complexity to make rigid rules brittle: model routing, support and operations triage, agent action verification, compliance review, large-scale feature extraction, and real-time personalization. Model routing may be the cleanest first test.
How should an enterprise evaluate Jev?
Pick one bounded, high-volume decision, measure the current baseline, define the state and criteria clearly, and build a labeled evaluation set. Run Jev in shadow mode, add confidence thresholds and human fallbacks, version-pin the validated model, and roll out gradually with a canary release.
