Best Jev Alternatives: Hosted APIs and Open Models (2026)

Jev had competitors before it was even a month old. TypeSafe launched it on September 15, and by the first week of October OpenAI had announced a Decisions API, Cloudflare and AWS had shipped open-weight decision models, and GitHub had a shelf of open-source Jev alternatives: Laya, OpenJev, Kev, AnyJev. We ran Jev and the alternatives you can actually reach today on the same decisions.

The Jev alternatives sort into three routes: a hosted decision API, an open model you run yourself, or the LLM endpoint your product already calls, told to answer only from a fixed list. That third route is where DeepInfra fits, and most teams can try it this afternoon. It isn’t the fastest route. Jev answered in 245 ms at the median, against 568 ms for DeepSeek-V4.1-Flash on DeepInfra at the same 96.5% accuracy, and a 2B model on a laptop beat both.

What a Jev alternative has to replace

Jev is a decision model. You send it a state (text or JSON) and a set of named questions, and it sends back numbers: which option fits, where the text sits on a scale, or how likely a yes/no statement is. It never writes prose, so it can’t return an option you didn’t give it. Our TypeSafe Jev review tested it on five small jobs.

Any alternative has to match four things, and Jev sets the bar on each:

Speed and price are where Jev is hardest to beat: the review’s five jobs used about 11,500 input tokens, and the $5 trial balance never moved. But confidence is where alternatives differ most. A probability only helps if 0.9 means right about nine times in ten. That’s calibration, measured below as expected calibration error (ECE), the average gap between stated confidence and actual accuracy. AI model calibration, the benchmark nobody optimizes covers what that gap does once a threshold in your code depends on it.

Route 1: hosted Jev alternatives

A hosted API keeps Jev’s best property: there’s nothing to run. What changes is who you depend on.

OpenAI Decisions API. OpenAI announced it at DevDay on September 29 and opened it as a public beta on October 6. It runs on GPT-6 Luna and reads both text and images; images are the one input Jev can’t read. A choice answer comes back in Jev’s shape, a probability per option plus a confidence field. Input costs $0.10 per 1M tokens with output free, a bit more than twice Jev’s rate. It wasn’t part of this round of tests.

Cloudflare Clef and Clef-flash. Cloudflare released both on October 1 as open weights under Apache 2.0, and hosts them on Workers AI at $0.24 and $0.09 per 1M input tokens. That’s two to six times Jev’s price, but you can take the weights elsewhere if the hosting terms stop suiting you, and Clef reads images and video. Cloudflare’s launch post puts Clef at 94.2 macro-F1 on BANKING77 against Jev’s 79.7. Those are the vendor’s numbers; Clef’s hosted copy didn’t run in our lanes either.

The trade with either one is the same as with Jev: a decision-specific API from one company, priced separately from the LLM you already pay for.

Route 2: open-source Jev alternatives you run yourself

The open-source Jev alternatives fall into three families, and the family decides what each one costs to run.

Small encoders. Laya is a 322M to 421M ModernBERT-class model with a decision head, light enough for a CPU. Its README shows where encoders run out: against Jev’s third-party published numbers, it wins 4-way AG News (0.950 to 0.910) and drops to 0.425 against 0.870 on BANKING77’s 70-plus labels.

Fine-tuned Qwen with a pointer head. Strands Decider 2B, OpenJev, and Kev swap a small Qwen model’s text head for a classifier head, so one forward pass returns a probability per option. Kev 1.0 ships 0.8B to 27B, and its README puts Kev-27B at 0.851 against Jev’s 0.857 on the same development set. AWS published Strands Decider 2B’s weights, training data, and recipe.

Training-free logit readers. SemIf and Nokia’s AnyJev read a stock open model’s next-token probabilities over the option labels, with nothing to train. AnyJev also rotates option order to cancel position bias, which on Qwen3-8B lifted 20-way BANKING77 accuracy from 0.747 to 0.803 and cut ECE from 0.240 to 0.184.

Four of the six speak Jev’s /v1/systemone wire format, so moving the review’s helper to a local model is a change of URL:

