Skip to content
MrJev

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.

  1. Shopping cart cookbook: a loop of Choice questions builds an order

    A new Shopping cart cookbook turns a one-sentence cafe order, “a large oat milk latte and a blueberry muffin”, into a structured cart. A Choice question returns one option, so the cart is built in two stages. First a loop asks which remaining menu item the order mentions, removes each pick from the next request’s options, and stops when Jev chooses the nothing_else sentinel, which every request includes because a Choice question must pick something. Then one request per found item asks a Choice question for each of its known fields, such as size and milk, and code assembles the answers.

    It runs on a four-item menu and one hard-coded order, pinned to jev-1.14.0, with the shared cooksafe helpers. Its json_cache.json lives in typesafe-public-examples, so the published run can be replayed without a key.

    On 1 November the cookbooks stopped passing their pinned model when they build their “Open in the TypeSafe playground” links. The other docs changes over the two days were wording and layout.

    Source →

  2. Three image cookbooks, and the cookbooks link their files

    The cookbooks index has a new “Image processing” group with three recipes, all built on Box questions and pinned to jev-1.14.0:

    • Reading a scanned vaccination record finds each vaccine’s row with a Noul and a Box, and reads each dose’s year with a Choice that can answer “unreadable”. Code then checks the doses against the trip in a text-only request.
    • OCR confidence and bounding boxes checks what an OCR extractor read from invoice photos. Jev boxes each value, scores it on the page and again on a zoomed crop, and low scores go to review.
    • Feeder-cam visit log asks five questions per frame of bird-feeder footage, one a Box around the bird, and turns the answers into a visit log per species in plain code.

    All three still need the TypeSafe-Danger-Zone-Images: true header, and the pages call images and Box experimental.

    The older cookbooks changed too. Instead of saying their json_cache.json “ships with the cookbook”, they now link the matching folder in typesafe-public-examples, and documents that came from personal gists now load from there. That closes the gap we noted on 6 October. The function-calling cookbook now also says its prices are simulated from a fixed seed, not market data.

    The Box page dropped its section on checking a box with one Noul per edge. Padding the box and asking again on a larger crop are still there.

    Source →

  3. Higher limits and ZDR now go through support forms

    The docs no longer send you to sales@typesafe.ai. To ask for higher rate limits, the Models page now links a rate limit increase request form. For zero data retention on enterprise accounts, the legal page links the general support request form. Neither offer changed. The enterprise page still describes both terms.

    The same day, the docs settled on their words: a “request” is what you send, “call” replaces “query”, and “Choice” and “Score” now read “Choice question” and “Score question”. Nothing about the API changed.

    Source →

  4. Intelliprompter cookbook: ticking off talking points as you speak

    A new Intelliprompter cookbook checks a presenter’s notes against what they have said so far. The live demo transcribes the microphone with ElevenLabs. About every half second, if the transcript has changed, it sends the whole transcript to Jev with one Score question per point not yet covered: “How completely has the speaker covered this criterion?” Each question has five levels, from not mentioned to fully covered. Code ticks a point off once its score passes the demo’s own threshold, and a ticked point is never unticked. The page says the threshold is the app’s choice, not a TypeSafe default.

    The cookbook skips the audio and feeds six hard-coded transcript chunks, pinned to jev-1.13.0. Its json_cache.json is the file that appeared in typesafe-public-examples on 11 October, two weeks before this page did, so the results can be replayed without a key.

    The same day, the API reference added a 400 response for “application validation failures”. Its detail is a string or an object, and long text in it may be shortened and end with “…”. The validation error fields of a 422 now say the same.

    Source →

  5. jev-latest now points to Jev 1.14

    The jev-latest alias moved from jev-1.13.0 to jev-1.14.0, ten days after 1.14 shipped as jev-preview. The models page changed on 24 October. jev-latest is the default in both official SDKs, so code that doesn’t name a model is now answered by 1.14. Price and context limits are unchanged.

    jev-preview points to the same model for now: “There is no preview build available right now.” jev-1.13.0 is still served, and TypeSafe has promised 60 days’ notice before it is deprecated. If you tuned confidence thresholds on 1.13, pin jev-1.13.0 until you have re-checked them on 1.14. The model field in each response names the version that answered.

    The Box page no longer tells you to send jev-preview or jev-1.14.0, and its example now uses jev-latest. Box still needs the TypeSafe-Danger-Zone-Images header.

    Source →

  6. Noul thresholds: start at 0.7 and 0.3

    The Noul page now gives a starting point: “0.7 for yes and 0.3 for no”. Often you only act on a yes, and “0.7 is the only threshold you need”. Answers between 0.3 and 0.7 “can go to a person rather than either code path”. The page also warns against “fitting thresholds closely to a handful of test cases”. It dropped the old advice to “use 0.5 when yes and no are equally easy to act on”, and its example constants changed from 0.8 and 0.2 to 0.7 and 0.3. The confidence page and How to build with System One repeat the same starting point.

    These are starting values, not tuned ones. Our confidence thresholds guide shows how to set them on your own labelled data.

    Source →

  7. API reference split into three pages, now covering images and Box

    The API reference, one page until now, is split into three: System One for POST /v1/systemone, List models for GET /v1/models, and Request rules and errors for the size, encoding and compression rules and the status codes. /api now redirects to the System One page, so old links to its sections land at the top. The rules and the error codes are unchanged.

    The reference now covers what the 14 October experimental features added. It documents the TypeSafe-Danger-Zone-Images and TypeSafe-Danger-Zone-Long-Context headers, image assets, Box questions and their answers, and a multipart/form-data form of the request: the JSON as a first part named request, then each image as its own part. One detail is new. A Box answer’s confidence can be null, “when the model does not provide confidence”. Code that reads it as a number should check first.

    The Choice page also gained a tip. A none of the above option “may not work well in many use cases”. Instead, ask a Noul question in the same request that checks whether any option fits, and read the Choice answer only when the Noul says yes.

    Source →

  8. Images, Box questions and 262K context, opt-in

    Alongside Jev 1.14, TypeSafe added three features that are off by default. Each one is switched on by sending a header with the request. TypeSafe calls them “dreamer-ready”, not ready for production: the formats, answers and limits may change between releases.

    Images (TypeSafe-Danger-Zone-Images: true). An image can go anywhere text can: in the state, in a question’s instructions, or in the criteria that define options. Every question type accepts them, and they work on Jev 1.13 as well as 1.14. Each image is listed once in a top-level assets map under a reference string, and the reference is written where the image belongs. Images are sent as multipart file parts or as base64 in JSON. Formats are PNG or JPEG. Each side must be 280 to 1,568 pixels (the minimum was 256 until a docs change on 16 October). Images are billed as input tokens at the normal price, and TypeSafe has not yet said how many tokens an image costs. The API strips metadata and ignores EXIF rotation, so rotate the pixels yourself.

    Box questions find something in an image and return its four edges as fractions of the width and height, plus a confidence. They need the images header and Jev 1.14 (jev-preview or jev-1.14.0). A Box answer is always a box: there is no “not found”. The docs suggest asking a Noul in the same request to check whether the target is there at all.

    Long context (TypeSafe-Danger-Zone-Long-Context: true). Both limits rise to 262K tokens, on 1.13 and 1.14, at the same price. The docs say it is slower and less accurate than the default 64K/32K, so send the header only on requests that need it. OpenRouter now lists 262,144 tokens for both versions.

    The State page no longer says Jev accepts text only. The docs now speak of “question types” where they used to say “three”, and say that only some types return confidence.

    Source →

  9. Jev 1.14 ships as jev-preview; jev-latest to follow

    TypeSafe released Jev 1.14 (jev-1.14.0) on 14 October. It is served under the jev-preview alias for now. jev-latest still points at jev-1.13.0, and the post says it will move to 1.14 “in a week”. The announcement calls 1.14 “small, subtle improvements to everything”, with the largest gain expected in languages other than English. Price and context limits match 1.13: $0.042 per million input tokens, output free, 64K per request and 32K per question.

    If you have tuned confidence thresholds, send jev-1.13.0 rather than jev-latest before the alias moves, and switch when you have re-checked them. jev-1.13.0 “will be available for a while”. The post promises 60 days’ notice before 1.13 is deprecated, 30 days for 1.14, and a written deprecation policy before either happens. Each response’s model field names the version that answered.

    Three other changes came with the release:

    • Experimental features behind headers. Images, a new Box question type and a 262K-token context are each switched on with a TypeSafe-Danger-Zone-* header. TypeSafe says they are not ready for production. See the next entry.
    • Rate limits are no longer published. The models page used to list fixed numbers, changed on 30 September. It now says limits are set per organization and shown in the developer console.
    • An opt-in for debugging. The post says users can now opt in to letting TypeSafe use their queries to find where Jev is weak, and that it still won’t train on them. The docs don’t yet say where the setting is.

    The post also includes TypeSafe’s own chart comparing Jev with open-weight models on an internal test set, with the caveat that it is “likely biased towards our models”. We don’t republish it. OpenRouter listed typesafe/jev-1.14 the same day, and Vercel AI Gateway listed typesafe-ai/jev-1.14.0 two days later, both at the same price.

    Source →

  10. SDKs add images and compress requests by default

    Both official SDKs were released on 14 October: Python typesafe-sdk 0.7.5 and JavaScript @typesafe-ai/sdk 0.7.0. Both add image objects and Box questions for the experimental features. Python’s comes from bytes, a file path, base64 or a Pillow image with the pil extra; JavaScript’s comes from image(). Both also add ways to mention an image inside a sentence. The JavaScript release has two breaking changes: it needs Node.js 22 or newer, and it no longer exports the request payload types.

    The change that matters most for people who aren’t using images: both SDKs now compress request bodies of 1 KiB or more with zstd by default wherever the runtime has it. That means Python 3.14, or Python 3.13 and earlier with the zstd extra, and Node.js 22.15 or newer. TypeSafe’s own API accepts this. The API page now documents gzip and zstd bodies, a 32 MiB size limit (413), 415 for an unsupported encoding, and 400 for invalid UTF-8, nesting deeper than 64 levels, or NaN.

    Servers that copy Jev’s API may not accept it, and the Python changelog warns of this. We checked: on Python 3.14, SDK 0.7.5 sent a 5 KB request zstd-compressed. A plain FastAPI server rejected it with 400 There was an error parsing the body, and accepted the same request uncompressed. Requests under 1 KiB were not compressed, so a quick test can pass while real requests fail. If you point the SDK at a self-hosted alternative or a proxy, turn compression off:

    client = TypeSafeClient(base_url="http://localhost:8000", compression=False)
    const client = new TypeSafeClient({ baseURL: "http://localhost:8000", compression: false });

    Source →

  11. Cookbooks regrouped by problem, with two new recipes

    The cookbook index is now organised by the problem a recipe solves rather than by technique: LLMs and agents, classification, extraction, search and matching, and a final techniques section for self-consistency, parallel questions and autoresearch feature discovery. Each cookbook is listed once, and the page says many use techniques from other sections.

    Two recipes are new. Simple memory system wraps the Jev call in an ask_with_memory() function that takes the same arguments as the plain call. After each answer, a second request with one Noul question decides whether the ticket stated a fact about the customer worth keeping, and saved memories are added to that customer’s later states. That is two sequential requests per call. Twitch chat filter sends each chat message in its own request with three questions (what kind of message, whether it is toxic, whether it spoils the game) and leaves hiding, blurring and highlighting to plain code.

    Both pages link their json_cache.json in typesafe-public-examples, so their published numbers can be replayed without a key. When that repository first appeared it held inputs only. A commit on 11 October added four cache files: these two recipes, plus “intelliprompter” and “shopping cart”, which have no docs page yet. Older recipes such as parallel questions still mention a cache file that the repository does not hold.

    Source →

  12. 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 →

  13. 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 →

  14. 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 →

  15. 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 →

  16. 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 →

  17. 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: (pmax − 1/n) / (1 − 1/n) — how far the selected option sits above an even split, from 0 to 1.
    • Score: max(0, 1 − Σ pi·|i − m| / MADunif), where m is the most likely level and MADunif 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 →

  18. 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 →

  19. 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 →

  20. 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 →

  21. 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 →

  22. 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 →

  23. 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 →

  24. 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 →

  25. 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 →

  26. 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 →

  27. 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 →

  28. 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 →

  29. 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 →

  30. 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 →

  31. 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 →

  32. 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 →

  33. 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 →

  34. 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 →

  35. 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 →

  36. 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 →

Get Jev updates by email

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

Powered by Buttondown. See our privacy policy.