Laya vs TypeSafe Jev: which decision model should you use?

Laya and Jev are both System 1 decision models: they read a piece of text and return typed answers with probabilities instead of writing text. Laya is open source (Apache-2.0) and faster at the model level; Jev is a closed hosted API that handles far more options and longer inputs. Neither wins everywhere.

Laya and Jev are two implementations of one idea. Instead of generating text, a System 1 decision model reads a state and returns typed answers: a choice from options you define, a score on an ordered rubric, or a noul (the probability that a statement is true). Every answer comes with probabilities. Both are trained with a method called RLCD (Reinforcement Learning for Calibrated Decisions), and both expose the same HTTP request: POST /v1/systemone.

The practical differences:

• Openness. Laya's weights are open under Apache-2.0. Jev's are closed.
• Speed. The Laya model card reports 39.5 ms (English) and 32.8 ms (multilingual) for a single question on a T4. It cites independent measurements of Jev at 236–276 ms p50; see the caveats below.
• Accuracy. Laya leads on AG News, DAIR Emotion and typed-decisions. Jev leads by a wide margin on Banking77 (0.870 vs 0.425) and on anything with many options.
• Context. Jev accepts 32k tokens of state. Laya reads 512–1,024 tokens per question.

Laya Studio is an independent hosted API powered by the open-source Laya model. It is not affiliated with or endorsed by Convai Innovations or TypeSafe. It speaks the Jev wire protocol, so moving a workload between the two usually means changing a base URL and an API key.

Laya

The Laya model card documents the architecture in full:

Each question is packed into one encoder sequence:

[CLS] <type> question: instructions [SEP] [MASK] opt0 [MASK] opt1 ... [SEP] state [SEP]

A small head scores the hidden state at each [MASK] marker, and a softmax gives the answer distribution. This is option-marker scoring: the options are part of the input, so the label set is defined per request with no retraining. All questions share one batched forward pass, and nothing is decoded, so usage.output_tokens is always 0. An act/escalate head outputs action.act_probability, which "carries no usable signal yet" (issue #185). Gate on confidence instead.

Jev

TypeSafe's launch post describes "a new model architecture, parallel sampler for maximum efficiency, and training method we call Reinforcement Learning for Calibrated Decisions (RLCD)". It says Jev "outputs all probabilities in parallel instead of autoregressively generating by token". Parameter count, backbone and head design are not publicly documented. What is documented is the interface: text-only input, a context of 64k tokens per request (32k for the state plus the longest question), up to 255 options per Choice, and up to 10 Score levels (Models, API reference).

In short, Laya trades context length and option count for speed and openness. A few-hundred-million-parameter encoder is cheap to run on one GPU, and it can run on CPU. But it cannot read a 20-page contract in one question, and it cannot separate 77 labels squeezed into a 256-token budget.

The Laya package ships laya-serve. Its source describes it as an "HTTP server exposing Laya over TypeSafe Jev's /v1/systemone wire protocol". Laya Studio exposes the same contract at https://api.laya.studio/v1/systemone. A Jev request works unchanged:

curl -s https://api.laya.studio/v1/systemone \
  -H "Authorization: Bearer lsk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "state": {"subject": "Duplicate charge on invoice #4411",
              "body": "We were billed twice for March. Refund the duplicate today or we cancel."},
    "model": "jev-latest",
    "questions": {
      "department": {"type": "choice", "instructions": "Which team should handle this?",
        "criteria": {"billing": "invoices, payments, refunds", "technical": "bugs, outages",
                     "sales": "pricing, new contracts", "other": "everything else"}},
      "urgency": {"type": "score", "instructions": "How urgent is this request?",
        "criteria": ["not urgent", "soon", "critical deadline or blocking issue"]},
      "churn_risk": {"type": "noul", "instructions": "Does the sender threaten to cancel?"}
    }
  }'

The response has the Jev shape, and Laya adds a few fields. The values below are illustrative; the field names come from Laya's agent.py and router.py:

{
  "model": "laya-rl-agent",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": {"billing": 0.91, "technical": 0.04, "sales": 0.03, "other": 0.02},
      "confidence": 0.7128,
      "action": {"act_probability": 1.0}
    },
    "urgency": {
      "type": "score",
      "score": 1.78,
      "legend": {"0": "not urgent", "1": "soon", "2": "critical deadline or blocking issue"},
      "probabilities": {"0": 0.02, "1": 0.18, "2": 0.8},
      "confidence": 0.4853,
      "action": {"act_probability": 1.0}
    },
    "churn_risk": {
      "type": "noul",
      "noul": 0.93,
      "confidence": 0.93,
      "action": {"act_probability": 1.0}
    }
  },
  "usage": {"input_tokens": 412, "output_tokens": 0},
  "routing": {
    "model": "english",
    "repo": "convaiinnovations/laya",
    "reason": "English Latin text"
  }
}

Field-by-field compatibility

Two differences matter. First, sending jev-latest in the model field does not fail; Laya ignores it and routes. Second, confidence is computed differently. Laya uses 1 − H(p)/log k. TypeSafe illustrates Jev's for three options as (3 × largest − 1)/2. For {0.91, 0.04, 0.03, 0.02}, Laya reports about 0.71, while a max-probability formula gives about 0.88. Re-tune your thresholds; don't copy them over. See choice, score and noul.

The Laya model card reports these single-question and batched latencies on a Tesla T4. Each checkpoint answered byte-identical questions:

For Jev, the Laya card cites two independent benchmarks. AbdelStark/jev-benchmarks measured 236–256 ms p50 on 4- and 6-label tasks and 246 ms on a 72-label task, calling the hosted API from France. nibzard/decision-model-benchmark measured 264–276 ms p50, "flat from 2 to 255 options". The Laya card summarises the range as 236–276 ms p50. TypeSafe's own launch post states an end-to-end response time of "70ms-500ms".

Caveats you should apply

1. The measurements are not like for like. Laya's figures are in-process GPU timings. Jev's are end-to-end HTTP calls over the internet. Calling Laya Studio adds your own network round trip too, so expect more than 32.8 ms end to end.
2. Batching favours the multilingual checkpoint. It costs about 7 ms per question at 10 or more questions. How Jev's latency scales with question count is not publicly documented. DMB found it flat across option counts.
3. CPU is slower. A preloaded Laya on CPU takes 193–464 ms per request, per the card.

In summary: at the model level Laya is several times faster, and the gap narrows but stays large on a GPU host near your application. See latency budgets for agents.

All Laya numbers below come from the Laya model card and BENCHMARKS.md. The Jev numbers are third-party published figures quoted on that card. The Laya authors state that they had "no TypeSafe API access", so sample sizes and prompts differ. Treat the comparison as indicative.

Why Laya loses Banking77

The loss is architectural, not a question of intelligence. Every option of a choice question shares one fixed token budget (head_max_len, 192 or 256 tokens). With 77 options, each label gets roughly 3–4 tokens, and many labels stop being distinguishable. Both base checkpoints score exactly 0.425, which points to a budget ceiling. Jev accepts up to 255 options. The DMB benchmark found Jev at 100% accuracy on a synthetic task up to 255 options, and returning 400 Too many choices. at 256.

Mitigations on the Laya side:

• Split the label space into a two-step hierarchy (coarse group, then fine label).
• Use an embedding shortlist to cut 77 labels to 20 before asking Laya. The laya package ships this as predict_shortlist. See Laya vs embeddings + kNN.
• If you self-host, raise head_max_len at runtime. This costs context available for the state.

Why the typed-decisions win needs a caveat

The 0.766 comes from laya-typed-decisions, a checkpoint fine-tuned on that benchmark's own training split. The base laya checkpoint scores 0.362 zero-shot, below the 0.461 majority-class baseline. The model card says so directly: "Laya is a fast base to specialise, not a zero-shot decision engine." Jev's 0.727 comes from one general model with no task-specific fine-tuning. If you need strong results on a complex multi-question workflow with no training data, that is a real point for Jev.

