# Laya vs Jev for Agent Routing: Open Models and APIs

Source: https://www.humanstoknow.com/blog/laya-vs-jev-agent-routing-open-models

Laya accepts Jev-shaped requests, but it can choose a different route. Compare the open models and the checks that matter before switching.

Author: Akshay Apsingi
Published: 2026-09-28T11:07:48.292Z
Updated: 2026-09-28T11:07:48.292Z

## TL;DR

- Jev is hosted. Laya ships open weights and a Jev-shaped endpoint.
- A compatible request can select a different checkpoint; option limits and confidence also change.
- Compare wrong routes on your own labeled cases before switching models.

![One incoming request branches through two decision layers toward several possible routes.](https://www.humanstoknow.com/api/media/file/sha256-019e875b58a9ff8f05b60241e9625b2990b70da35e6f0ac64cb44151e54e669d.png)

A shared decision interface can lead to different routes when the underlying model changes.

A support agent can send a billing ticket to a lookup, a specialist, or a person. Jev and Laya can both return a typed choice for that ticket. Laya can even accept a Jev-shaped HTTP request, which makes a switch look simple. The answer can still change. Here is what Laya released, how the main open alternatives work, and what to test before changing a live route.

## What is a System One typed decision?

A request gives the model a **state** (the ticket) and a question with a fixed answer space. TypeSafe's [question reference](https://docs.typesafe.ai/primitives) defines three forms:

| Question | Example | Return |
| --- | --- | --- |
| `choice` | Which handler gets this ticket? | An option and its probability distribution. |
| `score` | How severe is it on a defined scale? | A weighted level and distribution. |
| `noul` | Is this likely to need a refund? | A yes probability from 0 to 1. |

The program still decides whether to act or send a case for review. A correctly formatted answer can be wrong. Our [Jev explainer](/blog/jev-ai-model-built-for-decisions) covers where this decision step fits in an agent.

## How did Laya emerge after Jev?

TypeSafe [announced Jev on 15 September 2026](https://typesafe.ai/blog/introducing-system-one-models-and-jev) as a hosted System One model for typed decisions. It describes parallel sampling and reinforcement learning for calibrated decisions, but has not published Jev's weights or full architecture.

Convai Innovations released an [initial Laya checkpoint on 18 September](https://huggingface.co/convaiinnovations/laya/commit/00c37c405e3c3ad73ee070227614c89cda06b99e), followed by [code and more checkpoints](https://github.com/NandhaKishorM/laya). Its founder traces the work to his [2025 SalesRLAgent paper](https://arxiv.org/abs/2503.23303) on predicting sales-conversation outcomes. In his [account](https://laya.convaiinnovations.com/), Jev's launch prompted him to broaden that work into an open typed-decision model.

## How does Laya make a decision?

Laya's [model card](https://huggingface.co/convaiinnovations/laya) describes a trained decision head on a bidirectional encoder. Its English and typed-decisions checkpoints use ModernBERT-large (421 million parameters); the multilingual checkpoint uses mmBERT-base (322 million). The model scores option markers rather than generating an answer sentence. Default context is 512 tokens for English and 1,024 for the other two checkpoints.

Laya's [router](https://github.com/NandhaKishorM/laya#quickstart) picks a checkpoint by language unless you specify one. A comparison that leaves this choice implicit may test different weights across examples. Laya publishes Apache 2.0 code and weights plus a [compatible HTTP server](https://github.com/NandhaKishorM/laya#self-hosting-http-server-jev-compatible); Jev's public offering is a hosted API.

## Which open alternatives are worth comparing?

Beyond Laya, three published approaches are worth a closer look:

- **[Kev](https://github.com/jaredpalmer/kev)** adds adapters and a pointer head to Qwen models. It publishes Apache 2.0 code and weights from 0.8B to 27B.
- **[Bespoke Nimble](https://github.com/bespokelabsai/nimble)** scores allowed answer-token logits from Qwen3.5-9B. It publishes an adapter, data, recipe, and local scorers; you also need the base weights.
- **[Decider](https://github.com/Mapika/decider)** reads answer-slot logits from Qwen-based models. It publishes Apache 2.0 code and checkpoints plus a `/v1/systemone` service.

[Laya batches questions](https://huggingface.co/convaiinnovations/laya#architecture), [Kev reuses a state cache](https://github.com/jaredpalmer/kev#how-it-works), and [Nimble's CUDA scorer evaluates fields separately](https://github.com/bespokelabsai/nimble#capabilities). A matching endpoint says little about latency for your request shape.

[SemIf](https://github.com/TheoLeeCJ/SemIf-OpenJev) and [AnyJev](https://github.com/nokia-applied-research/AnyJev) adapt existing models to typed decisions. [Decis](https://github.com/chaitin/Decis) and [OpenJev](https://github.com/razorback16/openjev) are serving layers, not new Jev weights.

## What does a Jev-compatible endpoint preserve?

TypeSafe's [HTTP contract](https://api.typesafe.ai/openapi.json) accepts a state, model name, and named questions at `POST /v1/systemone`. Laya's [server](https://github.com/NandhaKishorM/laya#self-hosting-http-server-jev-compatible) accepts that request shape. Start it on loopback:

```bash
python -m pip install "laya[serve]"
export LAYA_HOST=127.0.0.1
export LAYA_DEVICE=cpu
laya-serve
```

In another terminal, send a ticket to the pinned English checkpoint:

```bash
curl \
  http://127.0.0.1:8000/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "english",
    "state": "I was billed twice.",
    "questions": {
      "handler": {
        "type": "choice",
        "instructions": "Choose a handler.",
        "criteria": {
          "lookup": "Account facts",
          "specialist": "Billing dispute",
          "review": "Evidence unclear"
        }
      }
    }
  }'
```

The wire format survives a server switch. Three details may not:

1. **Model selection.** TypeSafe's SDK can default to `jev-latest`. Laya [routes unrecognized model names automatically](https://github.com/NandhaKishorM/laya/blob/main/laya/serve.py), so an unchanged client may quietly run Laya. Pin and log the actual checkpoint.
2. **Request limits.** Jev advertises up to [255 choice options](https://typesafe.ai/blog/introducing-system-one-models-and-jev). Laya's server [guards at 100](https://github.com/NandhaKishorM/laya#self-hosting-http-server-jev-compatible) and may trim descriptions around 20 choices. Test your largest real requests, not only a three-option demo.
3. **Confidence.** TypeSafe [describes confidence](https://docs.typesafe.ai/confidence) as a statistic of the answer distribution; Laya [uses normalized entropy](https://github.com/NandhaKishorM/laya#self-hosting-http-server-jev-compatible) for Choice and Score. A threshold chosen for one model cannot simply move with the URL.

## Do benchmarks show a winner?

TypeSafe's [launch comparison](https://typesafe.ai/blog/introducing-system-one-models-and-jev) compares Jev with LLMs asked to produce typed probabilities, not with Laya. Laya's [benchmark file](https://github.com/NandhaKishorM/laya/blob/main/BENCHMARKS.md) draws its Jev figures from other publications with different prompts and samples. On one typed-decisions suite, base Laya checkpoints scored 0.362 and 0.352 against a 0.461 majority-class baseline. Its 0.766 result belongs to a checkpoint fine-tuned on that suite's training split.

One [paired, 500-item evaluation](https://github.com/dhruvmehra/jevbench/blob/main/docs/results/2026-09-22-n500-summary.md) found Laya ahead on four-label AG News (90.6% versus Jev's 84.3%) and Jev ahead on 77-label Banking77 (76.4% versus Laya's 38.2%). Jev ran through OpenRouter and Laya ran locally, so that report does not establish a service-speed winner. These tasks produced different winners; neither result predicts your route.

## How should you test an agent route?

Use one decision your agent already makes, then compare models on the same cases:

1. Label routine tickets and the costly edge cases: missing evidence, negation, rare routes, long inputs, and relevant languages. Hold back a final test set.
2. Send the same state, instructions, and option descriptions to pinned model versions. Include your current rule or LLM route as a baseline.
3. Count wrong assignments by route and the high-confidence errors that would bypass review. Set review thresholds separately for each model.
4. Measure end-to-end p95 time and total cost at your expected traffic, including downstream work caused by a wrong route.

The [Jev Workflow Design skill](/company/humanstoknow/skill/jev-workflow-design) helps define the decision. Our [System One Model Evaluation skill](/company/humanstoknow/skill/system-one-model-evaluation) turns that decision into a paired trial with a recorded baseline and an adoption threshold.

## Which model should you try first?

Start with Jev if a managed API fits your route. Start with Laya if you need published weights or control over the server; consider Kev, Nimble, or Decider when their architecture and checkpoint size suit the same test. Keep your existing rules in the comparison. If no model reduces the mistakes that matter at an acceptable review rate and response time, the best result is to keep the route you already have.