A support message arrives with two requests: cancel a subscription and explain a charge. Your application needs to choose a queue, decide whether a person should respond, and assign a priority. A paragraph of generated text would give the application more work to do. A decision model can return the values the workflow needs.

Jev from TypeSafe takes information such as a customer message, along with questions that specify the allowed answer format. It returns choices, yes/no probabilities, or scores. Since our look at what developers are building with Jev, the same request style has spread to OpenAI, Google, Microsoft, and more than a dozen smaller providers, and to open-weight models that run on a laptop or a single GPU.

These options move different responsibilities into your application. A managed API leaves inference infrastructure with the provider. A local model puts serving and hardware in your hands. A classifier may cover routing and tagging while leaving scores or other decisions to separate code. The first question is which of those jobs you need to replace.

DataRoot Labs is an AI R&D company that develops and evaluates AI systems for clients. This review was first published on October 11, 2026 and updated on November 19, 2026. It draws on official documentation, model cards, pricing pages, and published source code checked on that date. We have not run these systems ourselves: the tables describe published capabilities, API contracts, and deployment requirements, and they do not rank accuracy. TypeSafe now prefers the name “System One model” for Jev; most other vendors say “decision model,” and this article uses that term for the category.

Where to start, by requirement

These pointers follow from the published specifications in the tables below. They are starting points for a test, not a ranking.

  • You want to keep your Jev client. Alibaba’s preview works with TypeSafe’s SDK through a different base URL, and Fireworks Rune and Levanto Sage2 accept Jev’s request shape. Most other hosted services use the same pattern with their own field details.
  • You are already on a large cloud. OpenAI, Google, and Microsoft each have an endpoint; all three need changes to the request.
  • You need images, audio, or video. Google’s Gemini Decision 1, Cloudflare’s Clef-omni, and Liquid’s d1.2 accept the widest range of inputs.
  • You want the lowest listed price. Perplexity’s flash model, Baseten’s joey-1, and Respan span-02 list $0.01 per million input tokens, a quarter of Jev’s price.
  • You want to run it yourself with a permissive license. Start with the first local table: Clef, pplx-decider, H2O-Lightning, Kev, Laya, and others are Apache 2.0.
  • You have a laptop or a small GPU. Laya, GLiNER2.5-Decide, Liquid’s d1-2B, and the 4B models from Perplexity, H2O, and Kev are the small end of the range.

What changed since October

  • Jev gained experimental image input. Jev 1.14 arrived on October 14 with opt-in images, a bounding-box question type, and an optional 262k-token context.
  • The large platforms moved. OpenAI’s Decisions API became generally available on October 22, Microsoft released a generally available 1.1 model on November 17, and Google launched Gemini Decision 1 on November 11.
  • More weights are public. Fastino, Respan, and Baseten published open models, Perplexity added a 4B model, and Liquid replaced d1-3B with d1-2B.
  • Public leaderboards appeared. Three boards now rank decision models, and they disagree with each other.

Hosted API comparison

Scroll horizontally to explore all columns →

Hosted API comparison
Product / routeInput contentDecision outputIntegration contract
TypeSafe Jev
Baseline · early access
Text, JSON; images (experimental)
Yes/no, choice, score; box (experimental)
State + named questions
Text, JSON, images
Yes/no, choice, score
Input + question array
Text, images, video, audio, PDF
Yes/no, choice, score
Input + named questions
Text, JSON, images
Yes/no, choice, score
Named questions + Foundry deployment
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images, audio, video
Yes/no, choice, score
State + named questions
Text, images, audio
Yes/no, choice, score, spans, boxes, values
State + named questions
Text, JSON, images
Yes/no, choice, score, text spans
State + named questions
Text, JSON, images
Yes/no, choice, score, text spans
State + named questions
Text, JSON
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score
State + named questions
Text
Labels, multi-label
Text + classification tasks
Text
Yes/no, choice, score
State + named questions, or OpenAI’s shape
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score, number
State + named questions
Text, JSON
Yes/no, choice, score
State + named questions
Text, JSON; images on the native endpoint (beta)
Yes/no, choice, score; native sort and tags
Jev-compatible SystemOne or native Decide
Together Tev1
Experimental
Text
One of 2–24 choices
Chat messages + labelled options
Text, JSON
Yes/no, choice, score
State + named questions
Text, structured data
Yes/no, choice, score
SQL function
Product / route
Input content
Decision output
Integration contract
TypeSafe Jev
Baseline · early access
Text, JSON; images (experimental)
Yes/no, choice, score; box (experimental)
State + named questions
Text, JSON, images
Yes/no, choice, score
Input + question array
Text, images, video, audio, PDF
Yes/no, choice, score
Input + named questions
Text, JSON, images
Yes/no, choice, score
Named questions + Foundry deployment
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images, audio, video
Yes/no, choice, score
State + named questions
Text, images, audio
Yes/no, choice, score, spans, boxes, values
State + named questions
Text, JSON, images
Yes/no, choice, score, text spans
State + named questions
Text, JSON, images
Yes/no, choice, score, text spans
State + named questions
Text, JSON
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score
State + named questions
Text
Labels, multi-label
Text + classification tasks
Text
Yes/no, choice, score
State + named questions, or OpenAI’s shape
Text, JSON, images
Yes/no, choice, score
State + named questions
Text, JSON, images
Yes/no, choice, score, number
State + named questions
Text, JSON
Yes/no, choice, score
State + named questions
Text, JSON; images on the native endpoint (beta)
Yes/no, choice, score; native sort and tags
Jev-compatible SystemOne or native Decide
Together Tev1
Experimental
Text
One of 2–24 choices
Chat messages + labelled options
Text, JSON
Yes/no, choice, score
State + named questions
Text, structured data
Yes/no, choice, score
SQL function

