JEV Fine-Tuning API Changes Across Versions

Jev has no fine-tuning endpoint, and there never has been one. A developer who searches for a Jev fine-tuning changelog is searching for something that does not exist, because TypeSafe trains the model once and serves that same set of weights to every account. What changes, release after release, is not the model but the surfaces around it: the shape of the request you send, the alias and endpoint behavior that decides which model answers you, and the SDK code that packages all of it for Python and JavaScript developers. Understanding that boundary first is what makes the rest of Jev's version history make sense, rather than reading like a list of unrelated patch notes.

What Jev returns

Jev is a hosted decision API: you send it state, you send it typed questions, and it returns structured, probabilistic answers that your code can use without parsing a block of prose first. Developers build those questions from three primitives: Choice, which selects among a defined set of options; Score, which grades against an ordered rubric; and Boolean, which returns the estimated probability that a statement is true. Because output tokens are free and billing runs only on input, the practical cost of a Jev integration is driven by how much state and how many questions you send in, not by how much it answers back. The context window reflects that same design: a request can carry up to 64,000 tokens across the state and all its questions combined, and state plus any single question must also fit inside a smaller per-question limit, so developers fan out large judgments into many small questions. Because the shape of each answer is defined by how a developer structures the question, any change to how an answer is serialized, such as the data type behind Score.criteria, breaks every piece of downstream code that expects the old shape. That is the concrete referent for "breaking change" in everything that follows.

The model alias system and version exposure

The model itself is frozen at jev-1.13.0, but TypeSafe also exposes aliases, and those aliases are where a static model can still surprise a developer who never touched their own code. The alias jev-latest, or ~typesafe/jev-latest when called through OpenRouter, always points to whatever model is current in the Jev family. A team that calls the alias instead of the versioned ID has agreed, without realizing it, to accept a new model's behavior the moment TypeSafe ships one. jev-preview goes further still, routing to the newest release regardless of whether that release is an official one. That means even more exposure for anyone who pins it. This matters most for teams that have tuned confidence thresholds against a specific model's calibration: an alias hop can quietly invalidate those thresholds with no error, no warning, and no failed request to flag it. TypeSafe's own documentation adds a related caution, noting that rate limits for the current model can change without notice, which is one more reason to log the resolved model ID on every response rather than trust that the alias you called is the model you are still getting. The rule that follows from this is straightforward: pin jev-1.13.0, or whatever versioned ID you are actually running against, for any integration where calibrated thresholds matter, and move to a new version only on purpose, after re-validating those thresholds against held-out data.

The Python SDK changelog: where the actual breaking changes have occurred

Every breaking change in Jev's history so far has happened in the Python SDK, not in the model, and the two changes that matter most both touch how answer objects are typed and converted to and from JSON. Version 0.6.0, released September 15, 2026, changed Score.criteria from a dictionary keyed by integers into an ordered sequence, a breaking change in its own right, and the release also added abstract input types, richer error messages, validation for RetryPolicy, and pickling for exceptions and responses. Version 0.7.0, released September 18, 2026, did something with wider consequences: it migrated the SDK's serialization library from msgspec to Pydantic, while also adding a response_model argument to system_one() and fixing a bug where string subclasses were serialized as lists of characters instead of strings. Version 0.7.1, released September 21, 2026, was comparatively quiet, validating the API key earlier in the request cycle, keeping it out of logged exceptions, and adding usage examples for the AI Gateway.

The Score.criteria change in 0.6.0 is a structural change to the contract itself: any code written to iterate criteria by integer key either breaks outright or silently returns wrong results, depending on how defensively that code was written. The msgspec-to-Pydantic migration in 0.7.0 carries a wider blast radius, because the SDK's public return types became Pydantic BaseModels, and msgspec raises an error when it tries to serialize them. Any downstream layer still using msgspec to re-serialize those return values, a common pattern for MCP servers that hand answer objects back out of their tools, starts failing. That is what happened to the open-source project blakestone-x/jev-mcp, which had to add a custom encoder hook after its tools began returning server errors following the upgrade to 0.7.x. The response_model addition in the same release is additive rather than breaking, but it changes the recommended way to pull structured output out of a Jev call, so teams that skip it are working against an older pattern even though nothing in their existing code will fail.

The JavaScript SDK gap for cross-language teams

The JavaScript and TypeScript SDK, @typesafe-ai/sdk, has not moved since it reached v0.6.0, and that version is not even the one it launched with: the initial public release was v0.5.7, and no point release has shipped since 0.6.0 landed. That leaves the JS and TS SDK without the Pydantic-based return types and the response_model argument that Python developers now have in 0.7.x. Teams running both SDKs side by side, especially those sharing tooling or MCP server infrastructure across languages, need to check feature parity directly rather than assume it: a pattern that works cleanly in Python 0.7.x is not guaranteed to be portable to the JavaScript SDK at its current version. One effect of the gap cuts the other way, in that the msgspec-to-Pydantic migration risk simply doesn't exist yet for JavaScript consumers, since that SDK never moved past the serialization library it launched with. The Score.criteria shape change from 0.6.0, however, applies to both SDKs equally, because it changed the API's data contract, a change that is language-independent.

Jev Router and AI SDK 7: how versioning is now extending above the model layer

