Jev for Code: How to Use TypeSafe AI’s Model in Your Programs
CoCounsel from Thomson Reuters is not a universal chat bot, but a dedicated tool for legal teams. In a similar vein, Jev is TypeSafe AI’s System One model, and you use jev in code by sending it program state plus typed questions and getting back structured probabilistic decisions. It strictly requires no text generation and involves zero prompt parsing. Developers install the SDK, generate an API key, define Choice, Score, or Noul questions, and directly call client.system_one.
Unlike an open-ended conversational LLM, Jev is a highly focused component you drop into an app wherever your code needs a fast, repeatable judgment. Whether you are routing a support ticket, extracting a specific feature, or deciding a logic branch, the engine returns choices, scores, and confidence values your code can act on directly.
This guide comprehensively details what the System One model is, how the API handles state and questions, the three core primitives, pricing limits, worked architectural patterns, and where Jev fits versus traditional language models.
What Jev Is and Why It’s Not an LLM
Jev is a System One model built by TypeSafe AI that takes as input unstructured program state and returns typed probabilistic decisions in one parallel pass, meaning it does not generate text like an LLM. Engineering teams integrate it strictly to replace fragile heuristic logic with mathematically rigorous probabilistic reasoning. This foundational shift in the System One AI architecture demands an entirely different implementation strategy than basic textual prompting.
System One vs text generation
A Large language model (LLM) fundamentally emits tokens one at a time to slowly build a continuous string of text. This sequential process requires developers to awkwardly parse strings or forcefully extract JSON structures out of conversational prose, adding unnecessary latency and fragility to the backend code.
By contrast, the System One approach completely abandons the token-by-token emission model in favor of instant categorical assignment. The Jev model instead reads the provided unstructured state and evaluates all requested dimensions simultaneously.
- It natively receives raw state data as primary input.
- It maps that unstructured input directly against your typed constraints.
- It outputs strict structured data ready for immediate code consumption.
Nothing is parsed out of prose because the output is already fully formed as programmatic variables. You receive direct boolean flags, categorical labels, or numeric scores without waiting for a string to complete.
Why it ‘can’t hallucinate’
TypeSafe claims Jev runs 40x-200x faster than frontier LLMs and mathematically cannot hallucinate or produce type errors. This assertion stems precisely from how the model aggressively binds its output space to strict predefined sets before execution begins.
Because outputs are rigorously constrained to the declared question types and option sets, the engine strictly picks among known answers rather than creatively inventing free text. If a developer asks for a category from a specific list of five departments, the system can only return one of those five options alongside its confidence metrics.
When to Use Jev in Your Code
The Jev model is best for high-volume repeated decisions with known answers where the engine takes as input unstructured program state and outputs strict logic variables. It slots perfectly into automated decision pipelines that require thousands of micro-judgments per minute without the massive overhead associated with traditional language systems.
Good fits
Developers actively deploy this decision model for real-time feature extraction, high-speed ticket classification, and continuous content moderation pipelines. The common architectural shape across all these applications involves a targeted judgment made rapidly, thousands of times, with a rigidly fixed answer space.
- Automated branching where hand-written conditional rules prove too brittle.
- Crucial output verification layers for larger autonomous agents.
- Computer-use step decisions requiring instant state evaluation.
These specific use cases demand absolute reliability and scale at the code level. A robust classification routing system can seamlessly process incoming user requests and dispatch them to the correct logical department with flawless schema compliance.
Poor fits
Jev is completely wrong for open-ended generation, writing conversational prose, detailed code synthesis, or any inherently creative task. If your application legitimately demands generating an email response or summarizing a lengthy legal document, you must use a standard LLM.
The System One model acts exclusively as a specialized component inside an application architecture, not a chatbot designed to casually converse with users. Tasks where the definitive set of possible answers is not known up front will inevitably fail, as the Questions object cannot generate novel text arrays.
Setup: Install the SDK and Get an API Key
Developers call Jev via the TypeSafe SDK client.system_one method after installing the package and generating a TypeSafe API key from console.typesafe.ai. The initialization process is designed strictly for backend integration rather than frontend conversational interfaces. You can review the complete setup sequence in the official developer documentation.
Install
The installation workflow relies entirely on standard package managers for both Python and JavaScript backend environments. Both language implementations intentionally expose the exact same API surface and methodological constraints.
For Python applications, developers run pip install typesafe-sdk in their terminal to pull the latest client payload. For JavaScript and TypeScript environments, the equivalent command is standard npm install @typesafe-ai/sdk.
- Ensure your server runtime meets the baseline version requirements.
- Install the target package globally or within an isolated virtual environment.
- Import the system_one client module directly into your routing logic.
Authenticate
Create a new API key at console.typesafe.ai and securely export it into your private server environment. The client specifically requires the credential variable to be explicitly named TYPESAFE_API_KEY utilizing the standard sk-... prefix format.
You must export the key directly to your environment variables using export TYPESAFE_API_KEY="sk-...". The SDK automatically reads this specific key from the environment when you initially instantiate it, ensuring zero hardcoded credentials remain in your production repository.
The Three Question Types: Choice, Score, Noul
Jev answers questions using Choice, Score and Noul primitives that map directly to your backend application logic. Instead of loosely prompting for a text description, developers define these exact primitive classes to shape the expected probabilistic output perfectly.
Choice
A Choice question supports up to 255 explicit options, allowing the System One engine to precisely categorize complex inputs across a wide array of potential labels. The combined maximum context is capped at a fixed limit, with roughly half heavily allocated for the single longest question payload.
The system consistently returns the chosen option alongside per-option probabilities and a definitive confidence value. Developers utilize this core primitive extensively for sorting intricate categories, assigning specific routing labels, and determining exact user intents from raw logs.
Score
The Score primitive accurately represents a position on a strictly ordered spectrum consisting of several distinct levels. This is fundamentally not a simple textual classification, but rather a continuous mathematical measurement applied cleanly to the input context.
It smoothly returns a numeric score that can land seamlessly between the defined spectrum levels depending on the confidence matrix. Engineering teams rely heavily on this primitive class to calculate urgent support priority, evaluate technical issue severity, or establish robust content quality ratings.
Noul
The Noul primitive functions purely as a strict yes or no boolean gate expressed dynamically as a continuous confidence value. It handles crucial binary decisions instantly without requiring the engine to weigh multiple competing categorical arrays.
This lightweight primitive is structurally perfect for determining backend flags like ‘refund_needed’ or ‘is_spam’ based directly on unstructured user interactions. The resulting confidence and probabilities output natively lets the host application decide exactly where to set the numerical threshold for execution acceptance.
Writing the Call: State and Questions
Developers call Jev via the TypeSafe SDK client.system_one method by passing a state object containing unstructured program context and a Questions object dictating the required schema, and the model returns typed probabilistic decisions in one parallel pass. Because Jev answers questions using Choice, Score and Noul primitives natively, the return payload maps immediately to backend execution variables. You can explore the comprehensive data structures at the typed decisions endpoint.
Shaping state
State securely holds your active application context in the form of raw text, a dense JSON object, or a structured array containing recent system logs. It effectively acts as the unstructured baseline input the model rapidly reads to understand the current operational scenario.
You absolutely do not need to meticulously pre-format this raw data into a lengthy conversational prompt string. The API call efficiently ingests the raw operational variables directly, fundamentally allowing the engine to evaluate the situational context without fragile semantic wrappers.
Defining questions
You pass a rigorous questions dictionary mapping specific property names directly to the locally initialized primitives. All questions accurately defined in this specific mapping are evaluated and securely answered in the exact same parallel pass.
- Define an explicit target category using the Choice class instance.
- Establish a numerical priority scale utilizing the Score class instance.
- Check for precise boolean flags employing the Noul class instance.
For example, an engineer might structure the active payload as {"category": Choice(...), "urgency": Score(...), "refund_needed": Noul(...)}. The Jev system seamlessly computes the probabilities for all three distinct keys simultaneously.
Reading the response
Reading the response payload systematically requires unpacking the strongly typed variables and automatically evaluating the securely attached statistical confidence.
- Extract the primary typed data value directly from the response key.
- Programmatically check the overall confidence score provided for the model’s answer.
- Branch on the confidence value to decide whether to accept the model’s answer natively.
- Seamlessly escalate the request to a human operator or an LLM fallback if the confidence falls below your designated numeric threshold.
Each returned answer securely carries its typed value alongside its strict confidence baseline, and for Choice questions, the full probability distribution across all possible options is deeply embedded in the output.
Pricing, Latency and Limits
Jev costs $0.042 per million input tokens with free output, and it dynamically responds in 70 to 500 milliseconds depending heavily on the total payload size. The underlying pricing model heavily favors high-throughput backend applications that strictly require constant, rapid state evaluation at scale. You can thoroughly review the complete commercial tiers on the token and subscription rates page.
Cost
The streamlined cost structure eliminates output generation charges entirely, meaning engineering teams only pay directly for the context they feed into the model. A standard typical case realistically costs about $0.0004 on standard benchmark workloads.
Concrete production runs deeply demonstrate extreme economic efficiency at enterprise scale. Strictly classifying 1,018 academic papers cost just $0.08 total, while a standard automated computer-use step decision predictably runs at a fraction of a cent per execution.
Speed and context
The sheer execution speed fundamentally allows the System One engine to block synchronous application backend flows without noticeably degrading the frontend user experience.
API calls return efficiently in roughly 70 to 500 milliseconds per call, securely placing the total latency well below human perception thresholds for background routing tasks. Total context is capped tightly at a fixed combined limit, with roughly half strictly allocated for the single longest question array.
| Metric | Measured Value | System Constraint |
|---|---|---|
| Input token cost | $0.042 | Priced per million tokens |
| Output token cost | Free | Flat zero rate |
| Average latency | 70-500 ms | Depending on server load |
| Maximum context | 64k tokens | Combined systemic limit |
| Maximum options | 255 | Per Choice primitive limit |
The hard constraints ensure the core engine rigorously maintains its deterministic speed advantages across all workloads. A single Choice primitive can easily list up to 255 distinct options, providing more than enough breadth for extensive categorical sorting comfortably within the strict 32k question limit.
Worked Patterns and Examples
Jev answers questions using Choice, Score and Noul primitives simultaneously, which is best for high-volume repeated decisions with known answers like dynamic triage and automated batch labeling. The model predictably returns typed probabilistic decisions in one parallel pass, allowing backend developers to execute complex multi-dimensional routing logic cleanly without chaining multiple expensive inference calls sequentially.
For standard support ticket triage, developers directly send the raw incoming ticket text as the State context input and securely ask three distinct foundational questions at once. A single API request can accurately map a department category via Choice, measure the priority urgency via Score, and actively flag a refund_needed variable via Noul. One single rapid call definitively returns all three answers, so the system can natively route, prioritize, and flag the issue in a single $0.0004 network request.
Automated batch classification pipelines similarly benefit heavily from this precise parallel architecture. Enterprise engineers effortlessly loop thousands of raw unstructured items directly through the system_one endpoint for cheap, high-volume data labeling tasks. The documented 1,018-paper run completely finished at $0.08 perfectly illustrates the profound economics of using this specific API code pattern where an engineering team would otherwise pay premium LLM prices per individual item.
Jev vs LLMs: Choosing the Right Tool
Jev does not generate text like an LLM and mathematically cannot hallucinate or produce type errors, making it vastly superior for closed routing logic. It was originally founded by Diogo Almeida, a notable co-author of InstructGPT, specifically to solve the massive systemic fragility of using slow conversational models for backend categorical assignment.
The model crushes traditional language systems in fixed-answer routing scenarios. For strict classification and categorical assignment, the proprietary system is 40x-200x faster and substantially cheaper per request. Large language models still win effortlessly for long-form prose generation, complex multi-step reasoning chains, and entirely open-ended text synthesis. Many modern enterprise applications actually use both distinct systems together, heavily utilizing the System One engine for the incredibly fast initial gate and deploying a standard LLM strictly behind a low-confidence fallback.
The engine relies on specialized synthetic training methods to achieve this speed. It specifically trains on curated synthetic data via advanced reinforcement learning from calibrated decisions. TypeSafe AI officially emerged from stealth on September 15, 2026 with a massive $40 million in initial seed funding led powerfully by DCVC. The tech company intentionally named its foundational model directly after the prominent economist William Stanley Jevons to deeply reflect its ongoing focus on raw operational utility and systemic efficiency.
| Feature Comparison | TypeSafe System One | Standard Large Language Model |
|---|---|---|
| Native output format | Strict typed primitives | Unstructured conversational text |
| Risk of hallucination | Mathematically impossible | Highly probable without parsing |
| Primary application | Rapid classification logic | Open ended text generation |
| Core execution style | Single parallel pass | Sequential token by token |