Jev changelog

Model releases, pricing changes, SDK updates, and access changes, newest first. Every entry links to its source. Also available as an RSS feed.

Oct 10, 2026
An enterprise page with SOC 2, zero data retention and higher limits on request
typesafe.ai/enterprise is new, along with a contact page. It is a sales page, but it states several data-handling terms for the first time in one place:
- SOC 2 Type II. The report is available on request through a Trust Center.
- Zero data retention is “available for enterprise customers”, set up per account.
- No training on your data. “We don’t use your prompts or other inputs to train or fine-tune models”, and the FAQ extends that to outputs.
- Higher rate limits on request, above the published 100K tokens and 40 requests per second.
The FAQ also lists the questions buyers ask: where data is processed, whether Jev can run in your own VPC or on-premises, whether TypeSafe will sign a BAA. Their answers are not in the page’s text as served, so we cannot report them yet.

The page repeats headline figures from the Jack & Jill case study and a classification benchmark. As with all first-party figures, we link to them rather than repeat them.
Source →
Oct 10, 2026
TypeSafe raises an $870M Series A at a $7.5B valuation
TypeSafe announced its Series A, titled “TypeSafe A raises Series AI”: $870 million at a $7.5 billion valuation, led by Andreessen Horowitz with Sequoia Capital, existing investor DCVC, and angel investors. Martin Casado joins the board.

The post is short and says what the money is for:
- Developers: “even more machine-native models”, meaning more System One models beyond Jev, and “everything else to be the best infrastructure for building smart software”.
- Businesses: “all the enterprise features you’ve been asking us for”. The new enterprise page went up the same day.
- Recruiting: “We are a real company and we’re here to stay.”
One claim does not agree with itself. The post says “a third of the Fortune 500” use Jev, and the enterprise page published the same day says 25%. Neither gives a source.

For anyone building on Jev, the funding mostly answers whether the API will be around next year, which is a fair thing to wonder about a model that launched on 15 September. The promise of more models is the part to watch. Every community project that hard-codes jev-latest will meet a second model family sooner or later.
Source →
Oct 9, 2026
OpenRouter now lists Jev with a 64K context
OpenRouter changed the context length it lists for typesafe/jev-1.13 and ~typesafe/jev-latest from 32,000 to 64,000 tokens, with up to 57,600 completion tokens. Prices did not change: $0.042 per million input tokens, output free.

That closes the gap we noted when Jev arrived on OpenRouter. TypeSafe documents 64K per request for its own API, but with a second limit: 32K for the state plus the longest single question. OpenRouter’s listing shows only the first number. So a request that fits in 64K can still break TypeSafe’s limit if the state and the longest question together pass 32K. Pack questions with that in mind.

Source →
Oct 8, 2026
TypeSafe publishes a customer case study, from Jack & Jill
The TypeSafe blog published a case study: Jack & Jill, an AI-agent talent marketplace, replaced Gemini 3.1 Flash Lite with Jev for the first-pass candidate scoring step in its matching pipeline, then used Jev in other parts of the product. The post reports cost, speed and quality figures for the switch. As with every first-party figure, we link to them rather than repeat them here.

What is worth knowing is how the comparison was run. Both models scored the same candidates for 150 live roles. Each role’s set included every past “winner”, a candidate a hiring manager later asked to meet, plus a weighted sample of the rest. The test then counted how many winners each model kept on the shortlist. The post reports a confidence interval for the quality difference and says the difference was not statistically significant. It also separates the savings at current volume from a projection that assumes growth.

That is the template for evaluating Jev on your own work: an offline test on your real cases, a metric tied to an outcome you already record, and an honest reading of whether the difference is noise. It is also one customer’s pipeline, measured by the vendor. Treat it as a description of a method, not a forecast for yours.