In this table, “state” is the content to evaluate, such as a message, a document, or an image. “Named questions” means the application gives each judgment a key and reads the answer back under the same key. OpenAI accepts an array of questions with an optional name. GLiNER exposes classification tasks, Tev1 uses Chat Completions, and Databricks wraps the contract in a SQL function. A matching request shape still leaves response fields, refusals, and score semantics to check before switching.

Jev’s image input and box questions are off by default. They are enabled per request with a header, and TypeSafe’s image documentation says they are not yet ready for production. The “early access” label comes from the launch post; we found no later statement of general availability.

Listed prices

Every service in the table below that lists a token price bills input tokens and lists no charge for output. The figures are list prices in US dollars per one million input tokens, as shown in each provider’s documentation or product pages on November 19, 2026.

Scroll horizontally to explore all columns →

Research data
ServiceListed input priceCondition
TypeSafe Jev
$0.042
Same for 1.13 and 1.14
OpenAI Decisions
$0.10
Cached input $0.01
Google Gemini Decision 1
$0.10
A free tier exists
Microsoft-Decision-1.1
$0.042
Global; $0.046–$0.05 in Data Zones
Cloudflare Clef / Clef-flash / Clef-omni
$0.24 / $0.038 / $0.15
Liquid d1.2 / d1.2-ultra
$0.02 / $0.042
Perplexity v1.3 / flash v1.3
$0.02 / $0.01
Web grounding costs extra per search
Inception Mercury Decide
$0.02
Shown as a 50% promotional discount
Upstage Solar Decide
$0.10
Fastino GLiDE / GLiNER2.5-Decide
$0.04 / $0.03
GLiDE usage sums internal passes
Fireworks Rune
$0.042
Cached input $0.0084
Baseten joey-1 / elephant-1 / mammoth-1
$0.01 / $0.035 / $0.10
Respan span-02
$0.01
Bespoke Nimble
$0.04
Levanto Sage2
$0.05
Free and Developer plans; monthly plans include usage
Together Tev1
$0.042
Alibaba decision-model-preview
Free for a limited time
No list price published
Databricks ai_decide
No per-token price
Billed through Databricks SQL

A token price is not the cost of a decision. Providers count tokens differently when one request carries several questions. Google bills the shared input once and adds each question’s own tokens. Fastino’s documentation says GLiDE’s reported input usage sums its internal passes across questions. Compare candidates on the cost of a complete request from your own workload.

Local deployment comparison

Permissive licenses (Apache 2.0)

Scroll horizontally to explore all columns →

