Alternatives to Jev

Jev went into early access on September 15. Four weeks later I count more than twenty models that answer the same kind of question: some you download, some you call, a few you can do both with. Many of them ship a table where they beat Jev.

That last part is the problem. When a market fills this fast, the comparisons come from the people selling the models, and the property that makes a decision model worth using, probabilities you can trust, is the one nobody has measured independently. So the question for this post: if you want what Jev does without Jev, what are your real options, and what do you actually know about them?

I've run one of them in production for a few weeks, Laya, so some of this is measured. Most of it isn't, and I'll say which is which. Every fact below comes from the project's own repo, model card, docs or pricing page; anything a vendor claims about itself is marked as theirs.

What you are replacing

Jev is TypeSafe's System One model: you send a state (text or JSON) and a set of typed questions, and get back typed answers with probabilities. The three types are a choice from a list, a score on an ordered scale, and a noul, a yes or no returned as the probability of yes. There's no generated text to parse.

The facts from TypeSafe's docs: the stable model is jev-1.13.0, a jev-1.14.0 preview has been available since October 14, input costs $0.042 per million tokens and output is free, and a request takes 64k tokens of context. It is API only, in early access, and TypeSafe publishes no benchmarks of its own; its "70 ms to 500 ms" and "193.6x faster" figures are measurements from its own evals.

That contract, POST /v1/systemone with those three question types, matters more than the model behind it. Several alternatives speak it exactly, so switching is a base URL.

Three ways to build one

The alternatives fall into three families, and the family tells you more about cost and hardware than any benchmark does.

• Small encoders read the state with each option and score it, like Laya does. They run on a CPU and fit in a couple of gigabytes; the catch, in my experience, is zero-shot accuracy and every option being another pass.
• LLMs with a decision head start from an open LLM (Qwen and Gemma, mostly) and train it to output decisions. They're bigger and better at hard questions, and they want a GPU.
• Logit readers don't train anything: they prompt an LLM you already run and read the probabilities of the answer tokens. Cheap to try, but raw logits aren't calibrated; SemIf fits a temperature per workload on labelled data for exactly that reason.

The ones you can run yourself

Two things the table makes easy to miss. "Open" mostly means open weights: Clef's training data isn't published, and Bespoke Nimble's repo doesn't state a license at all, so check before you ship it. And size decides where it runs before anything else does: by The Register's figures, Clef-flash needs 41 GB of GPU memory and Clef 85 GB, while Laya runs in about 2 GB on the four-core VPS this site lives on.

The ones you call

Prices are from the vendors' own pages on October 15, and Mercury's is a launch discount. Read "same schema, other path" as an afternoon of work, not a URL change. Perplexity, Liquid and Cloudflare also publish their weights, so you can move off their API later; Jev, OpenAI and Microsoft don't.

What has actually been measured

This is the section that changes how much the tables above are worth.

Most comparisons are run by the model's maker, against Jev called through its API, on a benchmark the maker chose. Some are more careful than others: Laya's README has a section on where Jev wins (Banking77, 0.870 against 0.425), Kev says its numbers aren't a controlled comparison, and jevos's own table puts Jev ahead on all six tasks. Cloudflare reports Jev at a 524 ms median against Clef-flash's 39 ms without naming the hardware.

The one independent comparison I found is AIMultiple's, updated October 13: 50 decision models on 1,655 classification questions, each answered once. Jev 1.13 averaged 47.9 on the two main tasks and Clef 51.0. On 50 browser tasks, Jev finished 17, against 40 for Kev-27B and 42 and 47 for the two general LLMs they used as references. The authors list their own caveats: one attempt per item, a step format built for Jev, and models that may have seen the test items in training.

And then the gap: nobody has published an independent measurement of calibration. AIMultiple says plainly that it didn't test whether the probabilities match the accuracy. Neither of the two arXiv papers on these models (crash narratives, penetration testing) compares Jev with the open alternatives. The whole point of a decision model is a 0.8 that means 80%, and for now every claim about that comes from the people selling it.

What one of them looks like in practice

The part I can speak to is Laya on a four-core VPS, which I wrote up in full. Measured on that server: about 0.3 seconds for a Spanish email and 0.7 for an English one, about 2 GB of memory with both checkpoints, and no difference in the answers after halving the memory with bf16. On English support emails it routed nine out of nine once each option had a short description of what it isn't; on Spanish ones, the multilingual checkpoint sent ordinary emails to the wrong team at 0.93 and 1.00 confidence.

That gap between a project's benchmark and your own emails is the thing to plan for, whichever model you pick.

How I'd choose

• You already use Jev and want out: Kev or decider if you have a GPU, Von if you don't. All three accept TypeSafe's SDK by changing the base URL, so you can run both side by side on your own traffic first.
• No GPU, data stays on your machine: a small encoder, Laya or Von. Expect to describe your options carefully and to fine-tune on a few hundred labelled examples before trusting it unattended; Laya's own README calls itself a base to specialise.
• You want hosted and cheap: pplx-decider and Liquid's d1 at $0.02, or Clef-flash at $0.038. Each has open weights, so you can move it in-house later.
• Compliance comes first: OpenAI's Decisions API lists zero data retention, HIPAA and EU data residency for eligible customers; Microsoft-Decision-1 lives inside Azure. Both are previews.
• You already serve an LLM: a logit reader like AnyJev or SemIf costs nothing to try, as long as you calibrate it on your own labels.

The honest limits

• This is a snapshot of one month. Versions change weekly; Nimble shipped v4 two days before I wrote this. Check the repo before trusting any number here.
• I haven't measured the others. The only one of these I've run is Laya. Everything else is what each project or vendor publishes, and I've only verified that they say it, not that it's true.
• Accuracy benchmarks don't transfer. A model that leads a classification suite can still misroute your emails, as Laya did with Spanish. Test on a few hundred of your own cases before choosing.
• Calibration is the open question. Until someone measures it independently, the safe assumption is that no model's 0.8 means 80% on your data until you've checked it on your data.

Jev made decision models a category; the alternatives made it a market in four weeks, faster than anyone could test them. The trade today isn't Jev against the rest. It's paying for one closed model's unpublished numbers or running an open one and producing the numbers yourself, and the second option is the only one that tells you whether its confidence is any good.