Source →
Oct 6, 2026
The files the cookbooks read are now public
typesafe-ai/typesafe-public-examples is a new repository in the official organisation, MIT-licensed, described as “content used as part of documentation, demos, and cookbooks”. Its one substantive commit adds a cookbooks/ folder with the input files for ten recipes: the function-calling cookbook’s spec.json, trader.py and dispatch.py, the 182-skill Hermes roster for skill suggestion, RFC 7519 for citation checking, the filings and SIC codes for classification, and the corpora for RAG passages, entity alignment, guardrails, question tuning, autoformat and semantic find.

This closes a real gap. Several cookbooks read their inputs from disk — the function-calling page says two modules “sit beside this file” and that the spec “lives in spec.json” — but of the four pages we checked, only semantic find said where to get its input, so the others could not be run as printed. Now it can, by fetching the folder for the recipe you want.

Two caveats as of today. The cookbook pages do not link to the repository yet, so you have to know it exists. And it holds inputs only: the json_cache.json files that some pages say let you reproduce their numbers without an API key are not in it.

Source →
Oct 3, 2026
TypeSafe publishes how confidence is calculated, including Score's
The confidence page gained a section called How confidence is calculated, with an exact formula for each answer type:
- Noul: no confidence is returned. The page suggests |2p − 1| if you want one on the same scale as Choice.
- Choice: (p_max − 1/n) / (1 − 1/n) — how far the selected option sits above an even split, from 0 to 1.
- Score: max(0, 1 − Σ p_i·|i − m| / MAD_unif), where m is the most likely level and MAD_unif is the mean absolute distance from the middle under an even spread. Probability one level away costs less than probability at the far end.
The Score formula is the new information. Until now it was undocumented, and tools that report Score confidence had to say so — System One Connector’s tool description still reads “TypeSafe publishes no formula for score”. The Choice formula matches the one that project had already written down, (N·p_top − 1)/(N − 1); the two are the same expression rearranged.

We recomputed every worked example on the page and they hold: (0, 0.5, 0.5) gives Score confidence 0.25 and (0.5, 0, 0.5) gives 0, where Choice’s formula would give both 0.25; (0.6, 0.3, 0.1) and (0.6, 0.2, 0.2) both give Choice confidence 0.4.

One gap: the page does not say which level is m when two levels tie for most likely, and it can change the answer. With four levels at (0.4, 0.4, 0, 0.2), taking m = 0 gives 0 and taking m = 1 gives 0.2. The page’s own examples happen to be symmetric, so they do not show it.

The same edit removed a passage on asking a question and its negation as two Nouls, which said P(noul) and 1 − P(not noul) “may not be directly comparable”. That was the effect we measured on jevos last week, where a negated question returned a near-constant value. The page now leaves it unsaid. The section also says the formulas are “one reasonable way to summarize a distribution, not the only one”, and recommends trying top probability and top-to-second ratio alongside them — which is the advice worth taking.
Source →
Sep 30, 2026
Jev's rate limits are cut to 100K tokens/s, and the request limit moves to per-second
The model page changed one table row for jev-1.13.0:

before after

tokens 250,000 per second 100,000 per second

requests 1,200 per minute 40 per second

Two different directions. The token allowance is 60% lower. The request allowance, read as a rate, is twice what it was — 1,200 a minute is 20 a second — but it is now enforced per second, so the burst that a per-minute budget allowed is gone. A fan-out that sent 600 requests in ten seconds was inside the old limit and is outside the new one.

Nothing else moved: the price is still $42 per Btok of input with output free, the context budget is still 64k per request and 32k for state plus the longest question, and the prose about 429 Too Many Requests and retry-after is unchanged apart from “per minute” becoming “per second”.

If you run anything from the directory, this is worth a grep. Several tools carry the old numbers as constants rather than reading them from a response header — a client-side budget built for 250,000 tokens a second will now push through the limit and rely on retries to sort it out, and one built for 1,200 a minute will throttle itself to half the rate it is allowed. We have told jevgrep, whose budget is exactly the old pair.

The docs still say limits are adjusting during early access, which is the part to design for: read retry-after, do not hardcode the pair.