Research data
Model / sizeDevice / runtimeMemory or hardware evidenceWeights license
CUDA · custom loader or SGLang
Tested on H200; no stated minimum
Apache 2.0
CUDA · custom loader or SGLang
Tested on H200; no stated minimum
Apache 2.0
CUDA · custom loader
Card states ~64 GB GPU memory
Apache 2.0
CUDA · separate decision head
~49 GiB weights, plus working memory
Apache 2.0
CUDA · separate decision head
~8.5 GiB weights, plus working memory
Apache 2.0
CPU / GPU · gliner2
Minimum not specified
Apache 2.0
NVIDIA Blackwell GPUs · bundled engine
16.4 GB weights; ~28 GB GPU memory by default
Apache 2.0
CUDA · vLLM + shim; GGUF for llama.cpp
9.3 GB weights; tested on a 48 GB GPU
Apache 2.0
Kev
0.8B / 4B / 9B / 27B
CUDA / Apple MLX
4B: 24 GB GPU or 32 GB Mac; 27B needs an 80 GB GPU
Apache 2.0
Laya
421M; multilingual 322M
CPU / CUDA / MPS / XPU
Minimum not specified
Apache 2.0
Strands Decider, Qwen variant
2B-class base + adapter
CPU / CUDA / MPS / MLX
Publisher checked L4 and CPU; minimum not specified
Apache 2.0
vLLM-SR d3 · 27B; d3-mini 4.5B
CUDA / AMD ROCm · vLLM
d3: ~52 GB weights, 65 GiB measured peak
Apache 2.0
CUDA · Transformers, vLLM or SGLang plugins
4B: ~9.1 GB weights; minimum not specified
Apache 2.0
AutoTrust
9B / 27B / 35B
CUDA · vLLM + bundled server
35B: card asks for an 80 GB GPU; quantized build 32 GB
Apache 2.0
Bespoke Nimble 9B v2
9B base + ~173 MB adapter
CUDA / Apple MLX after merge
~18 GB base weights, plus runtime and merge memory
Apache 2.0 adapter and base
Model / size
Device / runtime
Memory or hardware evidence
Weights license
CUDA · custom loader or SGLang
Tested on H200; no stated minimum
Apache 2.0
CUDA · custom loader or SGLang
Tested on H200; no stated minimum
Apache 2.0
CUDA · custom loader
Card states ~64 GB GPU memory
Apache 2.0
CUDA · separate decision head
~49 GiB weights, plus working memory
Apache 2.0
CUDA · separate decision head
~8.5 GiB weights, plus working memory
Apache 2.0
CPU / GPU · gliner2
Minimum not specified
Apache 2.0
NVIDIA Blackwell GPUs · bundled engine
16.4 GB weights; ~28 GB GPU memory by default
Apache 2.0
CUDA · vLLM + shim; GGUF for llama.cpp
9.3 GB weights; tested on a 48 GB GPU
Apache 2.0
Kev
0.8B / 4B / 9B / 27B
CUDA / Apple MLX
4B: 24 GB GPU or 32 GB Mac; 27B needs an 80 GB GPU
Apache 2.0
Laya
421M; multilingual 322M
CPU / CUDA / MPS / XPU
Minimum not specified
Apache 2.0
Strands Decider, Qwen variant
2B-class base + adapter
CPU / CUDA / MPS / MLX
Publisher checked L4 and CPU; minimum not specified
Apache 2.0
vLLM-SR d3 · 27B; d3-mini 4.5B
CUDA / AMD ROCm · vLLM
d3: ~52 GB weights, 65 GiB measured peak
Apache 2.0
CUDA · Transformers, vLLM or SGLang plugins
4B: ~9.1 GB weights; minimum not specified
Apache 2.0
AutoTrust
9B / 27B / 35B
CUDA · vLLM + bundled server
35B: card asks for an 80 GB GPU; quantized build 32 GB
Apache 2.0
Bespoke Nimble 9B v2
9B base + ~173 MB adapter
CUDA / Apple MLX after merge
~18 GB base weights, plus runtime and merge memory
Apache 2.0 adapter and base

Conditional, non-commercial, or unresolved licenses

Scroll horizontally to explore all columns →

Research data
Model / sizeDevice / runtimeMemory or hardware evidenceWeights license
CPU / CUDA / Apple MPS; GGUF, MLX, ONNX
3.84 GB weights; minimum not specified
LFM Open License · revenue condition
CPU / CUDA / Apple MPS; GGUF, MLX, ONNX
4.33 GB weights; minimum not specified
LFM Open License · revenue condition
CPU / CUDA / Apple MPS; GGUF, MLX
2.35 GB weights; minimum not specified
LFM Open License · revenue condition
CUDA · bundled server
52.2 GB weights; card asks for an 80 GB GPU
Fastino Community License · revenue condition
GLiDE 9B / 2B / 0.8B / 0.4B
CUDA · bundled server
15.9 / 3.8 / 1.5 / 0.8 GB weights; no stated minimum
Fastino Community License · revenue condition
GPU · publisher’s inference code
~55 GB weights; card asks for an 80 GB GPU
CC BY-NC 4.0 · non-commercial
Local setup needs validation, per card
Requirement not established
Weight license still being finalized; code is MIT
Model / size
Device / runtime
Memory or hardware evidence
Weights license
CPU / CUDA / Apple MPS; GGUF, MLX, ONNX
3.84 GB weights; minimum not specified
LFM Open License · revenue condition
CPU / CUDA / Apple MPS; GGUF, MLX, ONNX
4.33 GB weights; minimum not specified
LFM Open License · revenue condition
CPU / CUDA / Apple MPS; GGUF, MLX
2.35 GB weights; minimum not specified
LFM Open License · revenue condition
CUDA · bundled server
52.2 GB weights; card asks for an 80 GB GPU
Fastino Community License · revenue condition
GLiDE 9B / 2B / 0.8B / 0.4B
CUDA · bundled server
15.9 / 3.8 / 1.5 / 0.8 GB weights; no stated minimum
Fastino Community License · revenue condition
GPU · publisher’s inference code
~55 GB weights; card asks for an 80 GB GPU
CC BY-NC 4.0 · non-commercial
Local setup needs validation, per card
Requirement not established
Weight license still being finalized; code is MIT