import os, requests

def ask(state, questions, url="https://api.typesafe.ai/v1/systemone", key=None, model="jev-1.13.0"):
    headers = {"Authorization": f"Bearer {key}"} if key else {}
    r = requests.post(url, headers=headers, timeout=30,
                      json={"model": model, "state": state, "questions": questions})
    r.raise_for_status()
    return r.json()["answers"]

QUEUE = {"queue": {"type": "choice", "instructions": "Which support queue should handle this ticket?",
          "criteria": {"billing": "Charges, invoices, refunds",
                       "shipping": "Delivery status, lost or late packages",
                       "technical": "Errors, setup problems, broken features"}}}

ticket = "I was charged twice for my March invoice."
hosted = ask(ticket, QUEUE, key=os.environ["TYPESAFE_API_KEY"])
# Strands Decider 2B on the same laptop: strands-decider serve <checkpoint> --port 8000
local = ask(ticket, QUEUE, url="http://127.0.0.1:8000/v1/systemone")
copy

AWS’s docs say the Strands server’s compatibility with Jev’s API isn’t verified. In our run it took the same request unchanged, through the same ask() helper with only the URL swapped.

Route 3: Jev-style decisions on DeepInfra with structured outputs

Most teams reading about Jev already pay for an LLM endpoint. Can that endpoint make the decisions too? If it serves open models, yes, once you take away the model’s freedom to write. DeepInfra supports the OpenAI-compatible structured outputs json_schema mode, and a schema whose only field is an enum of your option ids leaves the decoder one thing to do: pick from the list. There’s no free text to parse, and you get the same guarantee Jev sells, that the answer is always one of your options.

import json, math, os
from openai import OpenAI

client = OpenAI(api_key=os.environ["DEEPINFRA_API_TOKEN"],
                base_url="https://api.deepinfra.com/v1/openai")

def decide(state, question, options, model="Qwen/Qwen3.5-9B", priority=False):
    listing = "\n".join(f"- {k}: {v}" for k, v in options.items())
    r = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": "You make one decision about the text. Pick exactly one of the listed options."},
                  {"role": "user", "content": f"Text:\n{state}\n\nQuestion: {question}\n\nOptions:\n{listing}"}],
        response_format={"type": "json_schema", "json_schema": {"name": "decision", "strict": True, "schema": {
            "type": "object", "properties": {"decision": {"type": "string", "enum": list(options)}},
            "required": ["decision"], "additionalProperties": False}}},
        temperature=0, max_tokens=20, logprobs=True,
        extra_body={"reasoning_effort": "none", "chat_template_kwargs": {"enable_thinking": False}},
        **({"service_tier": "priority"} if priority else {}),
    )
    choice = json.loads(r.choices[0].message.content)["decision"]
    conf = next((math.exp(t.logprob) for t in r.choices[0].logprobs.content
                 if t.token.strip(' "') and choice.startswith(t.token.strip(' "'))), None)
    return choice, conf
copy

A few settings carry the weight. temperature=0 makes the pick repeatable. Qwen3.5-9B is a hybrid reasoning model, so thinking has to be off, or you pay for a paragraph of reasoning to get one word back. logprobs=True returns the log probability of each generated token, and the first token of the chosen value is the closest thing this route has to a confidence score. It’s the probability of the pick only, not of every option. Small schemas like this one are also the ones that fail least, as reliable JSON-only responses explains.

The cost is different from Jev’s. Jev bills input only. Here the option list rides along in the prompt, and the output is about seven tokens of JSON, so a decision costs roughly one short prompt plus a few output tokens at the model’s list price. Any model the catalog tags for structured output works, including gpt-oss-20b at $0.03 per 1M input tokens and Mistral Small 3.2 at $0.07.

When a job needs a probability for every option, as the review’s ticket-routing margin does, score the options directly. The completions endpoint with echo=True returns the log probability of every prompt token, so you append each option to the prompt and read how likely the model found it. This is SemIf’s method, rebuilt over DeepInfra’s API:

TMPL = "<|im_start|>user\n{u}<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"