Source →
Sep 30, 2026
TypeSafe publishes the code behind evals.typesafe.ai
typesafe-ai/WorkflowEvals is a new public repository in the official organisation: the workflow code behind evals.typesafe.ai.

Worth noting for one reason. Until now, every eval harness in this directory has been somebody’s own: JevBench, Jevals, Typed Evals, and the per-project suites we run. Each one had to decide for itself what a fair comparison looks like — which is why the methodology sections of the better ones are longer than their code.

An official reference for how the vendor measures its own model gives those projects something to agree or disagree with. We will read it against what the community harnesses do and write that up separately rather than guess at it here.

Source →
Sep 26, 2026
Python SDK 0.7.2 adds HTTP/2, and the base-URL rule gets a spec
typesafe-sdk 0.7.2 is on PyPI with one new thing: an http2 extra, pulling httpx2[http2], and a documented way to use it.
```
client = TypeSafeClient(http_client=httpx2.Client(http2=True))
client = AsyncTypeSafeClient(http_client=httpx2.AsyncClient(http2=True))
```
The docs give the reason plainly — many concurrent requests multiplexed over one connection — which matters more here than for a generative API. The patterns TypeSafe itself documents are fan-out shaped: a question per candidate in a re-ranker, a question per passage in a RAG filter, a question per row. Those are exactly the workloads where connection setup stops being a rounding error.

The same rewrite of the usage page is the part worth reading twice if you run anything from this directory. Pointing the official SDK at another server was already possible through base_url or TYPESAFE_BASE_URL; the page now states the condition: “This requires the alternative API to follow the TypeSafe OpenAPI spec”, and links one — api.typesafe.ai/openapi.json, OpenAPI 3.1.0, two paths, /v1/systemone and /v1/models.

That turns a convention into a contract. A dozen projects we have reviewed serve that shape from their own weights, and until now “Jev-compatible” meant whatever each author inferred from the quickstart. There is now a document to check an implementation against, and the two endpoints in it are the two that matter.

The gateway sections were reorganised into tabs at the same time, with the OpenRouter and Vercel AI Gateway routes each given their own heading rather than sharing one paragraph.
Source →
Sep 25, 2026
Jev Router on OpenRouter picks the model and the effort for each request
OpenRouter lists typesafe/jev-router, “TypeSafe: Jev Router”, created on 25 September. We missed it at the time: our watcher only read OpenRouter’s decision models, and this is a text model. It now reads both lists.

It is a router, not a decision endpoint. You call it through Chat Completions, Responses or Messages like any model. Jev reads the conversation and judges what the task needs, how hard it is and whether a stronger model would help. A routing policy then picks a model and a reasoning effort, and that model writes the answer. The response’s model field names the model that served it, and X-OpenRouter-Metadata: enabled returns the candidates, their estimated costs and the reason for the choice.

An optional jev-router plugin takes a cost_tier of low, medium or high, plus models and excluded_models lists. The guide is precise about the edges:
- An include list that matches nothing is ignored, and the whole pool is used.
- An exclusion is never ignored. If it empties the pool, the request fails with 404 rather than reaching an excluded model.
- The lists can lower the capability the router aims for, and can remove the “expert advisor” it pairs with the hardest requests. The metadata says when either happened.
- A cost tier is “a routing preference, not a fixed model, guaranteed score, or per-request price cap”.
It has no price of its own: each request is billed at the price of the model that served it. It is available only in OpenRouter’s global data region and in workspaces that allow it.

This is TypeSafe applying Jev to model routing, the job that a good share of community projects were already doing. Those projects now have a first-party comparison.
Source →
Sep 23, 2026
The Acceptable Use Policy is published, and the agreement binds to it
The pointer that came and went last week is back, and this time the page behind it exists. typesafe.ai/legal/acceptable-use-policy is live, dated 23 September, and the Master Customer Agreement gained a clause to match: the list of things a customer will not do now includes (l) access or use the Services in a manner that violates TypeSafe’s Acceptable Use Policy, with the old catch-all pushed down to (m). The MCA’s effective date moved from 19 to 23 September, and both legal pages and the site footer now link the AUP.

