What Changed in the Latest JEV Release

Jev launched on September 15, 2026, and in the weeks since, TypeSafe AI has shipped a string of gateway integrations, SDK updates, and framework hooks that quietly rewrote what developers can actually do with the model. Access opened up through third-party gateways alongside TypeSafe's own console, and the tooling around Jev grew faster than the model itself changed.

Jev and how it differs from generative models

TypeSafe AI came out of stealth on September 15, 2026, with a $40 million seed round led by DCVC. The company was founded by Diogo Almeida, Erik Gafni, and Sasha Sheng, and its pitch runs against the grain of the last three years of AI product design: instead of another model that writes prose you then have to parse back into structure, Jev skips the middle step.

TypeSafe calls it a System One model. State goes in, a typed answer comes out. There's no JSON to parse, no schema coercion bolted on after the fact by the calling code, no generated text sitting between the question and the answer your program actually needs. The design rests on three primitives that cover the whole space of what a typed decision looks like: Choice, which picks one option out of up to 255; Score, which places something on an ordered scale from 2 to 10 levels; and Noul, a yes-or-no probability expressed as a number between 0 and 1.

Jev handles multiple questions in one request. Every question gets evaluated in parallel against the same state, so stacking on more questions barely moves the latency needle and avoids the context-rot that occurs when a long-context LLM has to hold a growing pile of instructions in its head at once.

The single model version behind all the changes: jev-1.13.0

Every change since launch, every gateway listing, every SDK update, traces back to one model version: jev-1.13.0. No point release has shipped since September 15. This means the entire wave of integration activity covered here happened around a fixed model, not in response to a new one.

Two aliases point at it. jev-latest currently resolves to jev-1.13.0, and jev-preview points at the exact same weights. TypeSafe's own documentation says no preview build exists right now, which makes jev-preview a placeholder rather than an early look at anything new. There's no changelog page on typesafe.ai, and no general-availability announcement has gone out.

The published specs carry a wrinkle that matters if you're deciding between the direct API and a gateway. Rate limits are 250,000 tokens and 200 requests. Context length is documented as 64,000 tokens in one place, but the Primitives page and the gateway listings both cite 32,000 tokens instead. That's not a rounding difference; it's roughly double, and anyone planning around large state payloads should check which number applies to the route they're actually using before they build around it.

SDK changes: what the Python and JavaScript packages shipped

The real SDK news is on the Python side. typesafe-sdk moved to version 0.7.0, and it carries a breaking change: serialization switched from msgspec to Pydantic. Anything in an existing codebase that leaned on msgspec's specific serialization behavior needs to be revisited before the upgrade goes in.

Beyond that swap, 0.7.0 added a response_model argument on system_one, fixed serialization bugs affecting str subclasses, and widened the type annotations SDK inputs accept to include abstract types like Mapping and Sequence rather than forcing exact dict or list types. Error handling also received attention in this release. The package requires Python 3.10 or newer.

The JavaScript and TypeScript SDK, @typesafe-ai/sdk, has not moved. It is still 0.6.0 from launch day, which puts JavaScript developers a full release behind their Python counterparts in terms of feature parity. Both SDKs were available at or around the public launch on September 15.

Separately, and this is an integration rather than a new SDK, Vercel's AI SDK 7 picked up an experimental evaluate API starting at version 7.0.105. It exposes Choice, Score, and Boolean directly, with the model called as typesafe-ai/jev. It's a meaningfully different way to reach Jev than either official package, and it's the on-ramp for the gateway story below.

The four gateway integrations that opened access before the waitlist did

Access to Jev didn't wait for TypeSafe's own console to open up. Four separate gateways picked up the model within about a week of each other, and each one comes with its own constraints to know before committing a workload to it.

Vercel's AI Gateway added Jev on September 16, one day after launch, and made it free to use until September 25. The model ID is typesafe-ai/jev, called through experimental_evaluate from AI SDK 7.0.105 or later. Evaluation only works through the AI SDK itself, not through the Gateway's OpenAI-compatible, Anthropic-compatible, or Cohere-compatible endpoints. That rules out a Go service, a Rails app, or anything else that talks to Jev through an OpenAI-shaped client pointed at a base URL. There's also no TypeSafe console and no per-key usage page reachable through this route, so anyone running meaningful volume needs to track request counts on their own. TypeSafe's own workflow benchmarks claim Jev runs many times faster and many times cheaper than LLMs, though that figure comes from TypeSafe's evaluations, not an outside party.

Netlify's AI Gateway followed on September 17 with the lowest-friction path of the four: install @typesafe-ai/sdk, call it from a Netlify Function, and there's nothing else to configure. No API keys, no provider setup, no base URL to wire in. Credentials get handled by the gateway automatically, and usage bills against Netlify credits rather than a separate invoice. The SDK defaults to the jev-latest alias, currently jev-1.13.0, and requires Node.js 20 or newer. State and questions together share a budget of roughly 32,000 tokens, which works out to something like 150,000 characters of English text.