Local input and output contracts. Hardware fit is only one part of the comparison:

  • Images, audio, and video: local Clef and Clef-flash accept text, JSON, images, and video frame arrays. Clef-omni adds audio. d1-2B takes text, pictures, and video, and d1-Omni-2B adds audio clips and spoken questions. The older d1-omni-600M accepts images or one audio clip in a request, but not both.
  • Images in some sizes only: in the GLiDE family, only the 27B model accepts images; the smaller checkpoints reject them. pplx-decider, H2O-Lightning, span-02, and d3 document image input. Strands’ Qwen 2B release needs its optional vision mode.
  • Text-based typed decisions: Kev and the original Laya checkpoints accept text or structured state and return yes/no, choice, and ordinal scores. An ordinal score can be the probability-weighted average of the levels, and not a selected integer.
  • Outputs beyond the three types: H2O-Lightning, Liquid’s 2B models, and Valen-Decision document bounding boxes. Perplexity’s v1.3 weights include an adapter for locating text spans. span-02 returns numbers as a fourth type.
  • Narrower or differently packaged outputs: GLiNER2.5-Decide classifies text into one or several labels; numeric labels remain classes. Tev1 selects one of 2–24 letters. Nimble 9B v2 returns boolean and enum fields.

The linked model cards and repositories supply the configurations above. Weights-only size, tested hardware, and a stated requirement are different measurements. We have not measured local memory use ourselves; context length, batch size, precision, and temporary allocations during loading affect the total. Kev’s 4B card, for example, gives “one 24 GB GPU or a 32 GB Apple Silicon Mac” as sizing guidance and separately reports 14.3 GB of resident GPU memory in its own measurement. Its 27B model has about 51 GB of weights and roughly 66 GB resident with serving buffers.

Check the license before the hardware. Apache-licensed weights carry no per-call model fee, although running them still consumes hardware, electricity, or cloud capacity. Three publishers attach commercial conditions. Liquid’s license guide allows free commercial use below $10 million in annual revenue and requires a separate license above it. The Fastino Community License sets the same $10 million threshold for production commercial use, counts a company’s internal operations as commercial use, and applies to fine-tuned and quantized derivatives. Bespoke’s Nimble-v4-max weights are CC BY-NC 4.0, which excludes commercial use. Tev1’s code license does not resolve its fine-tuned weight terms.

Jev competitors with a hosted API

OpenAI Decisions API

OpenAI Decisions is a direct functional alternative for bounded judgments. It has been generally available since October 22, uses gpt-6-luna, and supports predicate, choice, and score questions over text, images, and JSON. One request can carry up to 400 questions, and each question can bring its own images. Conversation history, including tool calls and their outputs, can serve as the input.

There is an integration change to account for. The Decisions API contract uses input and an array of questions, where Jev uses state and a map of named questions. Any question can return a refusal while the others are answered, so the application must handle a missing answer. Prompt caching applies to shared input of at least 1,024 tokens, which matters when many requests reuse one policy document.

Our OpenAI Decisions use-case review examines how developers use these judgments within a larger application.

Google Gemini Decision 1

Gemini Decision 1 launched on November 11. It accepts the widest range of inputs in this review, including video, audio, and PDF files, and allows up to 1,000 named questions per request within a 262,144-token input limit.

The Decisions API guide uses a v1beta path, and Google’s pages do not label the model as generally available or as a preview. It runs through the Gemini API; the announcement says support in Google Cloud is coming. The model page lists structured outputs, function calling, caching, and the Batch API as unsupported for this model.

Microsoft-Decision-1.1

Microsoft-Decision-1.1 became generally available in Microsoft Foundry on November 17. It adds PNG and JPEG image input to the typed judgments of the earlier model: yes/no probabilities, categorical choices, and ordered scores. Microsoft says the new version is built on a different base model, so thresholds tuned on the preview need re-testing. Microsoft-Decision-1 remains in the catalog as a text-only preview.

The integration uses a Foundry deployment and Azure authentication. The request identifies the deployed model by its deployment name, so adopting it involves more than changing the hostname in a Jev client. Data Zone deployments keep processing within a region group at a higher listed price.

Cloudflare Clef, Clef-flash, and Clef-omni

