Nine days after TypeSafe launched Jev on September 15, 2026, engineers had already built 10 open decision models to answer the same typed questions, and Respan benchmarked all of them against it.
The attention comes from the shape of the model. Jev answers typed questions with a probability instead of generating text, so a model call behaves like a function inside ordinary application code, fast and cheap enough to run on every request.
One gap from the launch hasn't closed, though. Jev is only available as a hosted model, so teams that need a decision model on their own hardware can't use it. Respan's Span-02 answers the same typed questions with open weights and an API that Jev clients work against unchanged.
The open models that followed vary widely. The first community projects ranged from within a few points of Jev to less than half its accuracy in Respan's evaluation, while larger models from Fastino, Baseten, and Perplexity now score above Jev on Artificial Analysis's shared index. Respan's Span-02 plus nine open models make up the 10 best Jev alternatives compared in 2026.
TL;DR: Top 10 Jev alternatives
Respan's Span-02 leads for decisions inside your code. The open models follow in order of their score on Artificial Analysis's index, then the community models in order of their accuracy in Respan's evaluation, then the one neither benchmark covered.
| Tool | Use it for | License | Cost |
|---|---|---|---|
| Span-02 | Jev-compatible decisions | Apache 2.0 | $0.01/1M hosted; weights free |
| GLiDE | Text and image decisions | Fastino Community License | Self-host or Fastino API |
| mammoth-1 | A 27B model under MIT | MIT | Self-host or Baseten API |
| Decider v1.2 | Open weights plus a hosted API | Apache 2.0 | $0.02/1M hosted; weights free |
| Clef | Workers AI or self-hosted | Apache 2.0 | Workers AI or self-host |
| Tev1 | Accuracy near Jev | MIT (code) | Self-host or Together API |
| Kev | Laptop drop-in for TypeSafe SDK | Apache 2.0 | Free, self-hosted |
| Laya | Multilingual self-hosted decisions | Apache 2.0 | Free, self-hosted |
| Von | Small CPU or GPU deployments | Apache 2.0 | Free, self-hosted |
| Nimble | Reproducible open training pipeline | Not stated | Self-host or Modal API |
Span-02's weights are open and its hosted API costs $0.01 per million input tokens, while every other model on the roster except GLiDE and Nimble ships under Apache 2.0 or MIT.
What is Jev?
Jev is a System One model from TypeSafe AI that returns typed decisions instead of text. You pass it application state and a set of typed questions, and it answers each one as a choice, a score, or a yes/no with a probability attached, without generating tokens one at a time.
Choices can run up to 255 options, and for high-cardinality ones Jev uses two stages, scoring each option independently and then making an explicit choice. TypeSafe opened Jev in early access on September 15, 2026, and dropped the waitlist about a week later. It serves Jev only as a hosted model, through its hosted System One API and gateways such as OpenRouter and Vercel, so there's no version to run on your own hardware. The current release, Jev 1.14, added an experimental bounding-box question type, with image input and a 262K context behind flags TypeSafe says aren't ready for production.
Because every answer carries a probability, Jev fits into routing and tool-gating code the way a function call does, which is where most of the Jev AI model's use cases come from.
How we evaluated Jev alternatives
Two benchmarks cover most of the roster. The larger models are scored on Artificial Analysis's Decision Index v2.1, which runs every model it covers through the same six evaluations and scores each answer on accuracy less the Brier score of its probability, from 0 to 100.
| Model | Artificial Analysis Decision Index v2.1 |
|---|---|
| GLiDE v1.2 | 73 |
| mammoth-1 | 71 |
| Perplexity Decider v1.2 | 70 |
| Jev 1.14 | 66 |
| Clef | 60 |
The community models come from Respan's decision-model eval, which scored 11 decision models on four measures: accuracy, consistency as paired flip rate, injection attack success rate (ASR), and expected calibration error (ECE). Higher accuracy is better, and lower is better on the other three. The full results are in Respan's launch benchmarks.
| Model | Accuracy | Paired flip rate | Injection ASR | ECE |
|---|---|---|---|---|
| Jev 1.13.0 | 0.932 | 0.021 | 0.063 | 0.045 |
| Tev1 4B | 0.901 | 0.052 | 0.042 | 0.031 |
| Kev 4B | 0.833 | 0.060 | 0.078 | 0.070 |
| Decider 2B v10 | 0.747 | 0.128 | 0.208 | 0.074 |
| AlexWortega OpenJev 4B v5 | 0.744 | 0.116 | 0.089 | 0.118 |
| Bosun v3.1 1.7B | 0.680 | 0.208 | 0.323 | 0.089 |
| Tiny-Jev 0.6B | 0.646 | 0.128 | 0.224 | 0.267 |
| Laya | 0.542 | 0.298 | 0.396 | 0.092 |
| MoJev 0.85B | 0.501 | 0.150 | 0.307 | 0.129 |
| Open-Jev DeBERTa v3 large | 0.472 | 0.194 | 0.385 | 0.147 |
| Von 1.2 | 0.422 | 0.242 | 0.297 | 0.071 |
In that run, Jev still led on accuracy and consistency. Tev1 trailed it by about three points of accuracy while posting a lower injection success rate and lower calibration error, and below Kev the accuracy drops from 0.747 to 0.422 across the rest of the table.
Nimble wasn't part of either benchmark, so its entry draws on its own repository for license, size, hardware, and Jev API compatibility, and leaves out accuracy figures the project reports about itself. Span-02 isn't on Artificial Analysis's index and was released after Respan's eval, so its score comes from the official Decision Index leaderboard.
10 best Jev alternatives
1. Span-02
Span-02 is Respan's open-weight answer to Jev, available on Respan's evaluation platform or on your own GPU. Its API follows TypeSafe's System One contract, so Jev clients work against it unchanged and moving existing calls over means changing the URL.
It also covers ground Jev doesn't, with number answers, choice questions of up to 679 options, and up to four images per request. Reasoning is adjustable: set budget_ms and it returns its best decision so far when time runs out, or leave it in the default auto mode, where it thinks only when it's unsure.

