TypeSafe Jev alternatives: open-source and hosted options compared

The main alternatives to TypeSafe Jev are Laya (an open-source model with the same API, hosted by Laya Studio or self-hosted), LLMs such as GPT or Claude with constrained output, GLiNER schema models, zero-shot NLI classifiers, fine-tuned BERT-style encoders, and embeddings with kNN. Only Laya speaks Jev's /v1/systemone protocol.

What Jev does

TypeSafe launched Jev on September 15, 2026 as "the first System One model". It is a hosted model that takes a state and typed questions (choice, score, noul) at POST https://api.typesafe.ai/v1/systemone and returns typed answers with probabilities. The current version is jev-1.13.0, with the aliases jev-latest and jev-preview. Pricing is $0.042 per million input tokens, and output is free. It supports up to 255 options per Choice and 32k tokens for the state plus the longest question. Weights are closed. English is its primary language. Details: what is Jev.

People look for alternatives for a few recurring reasons:

• Open weights and self-hosting, for data residency, air-gapped deployments or pinning exact weights.
• Latency. Independent benchmarks measured Jev at 236–276 ms p50 end-to-end.
• Languages. TypeSafe says non-English text is "handled but not equally well".
• Customisation. "Jev is not fine-tuned or LoRA-adapted with customer data."
• Vendor risk. It is one closed model behind one API, and jev-latest moves when a new release ships.

No alternative wins on all of these at once. The sections below go through them one at a time.

Laya is an Apache-2.0 family of three checkpoints from Convai Innovations on Hugging Face. They are encoder decision models (ModernBERT-large 421M for English, mmBERT-base 322M for 100+ languages, plus a checkpoint fine-tuned for typed-decisions), trained with RLCD against strictly proper scoring rules. It is the only alternative here that speaks Jev's wire protocol: laya-serve exposes POST /v1/systemone with Jev-shaped answers and usage.

Laya Studio is an independent managed API powered by the open-source Laya model. It is not affiliated with Convai Innovations or TypeSafe. The endpoint is https://api.laya.studio/v1/systemone, with bearer keys lsk_live_..., automatic language routing, and billing per input token (1 credit = 1 input token) at 30% below Jev's list price, after 5 free runs.

curl -s https://api.laya.studio/v1/systemone \
  -H "Authorization: Bearer lsk_live_..." -H "Content-Type: application/json" \
  -d '{"state": "Mein Konto wurde zweimal belastet",
       "questions": {"refund": {"type": "noul", "instructions": "Does the customer want money back?"}}}'
# routing.model -> "multilingual"

Published strengths (Laya model card; the Jev figures there are third-party):

• 39.5 ms (English) and 32.8 ms (multilingual) per single question on a T4.
• AG News 0.950 vs Jev 0.910, and DAIR Emotion 0.595 vs 0.480.
• typed-decisions 0.766 with the fine-tuned checkpoint, vs Jev 0.727.
• 45 of 51 languages above three times random when routed.

Published weaknesses:

• Banking77 0.425 vs Jev 0.870. Keep choice questions under ~20 options.
• Context per question is 512 or 1,024 tokens.
• Base checkpoints are near chance on typed-decisions zero-shot.
• Ships over-confident; refit temperatures.
• act_probability carries no usable signal yet.

Full breakdown: Laya vs Jev.

Any LLM can act as a classifier if you ask for JSON and constrain the output to your labels. The nibzard decision-model benchmark (DMB) is the most useful public comparison with Jev. It runs one frozen protocol over Jev, eight LLMs and three baselines, and publishes its raw logs and spend:

Among its findings: "No class wins on quality." Every LLM handled 512 options, where Jev returns 400 Too many choices. at 256 or more. On forced-uncertainty items the LLMs admitted ignorance 97.3–100% of the time with ECE 0.039–0.122. Jev admitted it 49.7% of the time with ECE 0.246.

Pick an LLM when you need reasoning over long documents, label spaces in the hundreds, or honest "I don't know" behaviour, and you can afford seconds of latency and per-token cost. Skip it when the decision sits in a hot path, or when you need a full probability distribution rather than a single label. See Laya vs LLM classifiers and LLM-as-classifier cost.

GLiNER2 models are compact open models with a schema-driven interface. They do extraction and classification, and they run locally. The AbdelStark jev-benchmarks pilot compared fastino/gliner2.5-multi-v1 against Jev on 300 BTZSC examples:

GLiNER ran at about 44 ms p50 on an Apple M4 Max CPU for the 4- and 6-label tasks, against Jev's 236–256 ms over the network from France. On DAIR Emotion GLiNER was better calibrated (Brier 0.668 vs 0.846). The authors call the result "deliberately mixed" and the sample a pilot.

Pick GLiNER for local, lightweight extraction plus classification. It does not offer Jev's score or noul question types in the same form, and it does not speak /v1/systemone.

Zero-shot NLI classifiers