Cloudflare’s Clef family offers two routes for each model: call it through Workers AI or run the released weights yourself. That makes it relevant to teams already using Cloudflare and to teams evaluating a move from a managed service to their own infrastructure.

The Clef API exposes typed decisions over shared state and supports up to four embedded images per request. Clef-flash is the smaller variant; its hosted context window is 24,576 tokens, against 65,536 for Clef. Clef-omni, released on October 9, adds audio clips and short videos.

All three sets of weights use Apache 2.0. The local loader includes the decision-specific head and preprocessing; loading a Clef model as an ordinary chatbot would omit that interface.

Liquid AI d1

Liquid’s hosted API now serves d1.2 and d1.2-ultra, announced on November 16. Both accept text, images, and audio, and they answer more than the three standard question types: they can also read a value, mark text spans, return bounding boxes, and select several options.

The October version of this article linked to the liquid/d1 route on OpenRouter. OpenRouter’s page for that route scheduled its removal for November 20, 2026, and the page for liquid/d1.1 gives November 24. The current route is d1.2, which OpenRouter lists with text and image input only.

The public checkpoints changed too. d1-2B replaces the deprecated d1-3B, with official builds in the GGUF format that llama.cpp reads, and for Apple’s MLX and for ONNX. One detail affects planning: under llama.cpp the 2B models answer only yes/no, choice, and score questions, and the additional answer types need Transformers or mlx-vlm. The license conditions are described in the license notes above.

Perplexity pplx-decider

Perplexity’s Decisions API accepts text, JSON, and images in a shared state, with named noul (yes/no), choice, and score questions. Version 1.3 adds locate, which returns matching text spans, and an optional web-grounding mode billed per search. The API now offers a 27B model and a 4B “flash” model. Requests that still name the v1.1 model are served by v1.2.

Perplexity publishes the weights for v1.3 and flash v1.3 under Apache 2.0. The 27B model is a substantial local deployment at roughly 49 GiB of weights; the 4B model needs about 8.5 GiB before working memory. A quantized build of the earlier flash model runs on Apple silicon through Perplexity’s Decider for Mac application.

Inception Mercury Decide

Inception’s documentation site refused our requests during this update, so this profile rests on archived copies of its pages dated October 18 to 29, 2026. Confirm the details against the live documentation before relying on them.

According to those copies, requests go to /v1/decisions with the model mercury-decide, shared state, and a map of named questions, and the response returns typed answers with probabilities under the same names. The endpoint accepts up to 16 base64 images per request. A fourth question type, extract, returns exact substrings with character offsets. Chat completions, streaming, and tool calling are not available on this endpoint.

Upstage Solar Decide

Solar Decide is Upstage’s beta decision endpoint on Solar Mini 4. It exposes choice, yes/no, and score outputs and documents a 512K context window, the largest in this review.

The System One API reference accepts a string or JSON state and questions keyed by name. The advertised window is an input allowance; it does not, by itself, demonstrate that a decision remains accurate when the relevant paragraph is buried near the end. Upstage still marks the endpoint as beta and warns that the schema may change before general availability.

Fastino: GLiDE and GLiNER2.5-Decide

GLiDE changed the most among the services we covered in October. The hosted model now accepts up to four images and prompts of up to 65,536 tokens, and Fastino released open weights in five sizes on November 5. The hosted service runs the 27B model, which is also the only size that takes images.

GLiNER2.5-Decide remains a compact English text classifier with Apache 2.0 weights. Its classification contract supports caller-defined labels, multiple classification tasks, and multi-label results. Its labels do not automatically become an ordered score rubric, and its tasks are evaluated independently.

The two products now differ in license as well as in contract. GLiNER2.5-Decide is Apache 2.0; the GLiDE weights carry the revenue condition described above.

Fireworks Rune and Baseten

Rune has been available on Fireworks’ serverless platform since October 27. It is text-only, and a request containing images is rejected. It answers on two routes, one in Jev’s shape and one in OpenAI’s, so a team with a client for either can test it with fewer changes.

Baseten’s joey-1, elephant-1, and mammoth-1 are 2B, 9B, and 27B models that accept text and images through a Jev-style endpoint. Each has a 16,384-token context, which rules out long documents. Baseten also publishes the weights under the MIT license, for example elephant-1. We have not reviewed their local runtime requirements, so they are absent from the local tables.

Respan span-02

In October this article described Respan’s span-01 as a narrow tool for scoring agent traces. Those documentation pages now redirect to span-02, which Respan launched on October 19 as a general decision model. It accepts text, JSON, and up to four images, and returns choices, yes/no probabilities, scores, and numbers.

