Jev vs Laya: pay per call or run it yourself?

Jev is a hosted service you pay for by the token. Laya is software you download, run on your own machine and look after yourself. Both answer the same kinds of question about some text and return a typed answer with a probability, and neither writes text.

Laya is a decision model from Convai Innovations, a company in Kerala, India. The GitHub project belongs to Nandakishor, whose profile lists him as the company's chief executive. It is a small encoder model, not a text generator. It reads your text and your question and returns a Choice, a Score or a yes/no (Noul) answer in a single pass, with a confidence value. The project comes as three versions: one for English, one multilingual, and one fine-tuned for typed-decision workflows, plus a router that picks a version for each request.

The GitHub project was created on 18 September 2026, three days after Jev launched, and shows 33,022 stars and 2,968 forks on 15 October. Its server answers at the same address and in the same format as TypeSafe's API, so an application written for Jev can usually be pointed at it. The maker lists differences: Laya's confidence is computed differently, so thresholds tuned for Jev do not carry over, and every score level needs a written description.

• What is Jev?

Nobody has shown this yet. The only side-by-side comparisons are on Laya's own page and in write-ups that repeat it, and they use Jev figures taken from other people's tests rather than their own runs of Jev. A write-up by Zylver, which uses Laya, says outright that it did not test Jev's API. Jev's figure for that main benchmark (0.727) could not be traced to a public test page at the time of writing.

With that said, here is what Laya's page reports, with Jev's numbers as it gives them:

• Typed-decisions benchmark (2,000 decisions across four business workflows): Laya's fine-tuned version 0.766, Jev 0.727. Laya's fine-tuned version was trained on that benchmark's training split, and its untuned versions score about 0.36, below the 0.461 you would get by always picking the most common answer.
• AG News (4 labels): Laya 0.950, Jev 0.910.
• DAIR Emotion (6 labels): Laya about 0.60, Jev 0.480. The test that produced Jev's figure also found it gave the right answer zero probability on 16% of examples.
• Banking questions with 77 labels: Jev 0.870, Laya 0.425 at its default settings. The maker puts this down to a fixed token budget shared between the options.

Jev's banking scores vary between tests: 87.0% on 72 labels in one 300-example pilot, 79.2% on the full 77-label test set in another, and 78.8% in a third. That spread is a reminder that the 0.870 figure above is one run on a small sample.

• Jev benchmarks: what do independent tests say?

Laya reports 32.8 ms for one question on a T4 graphics card, and 72.3 ms for ten questions in a batch. That is a model running on your own hardware with no network trip. TypeSafe describes Jev as 70 to 500 ms per request, and four independent tests measured between about 0.1 and 0.33 seconds, over the internet. A local model will usually beat a hosted one on delay for that reason, so the figures say more about where each runs than about the models.

Laya has no per-token fee. You pay for the machine: a graphics card, or a CPU for smaller loads, plus your own time to run and monitor it. Jev costs $0.042 per million input tokens with free output and no machine to run. At low volumes the paid API is usually simpler and cheaper; at very high steady volume, or when you already own spare hardware, running a model yourself can come out cheaper. The cost calculator shows the Jev side for your volume.

• Cost calculator

This is where the two differ most, going by what each side documents:

• Long input. Jev takes up to 64,000 tokens per request. Laya reads 512 tokens by default in English and up to 8,192 with the multilingual version, and its own chart shows accuracy falling on very long inputs.
• Many options. Laya shares a fixed token budget between the options and refuses more than 100 per question. Its page says Jev is better suited to 50 or more options without tuning.
• Languages. Laya's multilingual version covers 100+ languages, and the maker rates 48 of 51 tested languages as usable. TypeSafe says Jev works best in English and less reliably in other languages.
• Score questions. Zylver and innFactory both call Score questions Laya's weakest type.

Both give a confidence value, and both need checking. Laya's page says its shipped versions are over-confident until you fit calibration on your own data, and that its English version reported 0.952 confidence while scoring zero on Khmer. For Jev, independent tests found calibration errors from 0.011 to 0.108 depending on the task. Whichever you use, set the confidence threshold on a sample of your own labelled data.

Based on what each side documents:

• Choose Jev if you want an API that works from the first call without tuning, long inputs, many options, or no machines to run.
• Look at Laya if your data must stay on your own servers, you want to avoid per-token fees at high volume, or you have one narrow task you can tune it for, ideally with fewer than 50 options.
• Test before you commit. Laya's request format is compatible with Jev's, so you can send the same labelled sample to both and compare accuracy, time and cost.

Our read: Laya is a serious open option, and its fast start shows how many developers wanted one. But its strongest results need tuning, its comparisons use borrowed Jev numbers, and it is weaker exactly where Jev is strongest, on long inputs and large option lists. Until someone runs both on the same data, the safest conclusion is the one both sides' documents give: Jev is the easier choice, and Laya is the one to test if control or volume matters to you.

• Jev vs open models: Strands Decider and Cloudflare Clef
• How to use Jev