TypeSafe Jev Pricing, Rate Limits and Benchmarks (2026)

Last verified: 2026-10-09

Last updated: October 9, 2026. This revision re-verifies pricing, the jev-latest alias, rate limits, the workflow evals and the Clef comparison against primary sources, adds the AI SDK experimental_decide path and the context windows Cloudflare and Vercel list for Jev, and moves the open-replica note to Jeff v1.3.

The short answer: TypeSafe's Jev costs $0.042 per million input tokens ($42 per billion), output tokens are free, and the published rate limits are 100,000 tokens per second and 80 requests per second. As of October 9, 2026, jev-latest still resolves to jev-1.13.0, pricing is unchanged, and you get a key from the TypeSafe console with no waitlist.

Jev is a decision-only model: you send it a piece of state plus typed questions, and it returns choices, scores and booleans with calibrated probabilities instead of text, in 70-500 ms. TypeSafe documents a 64k-token budget per request, 32k of it for the state plus the longest question; Cloudflare Workers AI lists a 32,000-token context window and Vercel AI Gateway lists 32K. Input is text only, the limits are "adjusting dynamically," and the vendor publishes a jaggedness page listing nine ways Jev 1.13 gets things wrong. This page tracks what Jev costs, what the benchmarks say, where it still leads, and where it does not.

Founder Diogo Almeida, who worked on the instruction-following methods behind ChatGPT at OpenAI, argues chat-shaped models are the wrong interface for automation: software does not want strings, it wants values it can branch on.

What Changed Since Launch (October 9 Update)#

Re-verified on October 9, 2026: pricing is still $0.042 per million input tokens with output free, jev-latest still resolves to jev-1.13.0 in the quick start, whose sample response returns "model": "jev-1.13.0", and access still starts at console.typesafe.ai, where the quick start sends you to generate a key with no waitlist step. The models page now documents the limits you deploy against: 100,000 tokens per second and 80 requests per second, with a warning that the limits are adjusting dynamically and can change without notice while TypeSafe adds capacity. A request over either limit returns 429 Too Many Requests, and the official SDKs retry with backoff and honor the retry-after header. Context is 64k tokens per request, 32k of that for the state plus the longest question, and input is text only, so images, audio and binaries are yours to pre-process.

Three new docs pages change the honest picture of the model:

• The vendor now publishes a jaggedness list. Jev 1.13 jaggedness, last reviewed October 2, names nine failure modes: literal reading of instructions, unreliable counting and math, unreliable date comparison, accuracy loss from indirection and from large states full of irrelevant detail ("context rot"), susceptibility to adversarial content in the state, contradictory instructions and criteria, a bias toward the first option in a Choice, and no text generation. Each entry ships a workaround, and most of them move arithmetic, counting and comparison into code. It is the most useful page TypeSafe has published for builders, because it is the failure receipts behind the "keep code in control" stance.
• Coding agents get an explicit no. The new Jev with coding agents page says there is no model: "jev-latest" setting that turns your coding agent into a Jev-powered agent: keep the LLM-based coding agent (the harness stays the LLM's), and call Jev from the code it writes.
• Aliases, weights and data handling. jev-latest and jev-preview both point to jev-1.13.0 today, and there is no preview build, so pin the versioned id if you have tuned confidence thresholds. Jev is not fine-tuned or LoRA-adapted on customer data, every account gets the same weights, and the documented route to domain behavior is the state, instructions and criteria you write. English is the primary training language and the most accurate; other languages, CJK included, are "handled but not equally well." Requests and responses are not used for training, and zero data retention is available on enterprise terms.

The September 28 surface facts still hold: versioned model ids are the production choice, and Jev runs on Cloudflare Workers AI (typesafe/jev), Vercel AI Gateway (typesafe-ai/jev), Pydantic AI, and Simon Willison's llm-typesafe plugin. Two details on those surfaces:

• What the gateway pages list. Cloudflare's model page lists a 32,000-token context window for typesafe/jev, zero data retention, $0.042 per million input tokens and $0.00 output. Vercel AI Gateway lists two providers, TypeSafe AI and DigitalOcean, each with a 32K context and $0.04 per million input tokens. Neither page says whether that figure is the whole request or the same 32k state-plus-longest-question limit TypeSafe documents.
• The AI SDK has a decision primitive. The AI SDK Decisions docs document experimental_decide from ai, with typeSafeAi.decisionModel('jev-latest') from @ai-sdk/typesafe-ai and a default-provider string 'typesafe-ai/jev'. The SDK calls the third primitive boolean rather than noul, lists OpenAI, Anthropic and Google decision models beside Jev, and warns the API "may change in patch releases."

What is new in the field around it, verified October 9:

• Cloudflare shipped a bigger, faster Jev-compatible family on October 1. Clef (27B) and Clef-flash (9B) add Apache 2.0 weights, a 65,536-token context window and vision input, and arrive with an RL fine-tuning service. Pricing and Cloudflare's own latency numbers are compared in our Clef benchmark.
• Open replicas run locally. Jeff is now at v1.3: a new adapter-first 0.8B base with 15 LoRA adapters (the nine from v1.2 retrained plus new ones such as AML, sanctions and SOC), GGUF files for llama.cpp, and two Jeff-Code adapters aimed at speeding up coding tasks. v1.3 adapters only work on the v1.3 base, the v1.2 models stay available under their old names, and the median decision on GPU is 26.6 ms for the v1.3 base against 26.2 ms for v1.2, per its repo.

Every one of those surfaces, the Jev + Claude Opus 5.5 coding-agent pattern, and the open alternatives compared on independent benchmarks are in our follow-up: How to Use Jev.

Official Sources#

What Shipped#

Jev is an early-access hosted model you reach at POST https://api.typesafe.ai/v1/systemone with model id jev-latest. You send one state (unstructured text or program state) plus any number of typed questions, and get every answer in a single call. Three primitives cover the decision space:

• Choice: pick one option from a defined set, returns the choice, per-option probabilities, and a confidence value.
• Score: rate the state against ordered descriptive levels, returns a score with probabilities and confidence.
• Noul: a boolean question, returns the probability the answer is yes.

Each question is evaluated in parallel and in isolation against the same state, so adding questions barely changes latency and does not create context-rot. TypeSafe's cookbook for parallel questions reports a 13-question briefing in one call being 12.2x cheaper and 10.0x faster than per-question calls, with identical answers.

The architecture is the unusual part. Jev uses a parallel sampler instead of autoregressive token generation: possible outputs are enumerated in advance, so schema conformance is guaranteed rather than sampled. Training uses a new recipe, Reinforcement Learning for Calibrated Decisions (RLCD), which optimizes for "epistemically honest" probabilities instead of human preference: higher confidence means higher accuracy.

The Numbers#

TypeSafe publishes most of its receipts on the workflow evals site: fixed code-defined workflows, reference answers from the average of GPT-6 Astra and Fable 5.1, and every model run through the same constrained answering path. Best workflow row per model, as published:

Averaged across the four workflows with equal weight, the picture is tighter: Jev lands at 67.8% for $0.0004 and 0.4 seconds per case, level with Claude Sonnet 5 (67.8%), Terra (67.9%) and Luna (66.8%), behind Sol (74.1%) and Claude Opus 5 (73.1%). The per-workflow rows above are each model's best case, not its average.

Read the caveats before quoting these anywhere: the workflows were designed by TypeSafe's own capabilities team, the reference answers bias toward OpenAI and Anthropic models, and the company calls its homepage multipliers (193.6x faster, 444.6x cheaper) "the higher end of real world gains." None of that changes the shape of the result: on these decision tasks, Jev matches the mid-tier frontier models at 25-145x lower latency and hundreds to thousands of times lower cost.

The mechanism cost story is where the numbers get extreme. TypeSafe's own Doom demo bot fires 10 decisions per second for about $7 an hour. An "is this urgent" check on every inbound support message is no longer metered in anything an invoice notices.

Pricing#

First-party pricing from the announcement and TypeSafe pricing:

TypeSafe claims this is 238x cheaper on input than Claude Fable 5.1, and is candid that the price may be subsidized: "we'll need the long-term to prove the sustainability of our pricing (which we expect to go down, not up)." Output tokens are still counted in usage, but not billed.

Prices and limits re-verified October 9, 2026. The nearest decision-model comparison is now Cloudflare's Jev-compatible Clef family at $0.24 and $0.09 per million input tokens, so Jev stays the cheapest input price in the category, while Cloudflare's own run puts Clef-flash's median decision at 38.8 ms against Jev's 524.1 ms.

How to Call It#

There is no OpenCode provider for Jev yet - opencode models does not list it, and none of this site's automations run on it. The integration surface is the REST API plus official SDKs:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Hi, I have been trying to connect my Stripe account for 3 days and it keeps failing. I am losing sales. Please help ASAP.",
    "model": "jev-latest",
    "questions": {
      "urgency": { "type": "noul", "instructions": "Does this message express urgency?" }
    }
  }'