OpenRouter listed Jev without a waitlist under three model IDs: typesafe/jev-1.13, typesafe/jev-1.13-20260917, and typesafe/jev-latest. Pricing matches TypeSafe's direct rate of $0.042. The context window shown here is 32,000 tokens, again the smaller of the two figures floating around, so large-state workloads need to check that ceiling before moving over. There's an odd gap too: Jev doesn't appear in OpenRouter's public model list API, so any app that builds its model picker by enumerating that endpoint simply won't surface it as an option.

Cloudflare's AI Gateway carries a catalogue entry for typesafe/jev as well, listed under Cloudflare AI Gateway specifically, not Workers AI. That distinction matters because Workers AI, Cloudflare's separate inference product, does not carry Jev.

Framework integrations and community SDKs that extended the language surface

TypeSafe's own SDK coverage stops at Python and JavaScript, but the surrounding ecosystem didn't wait around for official ports. Community SDKs now cover Ruby, Rust, Elixir, Java, Go, Swift, Scala, Kotlin, and PHP, among others. Community SDK coverage has expanded to include JVM-based languages alongside others.

On the framework side, integrations now exist in source for LangChain, Pydantic AI, LiteLLM, Composio, Effect, BAML, Ax, and TanStack AI. Availability and release maturity vary a lot across that list, so checking the actual repository before depending on any one of them is worth the five minutes.

A handful stand out as confirmed and functional. Ax is listed among the framework integrations with a TypeSafe client. BAML added Jev support, though it's not part of BAML's stable release line yet, and BAML itself went through real churn in this window: a September 20 release removed the Collector API as a breaking change and restructured versioning so that legacy releases now get labeled BAML v0. Composio built a TypeSafe provider that integrates Jev's typed decisions into its tool-selection workflow. Effect's integration package maps Effect's own typed operations onto Jev's primitives.

On the agent and MCP side, Jevbridge acts as an adapter exposing Jev's typed decisions to LLMs that need a typed-decision layer without generating their own. A separate project, echohello-dev/jev-mcp, released version v2026.09.23 on September 23, the most recent MCP-related release across all these sources. TypeSafe also ships a drop-in agent skill for coding agents, which exists specifically to stop agents from generating a chat-completions-shaped call when what the task actually needs is a properly typed Jev request.

What independent benchmarks found about accuracy, calibration, and latency

The most important thing the ASSAY-001 calibration benchmark found is that Jev's confidence scores aren't reliably trustworthy across the board, they're trustworthy sometimes. On CLINC150, Jev came out calibrated, with an ECE of 0.0204, meaning its stated probabilities lined up with real-world outcome rates. On Banking77, the same model was not calibrated, with an ECE of 0.0936 and a systematic lean toward overconfidence. What held up across both datasets, all 8,576 responses, was the typed-output guarantee itself: zero type errors. The structure never broke, even when the confidence numbers inside that structure did. Don't assume a Jev probability is trustworthy on your domain until you've checked it against labeled examples from that same domain.

On the accuracy side, Jev scored 92.40% on Banking77 classification, against 93.66% reported by the original Banking77 paper for a fine-tuned BERT classifier, a gap of 1.26 percentage points. The run cost about $0.44 in API usage and took six minutes. Since Banking77 is a public dataset, there's a contamination question: TypeSafe's training-data FAQ states "We make all the data ourselves," which is a claim about how their training data gets produced, not a dataset-by-dataset audit ruling out overlap with Banking77 specifically.

A head-to-head run on OpenRouter across all 3,080 Banking77 test utterances puts the tradeoff in sharper relief. Jev 1.13 scored 81.0% accuracy at a 175ms median latency and roughly $0.11 per thousand calls. Claude Opus 5 scored 84.4% at 2,266ms median and roughly $2.42 per thousand. Jev loses on accuracy here, by a real margin, but wins on speed and cost by an order of magnitude each. That's the actual tradeoff, not a marketing one, and it's the one to weigh against whatever a given application actually needs.

A separate zero-shot comparison against frontier LLMs, run independently under ickma2311/jev-baselines-eval, found Jev beating gpt-5.4-nano on CLINC150 by 7.5 percentage points, while losing to frontier GPT-5.6 Terra on the same dataset by 4.5 percentage points. The latency numbers from that same evaluation are the ones worth reading carefully against TypeSafe's own gateway-side claims. Median call duration ran roughly half as long for Jev than for a nano LLM configuration on identical items (0.42 seconds versus 0.92 seconds), nowhere near the 40x to 200x gap suggested by TypeSafe's own comparisons. The difference reflects the specific client-and-service setups tested, and it's tied to those particular providers, that location, and that load.