- On the official Decision Index - Span-02 scored 62.6 on the official Decision Index leaderboard in October 2026, at a 33 ms median latency on a single RTX PRO 6000.
- More thinking, better answers - In Respan's Span-02 launch tests, accuracy on a land-or-sea coordinates task rose from 71.9% with thinking off to 84.7% at one second.
- Open weights on your own GPU - The weights are on Hugging Face under Apache 2.0, built on Gemma 4, and run on a single Blackwell GPU through the engine included with the model.
- Under a quarter of Jev's price when hosted - The hosted API costs $0.01 per million input tokens with output free, against Jev's $0.042.
- Connected to the rest of the platform - Span-02 runs on the traces Respan already captures, so a bad decision opens straight onto the trace behind it, and those traces can become the test set for the next fix.
2. Fastino GLiDE
Fastino Labs ships GLiDE as weights on Hugging Face and through its hosted API, which takes requests on a /v1/systemone endpoint. It reads text, JSON, and still images sent inline, though not video or remote image URLs, and answers choice questions with up to 255 options as well as noul and score questions.
Version 1.2 scores 73 on Artificial Analysis's index, seven points above Jev 1.14. What you take on with the weights is the license and the hardware: they use the Fastino Community License rather than Apache 2.0, so read its terms before building on them, and running it takes one GPU with 80 GB or more. Fastino's own latency test puts the median at 112 ms but the p99 at 3,702 ms, so set a timeout if it sits in the request path.
Quality: Strong decisions over text and images, with a long latency tail.
Cost: Weights under the Fastino Community License on an 80 GB GPU, or Fastino's hosted API, which Artificial Analysis measured at $780 per million tasks.
Benchmark score: 73 on Artificial Analysis's Decision Index v2.1 (Jev 1.14: 66).
3. Baseten mammoth-1
Baseten's research lab, Base Labs, released mammoth-1 on October 21 as a 27B decision model, a full fine-tune of Qwen3.5-27B under MIT. It takes text and images, answers yes/no, choice, and ordered-score questions, and Baseten also serves it on its Model APIs through a /v1/systemone endpoint.
It scores 71 on Artificial Analysis's index, five points above Jev 1.14, and it was trained with an "I don't know" option, which gives your code an explicit way to route a question it can't answer. The limits sit in the input: the context tops out at 16,384 tokens, and requests longer than the trained limits are refused rather than truncated, so long documents need splitting before they reach it. Baseten's free hosted week ended on October 27 with no published price after it, so self-hosting on a CUDA GPU is the predictable route for now.
Quality: Strong general decisions with an explicit "I don't know"; short context.
Cost: Weights under MIT to run yourself, or Baseten's API with no published price.
Benchmark score: 71 on Artificial Analysis's Decision Index v2.1 (Jev 1.14: 66).
4. Perplexity Decider
Perplexity ships Decider v1.2 both ways: as Apache 2.0 weights on Hugging Face and through its hosted Decisions API. Built on Qwen3.8-27B, it takes text and images, and Decider Flash v1.2, a model of about 4B distilled from the larger one, sits alongside it for higher-volume work.
Perplexity reports v1.2 at 68.09 on Decision Index 0.3 against 62.30 for v1.1 in its own evaluations. The hosted API costs $0.02 per million input tokens for v1.2 and $0.01 for Flash, with output free. Self-hosting the larger model takes a GPU with about 52 GiB for the BF16 weights plus working memory, and its model card notes training used sequences up to about 32K tokens, so long inputs are less tested than the 262,144-token limit suggests.
Quality: Strong decisions over text and images under a permissive license.
Cost: Free weights under Apache 2.0, or $0.02 per million input tokens hosted ($0.01 for Flash).
Benchmark score: 70 on Artificial Analysis's Decision Index v2.1 (Jev 1.14: 66).
5. Cloudflare Clef
Cloudflare open-sourced Clef under Apache 2.0 while also hosting it on Workers AI, in two sizes on Hugging Face: Clef on a frozen Qwen3.8-27B and Clef-flash on a frozen Qwen3.5-9B, each with trained routing heads and rank-256 LoRA adapters. Cloudflare describes both as fully Jev-API compatible, and Clef adds a vision encoder for image input.
On Artificial Analysis's index Clef scores 60, below Jev 1.14's 66, though Cloudflare's own launch panel had Clef ahead of Jev on seven of 10 benchmarks, with Jev leading on When2Call and BRIGHT. Clef-flash is the latency option, at a 38.8 ms median in Cloudflare's tests against 209.3 ms for Clef, and the open weights let you move a Workers AI deployment onto your own hardware without changing the API.
Quality: Jev-compatible, with a fast 9B option; below Jev on the shared index.
Cost: Free weights under Apache 2.0, or Workers AI from $0.038 per million input tokens for Clef-flash.
Benchmark score: 60 on Artificial Analysis's Decision Index v2.1 (Jev 1.14: 66).
6. Tev1
Together AI released Tev1 as an open-weight decision model fine-tuned on Qwen3.5-4B. It's an independent, Jev-inspired implementation that doesn't train on Jev's answers, and it handles policy decisions and routing with 2 to 24 options per question.
Tev1 answers with a single letter rather than Jev's typed response format, so existing Jev client code needs an adapter in front of it. The model also ships with an experimental tag, and its README notes that the scores it reports come from reused development benchmarks rather than untouched test sets.
Quality: Accuracy within a few points of Jev, with a lower injection success rate and calibration error; capped at 24 options.
Cost: Open weights to run yourself, or Together AI's hosted endpoint, which has no published per-model price.
Benchmark score: 0.901 accuracy, 0.052 flip rate, 0.042 injection ASR, 0.031 ECE (Jev: 0.932, 0.021, 0.063, 0.045).
7. Kev
If your code already calls Jev through the official TypeSafe SDK, Kev is built to take its place. Its API follows TypeSafe's System One contract, so the SDK works against a local Kev server once you change the base URL.
Kev 1.0 comes in four sizes on Qwen bases: 0.8B, 4B, and 9B checkpoints that each add a rank-16 LoRA adapter and a small pointer head, and a 27B model that fine-tunes every weight. All four answer yes/no, choice (1 to 255 options), and score questions, and the code and released models are Apache 2.0. The 0.8B runs on any Apple Silicon Mac or a 4 GB GPU, while the 27B needs an 80 GB card. What you take on is knowledge and calibration: the README puts Kev-9B at 0.59 on MMLU-Pro against Jev's 0.84, and at a 5% error budget the larger sizes automate 0.52 to 0.69 of new-source decisions against Jev's 0.70, so test thresholds on your own data before you switch.
Quality: Kev-27B scores 52.3 to Jev's 54.0 on Kev's own held-out index; knowledge depends on the base model.
Cost: Free to self-host, from a laptop for the 0.8B to an 80 GB GPU for the 27B.
Benchmark score: 0.833 accuracy, 0.060 flip rate, 0.078 injection ASR, 0.070 ECE (Kev-4B in Respan's run).
8. Laya
Laya takes the encoder route instead of adapting an LLM. It ships three Apache 2.0 checkpoints: an English model on ModernBERT-large (421M parameters), a multilingual model on mmBERT-base (322M) covering 100+ languages, and a typed-decisions fine-tune, and it routes between them by detected language.
The laya-serve server exposes a Jev-compatible /v1/systemone endpoint, and the models also run in the browser through ONNX or behind an MCP server. The README is direct about two limits: Jev does better on questions with 50+ options, and where an option sits in the prompt affects the answer, which the option_order parameter is there to mitigate. In Respan's run, Laya's answers were also less stable than Tev1's or Kev's, with a paired flip rate of 0.298 and an injection success rate of 0.396, against Jev's 0.021 and 0.063.
Quality: Broad language coverage on small encoders; weaker on high-cardinality questions and answer consistency.
Cost: Free to self-host on CPU or GPU.
Benchmark score: 0.542 accuracy, 0.298 flip rate, 0.396 injection ASR, 0.092 ECE.
9. Von
Von packs a ModernBERT-based model into 395M parameters (about 1.5 GB) and is fully compatible with TypeSafe's /v1/systemone specification. It runs in-process or as a server with von serve, on NVIDIA CUDA, AMD ROCm, Apple MPS, or multithreaded CPU, although the README lists CPU inference as far slower than GPU.
Von posted the lowest accuracy of the roster models Respan scored, at 0.422, but its calibration error of 0.071 sits close to Jev's, so its probabilities track how often it's actually right. That can make a confidence threshold with a fallback to a larger model worth testing.
Quality: Low accuracy with well-calibrated probabilities; pair it with a fallback.
Cost: Free to self-host, Apache 2.0.
Benchmark score: 0.422 accuracy, 0.242 flip rate, 0.297 injection ASR, 0.071 ECE.
10. Nimble
Bespoke Labs built Nimble around an open training pipeline. It fine-tunes Qwen3.5-9B with LoRA on answer tokens only, using 2,676 training examples and 324 held-out ones, and documents a contrastive curation method you can replay offline.
It answers choice, boolean, and score questions, with up to 255 choices per field. At 9B, the unquantized weights alone take about 18 GB, and it runs through MLX on Apple Silicon or CUDA on NVIDIA GPUs. The README states that its probabilities "are not a guarantee that an answer is correct," caps prompts at 8,192 tokens, and doesn't name a license, which is worth settling before any commercial deployment.
Quality: A larger backbone with a fully reproducible training set; text only, no explanations.
Cost: Self-host on hardware with 18 GB+ of memory, or call a public Modal API with no published price.
Jev-compatible API: No. Nimble is Jev-inspired but uses its own API.
What is the best Jev alternative?
For decisions inside your code, Span-02 is the Jev alternative to start with. It answers the same typed questions through an API Jev clients work against unchanged, costs under a quarter of Jev's input price when hosted, and ships open weights you can run on your own GPU.
If the independent score matters most, GLiDE v1.2, mammoth-1, and Perplexity's Decider v1.2 all score above Jev 1.14 on Artificial Analysis's index, and the choice between them mostly comes down to license: Fastino's own license for GLiDE, MIT for mammoth-1, and Apache 2.0 for Decider.
Among the community models, the choice comes down to how much of Jev's contract you need to keep. Tev1 scored nearest Jev in Respan's decision-model run and beat it on injection resistance and calibration, but it needs an adapter for Jev client code. Kev, Von, and Laya accept Jev's API format, so existing client code can point at them as they are.
Whichever model makes the decision, the harder part is knowing when its decisions start going wrong. Instead of reading logs after the fact, use Respan to run observability in production, know when production shifts, and act before it spreads.
What is the best open-source Jev alternative?
Span-02 is the open-weight Jev alternative to start with. Its weights are on Hugging Face under Apache 2.0, and its hosted API follows Jev's System One contract. Among the other open models, GLiDE v1.2 scores 73, mammoth-1 71, and Perplexity's Decider v1.2 70 on Artificial Analysis's index, against Jev 1.14's 66, and among community models Kev, Von, and Laya accept Jev's /v1/systemone format under Apache 2.0.
Is there a free Jev alternative?
Yes. Span-02's weights are free to download under Apache 2.0, and mammoth-1 (MIT), Perplexity's Decider v1.2, Clef, Kev, Laya, and Von (all Apache 2.0) are free to self-host as well. You still pay for the hardware they run on, which ranges from a laptop for Kev to a single 80 GB GPU for GLiDE.
Are there hosted Jev alternatives from OpenAI or Google?
Yes. OpenAI's Decisions API runs on GPT-6 Luna, and Google launched Gemini Decision 1 on November 11, 2026, alongside hosted models such as Liquid AI's d1-ultra and Nace AI's Drex Max. None of them publish weights, so they sit outside this list, and the best AI decision models roundup compares them with Jev instead. Span-02 covers both cases, with a hosted API and open weights.
Can you self-host a Jev alternative?
Yes. Span-02's open weights run on a single Blackwell GPU through the engine included with the model, and GLiDE, mammoth-1, Perplexity's Decider v1.2, Clef, Kev, Laya, and Von all ship open weights, with Tev1's weights open as well. Outside the roster, Nace AI's Drex 2.0 and Kakao's Kanana-2-v-decide also publish weights. When the concern is data handling rather than hardware, Respan's hosted Span-02 runs with SOC 2, HIPAA with a BAA, GDPR, and ISO 27001 coverage, plus PII masking and the option to omit logs.


