Laya: an open-source classifier for local decisions

Laya is a free-to-download decision model that you can run and adapt on your own hardware. Expect a development project rather than a ready-made home assistant. Its openness is useful, but the published results make a strong case for testing your exact task before trusting the default model.

Laya comes from Convai Innovations. It is an independent project, not TypeSafe releasing an open-source version of Jev. The first package release appeared on PyPI on September 18, 2026; the latest listed package when we checked on October 1 was 0.3.23, released that day.

For the broader idea behind these tools, start with our plain-English classifier guide. The short version is that they answer bounded questions so your application can decide what to do next.

Version update — October 10, 2026

The original package check was 0.3.23 on October 1. Our October 10 check found 0.4.2 on PyPI, released that day, also recorded in the upstream v0.4.2 release.

Since 0.4.0, text whose language the detector cannot identify falls back to the multilingual checkpoint instead of English. Identified English still routes to the English checkpoint. Pin the package version, checkpoint revision and router configuration when comparing results; an update can change which model answers.

This is a release-documentation update, not a new test. The benchmark research below remains dated October 1; we have not rerun or refreshed those measurements.

Version update — October 13, 2026

PyPI lists 0.4.6, uploaded October 12. The upstream release notes describe two fixes: the documented return type for the ONNX backend now matches its ONNXAgent implementation, and batch routing rejects a missing (None) input before loading a checkpoint. Neither establishes a new accuracy or speed result.

For long documents, the versioned package instructions explicitly select model="multilingual" and set max_len=8192. Increasing the token limit alone does not select that checkpoint: mostly English text otherwise routes to the English model. Test your own complete inputs, including questions and answer options, before relying on the longer context.

This update checks release documentation only. We have not installed or benchmarked 0.4.6; the benchmark discussion below remains scoped to the October 1 research.

What you actually get

Laya accepts text and typed questions, including choices, ordered scores, and yes/no judgments. It returns structured answers instead of writing a response. The English model card describes a roughly 421-million-parameter model built around a ModernBERT-large encoder with a decision head.

In everyday terms, it reads the supplied material and scores the possible answers. It does not have to compose a paragraph explaining itself. That makes it a candidate for jobs such as assigning document categories or choosing which part of an application should handle a request.

Your application still needs to load the document, extract any text, apply permissions, and handle uncertainty. For a scanned receipt, for example, optical character recognition is a separate step. A classifier alone does not turn the receipt image into usable text.

Open source changes who is responsible

The project’s code and published checkpoints use Apache-2.0 licensing. The model can be downloaded and self-hosted rather than accessed only through a vendor endpoint.

That gives you control over where inference runs and when you update it. It also gives you the work: installing dependencies, choosing a checkpoint, checking results, and maintaining the service if another application depends on it.

There is no metered Laya API bill when you run the model yourself. Electricity, hardware, storage, and your time still count. If an existing computer can handle your workload, try that before buying a dedicated box. A local model is not automatically the least expensive system once maintenance and mistakes are included.

Privacy also depends on the complete setup. A locally running classifier can keep its inputs on your infrastructure. A connected OCR service, cloud fallback, or externally hosted logging system may change that. Check those pieces too.

Choose the checkpoint deliberately

A checkpoint is a particular trained set of model weights. Laya offers several, and their results should not be treated as interchangeable.

• The English base model is the general starting point, with a default 512-token budget described in its model card. That is a short working input, not room for an entire household archive.
• The multilingual model is a separate, roughly 322-million-parameter model. Its documentation lists a default 1,024-token limit, configurable up to 8,192. Longer supported input does not promise equal accuracy throughout that range.
• The typed-decisions model has a default 1,024-token budget and is fine-tuned for four particular workflow families: agent traces, customer service, invoices, and security incidents. Its model card warns that this specialization is not a general upgrade for every task.

Those token limits cover the complete sequence for each question, including the question and option descriptions. The space left for your document depends on how those are written.

The package includes a router for selecting checkpoints. That router is part of Laya’s implementation; it should not be confused with a general system that chooses among all the chat models on your computer.

For your first evaluation, record the exact checkpoint and package version. Otherwise, changing the router configuration or installing an update can leave you comparing different systems without realizing it.

Read the benchmark footnotes first

The upstream benchmark document reports 76.6 percent accuracy for the specialized typed-decisions checkpoint. On that evaluation, the base English and multilingual checkpoints score 36.2 and 35.2 percent, below the 46.1 percent majority-class baseline. Those are task-specific results, not a universal accuracy rating.

The specialist was trained on this benchmark’s training split. Its test cases are synthetic and their reference answers come from another model, so the score measures agreement with that teacher rather than independently verified real-world correctness. The benchmark publisher explains that distinction.

There are two further qualifications. The document says the specialist headline lacks a committed result file from its fine-tuning run. It also says the Jev comparison figures were taken from third-party reporting with different prompts and sample sizes. They are not a controlled head-to-head test performed by the Laya project.

A September 27 independent preprint reproduced the specialist’s accuracy at 76.7 percent. The study’s confidence-gated workflow still missed its target of no more than 10 percent errors among automatically accepted decisions. That is useful supporting evidence for the narrow result, with the same synthetic-label limitation.

The practical conclusion is narrower than “Laya beats Jev.” A particular trained checkpoint can do substantially better on its target tasks than the base model. Whether that advantage carries over to your manuals, notes, or device commands needs its own evidence.

Speed comparisons need the same care. A local model measurement and a remote API response include different amounts of work. Before choosing hardware, measure the complete path you will use, including text extraction, model loading, and any follow-up processing. Separate the first request from requests made after the model is already loaded.

Start on your existing machine

The official installation instructions require Python 3.10 or newer and cover CPU and supported GPU setups. The project documents CPU operation, so a dedicated graphics card is not a prerequisite for investigating it. We have not measured its performance on a mini PC for this article.

Use a separate Python environment, follow the instructions for your hardware, and download the intended checkpoint before testing offline operation. Keep the first experiment small enough that you can inspect every result. For a local service, begin on the same machine rather than exposing its port to the internet.

An example project would be to suggest tags for a collection of public product manuals. Define a handful of distinct categories and an “other” option. Create examples with expected answers, including misleading titles and mixed subjects. Make the model write suggestions to a new file instead of moving the originals.

Then try breaking it. Change the order of the options. Rephrase the question. Include a document that tells the model to choose a particular label. Check whether a short excerpt works better than the full document. The project’s limitations section makes clear that option budgets, wording, and confidence estimates deserve attention.

If you fine-tune, keep final test examples out of the training and tuning process. Measure incorrect automatic decisions as well as the amount of work sent to review. A high apparent confidence should never bypass permissions or make a destructive action safe by itself.

Where Laya fits beside Jev

Jev is a managed, hosted option. Laya gives you downloadable models, source code, and the ability to specialize them. Those are meaningful differences before you compare speed or accuracy.

For a reader who wants a working assistant this afternoon with minimal setup, Laya is probably the wrong starting point. For someone already building local automation and willing to label examples and test the results, it is a concrete project to investigate.

Pick one useful decision, keep the consequences reversible, and find out whether Laya handles it better than your simplest alternative. You can decide what hardware it deserves after that.

Research note: This is a documentation-based guide, checked October 1, 2026, rather than a hands-on Laya review. Benchmark figures come from the cited project reports and independent preprint; we have not reproduced them. The household examples are proposed experiments, not verified integrations.