The three-outcome trace verdict we described, with “not observable” as a separate answer, no longer appears in Respan’s documentation. Respan’s platform still scores agent behaviors with span-02, and its review screen records a behavior as having happened or not.

The open weights are Apache 2.0, with a constraint: they run only on NVIDIA’s Blackwell-generation GPUs through Respan’s bundled engine, and the card says they do not load in Transformers or vLLM.

Bespoke Nimble

Bespoke now runs Nimble as a hosted API. The service launched on October 13 and has defaulted to nimble-v4.1-max since November 5. It accepts text or JSON state and up to 64 named questions.

The open releases have split by license. The 9B v2 adapter that we covered in October is still Apache 2.0. It is an adapter, a small set of additional weights, so deploying it requires the specified base model as well. The newer 27B weights and the 9B v3 adapter are non-commercial. The repository remains useful for its training and scoring code, whichever model a team runs.

Levanto Sage2

Levanto’s Jev-compatible endpoint, /v1/systemone, takes shared state and named yes/no, choice, or score questions. It returns an answer for each question, so your application sets the confidence threshold for sending a case to a human. Sage2’s native endpoint, /decide, also supports sorting and tagging, and accepts images in beta. When the model is unsure, a native yes/no answer, a choice, or an individual tag decision can be null.

Databricks and Alibaba

Two platform vendors offer the contract inside their own products. Databricks’ ai_decide is a beta SQL function that returns a probability, a choice, or a score for each row. Databricks does not name the underlying model and says it may change, which matters for anyone who needs stable thresholds.

Alibaba’s decision-model-preview names TypeSafe’s protocol as its own and works with TypeSafe’s SDK through a different base URL. It is limited to 16 questions per request, runs in the Singapore and Beijing regions, and is free during the preview.

Gateways

A gateway can reduce the work of trying several providers. OpenRouter, Vercel AI Gateway, Portkey, and LiteLLM each document a decisions route. LiteLLM translates between OpenAI’s shape and Jev’s. A gateway unifies the request; it does not make two models’ probabilities mean the same thing, and the modalities a route exposes can be narrower than the provider’s own API.

Open-source and local alternatives

Several models above also ship open weights: Clef, Liquid’s d1 checkpoints, pplx-decider, GLiDE, span-02, and the Baseten models. The projects below are local-first.

H2O-Lightning-4B

H2O-Lightning-4B is an Apache-licensed model built on Qwen3.5-4B, with text and image decision support. The current card describes version 1.4.2, with 9.3 GB of weights measured on a 48 GB GPU, and a box question type alongside the original three.

The serving path now has three variants. H2O recommends its own build of vLLM. Stock vLLM works in a reduced reading mode that scores lower in H2O’s own table. An official GGUF release runs on llama.cpp, with files from 1.9 to 8.4 GB. The published shim, a translation layer in front of the serving engine, is still required for the full contract: llama.cpp’s own decision endpoint has no box type.

Kev

Kev is a family of local decision models with a Jev-style API, pretrained releases, and a fine-tuning workflow. The project provides 0.8B, 4B, 9B, and 27B variants, with serving support for CUDA and for Apple Silicon through MLX.

That range is useful when the deployment constraint is concrete: a small local service, a Mac-based application, or a larger GPU installation. The Kev-4B model card distinguishes contexts the runtime accepts from contexts for which the authors validated accuracy.

The project has been quiet since its 1.0 release: the main branch has had no commits since October 22. An open issue, which the project’s own triage rates as medium, reports that the MLX loader can run Python code named in a checkpoint’s configuration file. It applies when loading a checkpoint from a third party on a Mac, and the proposed fixes were unmerged when we checked. Kev is an independently trained implementation, and API resemblance does not make it the original Jev model.

Laya

Laya takes a smaller text-model approach, with English, multilingual, and typed-decision checkpoints and a router that selects between them. It is the most actively developed project in this group, with a release the day before this update.

The project now leads with a different path. Since version 0.4.23, Agent(vegaml=True) uses a 0.8B reader that takes about 73,000 tokens of context and accepts images, speech, and video, at a higher latency per decision in the author’s own comparison. The original checkpoints remain available. Their limits are short: the English checkpoint defaults to 512 tokens and the other two to 1,024. The multilingual model accepts max_len=8192, and the README reports uneven results beyond roughly 4,000 tokens.

Strands Decider

Strands Decider provides code for training, evaluating, and serving small models, plus public checkpoints such as the Qwen3.5-based 2B release. It belongs to Strands Labs, the community’s experimental arm, and that status is part of its deployment context.

Installation is simpler than in October. The PyPI package now includes the MLX extra for Apple silicon, which needs Python 3.11 or later. The repository adds deployment guides for Amazon SageMaker and AWS Lambda. The Qwen 2B card still reports confident answers when an expected image is missing, a relevant failure case for a visual workflow.

