Jev AI: A Developer’s Guide to Decision‑Only AI

Overview and History of Jev AI and TypeSafe AI

Jev AI is a proprietary “decision‑only” artificial‑intelligence model built by TypeSafe AI, a San Francisco‑based startup founded in 2024. The company’s mission is to provide fast, inexpensive, and predictable AI services that are meant to be consumed by software rather than read by humans.

The model is named after the 19th‑century economist William Stanley Jevons, reflecting its focus on rational, utility‑driven output. When Jev was released in limited early access on September 15 2026, it arrived together with a $40 million seed round led by DCVC. The funding helped TypeSafe build the infrastructure needed to deliver the promised “System One” speed and cost advantages.

Since launch, TypeSafe has iterated quickly. The stable release version is jev‑1.13.0, and the product is marketed as a “fast, cheap decision function for automation code, not a chatbot.” The company’s public website is typesafe.ai.

Core Architecture: Non‑Autoregressive System One Design

Jev’s architecture departs from the familiar autoregressive language‑model pipeline. Instead of generating a token stream one step at a time, Jev evaluates an entire request in a single parallel pass. This design is what TypeSafe calls System One, echoing Daniel Kahneman’s concept of fast, intuitive thinking.

How System One Generates Decisions Without Autoregression

1. Input Normalization – The client sends a state (plain string, JSON object, or array) together with one or more typed questions.
2. Embedding & Context Fusion – The state is encoded into a dense representation. All questions are embedded simultaneously and merged with the state embedding.
3. Parallel Decision Heads – For each primitive question type (Choice, Score, Noul) there is a dedicated head that computes a probability distribution over the allowed output space. Because the heads run in parallel, the total compute cost is essentially constant regardless of how many questions are asked.
4. Calibration Layer – A lightweight post‑processing layer converts raw logits into calibrated probabilities and confidence scores that obey the declared schema.
5. Schema‑Constrained Decoding – The model never emits a value that violates the schema (e.g., it won’t output a string where a numeric score is required).

The result is a structured JSON payload that contains the answer, per‑option probabilities, and an overall confidence metric—all delivered in a single network forward pass.

Comparison with Traditional Autoregressive LLMs

Because Jev never performs step‑wise sampling, it can achieve up to 100 × faster inference and 100 × lower cost for decision‑oriented workloads.

Primitive Question Types and Their Use Cases

Jev supports exactly three primitive question types, each designed to fit a common pattern in programmatic decision making.

Choice – When and How to Use

Definition: Returns a single selected option from a predefined list, together with per‑option probabilities and a confidence score.

Typical use cases

• Routing: Choose the next micro‑service endpoint based on request metadata.
• Feature flag evaluation: Decide which experimental feature to enable for a user.
• Menu selection: Pick the most relevant UI component in a dynamic dashboard.

How to call

{
  "state": {"user_id": 123, "country": "FR"},
  "questions": [
    {
      "type": "choice",
      "name": "region_target",
      "options": ["EU", "NA", "APAC"]
    }
  ]
}

Score – When and How to Use

Definition: Produces a rating (commonly 1‑5 or 0‑10) with a probability distribution for each possible level and a confidence value.

Typical use cases

• Content quality scoring: Assign a risk score to user‑generated text.
• Priority ranking: Score a batch of tasks to decide execution order.
• Model guardrails: Give a “trust” score to the output of a downstream LLM before it is acted upon.

How to call

{
  "state": {"text": "User comment ..."},
  "questions": [
    {
      "type": "score",
      "name": "toxicity",
      "scale": 5
    }
  ]
}

Noul – When and How to Use

Definition: Returns a probability between 0 and 1 for a binary (yes/no) proposition, plus a confidence metric.

Typical use cases

• Eligibility checks: “Is this transaction fraudulent?”
• Feature enablement: “Should we show the discount banner?”
• Simulation: “Will the drone succeed in this maneuver?”

How to call

{
  "state": {"temperature": 22, "humidity": 55},
  "questions": [
    {
      "type": "noul",
      "name": "is_optimal"
    }
  ]
}

Performance Metrics: Speed, Latency, and Cost

Typical Latency Numbers

• End‑to‑end latency (including network) is reported between 70 ms and 500 ms.
• The variance mainly depends on request size (state length) and the number of parallel questions.

Cost per Token

