Jev: The AI Model That Makes Decisions Instead of Writing Text
Most AI models we use today are built to generate something.
They write emails, answer questions, summarize documents, generate code, and hold conversations. These models are generally known as large language models, or LLMs.
But many software systems do not need a paragraph of text. They need a decision.
They need answers such as:
Is this email important?
Should this transaction be reviewed?
Which tool should an AI agent call next?
Should this request be routed to a human?
Is this customer likely to cancel?
Should the system retry the failed operation?
For these tasks, generating a long explanation is often unnecessary. The software needs a clear, structured answer that it can use immediately.
This is the idea behind Jev, a new model released by TypeSafe AI in September 2026. Jev is designed to make fast, structured decisions for software instead of generating conversational text.
The Problem with Using LLMs for Every Task
Imagine that you are building an AI customer-support agent.
A customer sends this message:
“I was charged twice for my subscription. Please fix this.”
The system may need to make several decisions:
Is this a billing-related request?
Is the customer asking for a refund?
Does the account show duplicate charges?
Should the request be sent to a human?
Which tool should the agent call next?
A traditional LLM may be asked to answer all of these questions. It may return a long response containing explanations, suggestions, and possibly a tool call.
But the application may only need a few structured values:
Category: billing.
Urgency: high.
Human review required: yes.
Next action: check payment history.
Using a large language model for every small decision can create unnecessary cost, latency, and complexity. The model may generate more text than the software needs, and that text may have to be parsed and validated before the application can use it.
Jev is designed for this decision-making layer.
What Is Jev?
Jev is a model that takes some context and answers predefined questions about that context.
The context is called the state.
The questions are called typed questions because the developer defines the kind of answer expected in advance.
For example, the state might be:
“A customer reports being charged twice for the same subscription. The payment system shows two successful transactions within five minutes.”
The developer can ask Jev:
What category does this issue belong to?
How urgent is it?
Should a human review it?
Which action should happen next?
Jev does not respond with a paragraph. It returns structured decisions such as:
Category: billing.
Urgency score: 0.92.
Human review: yes.
Next action: verify duplicate payment.
The company describes this idea as:
Unstructured state in, typed probabilistic decisions out.[typesafe]
In simpler words:
Give Jev a situation and clear questions. It returns answers in a format that software can directly use.
An Everyday Analogy
Imagine a security guard at the entrance of a building.
The security guard does not write a detailed essay about every visitor. For each person, the guard makes a few practical decisions:
Is this person allowed to enter?
Which floor are they visiting?
Should their identity be verified?
Should security staff be called?
The answers are structured and actionable.
The guard may say:
Allowed: yes.
Verification required: no.
Destination: third floor.
Jev works in a similar way for software systems. It is not mainly trying to have a conversation with a person. It is helping an application decide what should happen next.
How Is Jev Different from an LLM?
The main difference is the type of output.
An LLM is optimized to generate text. Jev is optimized to return structured decisions.
AspectTraditional LLMJevMain purposeGenerate and understand languageMake structured decisionsOutputText, code, explanations, tool callsChoices, scores, yes/no values, probabilitiesGeneration styleProduces tokens sequentiallyEvaluates questions in parallelTypical useChatbots, writing, coding, reasoningClassification, routing, scoring, verificationOutput handlingOften needs parsing and validationDesigned for direct software useBest interactionHuman-facingApplication-facing
An LLM might answer:
“Based on the information provided, this appears to be a high-priority billing issue. I recommend checking the payment records and escalating it to a support specialist if duplicate charges are confirmed.”
Jev might return:
Issue type: billing.
Priority: high.
Duplicate payment check: required.
Human escalation: likely.
The LLM response is useful for a person.
The Jev response is useful for a program.
Why Does Jev Return Probabilities?
Jev does not only return a decision. It also provides probability information or confidence estimates.
Suppose an AI agent receives a customer message. Jev may produce:
Billing: 0.94.
Technical issue: 0.04.
Account issue: 0.02.
The application can use these values to decide what to do.
For example:
If the probability is above 0.90, continue automatically.
If it is between 0.60 and 0.90, request more information.
If it is below 0.60, send the case to a human.
This is useful because real-world decisions are not always equally certain.
A system that only returns “yes” or “no” does not communicate uncertainty. A system that also returns probabilities can make more informed decisions.
However, probability is not the same as guaranteed correctness. A high-confidence prediction can still be wrong. Developers still need evaluation, monitoring, and safety checks.
How Does Jev Work?
The complete internal architecture of Jev has not been publicly disclosed by TypeSafe AI. However, the company describes the model through a simple high-level process.
Step 1: The Application Provides the State
The application gives Jev the situation it needs to evaluate.
This could be:
A customer-support message.
A transaction record.
An email.
A document.
An AI-agent trace.
A game state.
A set of sensor readings.
For example:
“The user has attempted to reset the password five times from a new device. The account has no successful login from this device.”
This is the state.
Step 2: The Developer Defines the Questions
The developer decides what needs to be evaluated.
For the password example, the questions could be:
Is this suspicious?
Should the account be temporarily locked?
Should the user be asked for additional verification?
Which security workflow should be triggered?
The developer also defines the valid type of each answer.
For example:
Suspicious: yes or no.
Risk level: a score from zero to one.
Next action: one choice from a fixed list.
Step 3: Jev Evaluates the Questions
Jev evaluates the state and answers the questions.
Unlike an LLM that generates a response token by token, Jev is designed to evaluate multiple typed questions in parallel.[typesafe][indianexpress]
Step 4: The Software Uses the Decisions
The application receives the structured results and uses normal software logic to decide what happens next.
For example:
If suspicious is yes, require verification.
If risk is high, block the transaction.
If the next action is “human review,” create a support ticket.
If the next action is “retry,” call the external service again.
The final action is performed by software, not by a paragraph generated by the model.
[Figure 1: Jev workflow showing state and typed questions entering the model and structured decisions with probabilities being returned to software]
Jev Does Not Replace LLMs
Jev should not be understood as a complete replacement for LLMs.
It solves a different problem.
LLMs are still better when the application needs:
A natural-language answer.
An explanation.
Code generation.
Document summarization.
Creative writing.
A multi-turn conversation.
Complex human-facing reasoning.
Jev is better suited to tasks such as:
Classification.
Routing.
Scoring.
Verification.
Tool selection.
Retry decisions.
Safety checks.
Workflow branching.
A strong AI system may use both models.
For example:
An LLM reads a customer message and creates a draft response.
Jev classifies the issue and checks whether the response needs approval.
A deterministic backend verifies permissions and business rules.
The LLM communicates the final result to the customer.
The LLM handles language.
Jev handles structured decisions.
Normal software handles permissions and execution.
[Figure 2: Comparison showing an LLM handling language generation and Jev handling structured decisions inside the same AI application]
A Simple AI Agent Example
Consider an AI agent that processes incoming business emails.
The agent receives this email:
“The production database has been unavailable for the last twenty minutes. Please investigate immediately.”
The system may need to answer:
Is this an incident?
Is it urgent?
Which team should receive it?
Should an incident ticket be created?
Should the on-call engineer be notified?
An LLM could produce a detailed analysis, but the software needs structured values to trigger the correct workflow.
Jev could return:
Message type: production incident.
Urgency: critical.
Team: infrastructure.
Create ticket: yes.
Notify on-call engineer: yes.
The application can now execute the workflow:
Create an incident ticket.
Notify the infrastructure team.
Send an alert to the on-call engineer.
Ask an LLM to draft a human-readable confirmation message.
Jev does not need to write the message. It only needs to make the decisions that control the workflow.
How Jev Can Help AI Agents
AI agents often use LLMs to decide:
Which tool should be called.
Whether a tool call succeeded.
Whether the agent should retry.
Whether the task is complete.
Whether a human should be involved.
Which branch of a workflow should be followed.
These decisions may happen many times during a single task.
Suppose an agent needs to answer a customer question. It may:
Search the knowledge base.
Decide whether the retrieved information is sufficient.
Call an order-management tool.
Check whether the tool result is valid.
Decide whether another tool call is needed.
Decide whether a human should review the result.
If every small decision uses a large LLM, the application can become slow and expensive.
Jev can serve as a lightweight decision layer underneath the agent:
Jev decides which tool to use.
Jev checks whether the result looks valid.
Jev decides whether to retry.
Jev decides whether the task should be escalated.
The LLM generates the final response when needed.
[Figure 3: AI agent architecture showing Jev making routing, tool-selection, retry, and escalation decisions while an LLM handles language generation]
Why Could Jev Be Faster and Cheaper?
Traditional LLMs generate output one token at a time. If the application needs a short decision, the model may still process a relatively large amount of context and generate unnecessary text.
Jev does not need to generate a conversational response. It returns a structured answer.
TypeSafe AI says Jev is designed to be much faster and more efficient than existing LLMs for System One tasks. The company reports that Jev can respond in under half a second in some uses and lists a price of $0.042 per million input tokens with no output-token charge. These are company-reported figures, so they should be treated as early claims rather than universal benchmarks.
The practical benefit is not merely lower cost per request. Faster decisions can change the architecture of an entire application.
For example, instead of using one expensive LLM call to perform:
Classification.
Routing.
Safety checking.
Tool selection.
Final response generation.
a system could use Jev for the first four tasks and reserve the LLM for the final response.
This may reduce latency and allow the application to handle more requests.
Why Is Jev Called a “System One” Model?
The term comes from the distinction between fast and slow thinking described in Daniel Kahneman’s work.
System One thinking is:
Fast.
Intuitive.
Immediate.
Suitable for repeated decisions.
System Two thinking is:
Slower.
Deliberate.
Analytical.
Useful for complex reasoning.
Traditional reasoning-focused LLM workflows often behave more like System Two systems. They may spend more time generating explanations and exploring possibilities.
Jev is positioned as a System One model for fast decisions inside software. It is intended for situations where the application needs a quick evaluation rather than a long chain of reasoning.
For example:
“Is this request suspicious?”
“Which category does this belong to?”
“Should we retry?”
“Which option should the agent choose?”
These decisions do not always require a long explanation.
What Does “Cannot Hallucinate” Mean Here?
TypeSafe AI says Jev cannot hallucinate in the traditional sense because the developer defines the allowed output types in advance and Jev returns structured values rather than open-ended text.
For example, if a question allows only:
Yes.
No.
the model cannot invent a completely unrelated paragraph as the output.
If a question allows only one of:
Billing.
Technical.
Account.
Other.
the output remains within that defined structure.
This solves one important problem: invalid or malformed outputs.
However, structured output does not guarantee that the decision is correct.
Jev could still select the wrong category or assign an unsuitable score. Its output format may be type-safe, but its content still needs evaluation.
So, a more precise way to understand the claim is:
Jev may avoid open-ended textual hallucinations, but developers must still verify whether its decisions are accurate and appropriate.
This distinction matters when using the model in high-risk systems.
Where Can Jev Be Used?
AI Agent Routing
Jev can decide which agent, tool, or workflow should handle a request.
For example:
Billing request → Billing workflow.
Technical issue → Technical-support workflow.
Refund request → Human approval workflow.
Email Classification
It can classify large volumes of emails into predefined categories.
For example:
Urgent.
Promotional.
Customer complaint.
Sales lead.
Internal request.
Safety and Policy Checks
Jev can evaluate whether an input or proposed action violates a policy.
For example:
Is the request asking for sensitive data?
Does this tool call need approval?
Is the output safe to show to the user?
Is the agent trying to access an unauthorized resource?
Model Routing
A system can use Jev to decide which model should handle a request.
For example:
Simple question → small language model.
Complex question → advanced LLM.
Sensitive question → human review.
Unsupported question → refusal or fallback workflow.
Retry Decisions
When an external API fails, Jev can help determine whether the application should:
Retry immediately.
Wait and retry later.
Use a fallback service.
Ask the user for more information.
Escalate to a human.
Customer Support
Jev can score urgency, detect sentiment or issue type, and determine whether the case requires human involvement.
Real-Time Applications
Fast decision-making can be useful in:
Games.
Monitoring systems.
Sensor processing.
Fraud screening.
Operational alerts.
Edge applications.
A Complete Example: AI Customer Support
Let us design a simple customer-support workflow using both an LLM and Jev.
A customer sends:
“My payment failed, but the amount was deducted from my bank account.”
Step 1: The LLM Understands the Message
The LLM can read the message and extract the important context.
It may identify:
The issue involves a payment.
The customer claims money was deducted.
The customer needs an explanation or refund.
Step 2: Jev Makes Structured Decisions
Jev evaluates questions such as:
Is this a billing issue?
Is the issue urgent?
Is human review required?
Which backend tool should be called?
It returns structured decisions.
Step 3: The Backend Checks the Database
The backend checks the payment records and verifies whether the transaction succeeded, failed, or is still pending.
Step 4: Jev Evaluates the Next Action
Based on the updated state, Jev may decide:
If the payment is pending, ask the customer to wait.
If the payment failed but money was captured, create a refund case.
If the transaction is unclear, send it to a human agent.
Step 5: The LLM Writes the Customer Response
The LLM uses the verified result to write a clear response for the customer.
This division of responsibility is useful:
The LLM understands and communicates.
Jev makes fast structured decisions.
The backend verifies facts and performs actions.
[Figure 4: End-to-end customer-support workflow using an LLM for language, Jev for decisions, and backend systems for verification and action]
What Are the Limitations?
Jev is promising, but it is not suitable for every AI problem.
It Does Not Write Normal Text
Jev cannot replace an LLM when you need:
An article.
An email.
A chatbot response.
A code snippet.
A detailed explanation.
A creative idea.
It Requires Well-Defined Questions
The developer needs to define what the model should decide and what kind of answer is allowed.
If the problem is extremely open-ended, Jev may not be the right tool.
It Does Not Replace Business Rules
A model can recommend that a refund should be issued, but the final decision may still need to be controlled by deterministic business logic.
For example, a company may have a strict rule that refunds above a certain amount require manager approval.
Jev should not bypass that rule.
Confidence Is Not a Guarantee
A confidence score can help with routing and escalation, but it does not prove that the result is correct.
Developers should still test the model on representative data and monitor its behavior after deployment.
Its Architecture Is Still New
Jev is an early-access model, and TypeSafe AI has not publicly disclosed every architectural detail. Early performance and pricing claims may change as the product and infrastructure mature.
Is Jev Just a Smaller LLM?
Not exactly.
Jev uses transformer-based technology, like many modern generative AI models, but its intended interface and output behavior are different.
A smaller LLM still tries to generate language, even if it generates fewer tokens.
Jev is designed around structured decisions. The developer defines the questions and valid answer types, and the model returns answers that software can use directly.
A useful comparison is:
A smaller LLM is like a shorter writer.
Jev is like a fast decision function.
They may both process text, but they are optimized for different jobs.
How Should Developers Think About Jev?
Do not think of Jev as:
“A cheaper chatbot.”
Think of it as:
“A decision layer for software.”
It can sit between an application and its next action.
The application gives Jev:
The current state.
The questions that need answers.
The allowed output types.
Jev returns:
Choices.
Scores.
Yes/no decisions.
Probabilities.
The application then uses those outputs to select a workflow, call a tool, escalate a request, or ask another model to generate a response.
This makes Jev closer to an intelligent function than a conversational assistant.
What Does Jev Mean for AI/ML Engineers?
Jev represents an important direction in AI engineering: not every intelligent task requires a general-purpose language model.
AI systems may increasingly use multiple specialized layers:
A language model for understanding and generation.
A decision model for routing and classification.
A retrieval system for finding information.
A policy engine for permissions and safety.
Normal software for deterministic execution.
Monitoring systems for evaluation and observability.
This separation can make AI applications faster, cheaper, and easier to control.
For AI/ML engineers, the important skill is not learning one model and using it everywhere. It is learning how to choose the right model for each part of a system.
Use an LLM when the application needs flexible language generation.
Use a decision model when the application needs fast, structured choices.
Use normal code when the rule must be deterministic.
Final Takeaway
Jev is not designed to replace ChatGPT-style models in conversations. It is designed to solve a different problem: helping software make fast, structured decisions.
Traditional LLMs produce text. Jev produces choices, scores, probabilities, and other typed decisions.
An LLM might write the final customer response, while Jev decides whether the request is urgent, which tool should be called, whether the result is safe, and whether human review is required.
The most important idea is not that Jev will replace LLMs. It is that future AI systems may stop using one general-purpose model for everything.
Instead, they may combine:
LLMs for language.
Jev-like models for decisions.
Databases for facts.
Policy engines for safety.
Software for execution.
That could make AI applications more efficient and easier to integrate into real products.
The future of AI may not belong to a single model that does everything. It may belong to systems where every model does the job it is best suited for.