What Is Jev? TypeSafe AI's Decision Model Explained

Jev is a specialized decision model developed by TypeSafe AI that evaluates context to return typed decisions and mathematical probabilities instead of prose.

TypeSafe AI released that decision model in early access on September 15, 2026.

At Layer3Labs, we design and operate automated pipelines for business workflows, where choosing between traditional text generation and bounded decision systems shapes both runtime cost and infrastructure reliability.

System One Architecture and Probability Outputs

A System One model handles fast, instinctive evaluation rather than deliberate analytical prose.

TypeSafe AI designed Jev around this cognitive distinction. Traditional Large Language Models (LLMs) produce sequential text tokens that require strict JSON schema enforcement and custom parsing code. Jev bypasses text entirely. It ingests context and outputs deterministic data structures containing mathematical probabilities.

Developers receive direct enum selections and numerical floats without markdown wrapping. This design eliminates JSON syntax breaks and schema retry loops. TypeSafe AI reports end-to-end latency between 70 and 500 milliseconds for these operations. Diogo Almeida, formerly of OpenAI, claims the model runs 20 to 200 times faster than conversational alternatives.

• Core design: returns structured schema decisions and confidence scores instead of freeform prose.
• End-to-end latency: TypeSafe AI reports responses between 70 and 500 milliseconds.
• Output format: native JSON payloads with no text extraction or markdown stripping required.
• Leadership: developed by TypeSafe AI founder Diogo Almeida, formerly of OpenAI.

Three Question Types in the Jev Interface

Jev restricts its entire query interface to Choice, Score, and Noul questions.

Every evaluation task maps onto one of these three primitives. Choice questions select one item from an explicit list of up to 255 options. The API returns the chosen string, a full probability distribution across candidates, and a calculated confidence score. A customer support desk can categorize incoming tickets into billing, technical, or cancellation queues without parsing conversational text.

Score questions assign an input to an ordered rubric. The response provides the tier placement, the distribution across rubric levels, and confidence data. A sales pipeline can classify inbound leads into low, medium, or high qualification bands based on company attributes. Noul represents a yes or no question. The returned value is a single probability between 0 and 1 indicating whether the statement holds true. Noul returns no separate confidence field because the probability itself serves as the decision signal.

• Choice: selects one option from up to 255 candidates, returning the winner, full distribution, and confidence.
• Score: places input onto an ordered rubric, returning the selected tier, distribution, and confidence.
• Noul: evaluates a binary statement, returning a probability float between 0 and 1 with no separate confidence field.
• Implementation guide: explore complete payload structures in our guide on how to use Jev.

RLCD Training and Probability Calibration

TypeSafe AI trains Jev using Reinforcement Learning for Calibrated Decisions, an optimization method abbreviated as RLCD.

This technique targets decision correctness and probability alignment rather than conversational fluency. Calibration is a training objective rather than a guarantee of factual accuracy on specific prompts. In ideal calibration, predicted probabilities mirror empirical outcomes across large validation populations. A score of 0.80 does not guarantee that eighty percent of individual predictions are right.

Confidence metrics on Choice and Score questions are calculated directly from the underlying probability distribution. High confidence means the model concentrated weight on one candidate. It does not confirm that the answer is objectively true. Engineering teams must validate performance against their own historical data before trusting automated cutoff thresholds.

• Training objective: RLCD aligns predicted probabilities with decision outcomes across validation sets.
• Calibration limits: calibration is an optimization target, not an operational guarantee of correctness.
• Confidence derivation: scores reflect mathematical concentration across candidates rather than absolute truth.
• Threshold planning: teams must empirically verify scoring cutoffs using real internal datasets.

Parallel Execution and Token Economics

Jev answers multiple questions simultaneously against one shared input.

Appending additional questions adds minor token overhead without multiplying base latency. The model processes the entire question batch in one evaluation pass. Pricing is set at $0.042 per million input tokens, while output generation is completely free.

This pricing structure alters the arithmetic of high-volume triage. Consider a workload processing 100,000 requests of 1,000 input tokens each. That volume amounts to 100 million input tokens. On Jev, that batch costs exactly $4.20. Running that identical batch through OpenAI's GPT-5.6 Luna costs more. With input at $0.20 and output at $1.20 per million tokens, assuming 50 output tokens per request, the run costs $20.00 for input and $6.00 for output, yielding a $26.00 total. Processing the batch on Anthropic's Claude Haiku 4.5 ($1.00 input, $5.00 output per million tokens) with that same 50 output-token assumption costs $100.00 for input and $25.00 for output, totaling $125.00.

• Input pricing: $0.042 per million input tokens.
• Output pricing: zero cost for all generated decision payloads.
• Parallel evaluation: multiple Choice, Score, and Noul questions evaluate simultaneously across the same state.
• Pricing comparisons: review detailed cost modeling in our Jev pricing guide.

Strict Boundaries and Unsupported Tasks

Jev cannot generate text, write software code, or produce natural language explanations.

These omissions represent architectural boundaries rather than accidental product gaps. The model performs no arithmetic, counting, date comparisons, or multi-step indirect deduction. It is also vulnerable to adversarial prompt injection. TypeSafe AI explicitly advises developers to keep exact calculations in program code and make query prompts direct.

Input modality is limited strictly to plain text. There is no support for images, video, or audio files. The API provides no streaming responses. Choice questions accept a maximum of 255 options per field. The overall request budget sits at roughly 32,000 tokens, which TypeSafe AI describes as approximately 150,000 English characters. TypeSafe AI has not published official API rate limits.