Both models are trained with RLCD, whose goal is that a 0.8 answer is right about 80% of the time. The published evidence is mixed and comes from different benchmarks. We quote each figure with its source:

The card's headline "ECE 0.081 vs 0.246" sets Laya after temperature fitting on its own suites against Jev on DMB's items. That is a useful signal, but not a controlled head-to-head. What you can say fairly:

• Out of the box, Jev is better calibrated. The Laya card lists this under "Where Jev leads": ECE 0.213 vs 0.144 on typed-decisions.
• Laya can be refit cheaply. Fitting one temperature per (question type, option count) bucket on held-out data takes mean ECE from 0.466 to 0.081. See temperature scaling.
• Both have documented failure modes. Jev admitted uncertainty on only 49.7% of DMB's forced-uncertainty items, and it gave zero probability to the true label on 16% of DAIR Emotion examples. Laya's English checkpoint scores 0.000 accuracy on Khmer at 0.952 confidence. That is why Laya routes by script before the forward pass.

See expected calibration error.

TypeSafe's models page says English is Jev's primary training language and "where accuracy is currently best". It adds that other languages, including CJK scripts, "are handled but not equally well", and advises testing on your own content. A per-language Jev benchmark is not publicly documented.

Laya answers the language question with a separate checkpoint and a router. On the model card's shared benchmark:

Script detection takes under 0.5 ms. The router's reason is returned in routing.reason, and "model": "multilingual" overrides it. Low-resource languages are still weak (Swahili 0.210, Amharic 0.110). See language routing.

Deployment options

Self-hosting Laya takes one command:

pip install "laya[serve]"
LAYA_DEVICE=cuda LAYA_PRELOAD=1 LAYA_API_KEY=change-me laya-serve   # listens on 0.0.0.0:8000

Note that laya-serve binds to all interfaces with no authentication unless LAYA_API_KEY is set.

How you pay

• Jev: $0.042 per million input tokens, output free. DMB measured about $0.07 per 1,000 decisions on its banking suite.
• Laya Studio: per input token, 30% below Jev's list price (1 credit = 1 input token), with 5 free runs per new workspace. Like Jev, the state is read once per question, so the same request costs 30% less. Prices are on /pricing.
• Self-hosted Laya: no licence fee, but you pay for the hardware. The card reports 103–332 questions per second batched on one T4.

Token billing favours small states. Per-question billing favours large states with few questions. Either way, filter long documents first; TypeSafe gives the same advice in its jaggedness notes.

For teams in healthcare, HR, insurance or finance, where text is processed can matter as much as speed.