def option_probs(prompt, options, model="Qwen/Qwen3.5-9B"):
    base = TMPL.format(u=prompt + "\n\nAnswer with the option name only.")
    scores = {}
    for o in options:  # one call per option; run them in parallel in production
        lp = client.completions.create(model=model, prompt=base + o, max_tokens=1,
                                       temperature=0, logprobs=1, echo=True).choices[0].logprobs
        scores[o] = sum(v for off, v in zip(lp.text_offset, lp.token_logprobs)
                        if len(base) <= off < len(base) + len(o))
    z = sum(math.exp(v) for v in scores.values())
    return {o: math.exp(v) / z for o, v in scores.items()}
copy

Echo costs one call per option and re-sends the prompt each time, so a long state with many options adds up fast. In the bake-off below it cost almost three times as much per decision as the enum lane on the same model. The two readouts hand back different things, and that difference decides which jobs each one can serve:

Echo costs one call per option and re-sends the prompt each time, so a long state with many options adds up fast. In the bake-off below it cost almost three times as much per decision as the enum lane on the same model. The two readouts hand back different things, and that difference decides which jobs each one can serve:

Jev alternatives tested on one shared set

Every lane got the same 144 decisions from SemIf’s MIT-licensed authored144 set: three-way choices in three families, asking whether evidence supports a claim, whether a rule permits an action, and which candidate meets a requirement. SemIf’s own 4B model reports 0.813 balanced accuracy on it. Calls ran one at a time from a laptop on October 17, so latency is a full client round trip. Accuracy is exact match with the label, ECE uses ten confidence bins, and cost per 1,000 decisions comes from each response’s billed usage.

The lanes were Jev 1.13.0 on TypeSafe’s API; Qwen3.5-9B and DeepSeek-V4.1-Flash on DeepInfra with enum structured outputs; Qwen3.5-9B again on DeepInfra’s priority tier; Qwen3.5-9B with echo scoring; and Strands Decider 2B on an M1 Max MacBook Pro over MPS. DeepSeek-V4.1-Flash is in the set because it’s the model the review used to draft replies, the “endpoint you already call” case.

Jev and DeepSeek-V4.1-Flash tied on accuracy, 139 of 144 each, and Jev’s confidence was the best calibrated of any lane, with an ECE of 0.011 against DeepSeek’s 0.040. The enum lanes’ first-token confidence held up better than expected. On every DeepInfra lane, answers given at 0.85 or higher were right 99% of the time, so echo scoring earns its extra calls only when the readout has to cover every option instead of naming a winner. But Strands was the odd one. It matched echo on accuracy but undersold itself, averaging 0.80 confidence while it was right 94% of the time.

Strands on the laptop was fastest at 154 ms, with no network hop to pay for. Over the network, Jev answered in 245 ms and DeepSeek-V4.1-Flash in 568 ms, while Qwen3.5-9B, the smaller model, took about 1.2 seconds with or without priority.

Qwen3.5-9B with an enum schema was the cheapest hosted lane at $0.0126 per 1,000 decisions, about 20% under Jev. DeepSeek-V4.1-Flash cost $0.0173, and echo cost $0.0364 because it makes three calls per three-way decision. Put another way, a million decisions runs $13 to $36 on any hosted lane here.

One limit: every row is a three-option choice. The set doesn’t test score or noul, or the 70-plus-label routing.

When speed decides: a local decider in front of DeepInfra

If a gate sits on the request path, like the prompt-injection screen in front of an agent, a few hundred milliseconds matter. DeepInfra’s priority tier moves requests to the front of the scheduling queue for 1.5 times the standard price, and in our run it barely moved Qwen3.5-9B’s p50 (1,222 to 1,236 ms) while cutting its p95 from 2,578 to 1,822 ms. Priority trims the slow tail and leaves the typical call alone, and even the trimmed tail sits more than five times above Jev’s 341 ms. For a gate, the faster DeepInfra lever was the model: DeepSeek-V4.1-Flash’s p95 was 903 ms on the standard tier. Going the other way, decisions that can wait, like a nightly re-score of every open ticket, can run on the flex tier at 20% off.