The policy itself is four short sections: illegal and deceptive activity, child safety, “no disruptions”, and a line making you responsible for anyone you encourage. Most of it is the standard list. Four clauses are worth reading if you build on Jev rather than just call it:
- 1.4 — no misleading others about whether content, “including Output”, was generated by AI. That is a labelling obligation on the answers your app shows, not only on text a model wrote.
- 3.2 — no accessing the Services through unauthorised means, “e.g., scraping or crawling”.
- 3.4 — no overriding or circumventing safety filters or access controls, and no “intentionally driv[ing] TypeSafe’s AI model to act in a manner that contravenes TypeSafe’s policies”.
- 3.7 — no probing, scanning, penetrating or testing the vulnerability of TypeSafe’s system or network. The MCA already said this; now it is in a document that can be revised on its own, and the AUP says plainly that TypeSafe may revise it by posting a new version.
Enforcement is spelled out too: TypeSafe may monitor compliance, suspend access, and report suspected illegal activity to law enforcement along with information about the violation.

For anyone writing guardrail or evaluation tooling, 3.4 and 3.7 are the ones to read twice, and the distinction they turn on is whose system is under test. Probing your own application — feeding it hostile input, watching what it does with a hostile answer, checking that a gate fails closed — is testing your code. Aiming the same harness at the hosted service to see what the model can be made to do is the thing these clauses name. Every project in this directory that ships a red-team or injection suite is in the first category today; the line is worth knowing before someone writes a suite in the second.

Nothing here restricts publishing measurements. The no-benchmarks clause removed on 19 September has not returned, and the AUP does not mention benchmarks, performance claims or public statements at all.
Source →
Sep 23, 2026
The cookbooks get an index page, sorted by technique and level
docs.typesafe.ai/cookbooks is a new page: the seventeen existing cookbooks, grouped into Self-consistency, Batching, How-to, Extraction and Classification, each row labelled Beginner, Intermediate or Advanced. No new recipe was added — this is navigation for what was previously only reachable from the sidebar and llms.txt.

It also states its prerequisites up front: the section assumes you have read the primitives and the confidence page first.

The grouping is a useful map of what TypeSafe thinks Jev is for, and it lines up with what we keep finding in this directory — the recipes are all “decide one small thing, in code, with a probability attached”, never “write the answer”. Several of the table rows quote the cookbooks’ own headline figures; as always we link to them rather than repeat them here.

Source →
Sep 23, 2026
Cookbook installs come from public PyPI, no private index
Every cookbook’s setup line changed. What used to be
```
pip install ipython "typesafe-sdk>=0.5.7" cooksafe --extra-index-url https://pypi.typesafe.ai/
```
is now
```
pip install ipython 'cooksafe>=0.2.0,<0.3.0'
```
across all seventeen pages. cooksafe, the shared helper package the cookbooks import, was published to public PyPI as 0.2.0 on 2026-09-22, and it declares typesafe-sdk>=0.7.0,<0.8.0 itself, so neither the private index nor a hand-written SDK pin is needed any more.

We checked it rather than take the line for it: in a clean python:3.12-slim container with no extra index configured, that command installs cooksafe 0.2.0 and typesafe-sdk 0.7.1, and the package exposes JsonCache, cache, deeplinks and make_playground_link — the response cache and the playground links the notebooks use.

Two things worth knowing if you have an old copy of a cookbook. https://pypi.typesafe.ai/cooksafe/ is still up but stale: it lists 0.1.0, 0.1.1 and 0.1.2 and no 0.2.0, so the old command now resolves the newer package from PyPI regardless of the extra index. And the SDK range matters — 0.7.0 was the Pydantic switch, which is also why the re-ranking cookbook’s code dropped msgspec.json.encode(...) for model_dump_json(exclude_none=True) in the same pass.