Python SDK: pip install typesafe-sdk (a JavaScript SDK ships too), plus an agent skill installable into Claude Code (claude plugin marketplace add typesafe-ai/skills, then claude plugin install typesafe@typesafe-ai) or any agent via npx skills add typesafe-ai/skills --skill typesafe-ai. There is no waitlist: create an account at the console and generate an API key from the dashboard.

GET /v1/models lists the aliases your account can call, and versioned ids like jev-1.13.0 work whether or not they appear in the list. Pin the versioned id if your thresholds are tuned to this release, because the models page states that an alias moves when a new release ships and the answers behind it can change without a change on your side.

In TypeScript, the AI SDK path is one call to experimental_decide with model: 'typesafe-ai/jev' through Vercel AI Gateway, or typeSafeAi.decisionModel('jev-latest') from @ai-sdk/typesafe-ai against TypeSafe directly. For the llm CLI plugin, Pydantic AI, Cloudflare, Vercel, and OpenRouter options, see every way to call Jev.

When a Decision-Only Model Fits#

Jev is deliberately incapable of open-ended work. The fit is work that ends in a JSON object anyway: routing and escalation (which team, which handler, with confidence deciding whether a human reviews first), scoring and ranking (sentiment, document relevance, review priority, thresholded in code), guardrails (screening prompts and outputs for jailbreaks), and high-volume extraction and classification.

The architecture pattern TypeSafe pushes is "keep code in control": decompose a judgment into atomic questions, then combine them with weights and thresholds you own. That is the same decomposition our model routing orchestration layer playbook prescribes, and the confidence channel is a second axis that router comparisons rarely account for. In a gateway-style setup like Envoy AI Gateway, a decision model becomes one more route target.

If you want to test the pattern before committing to a decision model, TypeSafe publishes a System One adapter that constrains an ordinary LLM to the same typed questions and probability output in your own code.

TypeSafe's jaggedness page is the best argument for that split: ask Jev the judgment questions, keep counting, arithmetic and date comparison in code, and use the confidence channel to route uncertain decisions to review. The failure list is not a reason to avoid the model; it is the checklist for wiring it correctly.

The honest boundary: Jev can no more write a diff or answer an open question than a router can. The interesting question is which share of your agent's calls were ever really generative. For scale: the cheapest string model in the Claude line, Haiku 5.5, lists $0.10 per million input tokens (under 100K) plus output, so Jev's input price is less than half of it with nothing charged for output. If your agents mostly classify, score, and branch, the "decision lane" just got a price point that changes the arithmetic - the division of labor between string models and decision models becomes a real architectural choice rather than a vendor's slide.

FAQ#

What is Jev?#

Jev is TypeSafe AI's first System One model, in early access since September 15, 2026. It does not generate text: you send structured questions about a state and receive typed answers with calibrated probabilities and confidence, in 70-500ms.