• Input tokens are billed at $0.042 per million.
• Output tokens are free because the model returns structured JSON rather than free‑form text.

For a typical request of 200 input tokens, the cost is roughly $0.0000084 (well under a hundredth of a cent).

Benchmark Comparisons with GPT‑4, Claude, and Other LLMs

The numbers reflect the fact that Jev is optimized for decision‑only workloads, not for generating prose.

Pricing Model and Token Economics

Jev AI Pricing Tiers

1. Free Tier – 1 million input tokens per month, unlimited output, ideal for prototyping.
2. Pay‑As‑You‑Go – $0.042 per million input tokens beyond the free allowance. No hidden fees.
3. Enterprise – Custom volume discounts, SLA guarantees, dedicated support, and on‑prem licensing (see below).

Enterprise Options

• SLA‑backed latency (≤ 100 ms 99 % of the time)
• Private VPC connectivity for data‑sensitive environments
• Custom schema extensions (e.g., domain‑specific enumerations)

Detailed Token Pricing: Input vs Output

Because Jev never emits free‑form text, the cost model is dramatically simpler than for conventional LLMs.

Deployment Options and API Integration

Hosted API and Waitlist Access

Jev is currently offered as a hosted API. Access is granted via a waitlist; once approved, developers receive an API key and can start sending HTTPS POST requests to https://api.typesafe.ai/v1/jev.

Getting an API Key

1. Visit typesafe.ai/jev and click Join Waitlist.
2. Fill in company name, intended use case, and expected token volume.
3. After review (usually within 48 hours), you’ll receive an email with your secret key.

Vercel AI Gateway Setup

Vercel has added Jev as a first‑class model under the identifier typesafe-ai/jev. To use it:

npm i @vercel/ai

import { createOpenAI } from '@vercel/ai';
const jev = createOpenAI({
  apiKey: process.env.JEV_API_KEY,
  baseURL: 'https://api.typesafe.ai/v1/jev',
  model: 'jev-1.13.0'
});

The gateway handles request batching and automatic retry logic, making integration into Next.js or Remix apps trivial.

Self‑Hosted Deployment Models

For highly regulated sectors, TypeSafe offers a self‑hosted container (Docker image) that runs the inference engine behind a private load balancer. The container includes:

• Model weights (approx. 1.2 GB)
• Calibration utilities
• HTTPS endpoint compatible with the public API schema

Self‑hosting requires a GPU with at least 8 GB VRAM (e.g., NVIDIA RTX 3070) and a Linux host. Pricing for the on‑prem license is negotiated per‑enterprise.

Real‑World Applications and Early Demos

Routing Use Cases

A SaaS platform used Jev to decide which data‑center should serve an incoming request. By feeding request headers and user metadata into a Choice question, the system achieved sub‑100 ms routing decisions and reduced latency by 30 % compared to a rule‑based router.

Scoring Use Cases

A content‑moderation team integrated a Score primitive to rate user comments on toxicity. The calibrated probabilities allowed downstream logic to auto‑reject high‑risk posts while flagging borderline cases for human review.

Classification and Content Moderation Examples

Using a combination of Choice (topic classification) and Noul (policy‑violation flag), an e‑learning platform built an automated quiz‑grader that could instantly decide pass/fail and assign a confidence level, enabling real‑time feedback to learners.

Developers have also built Minecraft bots and simulated drones that rely on Jev’s instant decisions to navigate environments without the latency of a full LLM.

Limitations, Failure Modes, and Hallucination Risks

Schema Violations and Handling

Jev guarantees that output respects the declared schema, but the model can still return incorrect probabilities (e.g., low confidence on a clearly deterministic question). Applications should treat the confidence field as a trust indicator and fall back to a deterministic rule when confidence drops below a threshold.

Out‑of‑Distribution Inputs

When the state contains concepts the model has never seen during training, Jev may assign near‑uniform probabilities and low confidence. In such cases, a secondary validation step (e.g., rule‑based sanity check) is advisable.

Confidence Scores and Mitigation Strategies

• Thresholding – Discard answers with confidence < 0.6 and request a human or a fallback model.
• Ensemble – Run the same request through two independent Jev instances and compare results. Divergence can trigger a safety net.

Calibration, Confidence Scoring, and Probability Interpretation

Jev’s calibration layer maps raw logits to probabilities that are empirically aligned with observed frequencies. For a binary Noul question, a reported