Together Tev1

Together’s Tev1 has not changed since October and remains most useful as a training reference: the repository includes data preparation, training, and evaluation material. Its contract is narrower than Jev’s. The model card describes a state, a question, and 2–24 labelled options, and the model returns a letter that application code maps back to an answer. The card still says the license for the fine-tuned weights is being finalized.

Newer open families

Three Apache-licensed families appeared around or after our first review.

vLLM-SR d3 comes from the vLLM project’s semantic-router group. The 27B model accepts text, JSON, images, and video, and vLLM serves it through its built-in decision endpoint. The card reports verification on AMD GPUs as well as NVIDIA hardware. A 4.5B d3-mini is the practical starting point.

Valen-Decision 1.5 spans five sizes from 0.8B to 27B and adds bounding boxes to the three standard types. Its GGUF files target Valen’s own llama.cpp runtime, not the stock one, and the training data is not public.

AutoTrust offers 9B, 27B, and 35B models, and a quantized 35B build whose card asks for a 32 GB GPU. Three points affect an evaluation. The 9B card describes Jev 1.13 as the teacher model whose published outputs it was trained on. The endpoint is /v1/decide, not Jev’s. The 35B repository had no commits after mid-October when we checked.

Serving tools

The serving layer matured faster than the models. vLLM 0.32 added a /v1/systemone endpoint on October 18, and llama.cpp’s server and Ollama document the same route. Check which models each tool names before assuming support. vLLM’s endpoint is a generic read-out of label probabilities, and llama.cpp’s documentation lists Laya and H2O-Lightning but not Kev. Ollama’s documentation describes its confidence value as uncalibrated.

What public benchmarks say

Our October version cited no public comparison of decision models. Three boards now publish rankings. None is run by TypeSafe, each operator has interests of its own, and we have not reproduced any of their results. The figures below are as shown on each board on November 19, 2026.

Scroll horizontally to explore all columns →

Research data
BoardOperatorWhat it coversTop entryJev 1.14
Decision Index v2.1
Artificial Analysis, a benchmarking company with a paid tier
25 hosted decision models on six datasets
Liquid d1.2-ultra, 74.8
66.2, tenth of the 18 shown by default
JevBench v1.8, API board · updated November 11
Benchmark Heaven, a one-person project
54 hosted APIs; a separate board covers open weights
decide-1.1, by a composite of accuracy, calibration, speed, and cost
22nd of 54 by the same composite
Jev Decision Index v0.4.1
A Hugging Face community account
About 300 open-weight models
karpo-decision-31B and GLiDE 27B, within the board’s tie margin
60.2, a reference row recorded once in October

Three observations hold across the boards, and they are more useful than any single rank.

Jev does not lead any of them. It sits mid-table where it is ranked. That is evidence that alternatives are competitive on these test sets. It does not predict the order on your data. Size of the vendor is no guide either: on the Artificial Analysis board, OpenAI’s Decisions API scores 60.3, below Jev.

The boards name different leaders. They test different populations with different tasks: one covers hosted APIs on document and knowledge questions, another covers open reproductions of Jev. Baseten’s mammoth-1 is fifth on one board’s default view and outside the top fifteen on another. Scores cannot be compared across boards or across versions of one board, and the boards are not equally current. JevBench’s API board predates Microsoft-Decision-1.1 and Liquid d1.2.

All three measure calibration, each differently. Calibration asks whether a stated probability matches how often the answer is right. Artificial Analysis folds a calibration measure into its headline number, JevBench reports a separate calibration axis, and the Jev Decision Index shows calibration error without counting it. A model’s rank can change depending on whether a board rewards being right or being right about its own uncertainty.

Each board has limits. Large parts of the test sets are private and cannot be audited. On one Artificial Analysis dataset the reference answers are the consensus of two language models, with no human ground truth. The Jev Decision Index notes that several entries were trained on the public portions of its benchmarks. JevBench’s page says the same company runs a service that hosts some of the listed models.

One result deserves attention before a migration. On the Artificial Analysis board, general chat models run at maximum reasoning effort score above every decision model. The board lists GPT-6 Luna in that chat mode at about ten times Jev’s cost per task, with a response time above eleven seconds against 92 milliseconds for Jev. The trade is speed and price against accuracy, and the right point on it depends on the workflow.

What to compare before switching

Start with the decisions, not the model names. Take a labelled sample from one workflow, including ambiguous inputs and cases with missing evidence. Use development cases to choose prompts, checkpoints, and thresholds. Reserve a separate holdout for the final error-and-coverage comparison. This is our suggested evaluation design, not a benchmark result.