How much does Jev cost?#

$0.042 per million input tokens and no output charge, per the TypeSafe announcement. The company says the price may be subsidized and expects it to go down over time.

Can Jev hallucinate?#

By construction it cannot return a value outside your schema: possible outputs are enumerated in advance, so the answer is typed. It can still be wrong. TypeSafe's own jaggedness page lists where 1.13 fails, including counting, math, date comparison, literal reading and a first-option bias in Choices, which is why the calibrated confidence channel exists: threshold on it, and send low-confidence decisions to review.

What are Jev's rate limits?#

100,000 tokens per second and 80 requests per second, per the models page. TypeSafe warns the limits are adjusting dynamically and can change without notice, returns 429 above either limit, and exposes higher limits on custom and enterprise plans.

Is Jev available in OpenCode?#

Not as of October 9, 2026. There is no OpenCode provider or models.dev entry, and TypeSafe's coding-agents page says there is no model: "jev-latest" setting that turns a coding agent into a Jev-powered one. The supported surfaces are the TypeSafe REST API, the official Python and JavaScript SDKs, an installable agent skill, Cloudflare Workers AI (typesafe/jev), Vercel AI Gateway (typesafe-ai/jev), Pydantic AI, and the llm-typesafe plugin. For choosing the coding agent itself, see our OpenCode developer guide.

Is there still a waitlist for Jev?#

No. TypeSafe removed the waitlist on September 27, 2026, and anyone can create an account at console.typesafe.ai and generate a key, per the quick start. Cloudflare Workers AI and Vercel AI Gateway also expose it without a separate TypeSafe signup.

Can I call Jev from the Vercel AI SDK?#

Yes. The AI SDK ships experimental_decide, which takes a decision model, one state and a map of choice, score and boolean questions. Pass 'typesafe-ai/jev' to route through Vercel AI Gateway, or typeSafeAi.decisionModel('jev-latest') from @ai-sdk/typesafe-ai to call TypeSafe directly. The AI SDK docs mark the API experimental, so pin your ai version.

How does Jev compare to structured outputs or JSON mode?#

Structured outputs force a string model to emit JSON and parse it. Jev never produces strings: outputs are typed at the sampling layer, every answer carries probabilities and confidence, and all questions in a call resolve in parallel.

Sources#

Continue Reading#

• Cheapest Subagent Model: Haiku 5.5 or GPT-6 Luna? - the cheap string-model lane for subagent work that still needs text, next to Jev's decision lane
• What Is an Agent Harness? - Jev is a call inside the harness, not the model slot that runs your coding agent
• Pi 1.0 Release Guide: MCP, Codemode and Pi Durable - Pi's new Codemode can call Jev from inside a coding agent session
• OpenAI DevDay 2026 Recap: What Shipped and What to Test - OpenAI's Decisions API, a limited-preview classifier-style endpoint, shipped two weeks after Jev
• AI Model Routing and Orchestration Layer - how decision-shaped work should flow through your stack
• LLM Router Comparison 2026 - the routing layer as a second axis you control in code
• Envoy AI Gateway in Production - putting a decision-model route next to your chat models
• Jeff: Jev-Style Decision Models Trained at Home - the open 0.8B and 2B fine-tunes that speak Jev's request format, and where the field reports disagree with the benchmarks
• Cloudflare Clef: Jev-Compatible Decision Models, Benchmarked and Priced - the first platform player to ship a Jev-compatible family, with vision input, a 64k window and an RL fine-tuning service
• GPT-5.5 vs GLM-5.2: the Hallucination Benchmark - why hallucination rates are the same question with different instrumentation
• GPT-6 Astra Release Guide - the other end of the price range, and when a frontier model is worth it
• GPT-6 Sol vs Claude Opus 5.5 vs Grok 4.7: The September 2026 Price War - the string-model price tier Jev's per-token price is measured against
• Magnitude: A Self-Tuning Inference Engine Bids to Be Your Agent's Local Backend - the local serving layer where open Jev-style replicas run