• No text output: produces structured classifications and probability floats, never paragraphs or code.
• No programmatic logic: cannot execute arithmetic, counting, calendar logic, or indirect reasoning.
• Modality constraints: text-only ingestion with no support for multimodal inputs.
• Context envelope: request budget caps at roughly 32,000 tokens or about 150,000 English characters.
• System constraints: review full operational ceilings in our Jev limits guide.

Published Benchmarks and Raw Accuracy Tradeoffs

On TypeSafe AI's internal workflow dashboard, Jev aggregates at 67.8% accuracy compared to 74.1% for an unidentified top comparator.

Task-specific scores across that suite range from 61.7% to 76.0%. TypeSafe AI's own measurements show Jev trailing the unidentified comparator on raw decision accuracy. It trades raw accuracy points to achieve lower unit costs and faster latency. No independent third-party benchmark of Jev exists as of September 22, 2026.

Teams must evaluate accuracy tradeoffs against their own tolerance for classification errors. Diogo Almeida reports that creator demos achieved 724 ad evaluations in 40 seconds for $0.09, and 384 headline triages in 24.9 seconds for $0.19. Other vendor-reported tests include a browser flight search in 7 seconds for $0.0039 and a trading bot acting within 300 millisecond blocks. These figures demonstrate rapid execution under controlled setups, but they do not replace independent production verification.

• Internal benchmark: aggregates at 67.8% accuracy versus 74.1% for an unidentified comparator on TypeSafe AI's dashboard.
• Score range: specific evaluation tasks span from 61.7% to 76.0% accuracy.
• Independent verification: no third-party benchmarks have been published as of September 22, 2026.
• Vendor-reported demos: triaged 724 ads in 40 seconds for $0.09 and 384 headlines in 24.9 seconds for $0.19.

Community Implementations and the JevSEO Analyzer

The open-source JevSEO crawler illustrates how Jev functions inside real-world evaluation workflows.

Maintained by epergaboni under an MIT license, the tool scores web pages across Search Engine Optimization (SEO), Answer Engine Optimization (AEO), and Generative Engine Optimization (GEO). Its documentation at jevseo.epergaboni.com outlines an architecture pairing 20 deterministic code checks with approximately 25 semantic reading queries sent to Jev in a single request.

The crawler classifies pages into six typed verdicts: leave, improve, rewrite, merge, split, or prune. Each verdict includes its probability distribution and an effort ranking. The software runs locally on Node 22 using built-in SQLite, ensuring API keys never leave the host machine. The JevSEO project reports typical runtimes of 2.3 seconds per page, processing 3,969 input tokens at an estimated cost of about $0.0001. Documented boundaries remain explicit: it does not rewrite copy, execute client-side JavaScript, or predict search engine rankings, and it truncates documents exceeding 28,000 characters.

• Open-source implementation: community auditing utility hosted at github.com/epergaboni/jevseo.
• Three evaluation axes: distinct scoring models for SEO, AEO (40 to 60 word standalone answers), and GEO citation signals.
• Local execution: requires Node 22+ with embedded SQLite, keeping API credentials local.
• Project-reported metrics: analyzes a page across 25 semantic questions in 2.3 seconds for roughly $0.0001.

Jev Compared with Generative Model Options

Choosing between Jev and conversational LLMs requires balancing output requirements against per-token infrastructure expenses.

General LLMs such as GPT-5.6 Luna and Claude Haiku 4.5 excel at generating prose, explaining code, and drafting messages. Jev cannot perform any of those conversational tasks. However, when an automated pipeline only needs routing, scoring, or binary validation, paying for generative output tokens introduces unnecessary latency and billing overhead.

Developer access to Jev currently requires joining an early-access waitlist, though a browser playground is available. TypeSafe AI documents no free tier and no promotional credits. The model alias is jev-latest, and Cloudflare has published a model card at developers.cloudflare.com/ai/models/typesafe/jev/. Forbes reported on September 19, 2026, that Vercel and Cloudflare moved quickly to add integrations.

• Jev: $0.042 input, $0.00 output per million tokens; typed classifications and probabilities only; 70 to 500 ms latency.
• GPT-5.6 Luna: $0.20 input, $1.20 output per million tokens; full text, code, and conversational generation.
• Claude Haiku 4.5: $1.00 input, $5.00 output per million tokens; general text capabilities and nuanced analysis.
• Functional trade: Jev saves token costs on routing queues but cannot draft responses or explain reasoning.

Adoption Criteria and Workflow Fit

Jev fits high-volume backend queues that require deterministic categorization rather than creative text generation.

The model serves data routing layers, content moderation filters, automated audit checkers, and triage pipelines where responses occur thousands of times daily. Because output generation costs nothing, teams running large batched evaluations can scale processing volume without proportional infrastructure inflation.

This model is not built for teams needing customer-facing communication, conversational chatbots, software engineering tools, or complex mathematical deduction. In those environments, general LLMs remain necessary. Our evaluation would change if TypeSafe AI fails to close the 6.3 percentage point accuracy gap against the top comparator. It would also change if the major frontier providers dropped token pricing far enough to neutralize the cost gap. To assess whether Jev fits your existing software stack, catalog your high-volume prompt workloads and identify which jobs require typed categorization rather than natural language generation.

• Optimal workloads: high-frequency routing, batch record scoring, binary safety gates, and audit workflows.
• Poor workloads: creative writing, customer email drafts, software code generation, and mathematical reasoning.
• Reversal triggers: changes in the 6.3 percentage point benchmark gap or competitive price drops from general LLM providers.
• Next step: audit internal prompt logs to isolate structured classification tasks from text drafting tasks.