Jev vs Laya: When Local Control Is Worth the Work
Jev is TypeSafe AI's hosted model for returning structured decisions from text. Laya is Convai Innovations' open-weight decision-model family, which you can run and adapt yourself. For Jev vs Laya, our recommendation is to evaluate Jev first for varied tasks without training, and Laya first when keeping inference inside your own environment is a requirement. TypeSafe overview, Laya project
The tradeoff becomes clearer once you ask who will maintain the classifier. A small team routing unfamiliar customer requests has different needs from a team with labeled examples and a stable set of categories.
Last updated September 23, 2026. Pricing and documentation checked on that date. This comparison synthesizes published evidence; we have not run these models ourselves. Recommendations are our interpretation of the sources, not production guarantees.
Choose by the work your team can take on
Start with Jev for a hosted prototype that needs to make several judgments about each incoming message. Start with Laya for offline operation or a narrow classification task you can train and maintain. Keep your current system as a baseline in either evaluation.
Both use named decision types: Choice selects an option, Score evaluates a rubric, and Noul estimates whether a statement is true. Our Jev structured decision model covers those interfaces. The useful question here is which implementation earns a place in your application.
For a support inbox, separate assigning a queue from issuing a refund. A routing error can usually be corrected; a payment changes the customer's account. Our guide to AI assistance versus AI decision-making explains why those actions need different acceptance criteria.
Which is more accurate without fine-tuning?
Jev is our preferred starting point for unfamiliar decision tasks, based on the available comparisons. Laya has credible wins on individual datasets, so a universal accuracy ranking would overstate the evidence. Check whether a result measures the base model, a specialized checkpoint, or a router selecting between models before using it to choose.
Harry Munro's September 21 benchmark reported 92.9% accuracy for Jev 1.13.0, 65.3% for Laya's base English checkpoint, and 71.1% for its typed-decisions checkpoint. It covered 3,386 judgments across 1,470 synthetic items. The dataset filtered ambiguous labels and did not target Jev's arithmetic or multi-hop weaknesses. Those conditions limit what the headline predicts about messy customer traffic. Munro's report
A separate September 21 run by instax-dutta gives a less uniform picture. Across 751 states, Jev led the curated triage and moderation suites. Laya scored 94% against Jev's 91% on 100 AG News examples, and 98.3% against 86.7% on 60 MNLI examples. These small task samples show why the application matters. They do not establish that either model wins on every classification problem. sysone-bench results
Laya's own benchmark page reports 76.6% against a published Jev reference of 72.7% on typed decisions. It also states that Jev was not measured in that run and that prompts and sample sizes differ. Treat that comparison as a lead for further testing. Laya benchmark methodology
The project's README adds the decisive qualification: the strong result comes from a checkpoint fine-tuned on that benchmark's training split. Its description is useful: "Laya is a fast base to specialise, not a zero-shot decision engine." Laya's stated limits
That makes training data part of the purchase decision. If your team has no agreed labels, first settle what a correct answer means. A model comparison cannot resolve conflicting queue policies.
Which is faster in an actual workflow?
Laya is attractive for one short local judgment. Jev can become faster when you ask many independent questions about the same input. Compare the complete request shape on your deployment hardware and network. A single-question timing does not tell you how quickly an application can evaluate a whole ticket.
The following measurements come from Munro's September 21 report. Laya ran through MLX on an Apple M3 Pro; Jev ran through its hosted API. These are warm-call measurements, excluding model loading.
| Measured workload | Jev 1.13.0 | Laya English 421M |
|---|---|---|
| One short question, median | 136 ms | 42 ms |
| 50 questions on one state, median | 170 ms | 1,002 ms |
Benchmark author Munro describes the hosted result as "your round trip plus about 80 ms." That observation belongs to this setup; it is not a service guarantee. Network analysis
TypeSafe recommends grouping independent questions in one request. Additional questions still consume input tokens. Choice documentation
For your evaluation, replay a ticket with every question the application needs. Include routing, any urgency check, and the review decision. Measure median and slow-tail latency from the actual server region. Also measure cold starts for local inference. A laptop demo with a loaded model leaves out work a newly started service must perform.
Which is cheaper once you count deployment?
Jev's published input price makes a hosted trial inexpensive. Laya removes the model vendor's per-call fee, but you still supply compute and maintenance. At modest volume, engineering time can outweigh token spend. Local inference becomes more compelling when you already have capacity or need control over where the data goes.
As of September 23, Jev 1.13 costs $0.042 per million input tokens, with free output. Consider an illustrative workload of 100,000 requests averaging 1,000 billed input tokens each, including questions. That is 100 million input tokens, or $4.20 in model charges. This calculation excludes retries and other application costs. Current model pricing
The comparison to make is your monthly operating cost at an acceptable error rate. Track paid compute, staff time spent labeling and investigating mistakes, and the review queue each model creates. A system that sends twice as many cases to people can cost more despite a lower inference bill.
Avoid buying hardware before measuring the workload. Run a representative sample on equipment you have, record memory use and elapsed time, and estimate sustained capacity from that. Treat a free notebook session as an experiment, not a production hosting plan.
Where does each model reach its limits?
Jev gives you more room for long inputs; Laya requires closer attention to checkpoint and token budgets. Neither should receive an entire customer history merely because it fits. Send the evidence needed for the decision, then test whether removing unrelated material changes errors. Our context windows guide explains why capacity alone is insufficient.
Jev documents two limits: 64,000 tokens across the request, and 32,000 for the state plus the longest question. It does not offer customer-specific fine-tuning. Jev model specifications
Laya's current README lists default contexts of 512 tokens for English and 1,024 for multilingual and typed-decisions checkpoints. Question text shares that budget. Large option lists also compete for space. Pin the checkpoint and runtime before testing; a result from an older port may not describe today's configuration. Laya context budgets
Jev's own limitations include unreliable counting, date comparisons, and sensitivity to adversarial text. TypeSafe's instruction is plain: "Keep the arithmetic in code." Jev 1.13 limitations
For local deployment, inspect the whole application path, including logging and any hosted fallback. Running Laya yourself gives you control over that path; the model license does not configure it for you.
Can you trust the confidence score?
Use confidence as something to validate against outcomes. Jev's Choice and Score confidence field summarizes the shape of the probability distribution; Noul returns a probability without a separate confidence field. A displayed confidence of 0.9 should not automatically become a claim of 90% correctness. TypeSafe confidence documentation
Set a review threshold using labeled examples that resemble deployment traffic. Then evaluate that threshold on a separate, untouched set. Report both the error rate among accepted decisions and the share of cases accepted. Otherwise, a model can appear reliable by declining almost everything.
A local-first cascade is worth testing after you have that baseline. In yibie/laya-jev-lab, a threshold sweep over 40 Chinese support tickets found one configuration that matched Jev's reported 78% accuracy while reducing mean latency from 588 to 327 ms. The authors warn about the small sample and show that higher thresholds did not produce steadily better accuracy. This supports an experiment, not copying their threshold into production. Cascade experiment
Cloud fallback also changes your data-handling design. If the reason for choosing Laya is that records must remain local, route uncertain cases to local review.
Run this test before committing
Use one queue you understand. Write down the mistakes that would make automation unacceptable before looking at either model's results.
- Assemble a labeled sample with ordinary messages, ambiguous requests, and missing information. Include the languages and input lengths your application receives.
- Reserve separate sets for prompt changes or training, threshold selection, and final evaluation. Keep the final set untouched until the configuration is fixed.
- Give both systems the same decision criteria for the baseline. Record model IDs, checkpoint revisions, runtime settings, and any input truncation. Compare a tuned Laya configuration separately and include the work required to produce it.
- Measure mistakes by category. An urgent request sent to the wrong queue deserves its own count even when overall accuracy looks strong.
- Compare review workload, complete-request latency, and monthly cost. Retain examples of confident mistakes for the next evaluation.
For a small team, start with the configuration that passes those checks with the least maintenance. If both fail, narrow the decision or keep a person responsible for it. Adding another model call is only useful if it fixes an observed failure.
Questions builders are asking
Can Jev still get things wrong?
Yes. TypeSafe's own FAQ raises this question, and its limitations document describes concrete failures. Selecting an allowed label guarantees the answer has an expected shape; it does not establish that the label is correct. Keep exact calculations and permission checks in application code. TypeSafe FAQ, Documented failures
Is Jev just a smaller LLM?
TypeSafe describes Jev as a model trained for structured judgments. It accepts natural-language input but does not write explanations or replies. For choosing between Jev and Laya, compare their behavior on the decisions you need. Neither replaces a generative model when the output must be a new paragraph. System One explanation
Can confidence be trusted to gate automation?
Only after validation for your decision and input distribution. This is one of the explicit research questions in the local cascade experiment. Test accepted-case errors alongside coverage, and repeat the evaluation when the model, questions, or customer traffic changes. Experiment and caveats
Does a local-first cascade help over calling the API?
It can, if the local model handles enough cases correctly to justify the added step. Cases escalated to Jev incur both stages, so measure the full path. Start with standalone baselines, then test whether a cascade improves your chosen accuracy, latency, or data-handling requirement. Cascade results