Models such as facebook/bart-large-mnli score "this text is about {label}" as an entailment hypothesis, one pass per label (Yin et al., 2019). They are open, cheap and well understood. They cost one forward pass per label, their entailment scores are not calibrated per task, and ordinal scores are awkward. See Laya vs zero-shot NLI.

Fine-tuned encoder classifiers

A BERT-family model fine-tuned on your labels (see BERT, or SetFit for few-shot training) is fast and often the most accurate choice for one fixed task. It needs labelled data, and every change to the label set means retraining. Laya itself is a fine-tuned encoder: the typed-decisions model card lists a published "ModernBERT-base specialist" at 0.646 on typed-decisions, against Laya's fine-tuned 0.766. See Laya vs fine-tuned BERT.

Embeddings + kNN

Embedding similarity scales to thousands of labels and reuses your labelled history, but it returns votes and cosines rather than calibrated answers. It is a strong companion to a decision model as a shortlist stage. See Laya vs embeddings + kNN.

Baselines you should always run

DMB's keyword baseline scored 29.3% on banking and 54.0% on spam. Its majority baseline scored 87.7% on spam, above two of the OpenAI models tested. A decision model that cannot beat your majority class is not helping. The Laya benchmarks report the same kind of check: the base checkpoints score below the 0.461 majority baseline on typed-decisions zero-shot.

In practice many teams use two tiers. A fast decision model handles the bulk of traffic, and when confidence is low the case escalates to an LLM or a human. The pattern is in act/escalate routing and System 1 vs System 2 AI.

Data residency is one of the most common reasons to look beyond Jev. Where Jev processes requests is not publicly documented; TypeSafe states that Jev is not trained on customer requests or responses and offers zero data retention to enterprise customers.

You have two ways to keep decision traffic under your control:

1. Self-host an open model. Laya, GLiNER, NLI and BERT-family models can all run on your own hardware, so data stays wherever you run them.
2. Use Laya Studio, the hosted option with the Jev wire format. From our Swiss data residency page:

• Requests are answered on dedicated GPUs located in Switzerland, and every API response says where it was processed in the x-laya-region header.
• Zero content retention. The text and questions you send are processed in memory and discarded when the answer is returned. They are never written to a database or log, and never used to train anything.
• Swiss-only mode (one switch per workspace, or the x-laya-residency: ch header per request) means requests are only ever answered in Switzerland. If the Swiss pool is unavailable you get an error, never a silent detour abroad.
• Account data (accounts, API keys stored only as SHA-256 hashes, credit balances, usage metadata) lives in a Postgres database in the AWS Zurich region (eu-central-2). Request metadata only (time, status, number of questions, latency) is kept for 30 days.

Laya Studio is designed to support compliance with the Swiss nFADP and the EU GDPR, and a Data Processing Agreement is available on request. It holds no formal certification (such as ISO 27001) today and does not sign HIPAA BAAs. You remain responsible for your legal basis to process personal and health data.

Because Laya implements the same request, the cheapest way to evaluate it as an alternative is to replay Jev traffic against it:

import httpx, json

JEV = ("https://api.typesafe.ai/v1/systemone", "Bearer " + JEV_KEY)
LAYA = ("https://api.laya.studio/v1/systemone", "Bearer " + LAYA_KEY)   # lsk_live_...

def ask(target, body):
    url, auth = target
    return httpx.post(url, json=body, headers={"Authorization": auth}, timeout=15).json()

agree = total = 0
for body in load_logged_requests():              # your own request log
    a, b = ask(JEV, body)["answers"], ask(LAYA, body)["answers"]
    for qid, ans in a.items():
        if ans["type"] == "choice":
            total += 1
            agree += ans["choice"] == b[qid]["choice"]
print(f"choice agreement: {agree}/{total}")

Watch for three things:

• choice questions with more than 20 options;
• states longer than the per-question context;
• confidence thresholds. Laya's confidence is 1 − H(p)/log k and is not on the same scale as Jev's.

Details and SDK notes are in the migration guide. Get a key at /signup. Credit pricing is at /pricing.

Laya Studio hosts one of the alternatives on this page, so read it with that in mind. We have tried to limit that bias:

• Every Jev number is attributed to TypeSafe's own docs or to one of two independent benchmarks (AbdelStark, nibzard). We have not quoted any figure we could not source. Where something is not publicly documented, we say so: Jev's parameter count, per-language accuracy and self-hosting options are examples.
• Every Laya number comes from the Laya model cards and BENCHMARKS.md, published by Convai Innovations. The Laya authors state that they had no Jev API access, so their Jev figures are quoted from third parties.
• Losses are listed. Banking77, soft accuracy, raw calibration, long context and zero-shot complex workflows all favour Jev, and we list them.

Laya Studio is an independent service powered by the open-source Laya model. It is not affiliated with or endorsed by Convai Innovations or TypeSafe AI.