Verdict first: reach for Jev when you want a managed decision API today, self-host Laya when you need open weights and vendor-reported 33-millisecond latency on your own hardware, and distill single repetitive workflows such as form-filling into tiny specialists shaped like CUA-S1-FORMS. Everything below exists to defend that verdict: what a decision model is, a head-to-head grid in which every cell traces to a cited source, per-contender best-for notes, the honest limits, and answers to the questions readers actually ask. This comparison extends the pilot format from our local coding agents comparison and the story we first covered in the September 19 digest.
What Jev actually is
TypeSafe AI, founded by ex-OpenAI researcher Diogo Almeida, shipped Jev as a transformer that skips text generation entirely and returns calibrated probabilities over a fixed set of options for software automation; demand reportedly overwhelmed its API at launch (TechCrunch, September 18, 2026; Inputs Daily, September 20, 2026). The idea compresses to three decision primitives: choice over a bounded set of actions, score for each candidate, and a calibrated probability you can threshold, log, and test. When the action space is bounded — route this ticket, approve or escalate, fill these fields — scoring options beats sampling strings on cost, latency, and testability, because there is no prose to parse and no sampling temperature to tame. That is why the open-source response was immediate and viral: 36 million views in 48 hours, the fastest model adoption on record, and six community Jev clones in two days (AIStory, September 19, 2026). Demand context helps too: open-weight models carried 78.4 percent of token volume on September 19 versus 21.6 percent closed (RuntimeWire, September 20, 2026).
Head-to-head: Jev vs Laya vs CUA-S1-FORMS
The grid below summarizes the documented position of each system at the time of writing. Cells marked vendor-reported come from the vendor's own published tables; follow each link to the primary source before making a build decision, because shipping details move fast.
| Criterion | Jev (TypeSafe AI) | Laya (ConvAI Innovations) | CUA-S1-FORMS (Cua) |
|---|---|---|---|
| What it returns | Calibrated probabilities over fixed options, no text generation (TechCrunch) | Typed decisions with vendor-reported accuracy and calibration tables (vendor-reported via El Solitario) | Form-filling plans in one pass over predefined actions (RuntimeWire) |
| License | Proprietary managed API, closed weights (TechCrunch) | Apache 2.0 decision-model family (El Solitario) | MIT license with training code and dataset (RuntimeWire) |
| Size | Undisclosed; served API only (Inputs Daily) | 421M ModernBERT-large plus 322M multilingual checkpoints, vendor-reported (El Solitario) | 706,048 parameters in a 2.8 MB model (RuntimeWire) |
| Latency | Roughly 150 to 276ms per query in the vendor comparison table, vendor-reported (El Solitario) | 32.8ms per query, vendor-reported (El Solitario) | Single-pass plan over predefined actions, no per-call large-model round trips (RuntimeWire) |
| Cost | Metered API at $0.042 per million input tokens with zero output cost (El Solitario) | Free on self-hosted hardware under Apache 2.0 (El Solitario) | Free and self-hostable under MIT; 2.8 MB runs anywhere (RuntimeWire) |
| Self-hostable | No; API only, and launch demand reportedly overwhelmed it (TechCrunch) | Yes; downloadable weights for your own hardware (El Solitario) | Yes; tiny open weights with training code (RuntimeWire) |
| Accuracy signal | Calibrated probabilities; independent head-to-head numbers not published (TechCrunch) | 0.766 typed-decision accuracy, vendor-reported (El Solitario) | Single-workflow specialist; general decision accuracy not claimed (RuntimeWire) |
Jev: best for shipping this week on a managed API
Jev is the fastest path from idea to production when the decision set is fixed and you would rather pay per call than operate weights. The launch story matters here: developers overwhelmed the API on day one (TechCrunch), which signals real demand and a real dependency at once. Move routing, triage, and guardrail checks off generative models first: each is a bounded action space where a scored choice is cheaper, faster, and easier to test than a sampled paragraph. Keep the generative model for the open-ended steps — drafting the reply after the router chose its destination — and put the decision model in front as the gate. The trade is control for convenience: closed weights, metered pricing, and an API that can saturate, so budget a fallback and log every score for later audit.
Laya: best for local-first builders who self-host
Laya is the natural default for a reader of this journal: downloadable Apache 2.0 weights you can run on your own hardware, with vendor-reported latency near 33ms per query against roughly 150 to 276ms for Jev in the vendor's own comparison table (El Solitario, vendor-reported). The family ships two checkpoints — a 421M ModernBERT-large build and a 322M multilingual one — so teams outside English-first locales get a first-class option rather than an afterthought. The community reception backs the interest: the release thread drew 303 points and 54 comments (Hacker News discussion). If you already follow the open weights versus open source distinction, Laya sits on the right side of it: weights you can download plus a licence that permits self-hosting. Treat the vendor's accuracy and calibration tables as vendor-reported until independent reproductions land, pin the checkpoint you evaluated, and re-run the head-to-head on your own traffic before promising latency numbers to anyone.
CUA-S1-FORMS: best as a template for tiny specialists
CUA-S1-FORMS answers a narrower question and is more useful for it: what happens when one repetitive bounded workflow gets its own distilled model. At 706,048 parameters and 2.8 MB under MIT, with training code and dataset included, it plans form-filling in one pass over predefined actions instead of repeatedly calling a large model (RuntimeWire). Copy the pattern, not just the weights: pick your own highest-volume bounded workflow, collect the demonstrations, distill the specialist, and keep the big model out of the loop. The economics compound exactly like quantization does — a smaller artifact that fits cheaper hardware and answers faster — except the savings come from task narrowness rather than precision reduction. Best for: form-filling, field extraction, and any single workflow where the action set is fixed and the volume justifies one training run.
Honest limits
Three limits keep this comparison honest. First, the strongest numbers for Laya — 32.8ms latency, 0.766 typed-decision accuracy, and the head-to-head tables — are vendor-reported, published by the vendor and not yet independently reproduced; treat them as a claim to verify, not a result to quote (El Solitario). Second, discriminative decision models need predefined schemas: they score the options you declare and cannot invent a new action at runtime, so open-ended work still belongs to generative models — the same split behind retrieval grounding and watching for hallucination in sampled text. Third, Jev's closed weights mean the cheapest per-call option is also the least inspectable: no download, no local run, and pricing that moves with someone else's meter. None of these limits kills the category; each tells you which contender to distrust in which way.
How we compared
Scope honesty: we compared published documentation and reporting, not models on our own hardware. No synthetic benchmark scores, no invented win rates, no leaderboard. Every table cell links the source it came from, vendor-reported figures are labeled as such, and anything numeric describes a cited claim, not our measurement.
Our method follows the comparison pilot: verdict first, then evidence, then method, then questions. We read the launch reporting for Jev (TechCrunch; Inputs Daily), the viral-response analysis (AIStory), the Laya release tables (El Solitario) and discussion (Hacker News), the CUA-S1-FORMS release note (RuntimeWire), and the demand context (RuntimeWire). Readers should reproduce the comparison rather than trust our adjectives: each linked source contains enough detail to re-check every row of the grid in an afternoon.
Questions and answers
When should scoring beat sampling?
Whenever the action space is bounded and known in advance: routing, triage, approvals, guardrails, form-filling. Scoring gives you calibrated probabilities over fixed options that you can threshold, log, and regression-test; sampling gives you prose you must parse. Keep the generative model for steps where the output space is genuinely open.
Which open alternative to Jev should I try first?
Laya if you need a general decision model on your own hardware under Apache 2.0, with the caveat that its best numbers are vendor-reported. CUA-S1-FORMS if your workload is one repetitive workflow worth distilling into a 2.8 MB specialist. Both are free to self-host; Jev is the only metered API of the three.
Can I run a decision model entirely on my own hardware?
Yes with either open option: Laya's checkpoints download under Apache 2.0 and CUA-S1-FORMS is a 2.8 MB MIT artifact with training code. Size your hardware first with the quantization guide and confirm the licence permits your use with the open-weights explainer. Jev is API-only and cannot run locally.
What should I distrust in this space right now?
Unreproduced vendor tables and viral provenance chatter. Laya's latency and accuracy figures come from the vendor's own published comparison — useful directionally, not citable as fact until someone independent reruns them. The same discipline applies to every release: licence file, model card, downloadable weights, reproducible numbers, in that order.
Where do I go next on this site?
Draw the licence line with open weights versus open source, size your card with the quantization guide, revisit the format pilot in the coding-agents comparison, then catch the wider context in the September 19 digest where Jev and the forms model first appeared side by side.