What is Jev: TypeSafe AI's AI Structured Decision Model Returning Typed Judgments in 70 Milliseconds

What is Jev

Jev is an AI structured decision model from TypeSafe AI, founded by former OpenAI researcher Diogo Almeida. Jev is based on Transformer but is not a large language model; it does not output sentences, but returns typed decisions within preset options: Choice (option), Score (rating), Noul (probability), along with confidence. Model response latency is about 70–500 milliseconds, purpose-built for high-frequency Agent judgment scenarios such as tool routing, ticket triage, and game decisions.

Key Features of Jev

• Choice Option Decision: Selects the most suitable item from a preset option list (up to 255), returning the option, probability distribution, and confidence — suitable for routing and classification.
• Score Rating: Scores input on a custom scale (e.g., 1–5 levels), returning the score, probability, and confidence — used to measure urgency, quality, or risk level.
• Noul is Binary Judgment: Outputs a 0–1 probability value for "is this statement true" — suitable for binary judgments such as whether to escalate to a human or whether action is needed.
• Parallel Multi-Question: A single API call can mix multiple questions at once, sharing the same input with independent parallel evaluation — adding questions barely increases latency and produces no context rot.
• Confidence Output: Choice and Score come with calibrated confidence scores, so code can route accordingly — high confidence executes automatically, low confidence escalates to a large model or a human.
• Hallucination-Free Typed Output: Strictly limited to user-preset options and type ranges, no JSON parsing needed, eliminating format errors and out-of-bounds rambling.
• Ultra-Low Latency: End-to-end response of about 70–500 milliseconds, 20–200x faster than comparable large language models, supporting high-frequency decision loops of about 10 per second.

Jev's Three Output Forms

• Choice (Option Decision): Selects the most suitable item from a user-predefined option list (up to 255), returning the selected option, the probability distribution of options, and confidence — suitable for "pick one" scenarios like routing, classification, and tool selection.
• Score (Scale Rating): Scores the input state on a user-defined rating scale, returning the score, the probability distribution of levels, and confidence — suitable for "how many points" scenarios like urgency assessment, quality rating, and risk grading.
• Noul (Binary Judgment): Outputs a probability value between 0–1 for whether a statement is true, without a separate confidence return — suitable for binary judgment scenarios like "does this need human escalation" and "does this require action".

Relationship between the three: They can be mixed freely in the same API call, sharing the same input state with parallel independent evaluation — adding questions barely increases latency and produces no context rot.

How to Use Jev

• Register an Account: Visit the official Jev website https://console.typesafe.ai/ — registration allows immediate use.
• Get an API Key: Create and copy an API Key in the console for authentication in subsequent API calls.
• Prepare Input State: Organize the current situation into structured text or data, such as game state, web page element lists, or email content — Jev reads state descriptions, not raw screens.
• Define Questions: Choose from the three primitives based on your needs — Choice (option decision), Score (scale rating), Noul (binary judgment); each question asks only one specific thing.
• Send the Request: Send requests via REST API or the official SDK, with State and multiple questions in the same call; the model evaluates all questions in parallel.
• Parse Typed Results: Directly receive strongly-typed results such as options/scores/probabilities and confidence — no JSON prompts or extra parsers needed; code can consume them directly.
• Combine Multiple Questions in Code: Break complex judgments into multiple atomic questions, then weight and combine the results of each dimension with code logic, rather than letting the model weigh everything in a single prompt.
• Integrate Confidence Routing: Design strategies based on the returned confidence — e.g., above 90% execute automatically, 60–90% escalate to a large model, below 60% hand off to a human.
• Calibrate and Validate with Your Own Data: Before going live with automatic decision rules, first verify with business data whether model probabilities match actual outcomes — do not rely on a single confidence value alone.
• Pair with Generation Models: For scenarios that need text output (e.g., filling in form content), call a generation model separately — Jev is dedicated to the high-frequency "which one to choose" judgment step.

Core Advantages of Jev

• Extreme Speed: End-to-end latency of just 70–500 milliseconds, 20–200x faster than comparable large language models, supporting high-frequency decision loops of about 10 per second.
• No Format Hallucination: Output is strictly limited to user-preset options and type ranges, no JSON parsing needed, eliminating out-of-bounds rambling and format errors.
• Calibrated Confidence: Returns calibrated probability distributions and confidence scores, so code can make routing decisions — automatic execution, model escalation, or human intervention.
• Parallel Multi-Question: A single call can evaluate multiple independent questions simultaneously, sharing the same input with almost no added latency and no context rot.
• Decision-Generation Decoupling: Strips "judgment" out of full text generation, avoiding using a sledgehammer to crack a nut, letting generation models focus on the text output they excel at.
• Code-Composable: Atomic question design lets business logic settle in code — priority changes only require adjusting coefficients rather than rewriting prompts, with stronger controllability and maintainability.
• General Semantic Understanding: Based on the Transformer architecture with general semantic understanding capabilities — when rules and candidates change frequently, no retraining is needed as with traditional classifiers.

Comparison with Similar Competitors

Jev's Application Scenarios

• Agent Routing and Tool Scheduling: High-frequency judgment of whether the current intent should call search, database, or code execution — choosing only from a preset list of valid APIs, eliminating hallucinated tool names while supporting the Agent's fast loop with millisecond-level response.
• Customer Service Ticket Triage: A single call judges a ticket's owning team, urgency, and information completeness in parallel, letting millions of daily emails/tickets complete automatic triage at near-zero cost.
• Game and Simulation Decisions: Receives structured state output from game engines, making high-frequency move selections at about 10 per second within a preset action set, driving AI players in games like DOOM and Mario.
• Browser Automation: Numbers page elements and lets Jev decide step by step which button to click and which input box to fill — switching to a generation model only when text output is needed, completing tasks like flight searches with a dozen-plus steps in just seconds.
• Context Compression and Model Routing: In long contexts of millions of tokens, judges which information is critical and which can be discarded, and predicts task complexity in real time to decide whether to dispatch a lightweight model or a flagship model, achieving optimal cost-effectiveness allocation.

Frequently Asked Questions

Q1: What is Jev?

A1: Jev is an AI structured decision model from TypeSafe AI, based on Transformer but not generating text — instead returning three types of typed decisions within preset options: Choice (option), Score (rating), Noul (binary judgment), with calibrated confidence, purpose-built for high-frequency Agent judgment scenarios.

Q2: What is the difference between Jev and large language models?

A2: Jev is not a large language model; it does not output sentences, only returns structured decisions within user-preset options and type ranges, so there is no format hallucination; response latency is about 70–500 milliseconds, 20–200x faster than comparable large language models, suitable for high-frequency judgments like tool routing and ticket triage — text generation still needs to be left to generation models.

Q3: What are Jev's response speed and cost?

A3: End-to-end latency is about 70–500 milliseconds, supporting decision loops of about 10 per second; billing is $0.042 per million input tokens with free output, suitable for large-volume, high-frequency judgment-type calls.

Q4: What scenarios is Jev suitable for?

A4: Suitable for scenarios needing high-frequency, low-latency "which one to choose" judgments, such as Agent tool routing, customer service ticket triage, game AI move selection, browser automation operations, and information filtering and model routing in long contexts.