Laya Studio (details on 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.

Self-hosted Laya never leaves your infrastructure, because you run the open weights yourself.

Jev. TypeSafe's models page states that "Jev is not trained on customer requests or responses", and zero data retention (ZDR) is offered to enterprise customers. Where Jev requests are processed is not publicly documented. The launch post says TypeSafe's evals ran from the US West Coast, "where our service is currently based", but that is a latency note, not a data residency commitment.

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.

Choose Laya (self-hosted or via Laya Studio) when

• Latency is the constraint: agent tool routing inside a turn, guardrails on every message, real-time UX.
• You need open weights: regulated data, air-gapped deployment, or pinned, reproducible weights.
• Your traffic is multilingual. Routing to the multilingual checkpoint is automatic and logged.
• Data residency matters. Laya Studio answers in Switzerland with zero content retention (Swiss-only mode available), or you can self-host.
• You can fine-tune. The typed-decisions result (0.766 vs 0.727) is the published example.
• Your choice questions have fewer than ~20 options and each question's state fits in 512–1,024 tokens.

Choose Jev when

• Your label spaces are large: up to 255 options (Banking77: 0.870 vs 0.425).
• Your states are long, up to 32k tokens, and you cannot filter them.
• You need zero-shot quality on complex workflows, with no training data.
• You want a vendor-supported model with official Python and JavaScript SDKs.

Run both

Since the protocol is the same, you can send most traffic to Laya and questions with many options or long states to Jev. See act/escalate routing.

1. Raw HTTP: change the URL and key

# before
curl -s https://api.typesafe.ai/v1/systemone -H "Authorization: Bearer $TYPESAFE_API_KEY" ...
# after
curl -s https://api.laya.studio/v1/systemone -H "Authorization: Bearer $LAYA_API_KEY" ...

The body stays the same. You can leave "model": "jev-latest" in place; Laya ignores Jev model IDs and routes automatically.

2. Python: plain HTTP with a switchable base URL

import os, httpx

BASE_URL = os.environ.get("DECISION_BASE_URL", "https://api.laya.studio")
API_KEY = os.environ["DECISION_API_KEY"]          # lsk_live_... for Laya Studio

def system_one(state, questions, model=None):
    body = {"state": state, "questions": questions}
    if model:
        body["model"] = model
    r = httpx.post(f"{BASE_URL}/v1/systemone", json=body,
                   headers={"Authorization": f"Bearer {API_KEY}"}, timeout=10)
    r.raise_for_status()
    return r.json()

res = system_one("I was charged twice. Please fix this ASAP.",
                 {"billing": {"type": "noul", "instructions": "Is this ticket about billing?"}})
print(res["answers"]["billing"]["noul"], res.get("routing", {}).get("model"))

If you use TypeSafe's Python SDK, the AbdelStark benchmark notes that it "honors TYPESAFE_BASE_URL and TYPESAFE_DEFAULT_MODEL". Point TYPESAFE_BASE_URL at Laya Studio and set TYPESAFE_API_KEY to your lsk_live_ key. Check with your SDK version whether it expects the host alone or a path, and make one test call. Laya adds fields (routing, action, confidence on noul answers). Confirm that your SDK version ignores unknown fields before you rely on it.

3. TypeScript: fetch

const BASE_URL = process.env.DECISION_BASE_URL ?? "https://api.laya.studio";

export async function systemOne(state: unknown, questions: Record<string, unknown>) {
  const res = await fetch(`${BASE_URL}/v1/systemone`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.DECISION_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ state, questions }),
  });
  if (!res.ok) throw new Error(`systemone ${res.status}: ${await res.text()}`);
  return res.json() as Promise<{
    model: string;
    answers: Record<string, { type: "choice" | "score" | "noul"; confidence?: number; [k: string]: unknown }>;
    usage: { input_tokens: number; output_tokens: number };
    routing?: { model: string; reason: string };
  }>;
}

4. Haskell (hs-jev)

The Laya server source names hs-jev as a client that can "point its baseUrl at this server and keep working unchanged". It decodes answers and usage and ignores everything else.

5. Checklist

1. Option counts. For choice questions with more than 20 options, split them into a hierarchy, shortlist them, or keep them on Jev.
2. State length. Anything over about 320 tokens (English) or 768 (multilingual) per question is truncated. Filter it first.
3. Shadow traffic. Send the same requests to both and log per-question agreement.
4. Thresholds. Refit act/escalate cut-offs, since the confidence formulas differ.
5. noul answers. A noul can follow its false:/true: labels instead of the state (issue #156). If an answer looks stuck, ask a two-option choice with neutral keys instead.
6. act_probability. Ignore it; it carries no usable signal yet.

Full request and response reference: /docs. Create a key at /signup.

• No controlled head-to-head exists. The Jev numbers come from TypeSafe's docs, AbdelStark's 300-example pilot and nibzard's DMB. The Laya numbers come from the Laya authors, who had no Jev API access. Prompts, samples and label counts differ.
• Latency is measured differently on each side, so the ratio is indicative, not exact.
• Calibration figures come from different benchmarks. On the one benchmark both share, typed-decisions, Jev's ECE is better (0.144 vs 0.213).
• Laya's strongest number needs fine-tuning, and Laya ships over-confident.
• Both models move. jev-latest "moves when a new release ships". Re-check the current model cards before a large decision.
• Laya Studio is not the Laya authors. It is an independent service, and nothing here is endorsed by Convai Innovations or TypeSafe AI.

If you want to test this on your own traffic, the fastest path is to sign up (every new workspace gets 5 free runs) and point a copy of your Jev requests at api.laya.studio.