The other answer is to stop sending every decision over the network. A 2B decision model on the app server answers the short, easy questions, and anything it’s unsure about, or anything too long for it, goes to DeepInfra. Strands Decider 2B reads 4,096 tokens by default, so long states are an automatic escalation:

def route_ticket(ticket):
    a = ask(ticket, QUEUE, url="http://127.0.0.1:8000/v1/systemone")["queue"]
    if max(a["probabilities"].values()) >= 0.85 and len(ticket) < 8000:
        return a["choice"], "local"
    q = QUEUE["queue"]
    choice, conf = decide(ticket, q["instructions"], q["criteria"],
                          model="deepseek-ai/DeepSeek-V4.1-Flash", priority=True)
    return choice, "deepinfra"
copy

This is the private lane from the review’s model router, pointed the other way. There, the local model kept sensitive prompts off the cloud. Here, it keeps the fast, confident decisions off the network and spends DeepInfra calls on the cases a 2B model is more likely to get wrong. The 0.85 threshold held up on the bake-off set. Strands put 71 of its 144 answers at or above it, and all 71 were right. Sending the other 73 to DeepSeek-V4.1-Flash scored 139 of 144 overall, Jev’s number, with half the decisions never leaving the machine. That’s one run on three-option questions, so recheck the cutoff on your own labels. The same two-model shape for agents is in why two-tier agents need two models.

Which Jev alternative to pick

• Go with Jev if you need a hosted p95 under 400 ms, your inputs are English text, and a closed API is acceptable. It also had the best-calibrated confidence in the bake-off, at a price within a fraction of a cent of the cheapest lane.
• Go with DeepInfra structured outputs if you already call an open model there. It’s the same key, the same SDK, and one more schema, at $0.013 to $0.017 per 1,000 decisions, and small open-weight models keep that price low as volume grows. Switch to echo scoring when the job needs a probability on every option.
• Go with Strands Decider 2B or OpenJev for gates on the request path, or for data that can’t leave the machine.
• Go with Laya if you need 100-plus languages from its multilingual checkpoint, or CPU-only hosting.
• Go with Kev if you prototyped against Jev and want the same wire format on your own GPU or Mac.
• Go with AnyJev or SemIf if you already self-host an open model on vLLM or llama.cpp and want per-option probabilities without training anything.
• Go with Clef on Workers AI or the OpenAI Decisions API if your decisions depend on images. Only Clef reads video.

FAQ

Is there a free Jev alternative?

Yes. All six open projects above are free under Apache 2.0 or MIT, and Strands Decider 2B, Laya, and OpenJev’s 1.7B model run on a laptop. You pay for hardware instead of tokens, though Jev is close to free at small volume anyway.

Can I use a regular LLM instead of Jev?

Yes, if you constrain its output. An enum schema makes any supported open model pick from a fixed list, and logprobs give a confidence for the pick. Expect more latency than a dedicated decision model (568 ms for DeepSeek-V4.1-Flash against Jev’s 245 ms in our test), and turn thinking off on hybrid reasoning models.

Does OpenAI’s Decisions API return probabilities?

Yes. OpenAI’s Decisions guide says a choice answer carries a probability for each option plus a separate confidence field. We haven’t measured how well calibrated those probabilities are, so check them against your own labeled examples before a threshold in your code depends on them.

Can a Jev alternative run on CPU only?

Yes, slowly. Strands Decider 2B runs on CPU at about 1.6 seconds per short input on an eight-thread Xeon in published tests, and 16 to 18 seconds at around 3,000 tokens. That suits batch jobs, not gates a user waits on.

Start with the decider you already have

Even the fastest decision model needs something to write the reply. If that something is an open model on DeepInfra, start there: Qwen3.5-9B on DeepInfra, an enum schema, and the DeepInfra docs. To try the model you already run, change the model string; the schema stays the same, and so does the guarantee that every answer comes from your list. Tell us what you route with it at feedback@deepinfra.com, on Discord, or on X.