The practical gain is that a cookbook now installs in an environment that only reaches PyPI, which covers most locked-down CI and any mirror-only setup.
Source →
Sep 22, 2026
A docs page explaining that Jev is not your coding agent's model
A new page, “Jev with coding agents”, exists to answer a question TypeSafe evidently gets a lot:

If you found TypeSafe while looking for a model to plug into your coding agent, start here. Jev is not a drop-in…

It says plainly that Jev does not generate text, write code, or hold a conversation, that it returns a choice with per-option probabilities, a score on a rubric you define, or a noul between 0 and 1 — and that coding agents need an LLM which streams text, calls tools and edits files. The page then offers a table mapping what you were probably trying to do onto what you actually want.

Worth noting because the confusion it addresses is visible across this directory. The projects that work are the ones that give Jev the small judgment calls between steps and leave the writing to a generative model; the ones that struggle are the ones that expected a replacement. Our roundup of the tools we would use is organised around roughly that split.

Source →
Sep 22, 2026
The agreement drops its pointer to an unpublished use policy
When the Master Customer Agreement dropped its no-benchmarks clause on 2026-09-19, the revision added a new restriction pointing at an Acceptable Use Policy at typesafe.ai/legal/aup — a page that was not published at the time.

It still is not: typesafe.ai/legal/aup returns 404 today. In the 2026-09-22 revision the pointer is gone. Section 2.3’s list of licence restrictions no longer mentions an Acceptable Use Policy at all, and the phrase does not appear anywhere in the agreement. The wording around it was consolidated in the same edit, with the separate clause about using the Services or Output in a violating manner folded into the item before it.

We checked the rest of the section for the thing that matters to this site: there is still no restriction on publishing measurements of the Services. The only clause mentioning public statements is 16.4 Publicity, which covers announcing a business relationship and using the other party’s name or logo, not benchmarks.

The website terms changed the same day. Both pages also swapped their navigation from “API console / Talk to sales” back to “Sign in / Contact sales”, which is cosmetic.

Source →
Sep 22, 2026
Python SDK 0.7.1 validates the key early and documents a base URL
typesafe-sdk 0.7.1 landed on PyPI. One bug fix: the API key is validated early and excluded from logged exceptions. The client reference now states the rule — leading and trailing whitespace is stripped, and empty keys, internal whitespace, control characters and non-ASCII characters are rejected — and the error raised on a bad key changed from “the API key is missing or the timeout is invalid” to “missing or invalid”.

