Jev vs Laya: $40M API vs 421M Open Weights — The Decision-Model Showdown
September 2026 gave us two System One decision models, not one. Jev (TypeSafe AI, San Francisco) is the closed hosted API that crashed servers with demand. Laya (Convai Innovations, India) is the Apache 2.0 open-weights answer — same Choice/Score/Noul primitives, downloadable checkpoints, pip install laya. Same questions, opposite philosophies. Full breakdown below.
What each model is
Jev — the hosted decision API
Launched 15 Sep 2026 by TypeSafe AI (Diogo Almeida, ex-OpenAI; $40M seed). Transformer-based, trained with RLCD on synthetic data. You call the API with state + typed questions; it returns decisions with calibrated confidence in 70–500ms. Closed weights, pay-per-call ($0.042/M input, output free), early access clearing fast.
Laya — the open decision weights
Released ~18 Sep 2026 by Convai Innovations (India, CEO Nandakishor M). ModernBERT-large encoder (395M) fully fine-tuned + a decision head trained from scratch (2 transformer layers, option-marker scorer, act/escalate head) — 421M total, Apache 2.0 on Hugging Face. Three checkpoints: laya (English, 512 ctx), laya-multilingual (322M, 1024 ctx, 100+ languages), laya-typed-decisions (fine-tuned specialist, 1024 ctx). Python package with a Router that picks checkpoints per request. ~33ms per question on a T4 GPU.
How each works: same primitives, different engines
Both speak the same language — Choice (pick one + probabilities), Score (ordinal level + distribution), Noul (yes/no probability) — evaluated in one parallel forward pass, no text generated, nothing to parse. The engines differ:
| Jev | Laya | |
|---|---|---|
| Architecture | Undisclosed transformer (suspected open-weight base) | ModernBERT-large + custom decision head, fully disclosed |
| Training | RLCD on synthetic data | RLCD + human-annotated data, TD(λ) for dialogues |
| Options mechanism | Undisclosed | Each option scored at its own [MASK] token, softmaxed |
| Context per question | Large (API-side) | 512 tokens (1024 on two checkpoints) |
| Where it runs | TypeSafe servers | Your GPU/CPU, offline capable |
Head-to-head table
| Jev | Laya | |
|---|---|---|
| Access | Hosted API, waitlist clearing | Hugging Face + pip install laya |
| License | Proprietary | Apache 2.0 |
| Multilingual | Undisclosed | 100+ languages checkpoint + Router |
| Zero-shot quality | Strong generalist (0.727) | Near chance — needs fine-tuning |
| Fine-tuned quality | N/A (can't fine-tune) | 0.766, beats Jev + teacher ceiling |
| Calibration | ECE 0.144 as shipped | Over-confident until you fit temperatures (→0.081) |
| Data privacy | State goes to TypeSafe | Never leaves your box |
| Limits | Rate limits, API dependence | 512–1024 ctx, ~20 options max per question |
Benchmark chart: typed-decisions (2,000 decisions)
Read it honestly: fine-tuned Laya beats Jev — but only after training on the benchmark's own split. Base Laya zero-shot is near chance. Jev's strength is working out of the box; Laya's is becoming better than Jev once specialised. Latency: Laya ~33–158ms self-hosted vs Jev ~710ms via API.
Cost chart
| 1M decisions/month | Jev API | Laya self-hosted |
|---|---|---|
| Unit cost | ~$0.042/M input, output free | $0 marginal |
| Monthly total | ~$40–400 | $100–500 GPU (T4-class, shared) |
| Fixed costs | None | GPU + ops + fine-tune time |
| Winner when… | Bursty load, no GPU team | Steady load, privacy needs, owned GPUs |
Yes, Laya runs on 1GB RAM — all the ways to run it local
This is Laya's killer feature Jev can never match: the 421M weights fit almost anywhere. Community ports cover every runtime:
| Runtime | RAM needed | Speed | Best for |
|---|---|---|---|
| MLX (Mac) — laya-mlx | <1GB | 7–14ms, 60–75 decisions/sec (Snake demo) | MacBooks, background agents |
| ONNX CPU — int8 quant | ~0.5GB | ~64–169ms on 4 CPUs | Any laptop, VPS, tight boxes |
| ONNX / CUDA — fp32 | ~1.7GB | ~33–38ms on T4 | Workstations, servers |
| C++ (ggml) | <1GB | CPU-native | Embedded, no-Python boxes |
| Node.js (ONNX) | ~1GB | CPU | JavaScript stacks |
| Core ML / Elixir | <1GB | Neural Engine | iOS apps, BEAM systems |
No PyTorch, no GPU, no API key, no data leaving the box. Try that with a hosted API.
Where to use which
Pick Jev when…
- You need decisions this week with zero ML ops — API key and go
- Load is bursty; per-call billing beats idle GPUs
- Multilingual + general decisions out of the box
Pick Laya when…
- Data cannot leave your servers (DPDP-sensitive, on-prem)
- You can fine-tune: 1,200 labelled cases took ~2 hours and beat Jev
- Non-English workloads (multilingual checkpoint, 100+ languages)
- You want zero per-call cost at steady volume
Calibration warning (both)
Jev ships well-calibrated (ECE 0.144). Laya ships over-confident — fit one temperature per question type on held-out data first (drops ECE 0.466 → 0.081). Never trust raw probabilities for auto-escalation thresholds until measured.
Setup steps for both
Jev in 4 steps
- Join early access at TypeSafe AI (~$5 starter credits).
- Define ONE decision with 3–5 fixed categories.
- Call the API (or LangChain TypeSafeClassifier); log confidences for a week.
- Auto-act above 0.95, escalate the rest; measure 30 days.
Laya in 4 steps
pip install laya
# Python:
import laya
agent = laya.load("convaiinnovations/laya")
result = agent.predict(state, questions) # choice/score/noul + confidence
- Evaluate on YOUR data (base is near-chance zero-shot — fine-tune with the notebook on free Kaggle T4s).
- Fit calibration temperatures on held-out data.
- Deploy behind your API; keep a Jev key as fallback for overflow.
Verdict — the core difference in one paragraph: Jev is a finished product: strong zero-shot (0.727), calibrated out of the box, 64k context, no option cap — but closed, metered, and your data leaves the building. Laya is raw material: near-chance zero-shot (0.362), over-confident until you fit temperatures — but open, free, 1GB-RAM friendly, and fine-tunable past Jev itself (0.766). Jev for deciding this week; Laya for owning decisions forever.
FAQs
Jev vs Laya — which is better?
Fine-tuned Laya wins on accuracy (0.766 vs 0.727); Jev wins on zero-setup convenience. Pick by your constraints, not the leaderboard.
Is Laya free?
Yes — Apache 2.0 weights + pip package. You pay GPU time, not per-call fees.
Can I run Laya locally?
Yes — 421M params runs on a single GPU or CPU. Multilingual checkpoint is smaller (322M).
Does Laya work in Hindi/Punjabi?
Use laya-multilingual (100+ languages) — but measure on your language before trusting it; the English checkpoint collapses on other scripts.
Keep reading:
Want decision models for YOUR industry? Tell us your workflow — we'll map where Jev or Laya fits, including Hindi/Punjabi workloads. Free scoping.