Jev Router and the evaluate API in AI SDK 7 point to a different kind of version change than anything in the SDK changelog: not a change to model weights, and not a change to how a request gets serialized, but a change to which model actually answers a given request and how Jev's primitives get exposed inside a third-party framework. Jev Router, released September 25, 2026, picks the best model and reasoning effort for each request through a single endpoint that routes across TypeSafe's model ecosystem. A developer calling the Router endpoint can be served by different underlying models over time without ever touching their own code. That's the first real sign of model-selection logic sitting above the flat jev-1.13.0 endpoint: version differentiation is starting to live at the routing layer even while the underlying model weights stay frozen and shared across every account. AI SDK 7's evaluate API, which TypeSafe documentation marks as experimental, exposes the Choice, Score, and Boolean primitives directly inside that framework, adding a third surface for version drift that has nothing to do with Jev's own release notes. Put together, teams now need to watch three separate version surfaces to track Jev accurately: the TypeSafe Python SDK, the behavior of the Router endpoint itself, and whatever third-party framework adapter, whether AI SDK or OpenRouter, sits between their code and Jev.

Jaggedness documentation as a per-version artifact

TypeSafe publishes what it calls a jaggedness page for each model version, describing how accuracy shifts as the amount of state grows, and that page belongs in any serious effort to track the API, not just the SDK changelog. The page for Jev 1.13, last reviewed on October 2, 2026, documents nine distinct failure modes, including the jaggedness effect itself along with issues like literal reading, math and numbers, date comparison, and indirection. None of that is an SDK changelog entry. It's behavioral documentation tied to a specific model version: a developer who pins jev-1.13.0 should treat the 1.13 jaggedness page as a reference baseline worth saving alongside that pin, not a one-time read. If TypeSafe ships a future model version, its jaggedness page will describe a different set of failure modes, and that shift functions as the model layer's version of an SDK breaking change, even though not a single line of a developer's code has to change.

Why fine-tuning substitutes work at the request layer

Because the model itself cannot be changed, all adaptation in Jev happens through the request or through a layer built downstream of it: writing domain rules into a question's instructions and criteria, breaking a broad judgment into several narrow questions, and combining the resulting answers in application code. TypeSafe's own documentation recommends exactly this approach, going further by pointing developers toward training a separate downstream model on Jev's output probabilities, treating adjustment of Jev itself as unnecessary. A controlled study from AnthusAI tested this directly against a labeled dataset that included a deliberately planted labeling quirk. Fitting a small decision head over Jev's probabilities and calibrating it reduced expected calibration error from 0.151 down to 0.030, a reduction of more than ten points on that metric, and distilling the resulting calibrated system into a small classifier produced a student model that actually exceeded the teacher's accuracy on the held-out test set. The honest reading of that result is that request-layer adaptation closes most of the gap that weight-level fine-tuning would close on an open model, without fully replicating what fine-tuning would do on a model actually matched to the task.

TypeSafe's response to the absence of fine-tuning is a claim about governance rather than capability: its Privacy Policy states that it will not train or fine-tune any artificial intelligence or machine learning model on a customer's prompts or other input, and TypeSafe offers zero data retention for enterprise customers. Shared, frozen weights are framed there as a genuine trade-off rather than a workaround, a guarantee that one customer's data can never leak into another customer's model behavior and a claim worth taking at face value instead of dismissing as an excuse for a missing feature. Adding a new question to a request schema is itself a version event for the application built on top of Jev, every bit as much as an SDK upgrade is, and teams should version their question sets and track accuracy against each configuration the same way they would track a model upgrade.

Open-weight alternatives and RFDT: where fine-tuning is available

Developers who need true weight-level fine-tuning on a decision-model interface rather than the request-layer substitutes described above do have a path, just not through Jev itself. An open-weights ecosystem has grown up around the same interface Jev popularized, and Featherless AI's Simple Jev project is part of it, replicating Jev's Choice, Score, and Boolean interface on models that can actually be trained and fine-tuned directly. For teams whose use case genuinely depends on adjusting model weights rather than shaping requests or layering a downstream classifier on top of Jev's probabilities, that open-weight path is the honest answer, not a workaround bolted onto a hosted API that was never built to support it.

A practical version-tracking checklist for Jev integrations

Tracking Jev accurately means watching four distinct surfaces rather than waiting for a single breaking-change announcement to arrive at one endpoint, because each surface fails in its own way and on its own schedule. The first surface is the model alias versus the pinned model ID: calling jev-1.13.0, or whatever specific versioned ID is actually in use, rather than jev-latest or jev-preview, protects any integration with tuned confidence thresholds, and logging the model field on every response is the cheapest way to catch an alias quietly moving underneath you. The second surface is the Python and JavaScript SDK changelogs themselves, where the two documented breaking changes, the Score.criteria shape change in 0.6.0 and the msgspec-to-Pydantic migration in 0.7.0, show what kind of change to expect and why a downstream MCP server or any other re-serializing layer needs to be checked after every upgrade. The third surface is the jaggedness and accuracy documentation TypeSafe publishes per model version, with the 1.13 page last reviewed September 17, 2026 serving as the baseline to save alongside a pinned model ID, since a new model version carries its own distinct failure-mode profile. The fourth surface is the request schema a team builds for itself: every addition, rewording, or retirement of a question is a version event in its own right, and calibrated thresholds need re-validation against held-out data after any such change, exactly as they would after a model upgrade. Taken together, these four surfaces are what "API changes across versions" actually means for Jev, and a team that monitors all four will rarely be surprised by a change it had no way to see coming.