Measure four things together:

  1. Wrong automatic decisions. Count errors among the cases the system actually acts on. A high overall accuracy can conceal a costly failure category.
  2. Coverage at the chosen threshold. Record how much work the model completes and how much it sends to a person or another model. Compare candidates at a similar error tolerance.
  3. End-to-end latency. Include networking, image preparation, queueing, retries, and fallback calls. Report tail latency as well as the median.
  4. Cost per completed workflow. Include repeated context, multiple questions, internal passes where applicable, and the cost of running local hardware.

Then check the contract. What happens if none of the options fits? Are questions independent? Does an ordered score return a level, an expected value, or both? Does an oversized input fail or get truncated? The answers can change application behavior even when two providers accept similarly named fields.

What an adapter has to translate

The same routing question, as each vendor’s documentation writes it, shows the size of the change. In Jev’s request, options are a map and the question’s key identifies the answer:

JSON
{
  "model": "jev-1.14.0",
  "state": "My running shoes arrived in the wrong size.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Which team should handle this?",
      "criteria": {
        "returns": "Exchanges, wrong or damaged items",
        "billing": "Charges, invoices, payment problems"
      }
    }
  }
}

In OpenAI’s request, questions are an array, the key becomes a name field, and options are a list of values with descriptions:

JSON
{
  "model": "gpt-6-luna",
  "input": "My running shoes arrived in the wrong size.",
  "questions": [
    {
      "type": "choice",
      "name": "department",
      "instructions": "Which team should handle this?",
      "choices": [
        {"value": "returns", "description": "Exchanges, wrong or damaged items"},
        {"value": "billing", "description": "Charges, invoices, payment problems"}
      ]
    }
  ]
}

The response differs in the same way: Jev returns answers as a map under your keys, and OpenAI returns an array in question order. Jev’s yes/no type is called noul and OpenAI’s is predicate; both return a probability. An adapter also has to decide what a per-question refusal means for the workflow. These are illustrations assembled from the two vendors’ documentation; we have not executed them.

Questions about switching

Is there an OpenAI alternative to Jev?

Yes. The OpenAI Decisions API answers the same three question types and has been generally available since October 22, 2026. It lists a higher input price than Jev and uses a different request shape, so a client needs an adapter. Google and Microsoft offer comparable endpoints. We found no decision endpoint in Anthropic’s, Amazon Bedrock’s, or Mistral’s documentation as of November 19, 2026.

Which Jev alternatives are open source?

Apache 2.0 weights are available for Cloudflare’s Clef family, Perplexity’s pplx-decider, Respan span-02, H2O-Lightning-4B, Kev, Laya, Strands Decider, GLiNER2.5-Decide, vLLM-SR d3, Valen-Decision, and AutoTrust. Baseten’s models use the MIT license. Liquid’s d1 checkpoints and Fastino’s GLiDE weights are downloadable but carry a revenue condition, and Bespoke’s newest weights are non-commercial. Jev itself has no public weights.

Is there a free Jev alternative?

Running Apache- or MIT-licensed weights on hardware you already own avoids a per-call fee, though not the cost of the hardware. Among hosted services, Google lists a free tier for Gemini Decision 1 and Alibaba’s preview is free for a limited time. Both carry limits, and a preview price can change.

Can I switch by changing the API URL?

Rarely. Alibaba’s preview, Fireworks Rune, and Levanto Sage2 accept Jev’s request shape, and several other services use the same state-and-named-questions pattern. OpenAI uses input and an array of questions; Tev1 uses Chat Completions with labelled choices. Even similar request fields can produce different response shapes or confidence values, so the adapter is part of the migration.

Which alternatives can run locally?

Every model in the local tables has public artifacts and inference instructions. The smallest practical options are Laya, GLiNER2.5-Decide, Liquid’s d1-omni-600M and d1-2B, and the small GLiDE and Kev sizes. H2O-Lightning-4B and Liquid’s 2B models have official GGUF builds for llama.cpp. Start with the specific checkpoint and runtime, not a family name.

Is a structured-output LLM also an alternative?

For some workflows, yes. A generative model with Structured Outputs can be a better fit when the same call must extract a more complex object or produce an explanation. Schema conformance still does not establish that the values are correct. Keep the existing implementation in the evaluation as a baseline.

Should confidence thresholds carry over from Jev?

Re-evaluate them. GLiDE documents choice confidence as the gap between the two leading probabilities. An application that interprets every field named confidence as the probability of being correct would already be making the wrong assumption. Select thresholds against labelled cases and the consequences of a wrong decision.

Keep the current workflow as the baseline and compare it with one candidate that meets the actual requirements. Add a local model if data control, offline operation, or available hardware makes local serving relevant. Staying with the current implementation is also a valid result.

← Back to blog