The same release documents something that was previously only discoverable by reading the SDK: base_url on the client, or the TYPESAFE_BASE_URL environment variable. The usage page now has worked examples for pointing the official SDK at OpenRouter (https://openrouter.ai/api with model ~typesafe/jev-latest) and at Vercel’s AI Gateway (https://ai-gateway.vercel.sh/typesafe with model typesafe-ai/jev).

That is worth knowing beyond gateways. A documented base URL is what lets you drive a tool built on the official SDK against a server of your own — which is how any of these projects can be exercised without an account, and how we test most of them. Tools that hardcode the endpoint instead have to be patched; see what each tool sends, and where.

The async and sync client pages were also retitled to “Asynchronous client” and “Synchronous client”.

Source →
Sep 20, 2026
Questions accept structured instructions and criteria
instructions and criteria are no longer strings only: both now accept an object or an array. The documented pattern is to put the question in one field and the data it refers to in others, then name those fields in backticks — the same way a question already points at a nested state value.
```
"instructions": {
  "potential_duplicate": {
    "name": "John Smith",
    "location": "Oakland, California",
    "last_employer": "Google"
  },
  "question": "Is the resume for the same person as `potential_duplicate`?"
}
```
The API reference now types Noul’s criteria.true and criteria.false as string | object | array, Choice’s rubric map as map<string, string | object | array | null>, and Score’s levels as array<string | object | array>.

The guidance changed with it. The advice used to be a flat “use objects or arrays with named fields instead of flattening everything into a dense prose string”. It now says a string is all you need for a short, unambiguous question, and names three cases where structure earns its place: the question needs context or examples, part of it comes from your code (put the database value in its own field rather than splicing it into a template), or several questions in one request share similar instructions and need to be told apart.

Also newly stated in the API reference rather than only on the Choice page: a maximum of 255 options per Choice.
Source →
Sep 19, 2026
TypeSafe drops the no-benchmarks clause from its agreement
The Master Customer Agreement was updated on 2026-09-19. The restriction that previously barred customers from publishing “benchmarks or performance information about the Services” — item (f) of section 2.3 — is no longer in the list. The restrictions now run from selling the service standalone through to violating the law, with a new item pointing at an Acceptable Use Policy at typesafe.ai/legal/aup, which was not yet published at the time of writing.

Other changes in the same revision: an arbitration notice with a class-action waiver; acceptance now binds you personally unless you act for an entity; the data section gains perpetual rights to process customer data for telemetry, fraud and abuse monitoring, and legal compliance, while other processing is limited to the term; and the Data Processing Agreement moved to typesafe.ai/data-processing. The promise not to train on customer data without consent is unchanged.

The website terms were updated the same day, and contain no equivalent benchmark restriction. They did lose one thing worth noting: the licence restrictions used to include “use the Site to develop new products and services without TypeSafe’s express written permission”, and that item is no longer in the list. The restriction on scraping the Site with robots, spiders and crawlers remains. Most of the rest of the revision is punctuation.

Source →
Sep 18, 2026
Jev 1.13 is now on OpenRouter
OpenRouter now lists Jev 1.13 (typesafe/jev-1.13), plus a Jev Latest alias that always points at the newest version. Pricing matches TypeSafe’s direct API: $0.042 per million input tokens, with free output. OpenRouter lists a 32K context window, smaller than the 64K TypeSafe documents for its own API.

Source →
Sep 18, 2026
Python SDK 0.7.0 switches to Pydantic
Breaking change: the SDK now uses Pydantic instead of msgspec for serialization. system_one() gains a response_model argument that parses answers into your own Pydantic model. Also fixes str subclasses being serialized as lists of characters.

Source →
Sep 17, 2026
TypeSafe documents Jev 1.13's known weak spots
A new docs page lists nine failure modes of jev-1.13, including literal reading of instructions, arithmetic and counting, date comparison, multi-hop indirection, large distracting state, adversarial content, and text generation, with a recommended workaround for each.

Source →
Sep 16, 2026
Jev is available on Vercel AI Gateway
Jev can be called through Vercel AI Gateway as typesafe-ai/jev, using AI SDK 7’s experimental evaluate API (import { experimental_evaluate as evaluate } from 'ai'). Gateway calls carry your existing gateway key, appear in its logs and budgets, and expose Jev’s confidence at result.providerMetadata.typesafe.confidence. Zero Data Retention and No Training are available as provider options on this route. Vercel later reported that Jev was the fastest-adopted model in the gateway’s history.

Source →
Sep 15, 2026
TypeSafe launches Jev, the first System One model
TypeSafe AI announced Jev, a model that returns typed decisions (Choice, Score, and Noul) with calibrated probabilities instead of generated text. Access opened through an early-access waitlist. Pricing is $0.042 per million input tokens, and output tokens are free.

Source →
Sep 15, 2026
JavaScript SDK 0.6.0
Breaking change: Score criteria are now passed as an ordered array instead of an object keyed by integers. Install with npm install @typesafe-ai/sdk.

Source →
Sep 15, 2026
TypeSafe AI emerges from stealth with a $40M seed round
The round was led by DCVC. TypeSafe was founded in 2024 by Diogo Almeida (formerly of OpenAI), Erik Gafni, and Sasha Sheng, and is based in San Francisco.

Source →

	before	after
tokens	250,000 per second	100,000 per second
requests	1,200 per minute	40 per second

Get Jev updates by email

New Jev releases, pricing changes, and the best new projects, once a week. No spam; unsubscribe anytime.