$ cat blog/jev-ai-llm-integration-guide.md
What Is Jev? Integrating Jev With LLMs, Claude Code, and AI Agents
1. Introduction: Why Do We Need Jev?
We use LLMs for almost everything in AI applications. They answer questions, classify messages, decide which tools to call, extract information, and generate reports.
But do we really need an LLM to handle every one of those tasks?
Consider a customer support chatbot. When someone sends a message, the chatbot might need to determine whether the person has a billing problem, needs technical assistance, or wants to speak to someone.
That's a classification problem. The application needs to select one of several predefined options.
We could ask an LLM to return a JSON object containing the category. That works, and modern LLMs have structured-output capabilities that make this easier.
However, we're still using a model primarily designed for language generation to perform a small decision-making task.
The problem becomes more interesting when we build AI agents.
Imagine an agent that monitors hundreds of advertising campaigns. It identifies unusual performance changes, evaluates their importance, decides which ones require investigation, and generates reports.
Not every stage of that workflow requires text generation. Some stages involve calculations. Others involve interpreting evidence or selecting between known actions.
This is where TypeSafe AI introduces a different approach.
On September 15, 2026, TypeSafe introduced Jev, its first public System One Model. It's designed to make fast, structured decisions that applications can use directly.
The idea isn't to replace LLMs. It's to use different tools for different parts of an application.
In this article, we'll understand Jev, explore its official API and SDK, and integrate it into three existing workflows: a restaurant chatbot, an AI monitoring agent, and Claude Code.
We'll also examine alternatives and explain when adding Jev might introduce more complexity than value.
2. What Is Jev AI?
Understanding Jev and System One Models
Jev is an AI model developed by TypeSafe. Unlike a traditional LLM, it's designed to answer structured questions about the information you provide.
Think of it as a function that accepts two things: some information and a set of questions.
For example, imagine receiving this customer message:
"My order still hasn't arrived, and I've already been waiting for an hour!"
We want to determine which department should handle the message and whether it expresses urgency.
Instead of asking an LLM to generate an explanation, we give Jev the message and define exactly which decisions we need.
Jev might classify the message as an order-support request and return a high probability that it's urgent.
Your application then uses those results to decide what happens next.
TypeSafe calls this class of models System One Models. The name is inspired by the distinction between fast, intuitive thinking and slower, deliberate thinking described in Daniel Kahneman's Thinking, Fast and Slow.
Jev is optimized for focused judgments, typed outputs, and probability estimates rather than open-ended language generation.
Jev vs. Traditional LLMs
Both Jev and LLMs can evaluate information, but they have different interfaces and intended uses.
| Feature | Traditional LLM | Jev |
|---|---|---|
| Primary purpose | Generate language and solve general tasks | Make structured decisions |
| Output | Text, code or structured output | Predefined typed answers |
| Decision format | Usually defined through prompts or schemas | Defined using decision primitives |
| Generation | Typically sequential tokens | Parallel decision evaluation |
| Uncertainty | Depends on model and implementation | Probabilities and confidence are built into its interface |
| Typical use | Chatbots, coding, reasoning and writing | Classification, scoring, routing and verification |
A traditional LLM can also perform classification and generate valid structured JSON. Jev doesn't introduce an entirely new category of problems that LLMs cannot solve.
Its difference is specialization.
With an LLM, classification is one capability among many. With Jev, structured decisions are the main purpose of the model and its API.
TypeSafe reports latency of approximately 70 to 500 milliseconds and a launch price of $0.042 per million input tokens, without output-token charges. The company also reports substantial performance and cost advantages on its published System One workflow benchmarks.
These are company-reported figures, not guarantees for every application. End-to-end latency, pricing and practical accuracy should be verified against your own workload.
And there's another important distinction: Jev guarantees that its responses conform to the specified output types. This does not guarantee that its underlying judgments are correct.
3. How Does Jev Work?
Before integrating Jev into an application, we need to understand three concepts: state, questions, and answers.
Understanding the Core Architecture
State
State is the information Jev uses to make a decision.
It can be a simple string or a structured object containing relevant application information.
For our customer support example, the state might be:
{
"message": "My order still hasn't arrived!",
"order_status": "Preparing",
"delay_minutes": 60
}
The important thing is to provide enough relevant information for Jev to answer the questions correctly.
Sending an entire customer history when we only need to determine whether a message expresses urgency may introduce unnecessary noise.
Questions
Questions define the judgments Jev needs to make.
You specify the type of each question and, where appropriate, the possible answers.
For example, we might ask whether the message expresses urgency and which department should handle it.
Answers
Jev returns structured answers under the question identifiers supplied by your application.
Depending on the question type, those answers contain a selected option, a score or a probability.
Your application consumes the answers and executes its own business logic.
Understanding Jev's Decision Primitives
TypeSafe provides three question types: Choice, Noul and Score.
Choice: Selecting from predefined options
Use Choice when the possible answers are known in advance.
For example, a restaurant chatbot could classify a request into menu, ordering, support, off_topic, or unclear.
Jev returns the selected option, a probability distribution across the options, and a confidence value.
Noul: Evaluating a yes/no question
Noul returns a number between 0 and 1 representing the estimated probability that a statement is true.
For example, you might ask whether a customer message expresses urgency.
Unlike Choice and Score, Noul doesn't return a separate confidence field. Its probability is the value you work with.
Score: Evaluating an ordered scale
Use Score when a judgment belongs on an ordered scale.
For example, customer frustration might be evaluated using the levels calm, concerned, and very_frustrated.
Jev returns a score representing its position along those levels, along with a probability distribution and confidence.
The important point is that these primitives answer different kinds of questions. A probability of 0.5 on a Noul question means uncertainty between yes and no. It doesn't mean that the evaluated subject is average or moderate.
How Jev Makes Decisions
Traditional generative LLMs usually produce tokens sequentially. Jev uses an architecture designed to produce structured decisions in parallel.
You can submit several independent questions against the same state in one API request.
Each question evaluates the supplied state independently. One answer doesn't automatically become context for another question. If you need that dependency, your application must handle it explicitly.
This makes it possible to evaluate several aspects of an event without performing a separate sequential API call for every judgment.
TypeSafe also introduced a training approach called Reinforcement Learning for Calibrated Decisions, or RLCD, which focuses on the probabilities associated with decisions.
The company's public documentation explains the high-level approach, but developers shouldn't infer unpublished architectural or training details from it.
The result is an interface designed for software, with predefined answer types and estimated probabilities.
But a schema-valid answer can still be factually wrong. We'll return to that distinction when discussing production deployments.
4. When Should You Use Jev?
Jev becomes interesting when an application repeatedly needs to interpret information and make decisions that are difficult to express using ordinary rules.
It is not necessary for every AI operation.
Applications Where Jev Could Help
Intent classification and request routing
A customer support chatbot can use Jev to identify the type of request before selecting an appropriate handler.
For instance, an order-status request might go directly to your database, while a complicated support question might go to an LLM with the relevant context.
RAG document relevance evaluation
A retrieval-augmented generation system might retrieve several documents that appear similar to the user's question.
Jev can assess each passage for relevance, usable evidence, contradictions or possible injected instructions before passing selected material to the answering LLM.
TypeSafe publishes an official cookbook demonstrating this approach.
AI response verification
Jev can evaluate whether a generated response appears to satisfy specific requirements.
For example, it could assess whether a chatbot response contains an unsupported claim or whether a quoted source supports an associated statement.
These are model judgments, not formal guarantees.
Customer support automation
Jev can classify tickets, identify apparent urgency or select a category. Application rules can then determine which handler receives the request.
AI agent workflow decisions
An AI agent often needs to decide whether to continue, call another tool, request missing information or escalate a problem.
Jev can help evaluate focused conditions that inform those decisions.
Business-data interpretation
An automated monitoring system might detect unusual changes using deterministic calculations and ask Jev to assess which observations appear worth investigating.
However, Jev should only evaluate the evidence supplied to it. It cannot independently discover missing data or establish causes that the evidence doesn't support.
When You Shouldn't Use Jev
Knowing when not to use Jev is just as important.
If your application needs to generate a customer email, write code or explain a complicated issue, a generative LLM is appropriate.
If your application needs to calculate percentages, compare dates, enforce access controls or retrieve an exact database record, ordinary application code is usually appropriate.
Jev is also not designed to handle every type of complex, multi-stage reasoning. Its documented limitations include numerical precision, excessive irrelevant context and tasks involving several levels of indirection.
Consider a refund workflow.
If the refund policy says that a request submitted within 30 days is eligible, your application can calculate whether the request falls within that window. It doesn't need Jev.
However, if the customer writes an ambiguous message and you need to determine whether they're actually requesting a refund, Jev could be useful.
That's the distinction we'll use throughout this article.
5. Getting Started With Jev: Official TypeSafe Tools
What Does TypeSafe Officially Provide?
For this tutorial, we'll use TypeSafe's official interfaces rather than community-built wrappers.
TypeSafe provides a REST API, JavaScript/TypeScript SDK, Python SDK, web Playground and an official Agent Skill for coding agents.
The Playground is useful for experimenting with questions before writing code. The API and SDKs are designed for integrating Jev into applications. The Agent Skill supplies API knowledge and integration guidance to supported coding agents.
Setting Up Jev in a TypeScript Project
First, obtain API access through the TypeSafe Console.
Jev was launched with early access, so check current account availability and pricing before starting.
Next, create a TypeScript project or open an existing Node.js project. The official JavaScript SDK requires Node.js 20 or later.
Install the package:
npm install @typesafe-ai/sdk
Add your API key to your server environment:
export TYPESAFE_API_KEY="your-api-key"
Never expose this key through frontend code or commit it to your repository.
The SDK automatically reads TYPESAFE_API_KEY from the environment.
Building Our First Jev Decision
Let's use our restaurant example to classify a customer request.
We'll ask two questions in the same request: which category the message belongs to and whether it expresses urgency.
import {
TypeSafeClient,
choice,
noul
} from "@typesafe-ai/sdk";
const jev = new TypeSafeClient();
async function classifyMessage(message: string) {
const result = await jev.systemOne({
state: { message },
questions: {
intent: choice(
"What is the customer's request in `message`?",
{
menu: "Questions about restaurant food or menu",
ordering: "Placing or changing a food order",
support: "Restaurant-related customer support",
off_topic: "Unrelated to the restaurant",
unclear: "Not enough information to classify"
}
),
urgent: noul(
"Does `message` express urgency?"
)
}
});
return {
intent: result.answers.intent.choice,
confidence: result.answers.intent.confidence,
urgencyProbability: result.answers.urgent.noul
};
}
async function main() {
const result = await classifyMessage(
"My food hasn't arrived. Can you check my order?"
);
console.log(result);
}
main().catch(console.error);
This example uses the official SDK's documented request and response structure.
Instead of returning a generated paragraph, Jev supplies the classification and probability-related values.
The exact numbers will depend on the model's evaluation.
Your application can then use the classification to decide which handler should process the request.
In a production system, we'd also inspect uncertainty, handle API errors and provide a fallback when the classifier cannot reliably select a category.
We'll implement those considerations in the next example.
6. Combining Jev and LLMs: Building a Hybrid AI Architecture
The main goal of introducing Jev isn't to remove LLMs from our applications.
It's to avoid asking one model to handle everything.
Why Combine Two Models?
Consider an application with three different responsibilities.
It needs to calculate data, make a judgment about that data and generate a natural-language response.
We could assign all three tasks to an LLM, but there's no reason to do so.
Ordinary code can handle the calculations. Jev can evaluate the judgment when simple rules aren't sufficient. An LLM can generate the response.
Each part of the system has a specific responsibility.
For example, an AI support agent might need to understand whether a customer wants an order update, retrieve their order from a database, and explain the delivery status.
Jev can classify the request. Your backend retrieves the order. The LLM produces a response if natural-language generation is needed.
This is one possible hybrid architecture.
Designing a Hybrid Workflow
There isn't one fixed position where Jev belongs in an AI application.
It depends on which decision you're trying to improve.
Jev before the LLM: Use Jev to classify an incoming request or determine which handler to invoke. This is the pattern we'll use in our restaurant chatbot.
Jev after the LLM: Evaluate the generated response against specific criteria before returning it. For example, check whether an answer appears to contain unsupported information or violate the application's scope.
Jev between agent steps: Evaluate the information collected by an agent and help decide whether it should continue, investigate something else or request human review.
No Jev at all: Some requests can be handled entirely by ordinary code. Others may already work well with your existing LLM.
TypeSafe documents intent routing, confidence-based routing, RAG evaluation and LLM guardrails as examples of how to compose these decisions within applications.
The central principle is to retain control in your application. Jev evaluates a question, but your software decides what actions are authorized and how uncertainty should be handled.
Now let's apply this architecture to an existing chatbot.
7. Practical Example: Integrating Jev Into an Existing AI Chatbot
Let's look at a problem you might encounter when building a customer-facing AI chatbot.
Imagine you've built a chatbot for a restaurant website.
Customers can use it to browse the menu, ask about ingredients, place orders and get customer support.
The chatbot uses an LLM to understand requests and generate responses. It's connected to the restaurant's menu database and ordering system.
Everything works until a customer sends an unrelated question.
The Problem: A Restaurant Chatbot That Answers Unrelated Questions
A customer opens the chatbot and asks:
Write a Python program to reverse a binary tree.
The chatbot proceeds to explain binary trees and generates Python code.
Technically, the underlying LLM has done what it was trained to do. It understood the question and generated an appropriate answer.
But this isn't what we built the application for.
Our chatbot is supposed to handle restaurant-related requests. It shouldn't turn into a general-purpose assistant whenever someone asks an unrelated question.
There are several reasons to address this problem. Unrelated requests consume API resources, create inconsistent experiences and can distract the chatbot from its intended functionality.
The problem becomes more serious if users can also submit instructions that attempt to override the chatbot's rules.
This is where we need to establish a clear boundary between the user's request and the functionality our application is designed to provide.
Solution 1: Without Jev
Before adding another AI model, let's examine how we might solve this using our existing architecture.
The simplest approach is to improve the chatbot's system prompt.
For example:
You are a customer support assistant for a restaurant.
You can help customers with:
- Restaurant menu information
- Food orders
- Order tracking
- Restaurant-related customer support
Do not answer unrelated questions.
If a customer asks something outside your scope,
politely explain what you can help with.
This is a reasonable starting point.
However, a system prompt is an instruction to the LLM, not an application-level enforcement mechanism. The model might still produce an unrelated answer, particularly during long conversations or when confronted with adversarial instructions.
Another option is to add a separate LLM-based classifier.
Instead of forwarding every incoming message directly to the restaurant chatbot, we first ask a smaller LLM to classify the request.
The classifier might return structured JSON containing the request's category. Our application checks that category before deciding whether to call the main chatbot.
This gives us more control, but it introduces another LLM request.
There's also a third approach: restrict the architecture itself.
We can expose only approved restaurant operations, such as retrieving the menu or checking an existing order. However, restricting tools doesn't completely solve the problem. The LLM might still generate unrelated text even when it cannot execute unrelated tools.
For a production chatbot, I'd combine clear instructions, limited tools and application-level request validation.
Now let's see where Jev fits.
Solution 2: Adding Jev
Instead of using a second general-purpose LLM for classification, we'll use Jev.
The architecture is straightforward.
We'll start by defining the types of requests our restaurant chatbot supports.
In addition to the three supported categories, we'll include two additional categories: off_topic and mixed.
The mixed category matters because a customer might submit a legitimate restaurant request alongside an unrelated instruction.
For example:
"Order a pizza and write a Python program."
We shouldn't automatically process the entire message just because it contains the word pizza.
Let's implement the classification layer.
Create a file called restaurant-chat.ts.
import {
TypeSafeClient,
choice,
noul
} from "@typesafe-ai/sdk";
const jev = new TypeSafeClient();
const ROUTING = {
minimumConfidence: 0.75,
maximumOffTopicProbability: 0.35
};
// These handlers connect to your existing application.
type RestaurantHandlers = {
answerMenuQuestion:
(message: string) => Promise<string>;
handleOrder:
(message: string) => Promise<string>;
handleSupport:
(message: string) => Promise<string>;
};
export function createRestaurantChatbot(
handlers: RestaurantHandlers
) {
return async function handleMessage(
message: string
): Promise<string> {
let classification;
try {
classification = await jev.systemOne({
state: {
message,
applicationScope: [
"Restaurant menu information",
"Ingredients and allergens",
"Placing and managing food orders",
"Restaurant-related customer support"
]
},
questions: {
intent: choice(
"Classify the customer's request in `message`.",
{
menu:
"Questions about the restaurant menu " +
"or its food",
ordering:
"Requests to place or manage food orders",
support:
"Restaurant-related customer support",
off_topic:
"The request is unrelated to the restaurant",
mixed:
"The message includes both restaurant-related " +
"and unrelated requests",
unclear:
"The request is ambiguous or lacks context"
}
),
unrelated: noul(
"Does `message` contain a request that " +
"is unrelated to `applicationScope`?"
)
}
});
} catch (error) {
console.error("Jev classification failed", error);
// Don't silently bypass the scope check.
return "I couldn't process that request. " +
"Please try again or contact our staff.";
}
const intent = classification.answers.intent;
const unrelated =
classification.answers.unrelated.noul;
if (
intent.confidence < ROUTING.minimumConfidence
) {
return "Could you clarify your " +
"restaurant-related question?";
}
if (
unrelated > ROUTING.maximumOffTopicProbability
) {
return "I can help with our menu, " +
"food orders and restaurant-related support.";
}
switch (intent.choice) {
case "menu":
return handlers.answerMenuQuestion(message);
case "ordering":
return handlers.handleOrder(message);
case "support":
return handlers.handleSupport(message);
default:
return "I can help with our menu, " +
"orders and restaurant-related questions.";
}
};
}
This implementation uses TypeSafe's official Choice and Noul primitives. It asks two independent questions about the same state and handles the responses using ordinary TypeScript.
Notice that Jev isn't responsible for generating a refusal or deciding which API operations are permitted.
It classifies the message and supplies probabilities. Our application applies the routing rules.
The confidence and probability thresholds in this example are illustrative. They haven't been calibrated against actual restaurant conversations.
To connect the router to an existing chatbot, provide the handlers from your application:
import {
createRestaurantChatbot
} from "./restaurant-chat";
const chatbot = createRestaurantChatbot({
answerMenuQuestion: async (message) => {
// Your existing menu-aware LLM.
return existingMenuChatbot(message);
},
handleOrder: async (message) => {
// Your existing authenticated ordering workflow.
return existingOrderHandler(message);
},
handleSupport: async (message) => {
// Your existing customer support service.
return existingSupportHandler(message);
}
});
const response = await chatbot(
"What vegetarian pizzas do you have?"
);
console.log(response);
The existingMenuChatbot, existingOrderHandler and existingSupportHandler functions represent your existing application integrations. Supply those functions before running the example.
This keeps Jev separate from your existing LLM provider and business logic.
The same approach works regardless of whether your chatbot uses Claude, GPT or another language model.
There is one additional consideration for multi-turn conversations. A customer might first ask about pizza and then follow up with, "Does it contain nuts?"
In that situation, classifying only the latest message may not provide enough information.
A production implementation should supply the relevant conversation context to Jev, such as the current topic and the customer's latest message.
Extending the Chatbot With Jev
Intent classification is only one possible integration point.
Suppose our restaurant chatbot also uses RAG to answer questions about menu information, restaurant policies or special offers.
The retrieval system searches its knowledge base and returns documents that might be relevant to the customer's question.
We can introduce Jev between document retrieval and response generation.
For each retrieved passage, Jev can evaluate whether the passage is relevant, contains usable evidence, contradicts the question's assumptions or appears to contain instructions directed at the model.
Our application then selects which passages to provide to the answering LLM.
TypeSafe demonstrates this architecture in its official RAG passage-classification cookbook.
We can also introduce an optional output check.
Before returning the LLM's generated answer, we could ask Jev whether it appears to contain unrelated content or makes claims that aren't supported by the supplied restaurant information.
For example:
import { noul } from "@typesafe-ai/sdk";
// Inside a TypeSafe systemOne request:
const questions = {
offTopic: noul(
"Does the assistant response provide information " +
"unrelated to the restaurant request?"
),
unsupported: noul(
"Does the assistant response make factual claims " +
"not supported by the supplied restaurant context?"
)
};
These questions would be evaluated against state containing the generated response, the customer's request and the relevant restaurant context.
TypeSafe publishes a similar input-and-output screening pattern in its LLM guardrails cookbook.
However, adding Jev before and after every LLM request creates additional API calls. I'd start with intent classification and add other checks only where testing demonstrates that they're needed.
Neither input classification nor output verification guarantees protection against every prompt-injection attempt.
Also, a message being restaurant-related doesn't mean the customer is authorized to perform every restaurant action. Authentication, order ownership checks and permission enforcement must remain separate from Jev.
8. Practical Example: Integrating Jev Into an Existing AI Agent
Now let's look at an application that operates automatically rather than waiting for a customer to send a message.
Imagine we have an AI agent that monitors Google Ads campaigns.
It fetches performance data regularly, identifies unusual changes and notifies account managers about potential problems.
An existing implementation might rely on an LLM to investigate the anomalies, interpret performance data and generate reports.
Where could Jev help?
The Problem: Too Many Decisions in an Automated Agent
Suppose a Google Ads campaign normally generates 40 conversions per day. Suddenly, the campaign records only 12 conversions.
Our monitoring agent detects the change.
But identifying a drop in conversions and understanding what it means are two different problems.
There are several possible explanations. The campaign might have a genuine performance issue. Conversion tracking could have stopped working. The latest conversion data might still be incomplete.
The important thing is that our application needs evidence before deciding whether to notify someone.
Using an LLM to investigate every anomaly may be unnecessary, particularly when monitoring hundreds of campaigns.
We can introduce Jev as a decision layer that evaluates the evidence collected by the application.
Building an Agent That Combines Jev and an LLM
The first step is to separate calculations from judgments.
Our application should fetch Google Ads data and calculate performance changes using ordinary code.
For example:
type CampaignMetrics = {
campaignName: string;
currentSpend: number;
previousSpend: number;
currentConversions: number;
previousConversions: number;
};
function percentageChange(
current: number,
previous: number
): number | null {
if (previous <= 0) {
return null;
}
return ((current - previous) / previous) * 100;
}
function analyzeCampaign(
campaign: CampaignMetrics
) {
return {
campaignName: campaign.campaignName,
spendChange: percentageChange(
campaign.currentSpend,
campaign.previousSpend
),
conversionChange: percentageChange(
campaign.currentConversions,
campaign.previousConversions
)
};
}
This is ordinary TypeScript. We don't need Jev or an LLM to calculate percentage changes.
In a real monitoring system, we'd also need comparable reporting periods, conversion-delay handling and minimum data requirements.
Once the application identifies an anomaly, it should gather relevant information before sending anything to Jev.
That might include campaign objectives, recent configuration changes, tracking status, campaign history and previous alerts.
Now Jev can evaluate questions that require interpreting this information.
Here's a simplified Jev integration:
import {
TypeSafeClient,
noul,
choice
} from "@typesafe-ai/sdk";
const jev = new TypeSafeClient();
type AnomalyContext = {
campaignName: string;
spendChangePercent: number | null;
conversionChangePercent: number | null;
businessContext: string;
observations: string[];
};
export async function evaluateAnomaly(
anomaly: AnomalyContext
) {
const result = await jev.systemOne({
state: anomaly,
questions: {
actionable: noul(
"Given the supplied evidence, does this " +
"anomaly appear to require investigation " +
"rather than routine monitoring?"
),
urgent: noul(
"Does the supplied evidence indicate " +
"that this anomaly requires immediate " +
"human attention?"
),
explanation: choice(
"Which explanation is best supported " +
"by the supplied evidence?",
{
tracking:
"Evidence supports a tracking issue",
configuration:
"Evidence supports a configuration issue",
performance:
"Evidence supports a performance problem",
expected:
"Evidence supports expected variation",
unknown:
"There is insufficient evidence"
}
)
}
});
return {
actionableProbability:
result.answers.actionable.noul,
urgentProbability:
result.answers.urgent.noul,
suggestedExplanation:
result.answers.explanation.choice,
explanationConfidence:
result.answers.explanation.confidence
};
}
The important part is what happens after Jev returns these values.
We should not automatically treat its selected explanation as the actual cause of the anomaly.
For example, if Jev selects tracking, our application could investigate the tracking configuration before deciding whether that explanation is correct.
Likewise, a high probability of urgency doesn't automatically authorize the agent to change a campaign's budget.
Our application is still responsible for determining which actions are permitted.
Integrating It Into an Existing Workflow
If we already have an AI monitoring agent, we don't need to rebuild it.
We can introduce the Jev decision service between anomaly detection and investigation.
The existing scheduler, Google Ads integration, database and notification service remain unchanged.
Initially, I'd run Jev alongside the existing workflow without letting it modify notification behavior.
For each historical anomaly, compare the Jev evaluation with what actually happened and what the account manager considered important.
This helps establish whether Jev is making useful distinctions.
Once we have enough evidence, we can test policies for routine monitoring, additional investigation and human escalation.
Keep critical alerting rules separate. A mandatory alert should never disappear merely because Jev returned a low probability or its API was temporarily unavailable.
I'd also retain the existing notification deduplication logic. If the same anomaly is detected repeatedly, users shouldn't receive duplicate alerts simply because Jev evaluated it several times.
This is how Jev can coexist with an existing AI agent: it adds a focused decision service without replacing the infrastructure or LLM already in use.
9. Using Jev With Claude Code and Other Coding Agents
We've explored how Jev can work inside two applications. But can it also help during software development?
There's an important limitation to understand first.
Jev cannot replace the model powering Claude Code. It doesn't generate code, edit files or operate as a general-purpose coding agent.
TypeSafe explicitly distinguishes Jev from coding LLMs in its documentation.
However, we can use Jev in applications built with coding agents, and we can create custom development tools that call Jev through its official API.
Understanding the Official TypeSafe Agent Skill
TypeSafe provides an official Agent Skill that gives coding agents information about its API, decision primitives and integration patterns.
The skill helps an agent write appropriate TypeSafe integration code instead of guessing how the API works.
For Claude Code, install the official skill using:
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai
Restart Claude Code or reload the plugins.
You can explicitly invoke the skill using:
/typesafe:typesafe-ai
TypeSafe also provides an installation method for other supported coding agents:
npx skills add typesafe-ai/skills --skill typesafe-ai
These commands are documented in TypeSafe's official Agent Skill repository.
It's important to understand what the skill actually does.
Installing the skill doesn't automatically introduce Jev into Claude Code's internal development process.
Instead, the skill helps Claude understand how to build applications that use TypeSafe.
For example, we could ask Claude Code:
Use the official TypeSafe skill to review this project.
Find places where we're currently using an LLM
for classification, scoring, routing, or other
structured decisions.
For each opportunity:
- Explain the existing implementation.
- Explain whether Jev would be suitable.
- Compare it with the current approach.
- Identify additional API calls and dependencies.
- Explain how the integration would work.
Don't modify any code yet.
Prepare an implementation plan and wait for review.
This is useful when exploring an existing codebase because it helps identify potential integration points without changing your current development process.
Can Jev Help During Software Development?
What if we want to call Jev while writing code?
For example, after Claude Code modifies several files, we might want to identify whether the changes involve payment processing, database migrations or authentication.
A custom Jev tool could classify a description of those changes and identify areas for additional review.
However, we should be careful about what such a tool can actually achieve.
Classifying a code change isn't the same as finding a vulnerability. Jev doesn't replace a static analyzer, a security scanner or a developer reviewing the code.
Its potential role is to help prioritize the review process.
Building a Custom Development-Time Integration
We can build a small command-line script using TypeSafe's official TypeScript SDK.
This is our own custom integration, not an officially provided Jev CLI or code-review tool.
Create scripts/jev-review.ts:
import {
TypeSafeClient,
noul
} from "@typesafe-ai/sdk";
const jev = new TypeSafeClient();
// Supply a reviewed, non-sensitive summary.
const changeSummary = process.argv
.slice(2)
.join(" ");
if (!changeSummary.trim()) {
throw new Error(
"Provide a summary of the code changes."
);
}
async function main() {
const result = await jev.systemOne({
state: {
changeSummary
},
questions: {
paymentChanges: noul(
"Does `changeSummary` describe changes " +
"to payment or billing functionality?"
),
databaseChanges: noul(
"Does `changeSummary` describe changes " +
"to database schemas or data migrations?"
),
securityChanges: noul(
"Does `changeSummary` describe changes " +
"to authentication or authorization?"
)
}
});
console.log({
paymentChanges:
result.answers.paymentChanges.noul,
databaseChanges:
result.answers.databaseChanges.noul,
securityChanges:
result.answers.securityChanges.noul
});
}
main().catch((error) => {
console.error(error);
process.exitCode = 1;
});
Assuming the TypeSafe SDK is installed and the API key is configured, run the script using a TypeScript runner such as tsx:
npx tsx scripts/jev-review.ts \
"Updated checkout validation and payment handling"
The script will return Jev's estimated probabilities for the specified categories.
It doesn't analyze the entire codebase or prove whether a change is safe. Its assessment depends on the summary supplied to it.
You can ask Claude Code to run this script during your existing review process. For more automation, you could connect it through a custom Claude Code skill or hook.
The Jev functionality still comes from TypeSafe's official SDK. The command-line wrapper is code we've written ourselves.
For a real development workflow, I'd run it on demand initially. Adding another model request after every file edit would introduce complexity without necessarily improving code quality.
10. Production Considerations and Limitations
Jev gives us another way to make decisions inside software, but integrating it into production applications requires more than adding an API call.
Design specific questions. Jev works best when questions describe focused judgments. Avoid combining several unrelated conditions into one complicated question. Ask separate questions and combine the results in application code.
Handle probability and uncertainty carefully. Choice and Score provide confidence measures, while Noul returns a probability that a statement is true. These numbers aren't interchangeable. Test thresholds against real examples before using them to make production decisions.
Keep arithmetic and exact operations in code. TypeSafe explicitly documents Jev's limitations with calculations, counting, numerical precision and date comparisons. Ordinary code should handle operations that require deterministic results.
Implement failure handling. Decide what happens when the API is unavailable, a request times out or a result is uncertain. An appropriate fallback might be requesting clarification, retaining an existing workflow or escalating to a human.
Monitor decision quality. Record enough information to understand why your application followed a particular path. Evaluate false positives, false negatives and how often humans disagree with automated decisions. Avoid storing sensitive input unnecessarily.
Protect sensitive information. Treat TypeSafe as an external service when deciding what information to send. Keep API keys server-side, review applicable data-handling requirements and avoid transmitting confidential source code without appropriate authorization.
Understand what type safety guarantees. Jev's output types are constrained, but its decisions can still be incorrect. TypeSafe also acknowledges limitations involving adversarial content, irrelevant context and complex reasoning.
Most importantly, don't introduce Jev simply because it's available. Every additional model call introduces a dependency. Use it where a focused model judgment provides a measurable advantage over simpler approaches.
11. Frequently Asked Questions
Is Jev an LLM?
Jev is TypeSafe's first public System One Model. Unlike conventional generative LLMs, it is designed to produce structured decisions rather than open-ended text. Its interface consists of typed questions and answers.
Can Jev replace GPT or Claude?
Not for general-purpose language generation.
Jev doesn't generate conversational responses or write code. It can complement GPT, Claude and other LLMs by handling specific decision-making tasks inside applications.
How do I use Jev with Claude Code?
Install TypeSafe's official Agent Skill to help Claude Code understand the API and write Jev integrations.
If you want Claude to execute Jev during development, you can build a custom script or other tool using TypeSafe's official API or SDK.
The Agent Skill itself isn't a running Jev model.
Does Jev have an official MCP server or CLI?
The official interfaces covered in this guide are TypeSafe's REST API, SDKs, Playground and Agent Skill.
The official skill isn't an MCP server or a dedicated CLI for executing Jev. Developers can create their own command-line tools or integrations using the official API.
Can Jev prevent a chatbot from answering unrelated questions?
Jev can help classify incoming requests and allow application code to reject messages that fall outside the chatbot's intended scope.
However, it cannot guarantee perfect classification or eliminate every prompt-injection attempt. Use it alongside application-level rules, restricted permissions and appropriate testing.
Can Jev work with existing AI agents?
Yes. You can add Jev at specific decision points inside existing agents without replacing their current LLMs.
Examples include request routing, evidence evaluation, anomaly prioritization and escalation decisions.
Is Jev faster or cheaper than using an LLM?
TypeSafe reports speed and cost advantages on its published System One benchmarks.
Whether those advantages apply to your application depends on the workload, alternative models, integration architecture and additional API calls.
You should measure the complete workflow rather than assuming that a lower individual model cost guarantees a lower overall cost.
When should I use Jev instead of an LLM classifier?
Consider Jev when your application repeatedly needs focused, structured judgments using predefined questions and you can benefit from its probability-oriented interface.
However, an existing LLM classifier might already meet your accuracy, latency and cost requirements.
The decision should come from comparing both approaches against real application data.
12. Conclusion: Jev and LLMs Working Together
When building AI applications, it's easy to rely on an LLM for almost everything.
Sometimes that's appropriate. LLMs are useful for understanding complex requests, generating responses, investigating problems and writing code.
But many application tasks are much narrower. We might need to classify a customer request, decide whether an anomaly requires attention or evaluate whether a document supports an answer.
These are the kinds of tasks Jev is designed to handle.
In our restaurant chatbot example, we introduced Jev without replacing the existing LLM. It classified incoming requests while application code controlled which messages could reach the chatbot.
In our monitoring agent, ordinary code calculated performance changes, Jev evaluated the available evidence, and the LLM remained responsible for investigation and report generation.
We also explored TypeSafe's official Agent Skill and how to build custom development tools using its API.
The common idea is to give each part of the application a clear responsibility.
Use code for deterministic operations. Use Jev where focused judgments are useful. Keep an LLM for language generation and tasks that require more extensive reasoning.
That doesn't mean every application needs Jev.
Start by identifying one decision in an existing workflow. Implement a small integration, compare it against your current approach, and measure whether it improves the application.
The goal isn't to use more AI models. It's to build software where each tool has a clear purpose.
Official references
These are the primary sources used for the technical explanations and examples in this article.